terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/nat.js

@@ -0,0 +1,455 @@
+"use strict";
+var _a, _b, _c, _d, _e;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatInstanceImage = exports.NatInstanceProviderV2 = exports.NatInstanceProvider = exports.NatGatewayProvider = exports.NatProvider = exports.NatTrafficDirection = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/nat.ts
+const cdktf_1 = require("cdktf");
+const connections_1 = require("./connections");
+const instance_1 = require("./instance");
+const instance_types_1 = require("./instance-types");
+const machine_image_1 = require("./machine-image");
+const port_1 = require("./port");
+const security_group_1 = require("./security-group");
+const user_data_1 = require("./user-data");
+const vpc_1 = require("./vpc");
+const iam = require("../iam");
+/**
+ * Direction of traffic to allow all by default.
+ */
+var NatTrafficDirection;
+(function (NatTrafficDirection) {
+    /**
+     * Allow all outbound traffic and disallow all inbound traffic.
+     */
+    NatTrafficDirection["OUTBOUND_ONLY"] = "OUTBOUND_ONLY";
+    /**
+     * Allow all outbound and inbound traffic.
+     */
+    NatTrafficDirection["INBOUND_AND_OUTBOUND"] = "INBOUND_AND_OUTBOUND";
+    /**
+     * Disallow all outbound and inbound traffic.
+     */
+    NatTrafficDirection["NONE"] = "NONE";
+})(NatTrafficDirection || (exports.NatTrafficDirection = NatTrafficDirection = {}));
+/**
+ * NAT providers
+ *
+ * Determines what type of NAT provider to create, either NAT gateways or NAT
+ * instance.
+ *
+ *
+ */
+class NatProvider {
+    /**
+     * Use NAT Gateways to provide NAT services for your VPC
+     *
+     * NAT gateways are managed by AWS.
+     *
+     * @see https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html
+     */
+    static gateway(props = {}) {
+        return new NatGatewayProvider(props);
+    }
+    /**
+     * Use NAT instances to provide NAT services for your VPC
+     *
+     * NAT instances are managed by you, but in return allow more configuration.
+     *
+     * Be aware that instances created using this provider will not be
+     * automatically replaced if they are stopped for any reason. You should implement
+     * your own NatProvider based on AutoScaling groups if you need that.
+     *
+     * @see https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html
+     *
+     * @deprecated use instanceV2. 'instance' is deprecated since NatInstanceProvider
+     * uses a instance image that has reached EOL on Dec 31 2023
+     */
+    static instance(props) {
+        return new NatInstanceProvider(props);
+    }
+    /**
+     * Use NAT instances to provide NAT services for your VPC
+     *
+     * NAT instances are managed by you, but in return allow more configuration.
+     *
+     * Be aware that instances created using this provider will not be
+     * automatically replaced if they are stopped for any reason. You should implement
+     * your own NatProvider based on AutoScaling groups if you need that.
+     *
+     * @see https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html
+     */
+    static instanceV2(props) {
+        return new NatInstanceProviderV2(props);
+    }
+}
+exports.NatProvider = NatProvider;
+_a = JSII_RTTI_SYMBOL_1;
+NatProvider[_a] = { fqn: "terraconstructs.aws.compute.NatProvider", version: "0.0.12" };
+/**
+ * Provider for NAT Gateways
+ */
+class NatGatewayProvider extends NatProvider {
+    constructor(props = {}) {
+        super();
+        this.props = props;
+        this.gateways = new PrefSet();
+    }
+    configureNat(options) {
+        if (this.props.eipAllocationIds != null &&
+            !cdktf_1.Token.isUnresolved(this.props.eipAllocationIds) &&
+            this.props.eipAllocationIds.length < options.natSubnets.length) {
+            throw new Error(`Not enough NAT gateway EIP allocation IDs (${this.props.eipAllocationIds.length} provided) for the requested subnet count (${options.natSubnets.length} needed).`);
+        }
+        // Create the NAT gateways
+        let i = 0;
+        for (const sub of options.natSubnets) {
+            const eipAllocationId = this.props.eipAllocationIds
+                ? pickN(i, this.props.eipAllocationIds)
+                : undefined;
+            const gateway = sub.addNatGateway(eipAllocationId);
+            this.gateways.add(sub.availabilityZone, gateway.id);
+            i++;
+        }
+        // Add routes to them in the private subnets
+        for (const sub of options.privateSubnets) {
+            this.configureSubnet(sub);
+        }
+    }
+    configureSubnet(subnet) {
+        const az = subnet.availabilityZone;
+        const gatewayId = this.gateways.pick(az);
+        subnet.addRoute("DefaultRoute", {
+            routerType: vpc_1.RouterType.NAT_GATEWAY,
+            routerId: gatewayId,
+            enablesInternetConnectivity: true,
+        });
+    }
+    get configuredGateways() {
+        return this.gateways.values().map((x) => ({ az: x[0], gatewayId: x[1] }));
+    }
+}
+exports.NatGatewayProvider = NatGatewayProvider;
+_b = JSII_RTTI_SYMBOL_1;
+NatGatewayProvider[_b] = { fqn: "terraconstructs.aws.compute.NatGatewayProvider", version: "0.0.12" };
+/**
+ * NAT provider which uses NAT Instances
+ *
+ * @deprecated use NatInstanceProviderV2. NatInstanceProvider is deprecated since
+ * the instance image used has reached EOL on Dec 31 2023
+ */
+class NatInstanceProvider extends NatProvider {
+    constructor(props) {
+        super();
+        this.props = props;
+        this.gateways = new PrefSet();
+        if (props.defaultAllowedTraffic !== undefined &&
+            props.allowAllTraffic !== undefined) {
+            throw new Error("Can not specify both of 'defaultAllowedTraffic' and 'defaultAllowedTraffic'; prefer 'defaultAllowedTraffic'");
+        }
+        if (props.keyName && props.keyPair) {
+            throw new Error("Cannot specify both of 'keyName' and 'keyPair'; prefer 'keyPair'");
+        }
+    }
+    configureNat(options) {
+        const defaultDirection = this.props.defaultAllowedTraffic ??
+            ((this.props.allowAllTraffic ?? true)
+                ? NatTrafficDirection.INBOUND_AND_OUTBOUND
+                : NatTrafficDirection.OUTBOUND_ONLY);
+        // Create the NAT instances. They can share a security group and a Role.
+        const machineImage = this.props.machineImage ?? new NatInstanceImage();
+        this._securityGroup =
+            this.props.securityGroup ??
+                new security_group_1.SecurityGroup(options.vpc, "NatSecurityGroup", {
+                    vpc: options.vpc,
+                    description: "Security Group for NAT instances",
+                    allowAllOutbound: isOutboundAllowed(defaultDirection),
+                });
+        this._connections = new connections_1.Connections({
+            securityGroups: [this._securityGroup],
+        });
+        if (isInboundAllowed(defaultDirection)) {
+            this.connections.allowFromAnyIpv4(port_1.Port.allTraffic());
+        }
+        // FIXME: Ideally, NAT instances don't have a role at all, but
+        // 'Instance' does not allow that right now.
+        const role = new iam.Role(options.vpc, "NatRole", {
+            assumedBy: new iam.ServicePrincipal("compute.amazonaws.com"),
+        });
+        for (const sub of options.natSubnets) {
+            const natInstance = new instance_1.Instance(sub, "NatInstance", {
+                instanceType: this.props.instanceType,
+                machineImage,
+                sourceDestCheck: false, // Required for NAT
+                vpc: options.vpc,
+                vpcSubnets: { subnets: [sub] },
+                securityGroup: this._securityGroup,
+                role,
+                keyPair: this.props.keyPair,
+                keyName: this.props.keyName,
+                creditSpecification: this.props.creditSpecification,
+            });
+            // NAT instance routes all traffic, both ways
+            this.gateways.add(sub.availabilityZone, natInstance);
+        }
+        // Add routes to them in the private subnets
+        for (const sub of options.privateSubnets) {
+            this.configureSubnet(sub);
+        }
+    }
+    /**
+     * The Security Group associated with the NAT instances
+     */
+    get securityGroup() {
+        if (!this._securityGroup) {
+            throw new Error("Pass the NatInstanceProvider to a Vpc before accessing 'securityGroup'");
+        }
+        return this._securityGroup;
+    }
+    /**
+     * Manage the Security Groups associated with the NAT instances
+     */
+    get connections() {
+        if (!this._connections) {
+            throw new Error("Pass the NatInstanceProvider to a Vpc before accessing 'connections'");
+        }
+        return this._connections;
+    }
+    get configuredGateways() {
+        return this.gateways
+            .values()
+            .map((x) => ({ az: x[0], gatewayId: x[1].instanceId }));
+    }
+    configureSubnet(subnet) {
+        const az = subnet.availabilityZone;
+        const gatewayInstance = this.gateways.pick(az);
+        // TODO: Terraform provider does not support RouterType.INSTANCE
+        // subnet.addRoute("DefaultRoute", {
+        //   routerType: RouterType.INSTANCE,
+        //   routerId: gatewayInstance.instanceId,
+        //   enablesInternetConnectivity: true,
+        // });
+        // if (!gatewayInstance.primaryNetworkInterfaceId) {
+        //   throw new Error(
+        //     `Primary network interface not found for gateway instance ${gatewayInstance.node.path}`,
+        //   );
+        // }
+        // If there is no primary network interface, the value is ""
+        // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/ec2/ec2_instance.go#L1340
+        subnet.addRoute("DefaultRoute", {
+            routerType: vpc_1.RouterType.NETWORK_INTERFACE,
+            routerId: gatewayInstance.primaryNetworkInterfaceId,
+            enablesInternetConnectivity: true,
+        });
+    }
+}
+exports.NatInstanceProvider = NatInstanceProvider;
+_c = JSII_RTTI_SYMBOL_1;
+NatInstanceProvider[_c] = { fqn: "terraconstructs.aws.compute.NatInstanceProvider", version: "0.0.12" };
+/**
+ * Preferential set
+ *
+ * Picks the value with the given key if available, otherwise distributes
+ * evenly among the available options.
+ */
+class PrefSet {
+    constructor() {
+        this.map = {};
+        this.vals = new Array();
+        this.next = 0;
+    }
+    add(pref, value) {
+        this.map[pref] = value;
+        this.vals.push([pref, value]);
+    }
+    pick(pref) {
+        if (this.vals.length === 0) {
+            throw new Error("Cannot pick, set is empty");
+        }
+        if (pref in this.map) {
+            return this.map[pref];
+        }
+        return this.vals[this.next++ % this.vals.length][1];
+    }
+    values() {
+        return this.vals;
+    }
+}
+/**
+ * Modern NAT provider which uses NAT Instances.
+ * The instance uses Amazon Linux 2023 as the operating system.
+ */
+class NatInstanceProviderV2 extends NatProvider {
+    /**
+     * Array of gateway instances spawned by the provider after internal configuration
+     */
+    get gatewayInstances() {
+        return this.gateways.values().map(([, instance]) => instance);
+    }
+    constructor(props) {
+        super();
+        this.props = props;
+        this.gateways = new PrefSet();
+        if (props.defaultAllowedTraffic !== undefined &&
+            props.allowAllTraffic !== undefined) {
+            throw new Error("Can not specify both of 'defaultAllowedTraffic' and 'defaultAllowedTraffic'; prefer 'defaultAllowedTraffic'");
+        }
+        if (props.keyName && props.keyPair) {
+            throw new Error("Cannot specify both of 'keyName' and 'keyPair'; prefer 'keyPair'");
+        }
+    }
+    configureNat(options) {
+        const defaultDirection = this.props.defaultAllowedTraffic ??
+            ((this.props.allowAllTraffic ?? true)
+                ? NatTrafficDirection.INBOUND_AND_OUTBOUND
+                : NatTrafficDirection.OUTBOUND_ONLY);
+        // Create the NAT instances. They can share a security group and a Role. The new NAT instance created uses latest
+        // Amazon Linux 2023 image. This is important since the original NatInstanceProvider uses an instance image that has
+        // reached EOL on Dec 31 2023
+        const machineImage = this.props.machineImage ||
+            new machine_image_1.AmazonLinuxImage({
+                generation: machine_image_1.AmazonLinuxGeneration.AMAZON_LINUX_2023,
+                cpuType: this.props.instanceType.architecture == instance_types_1.InstanceArchitecture.ARM_64
+                    ? machine_image_1.AmazonLinuxCpuType.ARM_64
+                    : undefined,
+            });
+        this._securityGroup =
+            this.props.securityGroup ??
+                new security_group_1.SecurityGroup(options.vpc, "NatSecurityGroup", {
+                    vpc: options.vpc,
+                    description: "Security Group for NAT instances",
+                    allowAllOutbound: isOutboundAllowed(defaultDirection),
+                });
+        this._connections = new connections_1.Connections({
+            securityGroups: [this._securityGroup],
+        });
+        if (isInboundAllowed(defaultDirection)) {
+            this.connections.allowFromAnyIpv4(port_1.Port.allTraffic());
+        }
+        let userData = this.props.userData;
+        if (!userData) {
+            userData = user_data_1.UserData.forLinux();
+            userData.addCommands(...NatInstanceProviderV2.DEFAULT_USER_DATA_COMMANDS);
+        }
+        for (const sub of options.natSubnets) {
+            const natInstance = new instance_1.Instance(sub, "NatInstance", {
+                instanceType: this.props.instanceType,
+                machineImage,
+                sourceDestCheck: false, // Required for NAT
+                vpc: options.vpc,
+                vpcSubnets: { subnets: [sub] },
+                associatePublicIpAddress: this.props.associatePublicIpAddress,
+                securityGroup: this._securityGroup,
+                keyPair: this.props.keyPair,
+                keyName: this.props.keyName,
+                creditSpecification: this.props.creditSpecification,
+                userData,
+            });
+            // NAT instance routes all traffic, both ways
+            this.gateways.add(sub.availabilityZone, natInstance);
+        }
+        // Add routes to them in the private subnets
+        for (const sub of options.privateSubnets) {
+            this.configureSubnet(sub);
+        }
+    }
+    /**
+     * The Security Group associated with the NAT instances
+     */
+    get securityGroup() {
+        if (!this._securityGroup) {
+            throw new Error("Pass the NatInstanceProvider to a Vpc before accessing 'securityGroup'");
+        }
+        return this._securityGroup;
+    }
+    /**
+     * Manage the Security Groups associated with the NAT instances
+     */
+    get connections() {
+        if (!this._connections) {
+            throw new Error("Pass the NatInstanceProvider to a Vpc before accessing 'connections'");
+        }
+        return this._connections;
+    }
+    get configuredGateways() {
+        return this.gateways
+            .values()
+            .map((x) => ({ az: x[0], gatewayId: x[1].instanceId }));
+    }
+    configureSubnet(subnet) {
+        const az = subnet.availabilityZone;
+        const gatewayInstance = this.gateways.pick(az);
+        // TODO: Terraform provider does not support RouterType.INSTANCE
+        // subnet.addRoute("DefaultRoute", {
+        //   routerType: RouterType.INSTANCE,
+        //   routerId: gatewayInstance.instanceId,
+        //   enablesInternetConnectivity: true,
+        // });
+        // if (!gatewayInstance.primaryNetworkInterface) {
+        //   throw new Error(
+        //     `Primary network interface not found for gateway instance ${gatewayInstance.node.path}`,
+        //   );
+        // }
+        // If there is no primary network interface, the value is ""
+        // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/ec2/ec2_instance.go#L1340
+        subnet.addRoute("DefaultRoute", {
+            routerType: vpc_1.RouterType.NETWORK_INTERFACE,
+            routerId: gatewayInstance.primaryNetworkInterfaceId,
+            enablesInternetConnectivity: true,
+        });
+    }
+}
+exports.NatInstanceProviderV2 = NatInstanceProviderV2;
+_d = JSII_RTTI_SYMBOL_1;
+NatInstanceProviderV2[_d] = { fqn: "terraconstructs.aws.compute.NatInstanceProviderV2", version: "0.0.12" };
+/**
+ * Amazon Linux 2023 NAT instance user data commands
+ * Enable iptables on the instance, enable persistent IP forwarding, configure NAT on instance
+ * @see https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html#create-nat-ami
+ */
+NatInstanceProviderV2.DEFAULT_USER_DATA_COMMANDS = [
+    "yum install iptables-services -y",
+    "systemctl enable iptables",
+    "systemctl start iptables",
+    'echo "net.ipv4.ip_forward=1" > /etc/sysctl.d/custom-ip-forwarding.conf',
+    "sudo sysctl -p /etc/sysctl.d/custom-ip-forwarding.conf",
+    "sudo /sbin/iptables -t nat -A POSTROUTING -o $(route | awk '/^default/{print $NF}') -j MASQUERADE",
+    "sudo /sbin/iptables -F FORWARD",
+    "sudo service iptables save",
+];
+/**
+ * Machine image representing the latest NAT instance image
+ *
+ *
+ */
+class NatInstanceImage extends machine_image_1.LookupMachineImage {
+    constructor() {
+        super({
+            name: "amzn-ami-vpc-nat-*",
+            owners: ["amazon"],
+        });
+    }
+}
+exports.NatInstanceImage = NatInstanceImage;
+_e = JSII_RTTI_SYMBOL_1;
+NatInstanceImage[_e] = { fqn: "terraconstructs.aws.compute.NatInstanceImage", version: "0.0.12" };
+function isOutboundAllowed(direction) {
+    return (direction === NatTrafficDirection.INBOUND_AND_OUTBOUND ||
+        direction === NatTrafficDirection.OUTBOUND_ONLY);
+}
+function isInboundAllowed(direction) {
+    return direction === NatTrafficDirection.INBOUND_AND_OUTBOUND;
+}
+/**
+ * Token-aware pick index function
+ */
+function pickN(i, xs) {
+    if (cdktf_1.Token.isUnresolved(xs)) {
+        return cdktf_1.Fn.element(xs, i);
+    }
+    if (i >= xs.length) {
+        throw new Error(`Cannot get element ${i} from ${xs}`);
+    }
+    return xs[i];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"nat.js","sourceRoot":"","sources":["../../../src/aws/compute/nat.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/nat.ts\n\nimport { Fn, Token } from \"cdktf\";\nimport { Connections, IConnectable } from \"./connections\";\nimport { Instance } from \"./instance\";\nimport { InstanceArchitecture, InstanceType } from \"./instance-types\";\nimport { IKeyPair } from \"./key-pair\";\nimport { CpuCredits } from \"./launch-template\";\nimport {\n  AmazonLinuxCpuType,\n  AmazonLinuxGeneration,\n  AmazonLinuxImage,\n  IMachineImage,\n  LookupMachineImage,\n} from \"./machine-image\";\nimport { Port } from \"./port\";\nimport { ISecurityGroup, SecurityGroup } from \"./security-group\";\nimport { UserData } from \"./user-data\";\nimport { PrivateSubnet, PublicSubnet, RouterType, Vpc } from \"./vpc\";\nimport * as iam from \"../iam\";\n\n/**\n * Direction of traffic to allow all by default.\n */\nexport enum NatTrafficDirection {\n  /**\n   * Allow all outbound traffic and disallow all inbound traffic.\n   */\n  OUTBOUND_ONLY = \"OUTBOUND_ONLY\",\n\n  /**\n   * Allow all outbound and inbound traffic.\n   */\n  INBOUND_AND_OUTBOUND = \"INBOUND_AND_OUTBOUND\",\n\n  /**\n   * Disallow all outbound and inbound traffic.\n   */\n  NONE = \"NONE\",\n}\n\n/**\n * Pair represents a gateway created by NAT Provider\n */\nexport interface GatewayConfig {\n  /**\n   * Availability Zone\n   */\n  readonly az: string;\n\n  /**\n   * Identity of gateway spawned by the provider\n   */\n  readonly gatewayId: string;\n}\n\n/**\n * NAT providers\n *\n * Determines what type of NAT provider to create, either NAT gateways or NAT\n * instance.\n *\n *\n */\nexport abstract class NatProvider {\n  /**\n   * Use NAT Gateways to provide NAT services for your VPC\n   *\n   * NAT gateways are managed by AWS.\n   *\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/vpc-nat-gateway.html\n   */\n  public static gateway(props: NatGatewayProps = {}): NatProvider {\n    return new NatGatewayProvider(props);\n  }\n\n  /**\n   * Use NAT instances to provide NAT services for your VPC\n   *\n   * NAT instances are managed by you, but in return allow more configuration.\n   *\n   * Be aware that instances created using this provider will not be\n   * automatically replaced if they are stopped for any reason. You should implement\n   * your own NatProvider based on AutoScaling groups if you need that.\n   *\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html\n   *\n   * @deprecated use instanceV2. 'instance' is deprecated since NatInstanceProvider\n   * uses a instance image that has reached EOL on Dec 31 2023\n   */\n  public static instance(props: NatInstanceProps): NatInstanceProvider {\n    return new NatInstanceProvider(props);\n  }\n\n  /**\n   * Use NAT instances to provide NAT services for your VPC\n   *\n   * NAT instances are managed by you, but in return allow more configuration.\n   *\n   * Be aware that instances created using this provider will not be\n   * automatically replaced if they are stopped for any reason. You should implement\n   * your own NatProvider based on AutoScaling groups if you need that.\n   *\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html\n   */\n  public static instanceV2(props: NatInstanceProps): NatInstanceProviderV2 {\n    return new NatInstanceProviderV2(props);\n  }\n\n  /**\n   * Return list of gateways spawned by the provider\n   */\n  public abstract readonly configuredGateways: GatewayConfig[];\n\n  /**\n   * Called by the VPC to configure NAT\n   *\n   * Don't call this directly, the VPC will call it automatically.\n   */\n  public abstract configureNat(options: ConfigureNatOptions): void;\n\n  /**\n   * Configures subnet with the gateway\n   *\n   * Don't call this directly, the VPC will call it automatically.\n   */\n  public abstract configureSubnet(subnet: PrivateSubnet): void;\n}\n\n/**\n * Options passed by the VPC when NAT needs to be configured\n *\n *\n */\nexport interface ConfigureNatOptions {\n  /**\n   * The VPC we're configuring NAT for\n   */\n  readonly vpc: Vpc;\n\n  /**\n   * The public subnets where the NAT providers need to be placed\n   */\n  readonly natSubnets: PublicSubnet[];\n\n  /**\n   * The private subnets that need to route through the NAT providers.\n   *\n   * There may be more private subnets than public subnets with NAT providers.\n   */\n  readonly privateSubnets: PrivateSubnet[];\n}\n\n/**\n * Properties for a NAT gateway\n *\n */\nexport interface NatGatewayProps {\n  /**\n   * EIP allocation IDs for the NAT gateways\n   *\n   * @default - No fixed EIPs allocated for the NAT gateways\n   */\n  readonly eipAllocationIds?: string[];\n}\n\n/**\n * Properties for a NAT instance\n *\n *\n */\nexport interface NatInstanceProps {\n  /**\n   * The machine image (AMI) to use\n   *\n   * By default, will do an AMI lookup for the latest NAT instance image.\n   *\n   * If you have a specific AMI ID you want to use, pass a `GenericLinuxImage`. For example:\n   *\n   * ```ts\n   * compute.NatProvider.instance({\n   *   instanceType: new compute.InstanceType('t3.micro'),\n   *   machineImage: new compute.GenericLinuxImage({\n   *     'us-east-2': 'ami-0f9c61b5a562a16af'\n   *   })\n   * })\n   * ```\n   *\n   * @default - Latest NAT instance image\n   */\n  readonly machineImage?: IMachineImage;\n\n  /**\n   * Instance type of the NAT instance\n   */\n  readonly instanceType: InstanceType;\n\n  /**\n   * Whether to associate a public IP address to the primary network interface attached to this instance.\n   *\n   * @default undefined - No public IP address associated\n   */\n  readonly associatePublicIpAddress?: boolean;\n\n  /**\n   * Name of SSH keypair to grant access to instance\n   *\n   * @default - No SSH access will be possible.\n   * @deprecated - Use `keyPair` instead - https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#using-an-existing-ec2-key-pair\n   */\n  readonly keyName?: string;\n\n  /**\n   * The SSH keypair to grant access to the instance.\n   *\n   * @default - No SSH access will be possible.\n   */\n  readonly keyPair?: IKeyPair;\n\n  /**\n   * Security Group for NAT instances\n   *\n   * @default - A new security group will be created\n   * @deprecated - Cannot create a new security group before the VPC is created,\n   * and cannot create the VPC without the NAT provider.\n   * Set {@link defaultAllowedTraffic} to {@link NatTrafficDirection.NONE}\n   * and use {@link NatInstanceProviderV2.gatewayInstances} to retrieve\n   * the instances on the fly and add security groups\n   *\n   * @example\n   * const natGatewayProvider = compute.NatProvider.instanceV2({\n   *   instanceType: new compute.InstanceType('t3.small'),\n   *   defaultAllowedTraffic: compute.NatTrafficDirection.NONE,\n   * });\n   * const vpc = new compute.Vpc(this, 'Vpc', { natGatewayProvider });\n   *\n   * const securityGroup = new compute.SecurityGroup(this, 'SecurityGroup', {\n   *   vpc,\n   *   allowAllOutbound: false,\n   * });\n   * securityGroup.addEgressRule(compute.Peer.anyIpv4(), compute.Port.tcp(443));\n   * for (const gatewayInstance of natGatewayProvider.gatewayInstances) {\n   *    gatewayInstance.addSecurityGroup(securityGroup);\n   * }\n   */\n  readonly securityGroup?: ISecurityGroup;\n\n  /**\n   * Allow all inbound traffic through the NAT instance\n   *\n   * If you set this to false, you must configure the NAT instance's security\n   * groups in another way, either by passing in a fully configured Security\n   * Group using the `securityGroup` property, or by configuring it using the\n   * `.securityGroup` or `.connections` members after passing the NAT Instance\n   * Provider to a Vpc.\n   *\n   * @default true\n   * @deprecated - Use `defaultAllowedTraffic`.\n   */\n  readonly allowAllTraffic?: boolean;\n\n  /**\n   * Direction to allow all traffic through the NAT instance by default.\n   *\n   * By default, inbound and outbound traffic is allowed.\n   *\n   * If you set this to another value than INBOUND_AND_OUTBOUND, you must\n   * configure the NAT instance's security groups in another way, either by\n   * passing in a fully configured Security Group using the `securityGroup`\n   * property, or by configuring it using the `.securityGroup` or\n   * `.connections` members after passing the NAT Instance Provider to a Vpc.\n   *\n   * @default NatTrafficDirection.INBOUND_AND_OUTBOUND\n   */\n  readonly defaultAllowedTraffic?: NatTrafficDirection;\n\n  /**\n   * Specifying the CPU credit type for burstable EC2 instance types (T2, T3, T3a, etc).\n   * The unlimited CPU credit option is not supported for T3 instances with dedicated host (`host`) tenancy.\n   *\n   * @default - T2 instances are standard, while T3, T4g, and T3a instances are unlimited.\n   */\n  readonly creditSpecification?: CpuCredits;\n\n  /**\n   * Custom user data to run on the NAT instances\n   *\n   * @default UserData.forLinux().addCommands(...NatInstanceProviderV2.DEFAULT_USER_DATA_COMMANDS);  - Appropriate user data commands to initialize and configure the NAT instances\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html#create-nat-ami\n   */\n  readonly userData?: UserData;\n}\n\n/**\n * Provider for NAT Gateways\n */\nexport class NatGatewayProvider extends NatProvider {\n  private gateways: PrefSet<string> = new PrefSet<string>();\n\n  constructor(private readonly props: NatGatewayProps = {}) {\n    super();\n  }\n\n  public configureNat(options: ConfigureNatOptions) {\n    if (\n      this.props.eipAllocationIds != null &&\n      !Token.isUnresolved(this.props.eipAllocationIds) &&\n      this.props.eipAllocationIds.length < options.natSubnets.length\n    ) {\n      throw new Error(\n        `Not enough NAT gateway EIP allocation IDs (${this.props.eipAllocationIds.length} provided) for the requested subnet count (${options.natSubnets.length} needed).`,\n      );\n    }\n\n    // Create the NAT gateways\n    let i = 0;\n    for (const sub of options.natSubnets) {\n      const eipAllocationId = this.props.eipAllocationIds\n        ? pickN(i, this.props.eipAllocationIds)\n        : undefined;\n      const gateway = sub.addNatGateway(eipAllocationId);\n      this.gateways.add(sub.availabilityZone, gateway.id);\n      i++;\n    }\n\n    // Add routes to them in the private subnets\n    for (const sub of options.privateSubnets) {\n      this.configureSubnet(sub);\n    }\n  }\n\n  public configureSubnet(subnet: PrivateSubnet) {\n    const az = subnet.availabilityZone;\n    const gatewayId = this.gateways.pick(az);\n    subnet.addRoute(\"DefaultRoute\", {\n      routerType: RouterType.NAT_GATEWAY,\n      routerId: gatewayId,\n      enablesInternetConnectivity: true,\n    });\n  }\n\n  public get configuredGateways(): GatewayConfig[] {\n    return this.gateways.values().map((x) => ({ az: x[0], gatewayId: x[1] }));\n  }\n}\n\n/**\n * NAT provider which uses NAT Instances\n *\n * @deprecated use NatInstanceProviderV2. NatInstanceProvider is deprecated since\n * the instance image used has reached EOL on Dec 31 2023\n */\nexport class NatInstanceProvider extends NatProvider implements IConnectable {\n  private gateways: PrefSet<Instance> = new PrefSet<Instance>();\n  private _securityGroup?: ISecurityGroup;\n  private _connections?: Connections;\n\n  constructor(private readonly props: NatInstanceProps) {\n    super();\n\n    if (\n      props.defaultAllowedTraffic !== undefined &&\n      props.allowAllTraffic !== undefined\n    ) {\n      throw new Error(\n        \"Can not specify both of 'defaultAllowedTraffic' and 'defaultAllowedTraffic'; prefer 'defaultAllowedTraffic'\",\n      );\n    }\n\n    if (props.keyName && props.keyPair) {\n      throw new Error(\n        \"Cannot specify both of 'keyName' and 'keyPair'; prefer 'keyPair'\",\n      );\n    }\n  }\n\n  public configureNat(options: ConfigureNatOptions) {\n    const defaultDirection =\n      this.props.defaultAllowedTraffic ??\n      ((this.props.allowAllTraffic ?? true)\n        ? NatTrafficDirection.INBOUND_AND_OUTBOUND\n        : NatTrafficDirection.OUTBOUND_ONLY);\n\n    // Create the NAT instances. They can share a security group and a Role.\n    const machineImage = this.props.machineImage ?? new NatInstanceImage();\n    this._securityGroup =\n      this.props.securityGroup ??\n      new SecurityGroup(options.vpc, \"NatSecurityGroup\", {\n        vpc: options.vpc,\n        description: \"Security Group for NAT instances\",\n        allowAllOutbound: isOutboundAllowed(defaultDirection),\n      });\n    this._connections = new Connections({\n      securityGroups: [this._securityGroup],\n    });\n\n    if (isInboundAllowed(defaultDirection)) {\n      this.connections.allowFromAnyIpv4(Port.allTraffic());\n    }\n\n    // FIXME: Ideally, NAT instances don't have a role at all, but\n    // 'Instance' does not allow that right now.\n    const role = new iam.Role(options.vpc, \"NatRole\", {\n      assumedBy: new iam.ServicePrincipal(\"compute.amazonaws.com\"),\n    });\n\n    for (const sub of options.natSubnets) {\n      const natInstance = new Instance(sub, \"NatInstance\", {\n        instanceType: this.props.instanceType,\n        machineImage,\n        sourceDestCheck: false, // Required for NAT\n        vpc: options.vpc,\n        vpcSubnets: { subnets: [sub] },\n        securityGroup: this._securityGroup,\n        role,\n        keyPair: this.props.keyPair,\n        keyName: this.props.keyName,\n        creditSpecification: this.props.creditSpecification,\n      });\n      // NAT instance routes all traffic, both ways\n      this.gateways.add(sub.availabilityZone, natInstance);\n    }\n\n    // Add routes to them in the private subnets\n    for (const sub of options.privateSubnets) {\n      this.configureSubnet(sub);\n    }\n  }\n\n  /**\n   * The Security Group associated with the NAT instances\n   */\n  public get securityGroup(): ISecurityGroup {\n    if (!this._securityGroup) {\n      throw new Error(\n        \"Pass the NatInstanceProvider to a Vpc before accessing 'securityGroup'\",\n      );\n    }\n    return this._securityGroup;\n  }\n\n  /**\n   * Manage the Security Groups associated with the NAT instances\n   */\n  public get connections(): Connections {\n    if (!this._connections) {\n      throw new Error(\n        \"Pass the NatInstanceProvider to a Vpc before accessing 'connections'\",\n      );\n    }\n    return this._connections;\n  }\n\n  public get configuredGateways(): GatewayConfig[] {\n    return this.gateways\n      .values()\n      .map((x) => ({ az: x[0], gatewayId: x[1].instanceId }));\n  }\n\n  public configureSubnet(subnet: PrivateSubnet) {\n    const az = subnet.availabilityZone;\n    const gatewayInstance = this.gateways.pick(az);\n    // TODO: Terraform provider does not support RouterType.INSTANCE\n    // subnet.addRoute(\"DefaultRoute\", {\n    //   routerType: RouterType.INSTANCE,\n    //   routerId: gatewayInstance.instanceId,\n    //   enablesInternetConnectivity: true,\n    // });\n    // if (!gatewayInstance.primaryNetworkInterfaceId) {\n    //   throw new Error(\n    //     `Primary network interface not found for gateway instance ${gatewayInstance.node.path}`,\n    //   );\n    // }\n    // If there is no primary network interface, the value is \"\"\n    // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/ec2/ec2_instance.go#L1340\n    subnet.addRoute(\"DefaultRoute\", {\n      routerType: RouterType.NETWORK_INTERFACE,\n      routerId: gatewayInstance.primaryNetworkInterfaceId,\n      enablesInternetConnectivity: true,\n    });\n  }\n}\n\n/**\n * Preferential set\n *\n * Picks the value with the given key if available, otherwise distributes\n * evenly among the available options.\n */\nclass PrefSet<A> {\n  private readonly map: Record<string, A> = {};\n  private readonly vals = new Array<[string, A]>();\n  private next: number = 0;\n\n  public add(pref: string, value: A) {\n    this.map[pref] = value;\n    this.vals.push([pref, value]);\n  }\n\n  public pick(pref: string): A {\n    if (this.vals.length === 0) {\n      throw new Error(\"Cannot pick, set is empty\");\n    }\n\n    if (pref in this.map) {\n      return this.map[pref];\n    }\n    return this.vals[this.next++ % this.vals.length][1];\n  }\n\n  public values(): Array<[string, A]> {\n    return this.vals;\n  }\n}\n\n/**\n * Modern NAT provider which uses NAT Instances.\n * The instance uses Amazon Linux 2023 as the operating system.\n */\nexport class NatInstanceProviderV2 extends NatProvider implements IConnectable {\n  /**\n   * Amazon Linux 2023 NAT instance user data commands\n   * Enable iptables on the instance, enable persistent IP forwarding, configure NAT on instance\n   * @see https://docs.aws.amazon.com/vpc/latest/userguide/VPC_NAT_Instance.html#create-nat-ami\n   */\n  public static readonly DEFAULT_USER_DATA_COMMANDS = [\n    \"yum install iptables-services -y\",\n    \"systemctl enable iptables\",\n    \"systemctl start iptables\",\n    'echo \"net.ipv4.ip_forward=1\" > /etc/sysctl.d/custom-ip-forwarding.conf',\n    \"sudo sysctl -p /etc/sysctl.d/custom-ip-forwarding.conf\",\n    \"sudo /sbin/iptables -t nat -A POSTROUTING -o $(route | awk '/^default/{print $NF}') -j MASQUERADE\",\n    \"sudo /sbin/iptables -F FORWARD\",\n    \"sudo service iptables save\",\n  ];\n\n  private gateways: PrefSet<Instance> = new PrefSet<Instance>();\n  private _securityGroup?: ISecurityGroup;\n  private _connections?: Connections;\n\n  /**\n   * Array of gateway instances spawned by the provider after internal configuration\n   */\n  public get gatewayInstances(): Instance[] {\n    return this.gateways.values().map(([, instance]) => instance);\n  }\n\n  constructor(private readonly props: NatInstanceProps) {\n    super();\n\n    if (\n      props.defaultAllowedTraffic !== undefined &&\n      props.allowAllTraffic !== undefined\n    ) {\n      throw new Error(\n        \"Can not specify both of 'defaultAllowedTraffic' and 'defaultAllowedTraffic'; prefer 'defaultAllowedTraffic'\",\n      );\n    }\n\n    if (props.keyName && props.keyPair) {\n      throw new Error(\n        \"Cannot specify both of 'keyName' and 'keyPair'; prefer 'keyPair'\",\n      );\n    }\n  }\n\n  public configureNat(options: ConfigureNatOptions) {\n    const defaultDirection =\n      this.props.defaultAllowedTraffic ??\n      ((this.props.allowAllTraffic ?? true)\n        ? NatTrafficDirection.INBOUND_AND_OUTBOUND\n        : NatTrafficDirection.OUTBOUND_ONLY);\n\n    // Create the NAT instances. They can share a security group and a Role. The new NAT instance created uses latest\n    // Amazon Linux 2023 image. This is important since the original NatInstanceProvider uses an instance image that has\n    // reached EOL on Dec 31 2023\n    const machineImage =\n      this.props.machineImage ||\n      new AmazonLinuxImage({\n        generation: AmazonLinuxGeneration.AMAZON_LINUX_2023,\n        cpuType:\n          this.props.instanceType.architecture == InstanceArchitecture.ARM_64\n            ? AmazonLinuxCpuType.ARM_64\n            : undefined,\n      });\n    this._securityGroup =\n      this.props.securityGroup ??\n      new SecurityGroup(options.vpc, \"NatSecurityGroup\", {\n        vpc: options.vpc,\n        description: \"Security Group for NAT instances\",\n        allowAllOutbound: isOutboundAllowed(defaultDirection),\n      });\n    this._connections = new Connections({\n      securityGroups: [this._securityGroup],\n    });\n\n    if (isInboundAllowed(defaultDirection)) {\n      this.connections.allowFromAnyIpv4(Port.allTraffic());\n    }\n\n    let userData = this.props.userData;\n    if (!userData) {\n      userData = UserData.forLinux();\n      userData.addCommands(...NatInstanceProviderV2.DEFAULT_USER_DATA_COMMANDS);\n    }\n\n    for (const sub of options.natSubnets) {\n      const natInstance = new Instance(sub, \"NatInstance\", {\n        instanceType: this.props.instanceType,\n        machineImage,\n        sourceDestCheck: false, // Required for NAT\n        vpc: options.vpc,\n        vpcSubnets: { subnets: [sub] },\n        associatePublicIpAddress: this.props.associatePublicIpAddress,\n        securityGroup: this._securityGroup,\n        keyPair: this.props.keyPair,\n        keyName: this.props.keyName,\n        creditSpecification: this.props.creditSpecification,\n        userData,\n      });\n      // NAT instance routes all traffic, both ways\n      this.gateways.add(sub.availabilityZone, natInstance);\n    }\n\n    // Add routes to them in the private subnets\n    for (const sub of options.privateSubnets) {\n      this.configureSubnet(sub);\n    }\n  }\n\n  /**\n   * The Security Group associated with the NAT instances\n   */\n  public get securityGroup(): ISecurityGroup {\n    if (!this._securityGroup) {\n      throw new Error(\n        \"Pass the NatInstanceProvider to a Vpc before accessing 'securityGroup'\",\n      );\n    }\n    return this._securityGroup;\n  }\n\n  /**\n   * Manage the Security Groups associated with the NAT instances\n   */\n  public get connections(): Connections {\n    if (!this._connections) {\n      throw new Error(\n        \"Pass the NatInstanceProvider to a Vpc before accessing 'connections'\",\n      );\n    }\n    return this._connections;\n  }\n\n  public get configuredGateways(): GatewayConfig[] {\n    return this.gateways\n      .values()\n      .map((x) => ({ az: x[0], gatewayId: x[1].instanceId }));\n  }\n\n  public configureSubnet(subnet: PrivateSubnet) {\n    const az = subnet.availabilityZone;\n    const gatewayInstance = this.gateways.pick(az);\n    // TODO: Terraform provider does not support RouterType.INSTANCE\n    // subnet.addRoute(\"DefaultRoute\", {\n    //   routerType: RouterType.INSTANCE,\n    //   routerId: gatewayInstance.instanceId,\n    //   enablesInternetConnectivity: true,\n    // });\n    // if (!gatewayInstance.primaryNetworkInterface) {\n    //   throw new Error(\n    //     `Primary network interface not found for gateway instance ${gatewayInstance.node.path}`,\n    //   );\n    // }\n    // If there is no primary network interface, the value is \"\"\n    // https://github.com/hashicorp/terraform-provider-aws/blob/v5.88.0/internal/service/ec2/ec2_instance.go#L1340\n    subnet.addRoute(\"DefaultRoute\", {\n      routerType: RouterType.NETWORK_INTERFACE,\n      routerId: gatewayInstance.primaryNetworkInterfaceId,\n      enablesInternetConnectivity: true,\n    });\n  }\n}\n\n/**\n * Machine image representing the latest NAT instance image\n *\n *\n */\nexport class NatInstanceImage extends LookupMachineImage {\n  constructor() {\n    super({\n      name: \"amzn-ami-vpc-nat-*\",\n      owners: [\"amazon\"],\n    });\n  }\n}\n\nfunction isOutboundAllowed(direction: NatTrafficDirection) {\n  return (\n    direction === NatTrafficDirection.INBOUND_AND_OUTBOUND ||\n    direction === NatTrafficDirection.OUTBOUND_ONLY\n  );\n}\n\nfunction isInboundAllowed(direction: NatTrafficDirection) {\n  return direction === NatTrafficDirection.INBOUND_AND_OUTBOUND;\n}\n\n/**\n * Token-aware pick index function\n */\nfunction pickN(i: number, xs: string[]) {\n  if (Token.isUnresolved(xs)) {\n    return Fn.element(xs, i);\n  }\n\n  if (i >= xs.length) {\n    throw new Error(`Cannot get element ${i} from ${xs}`);\n  }\n\n  return xs[i];\n}\n"]}