terraconstructs 0.0.8

package/lib/aws/network/simple-ipv4-vpc.d.ts

@@ -0,0 +1,84 @@
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps } from "../aws-construct";
+import { INetwork, NetworkOutputs } from "./network";
+import { ISubnet } from "./subnet";
+import { ISubnetGroup } from "./subnet-group";
+export declare enum NatGatewayOption {
+    SINGLE_NAT_GATEWAY = "single-nat-gateway",
+    NAT_PER_AVAILABILITY_ZONE = "nat-per-availability-zone"
+}
+export interface SimpleIPv4Props extends AwsConstructProps {
+    /**
+     * The number of availability zones to use.
+     *
+     * @default 2
+     */
+    readonly azCount?: number;
+    /**
+     * The IPv4 CIDR block for the VPC.
+     */
+    readonly ipv4CidrBlock: string;
+    /**
+     * The NAT Gateway set up.
+     *
+     * @default NatGatewayOption.NAT_PER_AVAILABILITY_ZONE
+     */
+    readonly natGatewayOption?: NatGatewayOption;
+    /**
+     * Provisions a Service Discovery Private DNS Namespace resource.
+     */
+    readonly internalDomain: string;
+}
+/**
+ * Define an AWS Virtual Private Cloud simple IPv4 network.
+ *
+ * See the package-level documentation of this package for an overview
+ * of the various dimensions in which you can configure your VPC.
+ *
+ * For example:
+ *
+ * ```ts
+ * const network = new network.SimpleIPv4(awsStack, "network", {
+ *  ipv4CidrBlock: "10.0.0.0/16",
+ *  internalDomain: "example.local",
+ * });
+ *
+ * // Add a subnet group for RDS
+ * network.enableDbSubnetGroup();
+ * ```
+ *
+ * @resource aws_vpc
+ * @beacon-class network.SimpleIPv4Vpc
+ */
+export declare class SimpleIPv4Vpc extends AwsConstructBase implements INetwork {
+    private readonly _props;
+    private readonly _outputs;
+    get networkOutputs(): NetworkOutputs;
+    get outputs(): Record<string, any>;
+    private readonly ipv4CidrBlock;
+    private readonly natGatewayOption;
+    private readonly natGateways;
+    private readonly privateRouteTables;
+    private readonly azCount;
+    private readonly availabilityZones;
+    private readonly vpc;
+    get vpcId(): string;
+    private readonly _publicSubnets;
+    get publicSubnets(): ISubnet[];
+    private readonly _privateSubnets;
+    get privateSubnets(): ISubnet[];
+    private readonly _dataSubnets;
+    get dataSubnets(): ISubnet[];
+    private _dbSubnetGroup?;
+    get dbSubnetGroup(): ISubnetGroup | undefined;
+    private _elastiCacheSubnetGroup?;
+    get elastiCacheSubnetGroup(): ISubnetGroup | undefined;
+    private readonly serviceDiscoveryNamespace;
+    get serviceDiscoveryNamespaceArn(): string;
+    constructor(scope: Construct, id: string, props: SimpleIPv4Props);
+    enableDbSubnetGroup(): void;
+    enableElastiCacheSubnetGroup(): void;
+    private createPublicSubnets;
+    private createPrivateSubnets;
+    private createDataSubnets;
+}

package/lib/aws/network/simple-ipv4-vpc.js

@@ -0,0 +1,236 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleIPv4Vpc = exports.NatGatewayOption = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+const subnet_1 = require("./subnet");
+const subnet_group_1 = require("./subnet-group");
+var NatGatewayOption;
+(function (NatGatewayOption) {
+    NatGatewayOption["SINGLE_NAT_GATEWAY"] = "single-nat-gateway";
+    NatGatewayOption["NAT_PER_AVAILABILITY_ZONE"] = "nat-per-availability-zone";
+})(NatGatewayOption || (exports.NatGatewayOption = NatGatewayOption = {}));
+/**
+ * Define an AWS Virtual Private Cloud simple IPv4 network.
+ *
+ * See the package-level documentation of this package for an overview
+ * of the various dimensions in which you can configure your VPC.
+ *
+ * For example:
+ *
+ * ```ts
+ * const network = new network.SimpleIPv4(awsStack, "network", {
+ *  ipv4CidrBlock: "10.0.0.0/16",
+ *  internalDomain: "example.local",
+ * });
+ *
+ * // Add a subnet group for RDS
+ * network.enableDbSubnetGroup();
+ * ```
+ *
+ * @resource aws_vpc
+ * @beacon-class network.SimpleIPv4Vpc
+ */
+class SimpleIPv4Vpc extends aws_construct_1.AwsConstructBase {
+    get networkOutputs() {
+        return this._outputs;
+    }
+    get outputs() {
+        return this._outputs;
+    }
+    get vpcId() {
+        return this.vpc.id;
+    }
+    get publicSubnets() {
+        return this._publicSubnets;
+    }
+    get privateSubnets() {
+        return this._privateSubnets;
+    }
+    get dataSubnets() {
+        return this._dataSubnets;
+    }
+    get dbSubnetGroup() {
+        return this._dbSubnetGroup;
+    }
+    get elastiCacheSubnetGroup() {
+        return this._elastiCacheSubnetGroup;
+    }
+    get serviceDiscoveryNamespaceArn() {
+        return this.serviceDiscoveryNamespace.arn;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.natGateways = [];
+        this.privateRouteTables = [];
+        this._publicSubnets = [];
+        this._privateSubnets = [];
+        this._dataSubnets = [];
+        this._props = props;
+        this.azCount = this._props.azCount ?? 2;
+        if (this.azCount > 4) {
+            throw new Error("azCount must be less than or equal to 4");
+        }
+        this.availabilityZones = this.stack.availabilityZones(this.azCount);
+        this.ipv4CidrBlock = this._props.ipv4CidrBlock;
+        this.vpc = new provider_aws_1.vpc.Vpc(this, "Resource", {
+            cidrBlock: this.ipv4CidrBlock,
+            enableDnsSupport: true,
+            enableDnsHostnames: true,
+        });
+        const igw = new provider_aws_1.internetGateway.InternetGateway(this, "igw", {
+            vpcId: this.vpc.id,
+            tags: {
+                Name: `${this.friendlyName}-igw`,
+            },
+        });
+        // adopt default route table and add tags
+        new provider_aws_1.defaultRouteTable.DefaultRouteTable(this, "DefaultRouteTable", {
+            defaultRouteTableId: this.vpc.defaultRouteTableId,
+            tags: {
+                Name: `${this.friendlyName}-default-route-table`,
+            },
+            route: [
+                {
+                    cidrBlock: "0.0.0.0/0",
+                    gatewayId: igw.id,
+                },
+            ],
+        });
+        this.natGatewayOption =
+            this._props.natGatewayOption ??
+                NatGatewayOption.NAT_PER_AVAILABILITY_ZONE;
+        this.createPublicSubnets(cdktf_1.Fn.cidrsubnet(this.ipv4CidrBlock, 2, 0));
+        this.createPrivateSubnets(cdktf_1.Fn.cidrsubnet(this.ipv4CidrBlock, 2, 1));
+        this.createDataSubnets(cdktf_1.Fn.cidrsubnet(this.ipv4CidrBlock, 2, 2));
+        this.serviceDiscoveryNamespace =
+            new provider_aws_1.serviceDiscoveryPrivateDnsNamespace.ServiceDiscoveryPrivateDnsNamespace(this, "ServiceDiscoveryNamespace", {
+                name: this._props.internalDomain,
+                vpc: this.vpc.id,
+                description: `Private DNS namespace for ${this.friendlyName}`,
+                tags: {
+                    Name: `${this.friendlyName}-service-discovery-namespace`,
+                },
+            });
+        this._outputs = {
+            vpcId: this.vpc.id,
+            publicSubnetIds: this.publicSubnets.map((subnet) => subnet.subnetId),
+            privateSubnetIds: this.privateSubnets.map((subnet) => subnet.subnetId),
+            dataSubnetIds: this.dataSubnets.map((subnet) => subnet.subnetId),
+            // only known at synth time
+            // explicit `null` required to avoid syntax errors when using stringValue && "undefined"
+            dbSubnetGroup: cdktf_1.Lazy.anyValue({
+                produce: () => this.dbSubnetGroup?.gridUUID ?? null,
+            }),
+            elastiCacheSubnetGroup: cdktf_1.Lazy.anyValue({
+                produce: () => this.elastiCacheSubnetGroup?.gridUUID ?? null,
+            }),
+            serviceDiscoveryNamespaceName: this.serviceDiscoveryNamespace.name,
+        };
+    }
+    enableDbSubnetGroup() {
+        if (this._dbSubnetGroup) {
+            return;
+        }
+        this._dbSubnetGroup = new subnet_group_1.DbSubnetGroup(this, "DbSubnetGroup", {
+            subnets: this._dataSubnets,
+            tags: {
+                Name: `${this.friendlyName}-db-default-subnet-group`,
+            },
+        });
+    }
+    enableElastiCacheSubnetGroup() {
+        if (this._elastiCacheSubnetGroup) {
+            return;
+        }
+        this._elastiCacheSubnetGroup = new subnet_group_1.ElastiCacheSubnetGroup(this, "ElastiCacheSubnetGroup", {
+            subnets: this._dataSubnets,
+            tags: {
+                Name: `${this.friendlyName}-elasticache-default-subnet-group`,
+            },
+        });
+    }
+    createPublicSubnets(publicIpv4CidrBlock) {
+        for (let i = 0; i < this.azCount; i++) {
+            // if SingleNatGateway, only create NAT Gateway for first public subnet
+            const createNatGateway = this.natGatewayOption !== NatGatewayOption.SINGLE_NAT_GATEWAY ||
+                i === 0;
+            const availabilityZone = cdktf_1.Fn.element(this.availabilityZones, i);
+            const publicSubnet = new subnet_1.PublicSubnet(this, `PublicSubnet${i}`, {
+                vpc: this.vpc,
+                availabilityZone,
+                ipv4CidrBlock: cdktf_1.Fn.cidrsubnet(publicIpv4CidrBlock, 2, i),
+                defaultRouteTableId: this.vpc.defaultRouteTableId,
+                tags: {
+                    Name: `${this.friendlyName}-public-subnet-${availabilityZone}`,
+                },
+                createNatGateway,
+            });
+            if (createNatGateway) {
+                const gw = publicSubnet.natgateway;
+                // create route table per NAT gateway
+                this.privateRouteTables.push(new provider_aws_1.routeTable.RouteTable(this, `PrivateRouteTable${i}`, {
+                    vpcId: this.vpc.id,
+                    route: [
+                        {
+                            cidrBlock: "0.0.0.0/0",
+                            natGatewayId: gw.id,
+                        },
+                    ],
+                    tags: {
+                        Name: `${this.friendlyName}-private-route-table-${availabilityZone}`,
+                        "aws-cdk:subnet-name": "Public",
+                        "aws-cdk:subnet-type": "Public",
+                        "kubernetes.io/role/elb": "1",
+                    },
+                }));
+                this.natGateways.push(gw);
+            }
+            this._publicSubnets.push(publicSubnet);
+        }
+    }
+    createPrivateSubnets(privateIpv4CidrBlock) {
+        for (let i = 0; i < this.azCount; i++) {
+            const availabilityZone = cdktf_1.Fn.element(this.availabilityZones, i);
+            const rtbIdx = this.privateRouteTables.length >= this.azCount ? i : 0;
+            const privateSubnet = new subnet_1.PrivateSubnet(this, `PrivateSubnet${i}`, {
+                vpc: this.vpc,
+                availabilityZone,
+                ipv4CidrBlock: cdktf_1.Fn.cidrsubnet(privateIpv4CidrBlock, 2, i),
+                routeTable: this.privateRouteTables[rtbIdx],
+                tags: {
+                    Name: `${this.friendlyName}-private-subnet-${availabilityZone}`,
+                    "aws-cdk:subnet-name": "Private",
+                    "aws-cdk:subnet-type": "Private",
+                    "kubernetes.io/role/internal-elb": "1",
+                },
+            });
+            this._privateSubnets.push(privateSubnet);
+        }
+    }
+    createDataSubnets(dataIpv4CidrBlock) {
+        for (let i = 0; i < this.azCount; i++) {
+            const availabilityZone = cdktf_1.Fn.element(this.availabilityZones, i);
+            const rtbIdx = this.privateRouteTables.length >= this.azCount ? i : 0;
+            const dataSubnet = new subnet_1.DataSubnet(this, `DataSubnet${i}`, {
+                vpc: this.vpc,
+                availabilityZone,
+                ipv4CidrBlock: cdktf_1.Fn.cidrsubnet(dataIpv4CidrBlock, 2, i),
+                routeTable: this.privateRouteTables[rtbIdx],
+                tags: {
+                    Name: `${this.friendlyName}-data-subnet-${availabilityZone}`,
+                    "aws-cdk:subnet-name": "Data",
+                    "aws-cdk:subnet-type": "Isolated",
+                },
+            });
+            this._dataSubnets.push(dataSubnet);
+        }
+    }
+}
+exports.SimpleIPv4Vpc = SimpleIPv4Vpc;
+_a = JSII_RTTI_SYMBOL_1;
+SimpleIPv4Vpc[_a] = { fqn: "terraconstructs.aws.network.SimpleIPv4Vpc", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"simple-ipv4-vpc.js","sourceRoot":"","sources":["../../../src/aws/network/simple-ipv4-vpc.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  vpc,\n  natGateway,\n  routeTable,\n  internetGateway,\n  defaultRouteTable,\n  serviceDiscoveryPrivateDnsNamespace,\n} from \"@cdktf/provider-aws\";\nimport { Fn, Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AwsConstructBase, AwsConstructProps } from \"../aws-construct\";\nimport { INetwork, NetworkOutputs } from \"./network\";\nimport { PublicSubnet, PrivateSubnet, DataSubnet, ISubnet } from \"./subnet\";\nimport {\n  ISubnetGroup,\n  DbSubnetGroup,\n  ElastiCacheSubnetGroup,\n} from \"./subnet-group\";\n\nexport enum NatGatewayOption {\n  SINGLE_NAT_GATEWAY = \"single-nat-gateway\",\n  NAT_PER_AVAILABILITY_ZONE = \"nat-per-availability-zone\",\n}\n\nexport interface SimpleIPv4Props extends AwsConstructProps {\n  /**\n   * The number of availability zones to use.\n   *\n   * @default 2\n   */\n  readonly azCount?: number;\n  /**\n   * The IPv4 CIDR block for the VPC.\n   */\n  readonly ipv4CidrBlock: string;\n  /**\n   * The NAT Gateway set up.\n   *\n   * @default NatGatewayOption.NAT_PER_AVAILABILITY_ZONE\n   */\n  readonly natGatewayOption?: NatGatewayOption;\n  /**\n   * Provisions a Service Discovery Private DNS Namespace resource.\n   */\n  readonly internalDomain: string;\n}\n\n/**\n * Define an AWS Virtual Private Cloud simple IPv4 network.\n *\n * See the package-level documentation of this package for an overview\n * of the various dimensions in which you can configure your VPC.\n *\n * For example:\n *\n * ```ts\n * const network = new network.SimpleIPv4(awsStack, \"network\", {\n *  ipv4CidrBlock: \"10.0.0.0/16\",\n *  internalDomain: \"example.local\",\n * });\n *\n * // Add a subnet group for RDS\n * network.enableDbSubnetGroup();\n * ```\n *\n * @resource aws_vpc\n * @beacon-class network.SimpleIPv4Vpc\n */\nexport class SimpleIPv4Vpc extends AwsConstructBase implements INetwork {\n  private readonly _props: SimpleIPv4Props;\n  private readonly _outputs: NetworkOutputs;\n  public get networkOutputs(): NetworkOutputs {\n    return this._outputs;\n  }\n  public get outputs(): Record<string, any> {\n    return this._outputs;\n  }\n  private readonly ipv4CidrBlock: string;\n  private readonly natGatewayOption: NatGatewayOption;\n  private readonly natGateways: natGateway.NatGateway[] = [];\n  private readonly privateRouteTables: routeTable.RouteTable[] = [];\n  private readonly azCount: number;\n  private readonly availabilityZones: string[]; // Token as StringList\n  private readonly vpc: vpc.Vpc;\n  public get vpcId(): string {\n    return this.vpc.id;\n  }\n  private readonly _publicSubnets: PublicSubnet[] = [];\n  public get publicSubnets(): ISubnet[] {\n    return this._publicSubnets;\n  }\n  private readonly _privateSubnets: PrivateSubnet[] = [];\n  public get privateSubnets(): ISubnet[] {\n    return this._privateSubnets;\n  }\n  private readonly _dataSubnets: DataSubnet[] = [];\n  public get dataSubnets(): ISubnet[] {\n    return this._dataSubnets;\n  }\n\n  private _dbSubnetGroup?: ISubnetGroup;\n  public get dbSubnetGroup(): ISubnetGroup | undefined {\n    return this._dbSubnetGroup;\n  }\n\n  private _elastiCacheSubnetGroup?: ISubnetGroup;\n  public get elastiCacheSubnetGroup(): ISubnetGroup | undefined {\n    return this._elastiCacheSubnetGroup;\n  }\n\n  private readonly serviceDiscoveryNamespace: serviceDiscoveryPrivateDnsNamespace.ServiceDiscoveryPrivateDnsNamespace;\n  public get serviceDiscoveryNamespaceArn(): string {\n    return this.serviceDiscoveryNamespace.arn;\n  }\n\n  constructor(scope: Construct, id: string, props: SimpleIPv4Props) {\n    super(scope, id, props);\n    this._props = props;\n    this.azCount = this._props.azCount ?? 2;\n    if (this.azCount > 4) {\n      throw new Error(\"azCount must be less than or equal to 4\");\n    }\n\n    this.availabilityZones = this.stack.availabilityZones(this.azCount);\n    this.ipv4CidrBlock = this._props.ipv4CidrBlock;\n    this.vpc = new vpc.Vpc(this, \"Resource\", {\n      cidrBlock: this.ipv4CidrBlock,\n      enableDnsSupport: true,\n      enableDnsHostnames: true,\n    });\n\n    const igw = new internetGateway.InternetGateway(this, \"igw\", {\n      vpcId: this.vpc.id,\n      tags: {\n        Name: `${this.friendlyName}-igw`,\n      },\n    });\n\n    // adopt default route table and add tags\n    new defaultRouteTable.DefaultRouteTable(this, \"DefaultRouteTable\", {\n      defaultRouteTableId: this.vpc.defaultRouteTableId,\n      tags: {\n        Name: `${this.friendlyName}-default-route-table`,\n      },\n      route: [\n        {\n          cidrBlock: \"0.0.0.0/0\",\n          gatewayId: igw.id,\n        },\n      ],\n    });\n\n    this.natGatewayOption =\n      this._props.natGatewayOption ??\n      NatGatewayOption.NAT_PER_AVAILABILITY_ZONE;\n\n    this.createPublicSubnets(Fn.cidrsubnet(this.ipv4CidrBlock, 2, 0));\n    this.createPrivateSubnets(Fn.cidrsubnet(this.ipv4CidrBlock, 2, 1));\n    this.createDataSubnets(Fn.cidrsubnet(this.ipv4CidrBlock, 2, 2));\n\n    this.serviceDiscoveryNamespace =\n      new serviceDiscoveryPrivateDnsNamespace.ServiceDiscoveryPrivateDnsNamespace(\n        this,\n        \"ServiceDiscoveryNamespace\",\n        {\n          name: this._props.internalDomain,\n          vpc: this.vpc.id,\n          description: `Private DNS namespace for ${this.friendlyName}`,\n          tags: {\n            Name: `${this.friendlyName}-service-discovery-namespace`,\n          },\n        },\n      );\n\n    this._outputs = {\n      vpcId: this.vpc.id,\n      publicSubnetIds: this.publicSubnets.map((subnet) => subnet.subnetId),\n      privateSubnetIds: this.privateSubnets.map((subnet) => subnet.subnetId),\n      dataSubnetIds: this.dataSubnets.map((subnet) => subnet.subnetId),\n      // only known at synth time\n      // explicit `null` required to avoid syntax errors when using stringValue && \"undefined\"\n      dbSubnetGroup: Lazy.anyValue({\n        produce: () => this.dbSubnetGroup?.gridUUID ?? null,\n      }),\n      elastiCacheSubnetGroup: Lazy.anyValue({\n        produce: () => this.elastiCacheSubnetGroup?.gridUUID ?? null,\n      }),\n      serviceDiscoveryNamespaceName: this.serviceDiscoveryNamespace.name,\n    };\n  }\n\n  public enableDbSubnetGroup(): void {\n    if (this._dbSubnetGroup) {\n      return;\n    }\n    this._dbSubnetGroup = new DbSubnetGroup(this, \"DbSubnetGroup\", {\n      subnets: this._dataSubnets,\n      tags: {\n        Name: `${this.friendlyName}-db-default-subnet-group`,\n      },\n    });\n  }\n\n  public enableElastiCacheSubnetGroup(): void {\n    if (this._elastiCacheSubnetGroup) {\n      return;\n    }\n    this._elastiCacheSubnetGroup = new ElastiCacheSubnetGroup(\n      this,\n      \"ElastiCacheSubnetGroup\",\n      {\n        subnets: this._dataSubnets,\n        tags: {\n          Name: `${this.friendlyName}-elasticache-default-subnet-group`,\n        },\n      },\n    );\n  }\n\n  private createPublicSubnets(publicIpv4CidrBlock: string) {\n    for (let i = 0; i < this.azCount; i++) {\n      // if SingleNatGateway, only create NAT Gateway for first public subnet\n      const createNatGateway =\n        this.natGatewayOption !== NatGatewayOption.SINGLE_NAT_GATEWAY ||\n        i === 0;\n      const availabilityZone = Fn.element(this.availabilityZones, i);\n      const publicSubnet = new PublicSubnet(this, `PublicSubnet${i}`, {\n        vpc: this.vpc,\n        availabilityZone,\n        ipv4CidrBlock: Fn.cidrsubnet(publicIpv4CidrBlock, 2, i),\n        defaultRouteTableId: this.vpc.defaultRouteTableId,\n        tags: {\n          Name: `${this.friendlyName}-public-subnet-${availabilityZone}`,\n        },\n        createNatGateway,\n      });\n\n      if (createNatGateway) {\n        const gw = publicSubnet.natgateway!;\n        // create route table per NAT gateway\n        this.privateRouteTables.push(\n          new routeTable.RouteTable(this, `PrivateRouteTable${i}`, {\n            vpcId: this.vpc.id,\n            route: [\n              {\n                cidrBlock: \"0.0.0.0/0\",\n                natGatewayId: gw.id,\n              },\n            ],\n            tags: {\n              Name: `${this.friendlyName}-private-route-table-${availabilityZone}`,\n              \"aws-cdk:subnet-name\": \"Public\",\n              \"aws-cdk:subnet-type\": \"Public\",\n              \"kubernetes.io/role/elb\": \"1\",\n            },\n          }),\n        );\n        this.natGateways.push(gw);\n      }\n      this._publicSubnets.push(publicSubnet);\n    }\n  }\n\n  private createPrivateSubnets(privateIpv4CidrBlock: string) {\n    for (let i = 0; i < this.azCount; i++) {\n      const availabilityZone = Fn.element(this.availabilityZones, i);\n      const rtbIdx = this.privateRouteTables.length >= this.azCount ? i : 0;\n      const privateSubnet = new PrivateSubnet(this, `PrivateSubnet${i}`, {\n        vpc: this.vpc,\n        availabilityZone,\n        ipv4CidrBlock: Fn.cidrsubnet(privateIpv4CidrBlock, 2, i),\n        routeTable: this.privateRouteTables[rtbIdx],\n        tags: {\n          Name: `${this.friendlyName}-private-subnet-${availabilityZone}`,\n          \"aws-cdk:subnet-name\": \"Private\",\n          \"aws-cdk:subnet-type\": \"Private\",\n          \"kubernetes.io/role/internal-elb\": \"1\",\n        },\n      });\n      this._privateSubnets.push(privateSubnet);\n    }\n  }\n\n  private createDataSubnets(dataIpv4CidrBlock: string) {\n    for (let i = 0; i < this.azCount; i++) {\n      const availabilityZone = Fn.element(this.availabilityZones, i);\n      const rtbIdx = this.privateRouteTables.length >= this.azCount ? i : 0;\n      const dataSubnet = new DataSubnet(this, `DataSubnet${i}`, {\n        vpc: this.vpc,\n        availabilityZone,\n        ipv4CidrBlock: Fn.cidrsubnet(dataIpv4CidrBlock, 2, i),\n        routeTable: this.privateRouteTables[rtbIdx],\n        tags: {\n          Name: `${this.friendlyName}-data-subnet-${availabilityZone}`,\n          \"aws-cdk:subnet-name\": \"Data\",\n          \"aws-cdk:subnet-type\": \"Isolated\",\n        },\n      });\n      this._dataSubnets.push(dataSubnet);\n    }\n  }\n}\n"]}

package/lib/aws/network/subnet-group.d.ts

@@ -0,0 +1,42 @@
+import { dbSubnetGroup, elasticacheSubnetGroup } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "../aws-construct";
+import { ISubnet } from "./subnet";
+export declare enum SubnetGroupType {
+    /**
+     * RDS and DocDb SubnetGroup
+     */
+    DB = "DB",
+    /**
+     * ElastiCache SubnetGroup
+     */
+    ELASTICACHE = "ELASTICACHE"
+}
+export interface SubnetGroupProps extends AwsConstructProps {
+    readonly subnets: ISubnet[];
+    readonly tags?: Record<string, string>;
+}
+export interface ISubnetGroup extends IAwsConstruct {
+    readonly type: SubnetGroupType;
+    readonly arn: string;
+    readonly subnets: ISubnet[];
+}
+export declare abstract class BaseSubnetGroup extends AwsConstructBase implements ISubnetGroup {
+    readonly type: SubnetGroupType;
+    readonly tags?: Record<string, string>;
+    private readonly _subnets;
+    get subnets(): ISubnet[];
+    abstract get arn(): string;
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, type: SubnetGroupType, props: SubnetGroupProps);
+}
+export declare class DbSubnetGroup extends BaseSubnetGroup {
+    readonly resource: dbSubnetGroup.DbSubnetGroup;
+    get arn(): string;
+    constructor(scope: Construct, id: string, props: SubnetGroupProps);
+}
+export declare class ElastiCacheSubnetGroup extends BaseSubnetGroup {
+    readonly resource: elasticacheSubnetGroup.ElasticacheSubnetGroup;
+    get arn(): string;
+    constructor(scope: Construct, id: string, props: SubnetGroupProps);
+}

package/lib/aws/network/subnet-group.js

@@ -0,0 +1,72 @@
+"use strict";
+var _a, _b, _c;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ElastiCacheSubnetGroup = exports.DbSubnetGroup = exports.BaseSubnetGroup = exports.SubnetGroupType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const aws_construct_1 = require("../aws-construct");
+var SubnetGroupType;
+(function (SubnetGroupType) {
+    /**
+     * RDS and DocDb SubnetGroup
+     */
+    SubnetGroupType["DB"] = "DB";
+    /**
+     * ElastiCache SubnetGroup
+     */
+    SubnetGroupType["ELASTICACHE"] = "ELASTICACHE";
+})(SubnetGroupType || (exports.SubnetGroupType = SubnetGroupType = {}));
+class BaseSubnetGroup extends aws_construct_1.AwsConstructBase {
+    get subnets() {
+        return this._subnets;
+    }
+    get outputs() {
+        return {
+            type: this.type,
+            arn: this.arn,
+            subnets: this.subnets.map((subnet) => subnet.outputs),
+        };
+    }
+    constructor(scope, id, type, props) {
+        super(scope, id, props);
+        this.type = type;
+        this.tags = props.tags;
+        this._subnets = props.subnets;
+    }
+}
+exports.BaseSubnetGroup = BaseSubnetGroup;
+_a = JSII_RTTI_SYMBOL_1;
+BaseSubnetGroup[_a] = { fqn: "terraconstructs.aws.network.BaseSubnetGroup", version: "0.0.8" };
+class DbSubnetGroup extends BaseSubnetGroup {
+    get arn() {
+        return this.resource.arn;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, SubnetGroupType.DB, props);
+        this.resource = new provider_aws_1.dbSubnetGroup.DbSubnetGroup(this, "Resource", {
+            name: this.gridUUID,
+            subnetIds: this.subnets.map((subnet) => subnet.subnetId),
+            tags: this.tags,
+        });
+    }
+}
+exports.DbSubnetGroup = DbSubnetGroup;
+_b = JSII_RTTI_SYMBOL_1;
+DbSubnetGroup[_b] = { fqn: "terraconstructs.aws.network.DbSubnetGroup", version: "0.0.8" };
+class ElastiCacheSubnetGroup extends BaseSubnetGroup {
+    get arn() {
+        return this.resource.arn;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, SubnetGroupType.ELASTICACHE, props);
+        this.resource = new provider_aws_1.elasticacheSubnetGroup.ElasticacheSubnetGroup(this, "Resource", {
+            name: this.gridUUID,
+            subnetIds: this.subnets.map((subnet) => subnet.subnetId),
+            tags: this.tags,
+        });
+    }
+}
+exports.ElastiCacheSubnetGroup = ElastiCacheSubnetGroup;
+_c = JSII_RTTI_SYMBOL_1;
+ElastiCacheSubnetGroup[_c] = { fqn: "terraconstructs.aws.network.ElastiCacheSubnetGroup", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/network/subnet.d.ts

@@ -0,0 +1,95 @@
+import { vpc, subnet, natGateway, routeTable } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "../";
+export declare enum SubnetType {
+    PUBLIC = "PUBLIC",
+    PRIVATE = "PRIVATE",
+    DATA = "DATA"
+}
+export interface BaseSubnetProps extends AwsConstructProps {
+    /**
+     * The VPC to create the subnet into
+     */
+    readonly vpc: vpc.Vpc;
+    /**
+     * The IPv4 CIDR block for the subnet.
+     */
+    readonly ipv4CidrBlock: string;
+    /**
+     * The availability zone for the subnet.
+     */
+    readonly availabilityZone: string;
+    /**
+     * Additional tags for the subnet.
+     *
+     * @default - No additional tags
+     */
+    readonly tags?: Record<string, string>;
+}
+export interface ISubnet extends IAwsConstruct {
+    /**
+     * The VPC ID of the subnet.
+     */
+    readonly vpcId: string;
+    /**
+     * The IPv4 CIDR block for the subnet.
+     */
+    readonly ipv4CidrBlock: string;
+    /**
+     * The availability zone for the subnet.
+     */
+    readonly availabilityZone: string;
+    /**
+     * The subnet ID of the subnet.
+     */
+    readonly subnetId: string;
+}
+export declare abstract class BaseSubnet extends AwsConstructBase implements ISubnet {
+    private readonly type;
+    private readonly _availabilityZone;
+    get availabilityZone(): string;
+    private readonly _subnetId;
+    get subnetId(): string;
+    protected readonly vpc: vpc.Vpc;
+    get vpcId(): string;
+    protected readonly cidr: string;
+    get ipv4CidrBlock(): string;
+    get outputs(): Record<string, any>;
+    readonly resource: subnet.Subnet;
+    constructor(scope: Construct, id: string, type: SubnetType, props: BaseSubnetProps);
+}
+export interface PublicSubnetProps extends BaseSubnetProps {
+    /**
+     * Whether to create a NAT gateway in the subnet.
+     */
+    readonly createNatGateway?: boolean;
+    /**
+     * The EIP allocation ID to use for the NAT gateway.
+     *
+     * @default - A new EIP is created
+     */
+    readonly eipAllocationId?: string;
+    /**
+     * The Route Table ID to associate with the subnet.
+     */
+    readonly defaultRouteTableId: string;
+}
+export declare class PublicSubnet extends BaseSubnet {
+    private readonly natGateway?;
+    private readonly eip?;
+    constructor(scope: Construct, id: string, props: PublicSubnetProps);
+    get natgateway(): natGateway.NatGateway | undefined;
+}
+export interface PrivateSubnetProps extends BaseSubnetProps {
+    readonly routeTable: routeTable.RouteTable;
+}
+export declare class PrivateSubnet extends BaseSubnet {
+    private readonly routeTable;
+    constructor(scope: Construct, id: string, props: PrivateSubnetProps);
+    get routeTableId(): string;
+}
+export declare class DataSubnet extends BaseSubnet {
+    private readonly routeTable;
+    constructor(scope: Construct, id: string, props: PrivateSubnetProps);
+    get routeTableId(): string;
+}