terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/aspects/require-imdsv2-aspect.js

@@ -0,0 +1,106 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LaunchTemplateRequireImdsv2Aspect = exports.InstanceRequireImdsv2Aspect = 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/aspects/require-imdsv2-aspect.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_stack_1 = require("../../aws-stack");
+const instance_1 = require("../instance");
+const launch_template_1 = require("../launch-template");
+/**
+ * Base class for Aspect that makes IMDSv2 required.
+ */
+class RequireImdsv2Aspect {
+    constructor(props) {
+        this.suppressWarnings = props?.suppressWarnings ?? false;
+    }
+    /**
+     * Adds a warning annotation to a node, unless `suppressWarnings` is true.
+     *
+     * @param node The scope to add the warning to.
+     * @param message The warning message.
+     */
+    warn(node, message) {
+        if (this.suppressWarnings !== true) {
+            // `@aws-cdk/aws-ec2:imdsv2${RequireImdsv2Aspect.name}`,
+            cdktf_1.Annotations.of(node).addWarning(`${RequireImdsv2Aspect.name} failed on node ${node.node.id}: ${message}`);
+        }
+    }
+}
+/**
+ * Aspect that applies IMDS configuration on EC2 Instance constructs.
+ *
+ * This aspect configures IMDS on an EC2 instance by creating a Launch Template with the
+ * IMDS configuration and associating that Launch Template with the instance. If an Instance
+ * is already associated with a Launch Template, a warning will (optionally) be added to the
+ * construct node and it will be skipped.
+ *
+ * To cover Instances already associated with Launch Templates, use `LaunchTemplateImdsAspect`.
+ */
+class InstanceRequireImdsv2Aspect extends RequireImdsv2Aspect {
+    constructor(props) {
+        super(props);
+        this.suppressLaunchTemplateWarning =
+            props?.suppressLaunchTemplateWarning ?? false;
+    }
+    visit(node) {
+        if (!(node instanceof instance_1.Instance)) {
+            return;
+        }
+        if (node.instance.launchTemplateInput !== undefined) {
+            this.warn(node, "Cannot toggle IMDSv1 because this Instance is associated with an existing Launch Template.");
+            return;
+        }
+        const lt = new provider_aws_1.launchTemplate.LaunchTemplate(node, "LaunchTemplate", {
+            metadataOptions: {
+                httpTokens: "required",
+            },
+        });
+        lt.name = aws_stack_1.AwsStack.uniqueId(lt);
+        node.instance.putLaunchTemplate({
+            name: lt.name,
+            version: lt.latestVersion.toString(),
+        });
+    }
+    warn(node, message) {
+        if (this.suppressLaunchTemplateWarning !== true) {
+            super.warn(node, message);
+        }
+    }
+}
+exports.InstanceRequireImdsv2Aspect = InstanceRequireImdsv2Aspect;
+_a = JSII_RTTI_SYMBOL_1;
+InstanceRequireImdsv2Aspect[_a] = { fqn: "terraconstructs.aws.compute.InstanceRequireImdsv2Aspect", version: "0.0.12" };
+/**
+ * Aspect that applies IMDS configuration on EC2 Launch Template constructs.
+ *
+ * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/launch_template#metadata-options
+ * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html
+ */
+class LaunchTemplateRequireImdsv2Aspect extends RequireImdsv2Aspect {
+    constructor(props) {
+        super(props);
+    }
+    visit(node) {
+        if (!(node instanceof launch_template_1.LaunchTemplate)) {
+            return;
+        }
+        const lt = node.node.tryFindChild("Resource");
+        const metadataOptions = lt.metadataOptionsInput;
+        // // metaDataOptions is ComplexListObject and can never be a token
+        // if (Tokenization.isResolvable(metadataOptions)) {
+        //   this.warn(node, "LaunchTemplateData.MetadataOptions is a CDK token.");
+        //   return;
+        // }
+        lt.putMetadataOptions({
+            ...metadataOptions,
+            httpTokens: "required",
+        });
+    }
+}
+exports.LaunchTemplateRequireImdsv2Aspect = LaunchTemplateRequireImdsv2Aspect;
+_b = JSII_RTTI_SYMBOL_1;
+LaunchTemplateRequireImdsv2Aspect[_b] = { fqn: "terraconstructs.aws.compute.LaunchTemplateRequireImdsv2Aspect", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"require-imdsv2-aspect.js","sourceRoot":"","sources":["../../../../src/aws/compute/aspects/require-imdsv2-aspect.ts"],"names":[],"mappings":";;;;;AAAA,iHAAiH;AACjH,sDAAqD;AACrD,iCAA6C;AAE7C,+CAA2C;AAC3C,0CAAuC;AACvC,wDAAoD;AAcpD;;GAEG;AACH,MAAe,mBAAmB;IAGhC,YAAY,KAAgC;QAC1C,IAAI,CAAC,gBAAgB,GAAG,KAAK,EAAE,gBAAgB,IAAI,KAAK,CAAC;IAC3D,CAAC;IAID;;;;;OAKG;IACO,IAAI,CAAC,IAAgB,EAAE,OAAe;QAC9C,IAAI,IAAI,CAAC,gBAAgB,KAAK,IAAI,EAAE,CAAC;YACnC,wDAAwD;YACxD,mBAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,UAAU,CAC7B,GAAG,mBAAmB,CAAC,IAAI,mBAAmB,IAAI,CAAC,IAAI,CAAC,EAAE,KAAK,OAAO,EAAE,CACzE,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AAmBD;;;;;;;;;GASG;AACH,MAAa,2BAA4B,SAAQ,mBAAmB;IAGlE,YAAY,KAAwC;QAClD,KAAK,CAAC,KAAK,CAAC,CAAC;QACb,IAAI,CAAC,6BAA6B;YAChC,KAAK,EAAE,6BAA6B,IAAI,KAAK,CAAC;IAClD,CAAC;IAED,KAAK,CAAC,IAAgB;QACpB,IAAI,CAAC,CAAC,IAAI,YAAY,mBAAQ,CAAC,EAAE,CAAC;YAChC,OAAO;QACT,CAAC;QACD,IAAI,IAAI,CAAC,QAAQ,CAAC,mBAAmB,KAAK,SAAS,EAAE,CAAC;YACpD,IAAI,CAAC,IAAI,CACP,IAAI,EACJ,4FAA4F,CAC7F,CAAC;YACF,OAAO;QACT,CAAC;QAED,MAAM,EAAE,GAAG,IAAI,6BAAc,CAAC,cAAc,CAAC,IAAI,EAAE,gBAAgB,EAAE;YACnE,eAAe,EAAE;gBACf,UAAU,EAAE,UAAU;aACvB;SACF,CAAC,CAAC;QACH,EAAE,CAAC,IAAI,GAAG,oBAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;QAChC,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC;YAC9B,IAAI,EAAE,EAAE,CAAC,IAAI;YACb,OAAO,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE;SACrC,CAAC,CAAC;IACL,CAAC;IAES,IAAI,CAAC,IAAgB,EAAE,OAAe;QAC9C,IAAI,IAAI,CAAC,6BAA6B,KAAK,IAAI,EAAE,CAAC;YAChD,KAAK,CAAC,IAAI,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;QAC5B,CAAC;IACH,CAAC;;AArCH,kEAsCC;;;AAQD;;;;;GAKG;AACH,MAAa,iCAAkC,SAAQ,mBAAmB;IACxE,YAAY,KAA8C;QACxD,KAAK,CAAC,KAAK,CAAC,CAAC;IACf,CAAC;IAED,KAAK,CAAC,IAAgB;QACpB,IAAI,CAAC,CAAC,IAAI,YAAY,gCAAc,CAAC,EAAE,CAAC;YACtC,OAAO;QACT,CAAC;QAED,MAAM,EAAE,GAAG,IAAI,CAAC,IAAI,CAAC,YAAY,CAC/B,UAAU,CACsB,CAAC;QACnC,MAAM,eAAe,GAAG,EAAE,CAAC,oBAAoB,CAAC;QAChD,mEAAmE;QACnE,oDAAoD;QACpD,2EAA2E;QAC3E,YAAY;QACZ,IAAI;QAEJ,EAAE,CAAC,kBAAkB,CAAC;YACpB,GAAG,eAAe;YAClB,UAAU,EAAE,UAAU;SACvB,CAAC,CAAC;IACL,CAAC;;AAxBH,8EAyBC","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/aspects/require-imdsv2-aspect.ts\nimport { launchTemplate } from \"@cdktf/provider-aws\";\nimport { IAspect, Annotations } from \"cdktf\";\nimport { IConstruct } from \"constructs\";\nimport { AwsStack } from \"../../aws-stack\";\nimport { Instance } from \"../instance\";\nimport { LaunchTemplate } from \"../launch-template\";\n\n/**\n * Properties for `RequireImdsv2Aspect`.\n */\ninterface RequireImdsv2AspectProps {\n  /**\n   * Whether warning annotations from this Aspect should be suppressed or not.\n   *\n   * @default - false\n   */\n  readonly suppressWarnings?: boolean;\n}\n\n/**\n * Base class for Aspect that makes IMDSv2 required.\n */\nabstract class RequireImdsv2Aspect implements IAspect {\n  protected readonly suppressWarnings: boolean;\n\n  constructor(props?: RequireImdsv2AspectProps) {\n    this.suppressWarnings = props?.suppressWarnings ?? false;\n  }\n\n  abstract visit(node: IConstruct): void;\n\n  /**\n   * Adds a warning annotation to a node, unless `suppressWarnings` is true.\n   *\n   * @param node The scope to add the warning to.\n   * @param message The warning message.\n   */\n  protected warn(node: IConstruct, message: string) {\n    if (this.suppressWarnings !== true) {\n      // `@aws-cdk/aws-ec2:imdsv2${RequireImdsv2Aspect.name}`,\n      Annotations.of(node).addWarning(\n        `${RequireImdsv2Aspect.name} failed on node ${node.node.id}: ${message}`,\n      );\n    }\n  }\n}\n\n/**\n * Properties for `InstanceRequireImdsv2Aspect`.\n */\nexport interface InstanceRequireImdsv2AspectProps\n  extends RequireImdsv2AspectProps {\n  /**\n   * Whether warnings that would be raised when an Instance is associated with an existing Launch Template\n   * should be suppressed or not.\n   *\n   * You can set this to `true` if `LaunchTemplateImdsAspect` is being used alongside this Aspect to\n   * suppress false-positive warnings because any Launch Templates associated with Instances will still be covered.\n   *\n   * @default - false\n   */\n  readonly suppressLaunchTemplateWarning?: boolean;\n}\n\n/**\n * Aspect that applies IMDS configuration on EC2 Instance constructs.\n *\n * This aspect configures IMDS on an EC2 instance by creating a Launch Template with the\n * IMDS configuration and associating that Launch Template with the instance. If an Instance\n * is already associated with a Launch Template, a warning will (optionally) be added to the\n * construct node and it will be skipped.\n *\n * To cover Instances already associated with Launch Templates, use `LaunchTemplateImdsAspect`.\n */\nexport class InstanceRequireImdsv2Aspect extends RequireImdsv2Aspect {\n  private readonly suppressLaunchTemplateWarning: boolean;\n\n  constructor(props?: InstanceRequireImdsv2AspectProps) {\n    super(props);\n    this.suppressLaunchTemplateWarning =\n      props?.suppressLaunchTemplateWarning ?? false;\n  }\n\n  visit(node: IConstruct): void {\n    if (!(node instanceof Instance)) {\n      return;\n    }\n    if (node.instance.launchTemplateInput !== undefined) {\n      this.warn(\n        node,\n        \"Cannot toggle IMDSv1 because this Instance is associated with an existing Launch Template.\",\n      );\n      return;\n    }\n\n    const lt = new launchTemplate.LaunchTemplate(node, \"LaunchTemplate\", {\n      metadataOptions: {\n        httpTokens: \"required\",\n      },\n    });\n    lt.name = AwsStack.uniqueId(lt);\n    node.instance.putLaunchTemplate({\n      name: lt.name,\n      version: lt.latestVersion.toString(),\n    });\n  }\n\n  protected warn(node: IConstruct, message: string) {\n    if (this.suppressLaunchTemplateWarning !== true) {\n      super.warn(node, message);\n    }\n  }\n}\n\n/**\n * Properties for `LaunchTemplateRequireImdsv2Aspect`.\n */\nexport interface LaunchTemplateRequireImdsv2AspectProps\n  extends RequireImdsv2AspectProps {}\n\n/**\n * Aspect that applies IMDS configuration on EC2 Launch Template constructs.\n *\n * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/launch_template#metadata-options\n * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html\n */\nexport class LaunchTemplateRequireImdsv2Aspect extends RequireImdsv2Aspect {\n  constructor(props?: LaunchTemplateRequireImdsv2AspectProps) {\n    super(props);\n  }\n\n  visit(node: IConstruct): void {\n    if (!(node instanceof LaunchTemplate)) {\n      return;\n    }\n\n    const lt = node.node.tryFindChild(\n      \"Resource\",\n    ) as launchTemplate.LaunchTemplate;\n    const metadataOptions = lt.metadataOptionsInput;\n    // // metaDataOptions is ComplexListObject and can never be a token\n    // if (Tokenization.isResolvable(metadataOptions)) {\n    //   this.warn(node, \"LaunchTemplateData.MetadataOptions is a CDK token.\");\n    //   return;\n    // }\n\n    lt.putMetadataOptions({\n      ...metadataOptions,\n      httpTokens: \"required\",\n    });\n  }\n}\n"]}

package/lib/aws/compute/bastion-host.d.ts

@@ -0,0 +1,172 @@
+import { Construct } from "constructs";
+import { InstanceType } from ".";
+import { Connections } from "./connections";
+import { IInstance, Instance, InstanceOutputs } from "./instance";
+import { IMachineImage } from "./machine-image";
+import { IPeer } from "./peer";
+import { ISecurityGroup } from "./security-group";
+import { BlockDevice } from "./volume";
+import { IVpc, SubnetSelection } from "./vpc";
+import { AwsConstructBase } from "../aws-construct";
+import { AwsStack } from "../aws-stack";
+import { IPrincipal, IRole } from "../iam";
+/**
+ * Properties of the bastion host
+ *
+ *
+ */
+export interface BastionHostLinuxProps {
+    /**
+     * In which AZ to place the instance within the VPC
+     *
+     * @default - Random zone.
+     */
+    readonly availabilityZone?: string;
+    /**
+     * VPC to launch the instance in.
+     */
+    readonly vpc: IVpc;
+    /**
+     * The name of the instance
+     *
+     * @default 'BastionHost'
+     */
+    readonly instanceName?: string;
+    /**
+     * Select the subnets to run the bastion host in.
+     * Set this to PUBLIC if you need to connect to this instance via the internet and cannot use SSM.
+     * You have to allow port 22 manually by using the connections field
+     *
+     * @default - private subnets of the supplied VPC
+     */
+    readonly subnetSelection?: SubnetSelection;
+    /**
+     * Security Group to assign to this instance
+     *
+     * @default - create new security group with no inbound and all outbound traffic allowed
+     */
+    readonly securityGroup?: ISecurityGroup;
+    /**
+     * Type of instance to launch
+     * @default 't3.nano'
+     */
+    readonly instanceType?: InstanceType;
+    /**
+     * The machine image to use, assumed to have SSM Agent preinstalled.
+     *
+     * @default - An Amazon Linux 2023 image if the `@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault` feature flag is enabled. Otherwise, an Amazon Linux 2 image. In both cases, the image is kept up-to-date automatically (the instance
+     * may be replaced on every deployment) and already has SSM Agent installed.
+     */
+    readonly machineImage?: IMachineImage;
+    /**
+     * Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.
+     *
+     * Each instance that is launched has an associated root device volume,
+     * either an Amazon EBS volume or an instance store volume.
+     * You can use block device mappings to specify additional EBS volumes or
+     * instance store volumes to attach to an instance when it is launched.
+     *
+     * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html
+     *
+     * @default - Uses the block device mapping of the AMI
+     */
+    readonly blockDevices?: BlockDevice[];
+    /**
+     * Whether IMDSv2 should be required on this instance
+     *
+     * @default - false
+     */
+    readonly requireImdsv2?: boolean;
+    /**
+     * Determines whether changes to the UserData will force instance replacement.
+     *
+     * Depending on the EC2 instance type, modifying the UserData may either restart
+     * or replace the instance:
+     *
+     * - Instance store-backed instances are replaced.
+     * - EBS-backed instances are restarted.
+     *
+     * Note that by default, restarting does not execute the updated UserData, so an alternative
+     * mechanism is needed to ensure the instance re-executes the UserData.
+     *
+     * When set to `true`, the instance's Logical ID will depend on the UserData, causing
+     * CloudFormation to replace the instance if the UserData changes.
+     *
+     * @default - `true` if `initOptions` is specified, otherwise `false`.
+     */
+    readonly userDataCausesReplacement?: boolean;
+}
+/**
+ * This creates a linux bastion host you can use to connect to other instances or services in your VPC.
+ * The recommended way to connect to the bastion host is by using AWS Systems Manager Session Manager.
+ *
+ * The operating system is Amazon Linux 2 with the latest SSM agent installed
+ *
+ * You can also configure this bastion host to allow connections via SSH
+ *
+ *
+ * @resource aws_instance
+ */
+export declare class BastionHostLinux extends AwsConstructBase implements IInstance {
+    get instanceOutputs(): InstanceOutputs;
+    get outputs(): Record<string, any>;
+    readonly stack: AwsStack;
+    /**
+     * Allows specify security group connections for the instance.
+     */
+    readonly connections: Connections;
+    /**
+     * The IAM role assumed by the instance.
+     */
+    readonly role: IRole;
+    /**
+     * The principal to grant permissions to
+     */
+    readonly grantPrincipal: IPrincipal;
+    /**
+     * The underlying instance resource
+     */
+    readonly instance: Instance;
+    /**
+     * @attribute
+     */
+    readonly instanceId: string;
+    /**
+     * @attribute
+     */
+    readonly instanceAvailabilityZone: string;
+    /**
+     * @attribute
+     */
+    readonly instancePrivateDnsName: string;
+    /**
+     * @attribute
+     */
+    readonly instancePrivateIp: string;
+    /**
+     * @attribute
+     */
+    readonly instancePublicDnsName: string;
+    /**
+     * @attribute
+     */
+    readonly instancePublicIp: string;
+    constructor(scope: Construct, id: string, props: BastionHostLinuxProps);
+    /**
+     * Returns the AmazonLinuxCpuType corresponding to the given instance architecture
+     * @param architecture the instance architecture value to convert
+     */
+    private toAmazonLinuxCpuType;
+    /**
+     * Allow SSH access from the given peer or peers
+     *
+     * Necessary if you want to connect to the instance using ssh. If not
+     * called, you should use SSM Session Manager to connect to the instance.
+     */
+    allowSshAccessFrom(...peer: IPeer[]): void;
+    /**
+     * Returns the machine image to use for the bastion host, respecting the feature flag
+     * to default to Amazon Linux 2023 if enabled, otherwise defaulting to Amazon Linux 2.
+     */
+    private getMachineImage;
+}

package/lib/aws/compute/bastion-host.js

@@ -0,0 +1,114 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BastionHostLinux = 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/bastion-host.ts
+const cdktf_1 = require("cdktf");
+const _1 = require(".");
+const instance_1 = require("./instance");
+const machine_image_1 = require("./machine-image");
+const port_1 = require("./port");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+const iam_1 = require("../iam");
+/**
+ * This creates a linux bastion host you can use to connect to other instances or services in your VPC.
+ * The recommended way to connect to the bastion host is by using AWS Systems Manager Session Manager.
+ *
+ * The operating system is Amazon Linux 2 with the latest SSM agent installed
+ *
+ * You can also configure this bastion host to allow connections via SSH
+ *
+ *
+ * @resource aws_instance
+ */
+class BastionHostLinux extends aws_construct_1.AwsConstructBase {
+    get instanceOutputs() {
+        return {
+            instanceId: this.instanceId,
+        };
+    }
+    get outputs() {
+        return this.instanceOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.stack = aws_stack_1.AwsStack.ofAwsConstruct(scope);
+        const instanceType = props.instanceType ??
+            _1.InstanceType.of(_1.InstanceClass.T3, _1.InstanceSize.NANO);
+        this.instance = new instance_1.Instance(this, "Resource", {
+            vpc: props.vpc,
+            availabilityZone: props.availabilityZone,
+            securityGroup: props.securityGroup,
+            instanceName: props.instanceName ?? "BastionHost",
+            instanceType,
+            machineImage: this.getMachineImage(this, instanceType, props),
+            vpcSubnets: props.subnetSelection ?? {},
+            blockDevices: props.blockDevices ?? undefined,
+            // init: props.init,
+            // initOptions: props.initOptions,
+            requireImdsv2: props.requireImdsv2 ?? false,
+            userDataCausesReplacement: props.userDataCausesReplacement,
+        });
+        this.instance.addToRolePolicy(new iam_1.PolicyStatement({
+            actions: [
+                "ssmmessages:*",
+                "ssm:UpdateInstanceInformation",
+                "ec2messages:*",
+            ],
+            resources: ["*"],
+        }));
+        this.connections = this.instance.connections;
+        this.role = this.instance.role;
+        this.grantPrincipal = this.instance.role;
+        this.instanceId = this.instance.instanceId;
+        this.instancePrivateIp = this.instance.instancePrivateIp;
+        this.instanceAvailabilityZone = this.instance.instanceAvailabilityZone;
+        this.instancePrivateDnsName = this.instance.instancePrivateDnsName;
+        this.instancePublicIp = this.instance.instancePublicIp;
+        this.instancePublicDnsName = this.instance.instancePublicDnsName;
+        new cdktf_1.TerraformOutput(this, "BastionHostId", {
+            description: "Instance ID of the bastion host. Use this to connect via SSM Session Manager",
+            value: this.instanceId,
+        });
+    }
+    /**
+     * Returns the AmazonLinuxCpuType corresponding to the given instance architecture
+     * @param architecture the instance architecture value to convert
+     */
+    toAmazonLinuxCpuType(architecture) {
+        if (architecture === _1.InstanceArchitecture.ARM_64) {
+            return machine_image_1.AmazonLinuxCpuType.ARM_64;
+        }
+        else if (architecture === _1.InstanceArchitecture.X86_64) {
+            return machine_image_1.AmazonLinuxCpuType.X86_64;
+        }
+        throw new Error(`Unsupported instance architecture '${architecture}'`);
+    }
+    /**
+     * Allow SSH access from the given peer or peers
+     *
+     * Necessary if you want to connect to the instance using ssh. If not
+     * called, you should use SSM Session Manager to connect to the instance.
+     */
+    allowSshAccessFrom(...peer) {
+        peer.forEach((p) => {
+            this.connections.allowFrom(p, port_1.Port.tcp(22), "SSH access");
+        });
+    }
+    /**
+     * Returns the machine image to use for the bastion host, respecting the feature flag
+     * to default to Amazon Linux 2023 if enabled, otherwise defaulting to Amazon Linux 2.
+     */
+    getMachineImage(_scope, instanceType, props) {
+        const defaultMachineImage = machine_image_1.MachineImage.latestAmazonLinux2023({
+            cpuType: this.toAmazonLinuxCpuType(instanceType.architecture),
+        });
+        return props.machineImage ?? defaultMachineImage;
+    }
+}
+exports.BastionHostLinux = BastionHostLinux;
+_a = JSII_RTTI_SYMBOL_1;
+BastionHostLinux[_a] = { fqn: "terraconstructs.aws.compute.BastionHostLinux", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"bastion-host.js","sourceRoot":"","sources":["../../../src/aws/compute/bastion-host.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/bastion-host.ts\n\nimport { TerraformOutput } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  InstanceArchitecture,\n  InstanceClass,\n  InstanceSize,\n  InstanceType,\n} from \".\";\n// import { CloudFormationInit } from \"./cfn-init\";\nimport { Connections } from \"./connections\";\nimport {\n  // ApplyCloudFormationInitOptions,\n  IInstance,\n  Instance,\n  InstanceOutputs,\n} from \"./instance\";\nimport {\n  AmazonLinuxCpuType,\n  IMachineImage,\n  MachineImage,\n} from \"./machine-image\";\nimport { IPeer } from \"./peer\";\nimport { Port } from \"./port\";\nimport { ISecurityGroup } from \"./security-group\";\nimport { BlockDevice } from \"./volume\";\nimport { IVpc, SubnetSelection } from \"./vpc\";\nimport { AwsConstructBase } from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\nimport { IPrincipal, IRole, PolicyStatement } from \"../iam\";\n\n/**\n * Properties of the bastion host\n *\n *\n */\nexport interface BastionHostLinuxProps {\n  /**\n   * In which AZ to place the instance within the VPC\n   *\n   * @default - Random zone.\n   */\n  readonly availabilityZone?: string;\n\n  /**\n   * VPC to launch the instance in.\n   */\n  readonly vpc: IVpc;\n\n  /**\n   * The name of the instance\n   *\n   * @default 'BastionHost'\n   */\n  readonly instanceName?: string;\n\n  /**\n   * Select the subnets to run the bastion host in.\n   * Set this to PUBLIC if you need to connect to this instance via the internet and cannot use SSM.\n   * You have to allow port 22 manually by using the connections field\n   *\n   * @default - private subnets of the supplied VPC\n   */\n  readonly subnetSelection?: SubnetSelection;\n\n  /**\n   * Security Group to assign to this instance\n   *\n   * @default - create new security group with no inbound and all outbound traffic allowed\n   */\n  readonly securityGroup?: ISecurityGroup;\n\n  /**\n   * Type of instance to launch\n   * @default 't3.nano'\n   */\n  readonly instanceType?: InstanceType;\n\n  /**\n   * The machine image to use, assumed to have SSM Agent preinstalled.\n   *\n   * @default - An Amazon Linux 2023 image if the `@aws-cdk/aws-ec2:bastionHostUseAmazonLinux2023ByDefault` feature flag is enabled. Otherwise, an Amazon Linux 2 image. In both cases, the image is kept up-to-date automatically (the instance\n   * may be replaced on every deployment) and already has SSM Agent installed.\n   */\n  readonly machineImage?: IMachineImage;\n\n  /**\n   * Specifies how block devices are exposed to the instance. You can specify virtual devices and EBS volumes.\n   *\n   * Each instance that is launched has an associated root device volume,\n   * either an Amazon EBS volume or an instance store volume.\n   * You can use block device mappings to specify additional EBS volumes or\n   * instance store volumes to attach to an instance when it is launched.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html\n   *\n   * @default - Uses the block device mapping of the AMI\n   */\n  readonly blockDevices?: BlockDevice[];\n\n  // /**\n  //  * Apply the given CloudFormation Init configuration to the instance at startup\n  //  *\n  //  * @default - no CloudFormation init\n  //  */\n  // readonly init?: CloudFormationInit;\n\n  // /**\n  //  * Use the given options for applying CloudFormation Init\n  //  *\n  //  * Describes the configsets to use and the timeout to wait\n  //  *\n  //  * @default - default options\n  //  */\n  // readonly initOptions?: ApplyCloudFormationInitOptions;\n\n  /**\n   * Whether IMDSv2 should be required on this instance\n   *\n   * @default - false\n   */\n  readonly requireImdsv2?: boolean;\n\n  /**\n   * Determines whether changes to the UserData will force instance replacement.\n   *\n   * Depending on the EC2 instance type, modifying the UserData may either restart\n   * or replace the instance:\n   *\n   * - Instance store-backed instances are replaced.\n   * - EBS-backed instances are restarted.\n   *\n   * Note that by default, restarting does not execute the updated UserData, so an alternative\n   * mechanism is needed to ensure the instance re-executes the UserData.\n   *\n   * When set to `true`, the instance's Logical ID will depend on the UserData, causing\n   * CloudFormation to replace the instance if the UserData changes.\n   *\n   * @default - `true` if `initOptions` is specified, otherwise `false`.\n   */\n  readonly userDataCausesReplacement?: boolean;\n}\n\n/**\n * This creates a linux bastion host you can use to connect to other instances or services in your VPC.\n * The recommended way to connect to the bastion host is by using AWS Systems Manager Session Manager.\n *\n * The operating system is Amazon Linux 2 with the latest SSM agent installed\n *\n * You can also configure this bastion host to allow connections via SSH\n *\n *\n * @resource aws_instance\n */\nexport class BastionHostLinux extends AwsConstructBase implements IInstance {\n  public get instanceOutputs(): InstanceOutputs {\n    return {\n      instanceId: this.instanceId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.instanceOutputs;\n  }\n\n  public readonly stack: AwsStack;\n\n  /**\n   * Allows specify security group connections for the instance.\n   */\n  public readonly connections: Connections;\n\n  /**\n   * The IAM role assumed by the instance.\n   */\n  public readonly role: IRole;\n\n  /**\n   * The principal to grant permissions to\n   */\n  public readonly grantPrincipal: IPrincipal;\n\n  /**\n   * The underlying instance resource\n   */\n  public readonly instance: Instance;\n\n  /**\n   * @attribute\n   */\n  public readonly instanceId: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instanceAvailabilityZone: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePrivateDnsName: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePrivateIp: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePublicDnsName: string;\n\n  /**\n   * @attribute\n   */\n  public readonly instancePublicIp: string;\n\n  constructor(scope: Construct, id: string, props: BastionHostLinuxProps) {\n    super(scope, id);\n    this.stack = AwsStack.ofAwsConstruct(scope);\n    const instanceType =\n      props.instanceType ??\n      InstanceType.of(InstanceClass.T3, InstanceSize.NANO);\n    this.instance = new Instance(this, \"Resource\", {\n      vpc: props.vpc,\n      availabilityZone: props.availabilityZone,\n      securityGroup: props.securityGroup,\n      instanceName: props.instanceName ?? \"BastionHost\",\n      instanceType,\n      machineImage: this.getMachineImage(this, instanceType, props),\n      vpcSubnets: props.subnetSelection ?? {},\n      blockDevices: props.blockDevices ?? undefined,\n      // init: props.init,\n      // initOptions: props.initOptions,\n      requireImdsv2: props.requireImdsv2 ?? false,\n      userDataCausesReplacement: props.userDataCausesReplacement,\n    });\n    this.instance.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          \"ssmmessages:*\",\n          \"ssm:UpdateInstanceInformation\",\n          \"ec2messages:*\",\n        ],\n        resources: [\"*\"],\n      }),\n    );\n    this.connections = this.instance.connections;\n    this.role = this.instance.role;\n    this.grantPrincipal = this.instance.role;\n    this.instanceId = this.instance.instanceId;\n    this.instancePrivateIp = this.instance.instancePrivateIp;\n    this.instanceAvailabilityZone = this.instance.instanceAvailabilityZone;\n    this.instancePrivateDnsName = this.instance.instancePrivateDnsName;\n    this.instancePublicIp = this.instance.instancePublicIp;\n    this.instancePublicDnsName = this.instance.instancePublicDnsName;\n\n    new TerraformOutput(this, \"BastionHostId\", {\n      description:\n        \"Instance ID of the bastion host. Use this to connect via SSM Session Manager\",\n      value: this.instanceId,\n    });\n  }\n\n  /**\n   * Returns the AmazonLinuxCpuType corresponding to the given instance architecture\n   * @param architecture the instance architecture value to convert\n   */\n  private toAmazonLinuxCpuType(\n    architecture: InstanceArchitecture,\n  ): AmazonLinuxCpuType {\n    if (architecture === InstanceArchitecture.ARM_64) {\n      return AmazonLinuxCpuType.ARM_64;\n    } else if (architecture === InstanceArchitecture.X86_64) {\n      return AmazonLinuxCpuType.X86_64;\n    }\n\n    throw new Error(`Unsupported instance architecture '${architecture}'`);\n  }\n\n  /**\n   * Allow SSH access from the given peer or peers\n   *\n   * Necessary if you want to connect to the instance using ssh. If not\n   * called, you should use SSM Session Manager to connect to the instance.\n   */\n  public allowSshAccessFrom(...peer: IPeer[]): void {\n    peer.forEach((p) => {\n      this.connections.allowFrom(p, Port.tcp(22), \"SSH access\");\n    });\n  }\n\n  /**\n   * Returns the machine image to use for the bastion host, respecting the feature flag\n   * to default to Amazon Linux 2023 if enabled, otherwise defaulting to Amazon Linux 2.\n   */\n  private getMachineImage(\n    _scope: Construct,\n    instanceType: InstanceType,\n    props: BastionHostLinuxProps,\n  ): IMachineImage {\n    const defaultMachineImage = MachineImage.latestAmazonLinux2023({\n      cpuType: this.toAmazonLinuxCpuType(instanceType.architecture),\n    });\n    return props.machineImage ?? defaultMachineImage;\n  }\n}\n"]}

package/lib/aws/compute/chain.js

@@ -64,5 +64,5 @@ class Chain {
 }
 exports.Chain = Chain;
 _a = JSII_RTTI_SYMBOL_1;
-Chain[_a] = { fqn: "terraconstructs.aws.compute.Chain", version: "0.0.10" };
+Chain[_a] = { fqn: "terraconstructs.aws.compute.Chain", version: "0.0.12" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/cidr-splits.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Return the splits necessary to allocate the given sequence of cidrs in the given order
+ *
+ * The entire block is of size 'rootNetmask', and subsequent blocks will be allocated
+ * from it sized according to the sizes in the 'netmasks' array.
+ *
+ * The return value is a list of `CidrSplit` objects, which represent
+ * invocations of a pair of `Fn.select(Fn.cidr(...))` operations.
+ *
+ * Strategy: walk through the IP block space, clipping to the next possible
+ * start of a block of the given size, then allocate it. Here is an unrealistic
+ * example (with a weird ordering of the netmasks to show how clipping and hence
+ * space wasting plays out in practice):
+ *
+ *                               root space  /16
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │                                                                                              │
+ *   A  /21             B  /19
+ * ┌───┬───┬───┬───┬───────────────┬───────────────┬───┬───────────┬───────────────┬──────────────┐
+ * │ A │ A │ A │###│       B       │       B       │ A │###########│       B       │     ....     │
+ * └───┴───┴───┴───┴───────────────┴───────────────┴───┴───────────┴───────────────┴──────────────┘
+ *              ^^^______ wasted space _________________^^^^^^
+ */
+export declare function calculateCidrSplits(rootNetmask: number, netmasks: number[]): CidrSplit[];
+/**
+ * A representation of a pair of `Fn.select(Fn.cidr())` invocations
+ */
+export interface CidrSplit {
+    /**
+     * The netmask of this block size
+     * (If you want a /24, netmask=24).
+     */
+    readonly netmask: number;
+    /**
+     * newbits = (childNetmask - rootNetmask), i.e. how many additional bits
+     * beyond the root's netmask we're subdividing by.
+     *
+     * Used directly by Terraform's `cidrsubnet(...)`.
+     */
+    readonly newbits: number;
+    /**
+     * How many parts the mask needs to be split into
+     */
+    readonly count: number;
+    /**
+     * What subnet index to select from the split
+     */
+    readonly index: number;
+}

package/lib/aws/compute/cidr-splits.js

@@ -0,0 +1,59 @@
+"use strict";
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/aws-cdk-lib/aws-ec2/lib/cidr-splits.ts
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateCidrSplits = calculateCidrSplits;
+/**
+ * Return the splits necessary to allocate the given sequence of cidrs in the given order
+ *
+ * The entire block is of size 'rootNetmask', and subsequent blocks will be allocated
+ * from it sized according to the sizes in the 'netmasks' array.
+ *
+ * The return value is a list of `CidrSplit` objects, which represent
+ * invocations of a pair of `Fn.select(Fn.cidr(...))` operations.
+ *
+ * Strategy: walk through the IP block space, clipping to the next possible
+ * start of a block of the given size, then allocate it. Here is an unrealistic
+ * example (with a weird ordering of the netmasks to show how clipping and hence
+ * space wasting plays out in practice):
+ *
+ *                               root space  /16
+ * ┌──────────────────────────────────────────────────────────────────────────────────────────────┐
+ * │                                                                                              │
+ *   A  /21             B  /19
+ * ┌───┬───┬───┬───┬───────────────┬───────────────┬───┬───────────┬───────────────┬──────────────┐
+ * │ A │ A │ A │###│       B       │       B       │ A │###########│       B       │     ....     │
+ * └───┴───┴───┴───┴───────────────┴───────────────┴───┴───────────┴───────────────┴──────────────┘
+ *              ^^^______ wasted space _________________^^^^^^
+ */
+function calculateCidrSplits(rootNetmask, netmasks) {
+    // NOTE: Terraform cidrsubnets() function does the same thing, but forces TF Tokens
+    // Local implementation of this logic allows more powerful configuration through constructs
+    // ref: https://developer.hashicorp.com/terraform/language/v1.7.x/functions/cidrsubnets
+    const ret = new Array();
+    let offset = 0;
+    for (const netmask of netmasks) {
+        const size = Math.pow(2, 32 - netmask);
+        // Clip offset to the next block of the given size
+        offset = nextMultiple(offset, size);
+        const count = Math.pow(2, netmask - rootNetmask);
+        const newbits = netmask - rootNetmask;
+        // if newbits is negative, it means the child netmask is bigger than the root netmask
+        // this will be caught by offset > Math.pow(2, 32 - rootNetmask) check below
+        ret.push({
+            count,
+            netmask,
+            newbits,
+            index: offset / size,
+        });
+        // Consume
+        offset += size;
+    }
+    if (offset > Math.pow(2, 32 - rootNetmask)) {
+        throw new Error(`IP space of size /${rootNetmask} not big enough to allocate subnets of sizes ${netmasks.map((x) => `/${x}`)}`);
+    }
+    return ret;
+}
+function nextMultiple(current, multiple) {
+    return Math.ceil(current / multiple) * multiple;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/aws/compute/client-vpn-authorization-rule.d.ts

@@ -0,0 +1,43 @@
+import { Construct } from "constructs";
+import { IClientVpnEndpoint } from "./client-vpn-endpoint-types";
+import { AwsConstructBase } from "../aws-construct";
+/**
+ * Options for a ClientVpnAuthorizationRule
+ */
+export interface ClientVpnAuthorizationRuleOptions {
+    /**
+     * The IPv4 address range, in CIDR notation, of the network for which access
+     * is being authorized.
+     */
+    readonly cidr: string;
+    /**
+     * The ID of the group to grant access to, for example, the Active Directory
+     * group or identity provider (IdP) group.
+     *
+     * @default - authorize all groups
+     */
+    readonly groupId?: string;
+    /**
+     * A brief description of the authorization rule.
+     *
+     * @default - no description
+     */
+    readonly description?: string;
+}
+/**
+ * Properties for a ClientVpnAuthorizationRule
+ */
+export interface ClientVpnAuthorizationRuleProps extends ClientVpnAuthorizationRuleOptions {
+    /**
+     * The client VPN endpoint to which to add the rule.
+     * @default clientVpnEndpoint is required
+     */
+    readonly clientVpnEndpoint: IClientVpnEndpoint;
+}
+/**
+ * A client VPN authorization rule
+ */
+export declare class ClientVpnAuthorizationRule extends AwsConstructBase {
+    get outputs(): Record<string, any>;
+    constructor(scope: Construct, id: string, props: ClientVpnAuthorizationRuleProps);
+}