terraconstructs 0.0.10 → 0.0.12

package/lib/aws/compute/ipam.js

@@ -0,0 +1,306 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ipam = exports.IpamScopeType = exports.AwsServiceName = exports.IpamPoolPublicIpSource = exports.AddressFamily = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/ipam.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const aws_construct_1 = require("../aws-construct");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+/**
+ * Represents the address family for IP addresses in an IPAM pool.
+ * IP_V4 - Represents the IPv4 address family.
+ * IP_V6 - Represents the IPv6 address family.
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-addressfamily
+ */
+var AddressFamily;
+(function (AddressFamily) {
+    /**
+     * Represents the IPv4 address family.
+     * Allowed under public and private pool.
+     */
+    AddressFamily["IP_V4"] = "ipv4";
+    /**
+     * Represents the IPv6 address family.
+     * Only allowed under public pool.
+     */
+    AddressFamily["IP_V6"] = "ipv6";
+})(AddressFamily || (exports.AddressFamily = AddressFamily = {}));
+/**
+ * The IP address source for pools in the public scope.
+ * Only used for provisioning IP address CIDRs to pools in the public scope.
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-publicipsource
+ */
+var IpamPoolPublicIpSource;
+(function (IpamPoolPublicIpSource) {
+    /**
+     * BYOIP Ipv6 to be registered under IPAM
+     */
+    IpamPoolPublicIpSource["BYOIP"] = "byoip";
+    /**
+     * Amazon Provided Ipv6 range
+     */
+    IpamPoolPublicIpSource["AMAZON"] = "amazon";
+})(IpamPoolPublicIpSource || (exports.IpamPoolPublicIpSource = IpamPoolPublicIpSource = {}));
+/**
+ * Limits which service in AWS that the pool can be used in
+ */
+var AwsServiceName;
+(function (AwsServiceName) {
+    /**
+     *  Allows users to use space for Elastic IP addresses and VPCs
+     */
+    AwsServiceName["EC2"] = "ec2";
+})(AwsServiceName || (exports.AwsServiceName = AwsServiceName = {}));
+/**
+ * Refers to two possible scope types under IPAM
+ */
+var IpamScopeType;
+(function (IpamScopeType) {
+    /**
+     * Default scopes created by IPAM
+     */
+    IpamScopeType["DEFAULT"] = "default";
+    /**
+     * Custom scope created using method
+     */
+    IpamScopeType["CUSTOM"] = "custom";
+})(IpamScopeType || (exports.IpamScopeType = IpamScopeType = {}));
+const NAME_TAG = "Name";
+/**
+ * Creates new IPAM Pool
+ * Pools enable you to organize your IP addresses according to your routing and security needs
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html
+ * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam_pool
+ * @resource aws_vpc_ipam_pool
+ * @internal
+ */
+class IpamPool extends aws_construct_1.AwsConstructBase {
+    get ipamPoolOutputs() {
+        return {
+            ipamPoolId: this.ipamPoolId,
+        };
+    }
+    get outputs() {
+        return this.ipamPoolOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        /**
+         * Pool CIDR for IPv6 to be provisioned with Public IP source set to 'Amazon'
+         */
+        this.ipamCidrs = [];
+        /**
+         * Pool CIDR for IPv4 to be provisioned using IPAM
+         * Required to check for subnet IP range is within the VPC range
+         */
+        this.ipamIpv4Cidrs = [];
+        const ipamPoolName = props.ipamPoolName ??
+            cdktf_1.Lazy.stringValue({
+                produce: () => this.stack.uniqueResourceName(this, {
+                    maxLength: 128,
+                    allowedSpecialCharacters: "_",
+                }),
+            });
+        if (props.addressFamily === AddressFamily.IP_V6 && !props.awsService) {
+            throw new Error("awsService is required when addressFamily is set to ipv6");
+        }
+        //Add tags to the IPAM Pool if name is provided
+        if (ipamPoolName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, ipamPoolName);
+        }
+        this._ipamPool = new provider_aws_1.vpcIpamPool.VpcIpamPool(this, "Resource", {
+            addressFamily: props.addressFamily,
+            locale: props.locale,
+            ipamScopeId: props.ipamScopeId,
+            publicIpSource: props.publicIpSource,
+            awsService: props.awsService,
+            allocationResourceTags: props.allocationResourceTags,
+        });
+        this.ipamPoolId = this._ipamPool.id;
+        // provisionedCidrs: props.ipv4ProvisionedCidrs?.map((cidr) => ({ cidr })),
+        // Populating to check for subnet range against all IPv4 ranges assigned to VPC including IPAM
+        props.ipv4ProvisionedCidrs?.forEach((cidr) => {
+            this.ipamIpv4Cidrs.push(cidr);
+            // Terraform VpcIpamPool does not support inline "ProvisionedCidrs" property
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-provisionedcidrs
+            this.provisionCidr("ProvisionedCidr", { cidr });
+        });
+    }
+    /**
+     * A CIDR provisioned to an IPAM pool.
+     * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam_pool_cidr
+     * @param id Name of Resource
+     * @param options Either a CIDR or netmask length must be provided
+     * @returns aws_vpc_ipam_pool_cidr
+     */
+    provisionCidr(id, options) {
+        // TODO: Error if neither or both cidr and netmask length are provided
+        const cidr = new provider_aws_1.vpcIpamPoolCidr.VpcIpamPoolCidr(this, id, {
+            ...options,
+            ipamPoolId: this.ipamPoolId,
+        });
+        this.ipamCidrs.push(cidr);
+        return cidr;
+    }
+}
+/**
+ * Creates custom Ipam Scope, custom IPAM scopes can only be private
+ * (can be used for adding custom scopes to an existing IPAM)
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html
+ * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam_scope
+ * @resource aws_vpc_ipam_scope
+ */
+class IpamScope extends aws_construct_1.AwsConstructBase {
+    get ipamScopeOutputs() {
+        return {
+            ipamScopeId: this.scopeId,
+        };
+    }
+    get outputs() {
+        return this.ipamScopeOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        this._ipamScope = new provider_aws_1.vpcIpamScope.VpcIpamScope(scope, "Resource", {
+            ipamId: props.ipamId,
+        });
+        aws_tags_1.Tags.of(this._ipamScope).add(NAME_TAG, props.ipamScopeName ?? "CustomIpamScope");
+        this.scopeId = this._ipamScope.id;
+        this.scopeType = IpamScopeType.CUSTOM;
+        this.scope = scope;
+        this.props = props;
+    }
+    /**
+     * Adds a pool to the IPAM scope.
+     * @external
+     */
+    addPool(id, options) {
+        return createIpamPool(this.scope, id, this.props, options, this.scopeId);
+    }
+}
+/**
+ * Base class for IPAM default scopes.
+ */
+class IpamScopeBase {
+    get ipamScopeOutputs() {
+        return {
+            ipamScopeId: this.scopeId,
+        };
+    }
+    get outputs() {
+        return this.ipamScopeOutputs;
+    }
+    constructor(scope, scopeId, props, scopeType) {
+        this.scope = scope;
+        this.scopeId = scopeId;
+        this.props = props;
+        this.scopeType = scopeType;
+        this.scopeType = IpamScopeType.DEFAULT;
+        if (!props.ipamScopeId) {
+            throw new Error("ipamScopeId is required");
+        }
+        else {
+            this.scopeId = props.ipamScopeId;
+        }
+    }
+    /**
+     * Adds a pool to the IPAM scope.
+     * @external
+     */
+    addPool(id, options) {
+        return createIpamPool(this.scope, id, this.props, options, this.scopeId);
+    }
+}
+/**
+ * Creates new IPAM with default public and private scope
+ * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html
+ * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam
+ * @resource aws_vpc_ipam
+ */
+class Ipam extends aws_construct_1.AwsConstructBase {
+    get ipamOutputs() {
+        return {
+            ipamId: this.ipamId,
+        };
+    }
+    get outputs() {
+        return this.ipamOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        /**
+         * List of scopes created under this IPAM
+         */
+        this.scopes = [];
+        if (props?.ipamName) {
+            aws_tags_1.Tags.of(this).add(NAME_TAG, props.ipamName);
+        }
+        if (!props?.operatingRegion && !this.env.region) {
+            throw new Error("Please provide at least one operating region");
+        }
+        this.operatingRegions = props?.operatingRegion ?? [this.env.region];
+        this.ipamName = props?.ipamName;
+        this._ipam = new provider_aws_1.vpcIpam.VpcIpam(this, "Ipam", {
+            operatingRegions: this.operatingRegions
+                ? this.operatingRegions.map((region) => ({ regionName: region }))
+                : [],
+        });
+        this.node.defaultChild = this._ipam;
+        this.ipamId = this._ipam.id;
+        this.publicScope = new IpamScopeBase(this, "DefaultPublicScope", {
+            ipamOperatingRegions: this.operatingRegions,
+            ipamId: this._ipam.id,
+            ipamScopeId: this._ipam.publicDefaultScopeId,
+        });
+        this.privateScope = new IpamScopeBase(this, "DefaultPrivateScope", {
+            ipamOperatingRegions: this.operatingRegions,
+            ipamId: this._ipam.id,
+            ipamScopeId: this._ipam.privateDefaultScopeId,
+        });
+        this.scopes.push(this.publicScope, this.privateScope);
+    }
+    /**
+     * Function to add custom scope to an existing IPAM
+     * Custom scopes can only be private
+     */
+    addScope(scope, id, options) {
+        const ipamScope = new IpamScope(scope, id, {
+            ...options,
+            ipamId: this.ipamId,
+            ipamOperatingRegions: this.operatingRegions,
+        });
+        this.scopes.push(ipamScope);
+        return ipamScope;
+    }
+}
+exports.Ipam = Ipam;
+_a = JSII_RTTI_SYMBOL_1;
+Ipam[_a] = { fqn: "terraconstructs.aws.compute.alpha.Ipam", version: "0.0.12" };
+/**
+ * Function to create IpamPool under scope
+ * @internal
+ */
+function createIpamPool(scope, id, scopeOptions, poolOptions, scopeId) {
+    const isLocaleInOperatingRegions = scopeOptions.ipamOperatingRegions
+        ? scopeOptions.ipamOperatingRegions
+            .map((region) => ({ regionName: region }))
+            .some((region) => region.regionName === poolOptions.locale)
+        : false;
+    if (!isLocaleInOperatingRegions) {
+        throw new Error(`The provided locale '${poolOptions.locale}' is not in the operating regions.`);
+    }
+    return new IpamPool(scope, id, {
+        ipamPoolName: poolOptions.ipamPoolName,
+        addressFamily: poolOptions.addressFamily,
+        ipv4ProvisionedCidrs: poolOptions.ipv4ProvisionedCidrs,
+        ipamScopeId: scopeId,
+        locale: poolOptions.locale,
+        publicIpSource: poolOptions.publicIpSource,
+        awsService: poolOptions.awsService,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ipam.js","sourceRoot":"","sources":["../../../src/aws/compute/ipam.ts"],"names":[],"mappings":"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","sourcesContent":["// https://github.com/aws/aws-cdk/blob/v2.175.1/packages/@aws-cdk/aws-ec2-alpha/lib/ipam.ts\n\nimport {\n  vpcIpam as tfIpam,\n  vpcIpamPool as tfIpamPool,\n  vpcIpamPoolCidr as tfIpamPoolCidr,\n  vpcIpamScope as tfIpamScope,\n} from \"@cdktf/provider-aws\";\nimport { Lazy } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\n\n/**\n * Represents the address family for IP addresses in an IPAM pool.\n * IP_V4 - Represents the IPv4 address family.\n * IP_V6 - Represents the IPv6 address family.\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-addressfamily\n */\nexport enum AddressFamily {\n  /**\n   * Represents the IPv4 address family.\n   * Allowed under public and private pool.\n   */\n  IP_V4 = \"ipv4\",\n\n  /**\n   * Represents the IPv6 address family.\n   * Only allowed under public pool.\n   */\n  IP_V6 = \"ipv6\",\n}\n\n/**\n * The IP address source for pools in the public scope.\n * Only used for provisioning IP address CIDRs to pools in the public scope.\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-publicipsource\n */\nexport enum IpamPoolPublicIpSource {\n  /**\n   * BYOIP Ipv6 to be registered under IPAM\n   */\n  BYOIP = \"byoip\",\n\n  /**\n   * Amazon Provided Ipv6 range\n   */\n  AMAZON = \"amazon\",\n}\n\n/**\n * Limits which service in AWS that the pool can be used in\n */\nexport enum AwsServiceName {\n  /**\n   *  Allows users to use space for Elastic IP addresses and VPCs\n   */\n  EC2 = \"ec2\",\n}\n\n/**\n * Options to create a new Ipam in the account\n */\nexport interface IpamProps {\n  /**\n   * The operating Regions for an IPAM.\n   * Operating Regions are AWS Regions where the IPAM is allowed to manage IP address CIDRs\n   * For more information about operating Regions, see [Create an IPAM](https://docs.aws.amazon.com//vpc/latest/ipam/create-ipam.html) in the *Amazon VPC IPAM User Guide* .\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html#cfn-ec2-ipam-operatingregions\n   *\n   * @default - Stack.region if defined in the stack\n   */\n  readonly operatingRegion?: string[];\n\n  /**\n   * Name of IPAM that can be used for tagging resource\n   *\n   * @default - If no name provided, no tags will be added to the IPAM\n   */\n  readonly ipamName?: string;\n}\n\n/**\n * Refers to two possible scope types under IPAM\n */\nexport enum IpamScopeType {\n  /**\n   * Default scopes created by IPAM\n   */\n  DEFAULT = \"default\",\n\n  /**\n   * Custom scope created using method\n   */\n  CUSTOM = \"custom\",\n}\n\n/**\n * Options for configuring an IPAM pool.\n *\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html\n */\nexport interface PoolOptions {\n  /**\n   * addressFamily - The address family of the pool (ipv4 or ipv6).\n   */\n  readonly addressFamily: AddressFamily;\n\n  /**\n   * Information about the CIDRs provisioned to the pool.\n   *\n   * @default - No CIDRs are provisioned\n   */\n  readonly ipv4ProvisionedCidrs?: string[];\n\n  /**\n   * The locale (AWS Region) of the pool. Should be one of the IPAM operating region.\n   *  Only resources in the same Region as the locale of the pool can get IP address allocations from the pool.\n   * You can only allocate a CIDR for a VPC, for example, from an IPAM pool that shares a locale with the VPC’s Region.\n   * Note that once you choose a Locale for a pool, you cannot modify it. If you choose an AWS Region for locale that has not been configured as an operating Region for the IPAM, you'll get an error.\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-locale\n   *\n   * @default - Current operating region of IPAM\n   */\n  readonly locale?: string;\n\n  /**\n   * The IP address source for pools in the public scope.\n   * Only used for IPv6 address\n   * Only allowed values to this are 'byoip' or 'amazon'\n   *\n   * @default amazon\n   */\n  readonly publicIpSource?: IpamPoolPublicIpSource;\n\n  /**\n   * Limits which service in AWS that the pool can be used in.\n   *\n   * \"ec2\", for example, allows users to use space for Elastic IP addresses and VPCs.\n   *\n   * @see http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-awsservice\n   *\n   * @default - required in case of an IPv6, throws an error if not provided.\n   */\n  readonly awsService?: AwsServiceName;\n\n  /**\n   * IPAM Pool resource name to be used for tagging\n   *\n   * @default - autogenerated by CDK if not provided\n   */\n  readonly ipamPoolName?: string;\n}\n\nconst NAME_TAG: string = \"Name\";\n\n/**\n * Properties for creating an IPAM pool.\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html\n */\ninterface IpamPoolProps extends PoolOptions, AwsConstructProps {\n  /**\n   * Scope id where pool needs to be created\n   */\n  readonly ipamScopeId: string;\n\n  /**\n   * Tags that are required for resources that use CIDRs from this IPAM pool. Resources that do not have\n   * these tags will not be allowed to allocate space from the pool. If the resources have their tags\n   * changed after they have allocated space or if the allocation tagging requirements are changed on\n   * the pool, the resource may be marked as noncompliant.\n   */\n  readonly allocationResourceTags?: Record<string, string>;\n\n  // TODO: Add support for more arguments\n  // @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam_pool#argument-reference\n  // @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html\n}\n\n/**\n * Options to provision CIDRs to an IPAM pool.\n * Used to create a new IpamPoolCidr\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampoolcidr.html\n */\nexport interface IpamPoolCidrProvisioningOptions {\n  /**\n   * Ipv6 Netmask length for the CIDR\n   *\n   * @default - pool provisioned without netmask length, need cidr range in this case\n   */\n  readonly netmaskLength?: number;\n\n  /**\n   * Ipv6 CIDR block for the IPAM pool\n   *\n   * @default - pool provisioned without netmask length, need netmask length in this case\n   */\n  readonly cidr?: string;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface IpamPoolOutputs {\n  /**\n   * Pool ID to be passed to the VPC construct\n   * @attribute IpamPoolId\n   */\n  readonly ipamPoolId: string;\n}\n\n/**\n * Definition used to add or create a new IPAM pool\n */\nexport interface IIpamPool extends IAwsConstruct {\n  /** strongly typed outputs */\n  readonly ipamPoolOutputs: IpamPoolOutputs;\n\n  /**\n   * Pool ID to be passed to the VPC construct\n   * @attribute IpamPoolId\n   */\n  readonly ipamPoolId: string;\n\n  /**\n   * Pool CIDR for IPv6 to be provisioned with Public IP source set to 'Amazon'\n   */\n  readonly ipamCidrs: tfIpamPoolCidr.VpcIpamPoolCidr[];\n\n  /**\n   * Pool CIDR for IPv4 to be provisioned using IPAM\n   * Required to check for subnet IP range is within the VPC range\n   */\n  readonly ipamIpv4Cidrs?: string[];\n\n  /**\n   * Function to associate a IPv6 address with IPAM pool\n   */\n  provisionCidr(\n    id: string,\n    options: IpamPoolCidrProvisioningOptions,\n  ): tfIpamPoolCidr.VpcIpamPoolCidr;\n}\n\n/**\n * IPAM scope is the highest-level container within IPAM. An IPAM contains two default scopes.\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html\n */\ninterface IpamScopeProps extends IpamScopeOptions {\n  /**\n   * IPAM id to which scope needs to be added\n   */\n  readonly ipamId: string;\n\n  /**\n   * Operating regions for the Ipam\n   * Required in order to validate the locale being set on pool\n   */\n  readonly ipamOperatingRegions: string[];\n\n  /**\n   * Custom ipam scope id to add a pool in order to support default scopes\n   *\n   * @default - throws an error if no scope id is provided\n   */\n  readonly ipamScopeId?: string;\n}\n\n/**\n * Being used in IPAM class to add pools to default scope created by IPAM.\n */\nexport interface IpamScopeOptions {\n  /**\n   * IPAM scope name that will be used for tagging\n   *\n   * @default - no tags will be added to the scope\n   */\n  readonly ipamScopeName?: string;\n}\n\n/**\n * Options for configuring an IP Address Manager (IPAM).\n *\n * For more information, see the {@link https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipam.html}.\n */\nexport interface IpamOptions {\n  /**\n   * CIDR Mask for Vpc\n   * Only required when using AWS Ipam\n   *\n   * @default - no netmask length for IPAM attached to VPC secondary address\n   */\n  readonly netmaskLength?: number;\n\n  /**\n   * Ipv4 or an Ipv6 IPAM pool\n   * Only required when using AWS Ipam\n   *\n   * @default - no pool attached to VPC secondary address\n   */\n  readonly ipamPool?: IIpamPool;\n\n  /**\n   * Required to set Secondary cidr block resource name\n   * in order to generate unique logical id for the resource.\n   */\n  readonly cidrBlockName: string;\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface IpamScopeOutputs {\n  /**\n   * Scope ID to be passed to the VPC construct\n   * @attribute IpamScopeId\n   */\n  readonly ipamScopeId: string;\n}\n\n/**\n * Interface for IpamScope Class\n */\nexport interface IIpamScopeBase {\n  /** strongly typed outputs */\n  readonly ipamScopeOutputs: IpamScopeOutputs;\n\n  /**\n   * Reference to the current scope of stack to be passed in order to create\n   * a new IPAM pool\n   */\n  readonly scope: Construct;\n\n  /**\n   * Default Scope ids created by the IPAM or a new Resource id\n   */\n  readonly scopeId: string;\n\n  /**\n   * Defines scope type can be either default or custom\n   */\n  readonly scopeType?: IpamScopeType;\n\n  /**\n   * Function to add a new pool to an IPAM scope\n   */\n  addPool(id: string, options: PoolOptions): IIpamPool;\n}\n\n/**\n * Creates new IPAM Pool\n * Pools enable you to organize your IP addresses according to your routing and security needs\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html\n * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam_pool\n * @resource aws_vpc_ipam_pool\n * @internal\n */\nclass IpamPool extends AwsConstructBase implements IIpamPool {\n  public get ipamPoolOutputs(): IpamPoolOutputs {\n    return {\n      ipamPoolId: this.ipamPoolId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.ipamPoolOutputs;\n  }\n  /**\n   * Pool ID to be passed to the VPC construct\n   * @attribute IpamPoolId\n   */\n  public readonly ipamPoolId: string;\n\n  /**\n   * Pool CIDR for IPv6 to be provisioned with Public IP source set to 'Amazon'\n   */\n  public readonly ipamCidrs: tfIpamPoolCidr.VpcIpamPoolCidr[] = [];\n\n  /**\n   * Pool CIDR for IPv4 to be provisioned using IPAM\n   * Required to check for subnet IP range is within the VPC range\n   */\n  public readonly ipamIpv4Cidrs: string[] = [];\n\n  /**\n   * Reference to ipamPool resource created in this class\n   */\n  private readonly _ipamPool: tfIpamPool.VpcIpamPool;\n\n  constructor(scope: Construct, id: string, props: IpamPoolProps) {\n    super(scope, id, props);\n    const ipamPoolName =\n      props.ipamPoolName ??\n      Lazy.stringValue({\n        produce: () =>\n          this.stack.uniqueResourceName(this, {\n            maxLength: 128,\n            allowedSpecialCharacters: \"_\",\n          }),\n      });\n\n    if (props.addressFamily === AddressFamily.IP_V6 && !props.awsService) {\n      throw new Error(\n        \"awsService is required when addressFamily is set to ipv6\",\n      );\n    }\n\n    //Add tags to the IPAM Pool if name is provided\n    if (ipamPoolName) {\n      Tags.of(this).add(NAME_TAG, ipamPoolName);\n    }\n\n    this._ipamPool = new tfIpamPool.VpcIpamPool(this, \"Resource\", {\n      addressFamily: props.addressFamily,\n      locale: props.locale,\n      ipamScopeId: props.ipamScopeId,\n      publicIpSource: props.publicIpSource,\n      awsService: props.awsService,\n      allocationResourceTags: props.allocationResourceTags,\n    });\n    this.ipamPoolId = this._ipamPool.id;\n\n    // provisionedCidrs: props.ipv4ProvisionedCidrs?.map((cidr) => ({ cidr })),\n    // Populating to check for subnet range against all IPv4 ranges assigned to VPC including IPAM\n    props.ipv4ProvisionedCidrs?.forEach((cidr) => {\n      this.ipamIpv4Cidrs.push(cidr);\n      // Terraform VpcIpamPool does not support inline \"ProvisionedCidrs\" property\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipampool.html#cfn-ec2-ipampool-provisionedcidrs\n      this.provisionCidr(\"ProvisionedCidr\", { cidr });\n    });\n  }\n\n  /**\n   * A CIDR provisioned to an IPAM pool.\n   * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam_pool_cidr\n   * @param id Name of Resource\n   * @param options Either a CIDR or netmask length must be provided\n   * @returns aws_vpc_ipam_pool_cidr\n   */\n  public provisionCidr(\n    id: string,\n    options: IpamPoolCidrProvisioningOptions,\n  ): tfIpamPoolCidr.VpcIpamPoolCidr {\n    // TODO: Error if neither or both cidr and netmask length are provided\n    const cidr = new tfIpamPoolCidr.VpcIpamPoolCidr(this, id, {\n      ...options,\n      ipamPoolId: this.ipamPoolId,\n    });\n    this.ipamCidrs.push(cidr);\n    return cidr;\n  }\n}\n\n/**\n * Creates custom Ipam Scope, custom IPAM scopes can only be private\n * (can be used for adding custom scopes to an existing IPAM)\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html\n * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam_scope\n * @resource aws_vpc_ipam_scope\n */\nclass IpamScope extends AwsConstructBase implements IIpamScopeBase {\n  public get ipamScopeOutputs(): IpamScopeOutputs {\n    return {\n      ipamScopeId: this.scopeId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.ipamScopeOutputs;\n  }\n  /**\n   * Stores the reference to newly created Resource\n   */\n  private readonly _ipamScope: tfIpamScope.VpcIpamScope;\n\n  /**\n   * ID for Resource IpamScope\n   * @attribute IpamScopeId\n   */\n  public readonly scopeId: string;\n\n  /**\n   * Properties to configure ipam scope\n   */\n  private readonly props: IpamScopeProps;\n\n  /**\n   * Reference to stack scope to be passed through addPool method inorder to create a new IpamPool\n   */\n  public readonly scope: Construct;\n\n  /**\n   * Defines scope type can be either default or custom\n   */\n  public readonly scopeType: IpamScopeType;\n\n  constructor(scope: Construct, id: string, props: IpamScopeProps) {\n    super(scope, id);\n    this._ipamScope = new tfIpamScope.VpcIpamScope(scope, \"Resource\", {\n      ipamId: props.ipamId,\n    });\n    Tags.of(this._ipamScope).add(\n      NAME_TAG,\n      props.ipamScopeName ?? \"CustomIpamScope\",\n    );\n    this.scopeId = this._ipamScope.id;\n    this.scopeType = IpamScopeType.CUSTOM;\n    this.scope = scope;\n    this.props = props;\n  }\n\n  /**\n   * Adds a pool to the IPAM scope.\n   * @external\n   */\n  addPool(id: string, options: PoolOptions): IIpamPool {\n    return createIpamPool(this.scope, id, this.props, options, this.scopeId);\n  }\n}\n\n/**\n * Base class for IPAM default scopes.\n */\nclass IpamScopeBase implements IIpamScopeBase {\n  public get ipamScopeOutputs(): IpamScopeOutputs {\n    return {\n      ipamScopeId: this.scopeId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.ipamScopeOutputs;\n  }\n  constructor(\n    readonly scope: Construct,\n    readonly scopeId: string,\n    private readonly props: IpamScopeProps,\n    readonly scopeType?: IpamScopeType,\n  ) {\n    this.scopeType = IpamScopeType.DEFAULT;\n    if (!props.ipamScopeId) {\n      throw new Error(\"ipamScopeId is required\");\n    } else {\n      this.scopeId = props.ipamScopeId;\n    }\n  }\n\n  /**\n   * Adds a pool to the IPAM scope.\n   * @external\n   */\n  addPool(id: string, options: PoolOptions): IIpamPool {\n    return createIpamPool(this.scope, id, this.props, options, this.scopeId);\n  }\n}\n\nexport interface IpamOutputs {\n  /**\n   * Ipam ID to be passed to the VPC construct\n   * @attribute IpamId\n   */\n  readonly ipamId: string;\n}\n\n/**\n * Creates new IPAM with default public and private scope\n * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html\n * @see https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/vpc_ipam\n * @resource aws_vpc_ipam\n */\nexport class Ipam extends AwsConstructBase {\n  public get ipamOutputs(): IpamOutputs {\n    return {\n      ipamId: this.ipamId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.ipamOutputs;\n  }\n  /**\n   * Provides access to default public IPAM scope through add pool method.\n   * Usage: To add an Ipam Pool to a default public scope\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html\n   */\n  public readonly publicScope: IIpamScopeBase;\n\n  /**\n   * Provides access to default private IPAM scope through add pool method.\n   * Usage: To add an Ipam Pool to a default private scope\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-ipamscope.html\n   * */\n  public readonly privateScope: IIpamScopeBase;\n\n  // Resource IPAM\n  private readonly _ipam: tfIpam.VpcIpam;\n  /**\n   * Access to Ipam resource id that can be used later to add a custom private scope to this IPAM\n   * @attribute IpamId\n   */\n  public readonly ipamId: string;\n\n  /**\n   * List of operating regions for IPAM\n   */\n  public readonly operatingRegions: string[];\n\n  /**\n   * List of scopes created under this IPAM\n   */\n  public readonly scopes: IIpamScopeBase[] = [];\n\n  /**\n   * IPAM name to be used for tagging\n   * @default no tag specified\n   * @attribute IpamName\n   */\n  public readonly ipamName?: string;\n\n  constructor(scope: Construct, id: string, props?: IpamProps) {\n    super(scope, id);\n    if (props?.ipamName) {\n      Tags.of(this).add(NAME_TAG, props.ipamName);\n    }\n    if (!props?.operatingRegion && !this.env.region) {\n      throw new Error(\"Please provide at least one operating region\");\n    }\n\n    this.operatingRegions = props?.operatingRegion ?? [this.env.region];\n    this.ipamName = props?.ipamName;\n\n    this._ipam = new tfIpam.VpcIpam(this, \"Ipam\", {\n      operatingRegions: this.operatingRegions\n        ? this.operatingRegions.map((region) => ({ regionName: region }))\n        : [],\n    });\n    this.node.defaultChild = this._ipam;\n\n    this.ipamId = this._ipam.id;\n    this.publicScope = new IpamScopeBase(this, \"DefaultPublicScope\", {\n      ipamOperatingRegions: this.operatingRegions,\n      ipamId: this._ipam.id,\n      ipamScopeId: this._ipam.publicDefaultScopeId,\n    });\n    this.privateScope = new IpamScopeBase(this, \"DefaultPrivateScope\", {\n      ipamOperatingRegions: this.operatingRegions,\n      ipamId: this._ipam.id,\n      ipamScopeId: this._ipam.privateDefaultScopeId,\n    });\n\n    this.scopes.push(this.publicScope, this.privateScope);\n  }\n\n  /**\n   * Function to add custom scope to an existing IPAM\n   * Custom scopes can only be private\n   */\n  public addScope(\n    scope: Construct,\n    id: string,\n    options: IpamScopeOptions,\n  ): IIpamScopeBase {\n    const ipamScope = new IpamScope(scope, id, {\n      ...options,\n      ipamId: this.ipamId,\n      ipamOperatingRegions: this.operatingRegions,\n    });\n    this.scopes.push(ipamScope);\n    return ipamScope;\n  }\n}\n\n/**\n * Function to create IpamPool under scope\n * @internal\n */\nfunction createIpamPool(\n  scope: Construct,\n  id: string,\n  scopeOptions: IpamScopeProps,\n  poolOptions: PoolOptions,\n  scopeId: string,\n): IpamPool {\n  const isLocaleInOperatingRegions = scopeOptions.ipamOperatingRegions\n    ? scopeOptions.ipamOperatingRegions\n        .map((region) => ({ regionName: region }))\n        .some((region) => region.regionName === poolOptions.locale)\n    : false;\n\n  if (!isLocaleInOperatingRegions) {\n    throw new Error(\n      `The provided locale '${poolOptions.locale}' is not in the operating regions.`,\n    );\n  }\n\n  return new IpamPool(scope, id, {\n    ipamPoolName: poolOptions.ipamPoolName,\n    addressFamily: poolOptions.addressFamily,\n    ipv4ProvisionedCidrs: poolOptions.ipv4ProvisionedCidrs,\n    ipamScopeId: scopeId,\n    locale: poolOptions.locale,\n    publicIpSource: poolOptions.publicIpSource,\n    awsService: poolOptions.awsService,\n  });\n}\n"]}

package/lib/aws/compute/key-pair.d.ts

@@ -0,0 +1,178 @@
+import { keyPair as tfKeyPair } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { OperatingSystemType } from "./machine-image";
+import { AwsConstructBase, AwsConstructProps, IAwsConstruct } from "../aws-construct";
+import { IStringParameter } from "../storage/parameter";
+/**
+ * The type of the key pair.
+ */
+export declare enum KeyPairType {
+    /**
+     * An RSA key.
+     */
+    RSA = "rsa",
+    /**
+     * An ED25519 key.
+     *
+     * Note that ED25519 keys are not supported for Windows instances.
+     */
+    ED25519 = "ed25519"
+}
+/**
+ * The properties of a Key Pair
+ */
+export interface KeyPairProps extends AwsConstructProps {
+    /**
+     * A unique name for the key pair.
+     *
+     * @default A generated name
+     */
+    readonly keyPairName?: string;
+    /**
+     * Creates a unique name beginning with the specified prefix.
+     *
+     * Conflicts with `keyPairName`. If neither `keyPairName` nor `keyPairNamePrefix` is provided,
+     * TerraConstructs will create a unique key name using the `gridUUID` as prefix.
+     *
+     * @default A generated name
+     */
+    readonly keyPairNamePrefix?: string;
+    /**
+     * The type of key pair.
+     *
+     * @default RSA (ignored if keyMaterial is provided)
+     */
+    readonly type?: KeyPairType;
+    /**
+     * The public key material.
+     *
+     * If this is provided the key is considered "imported". For imported
+     * keys, it is assumed that you already have the private key material
+     * so the private key material will not be returned or stored in
+     * AWS Systems Manager Parameter Store.
+     *
+     * The private key generated by this resource will be stored unencrypted
+     * in your Terraform state file.
+     *
+     * Omitting the publicKeyMaterial for production deployments is not recommended.
+     * Instead, generate a private key file outside of Terraform and distribute it
+     * securely to the system where Terraform will be run.
+     *
+     * @default a public and private key will be generated
+     */
+    readonly publicKeyMaterial?: string;
+}
+/**
+ * Outputs which may be registered for output via the Grid.
+ */
+export interface KeyPairOutputs {
+    /**
+     * The unique name of the key pair.
+     */
+    readonly keyPairName: string;
+    /**
+     * The type of the key pair.
+     *
+     * @default no type specified
+     */
+    readonly type?: KeyPairType;
+}
+/**
+ * Attributes of a Key Pair.
+ */
+export interface KeyPairAttributes {
+    /**
+     * The unique name of the key pair.
+     */
+    readonly keyPairName: string;
+    /**
+     * The type of the key pair.
+     *
+     * @default no type specified
+     */
+    readonly type?: KeyPairType;
+}
+/**
+ * An EC2 Key Pair.
+ */
+export interface IKeyPair extends IAwsConstruct {
+    /** Strongly typed outputs */
+    readonly keyPairOutputs: KeyPairOutputs;
+    /**
+     * The name of the key pair.
+     *
+     * @attribute
+     */
+    readonly keyPairName: string;
+    /**
+     * The type of the key pair.
+     */
+    readonly type?: KeyPairType;
+    /**
+     * Used internally to determine whether the key pair is compatible with an OS type.
+     *
+     * @internal
+     */
+    _isOsCompatible(osType: OperatingSystemType): boolean;
+}
+/**
+ * An EC2 Key Pair.
+ *
+ * @resource AWS::EC2::KeyPair
+ */
+export declare class KeyPair extends AwsConstructBase implements IKeyPair {
+    /**
+     * Imports a key pair based on the name.
+     */
+    static fromKeyPairName(scope: Construct, id: string, keyPairName: string): IKeyPair;
+    /**
+     * Imports a key pair with a name and optional type.
+     */
+    static fromKeyPairAttributes(scope: Construct, id: string, attrs: KeyPairAttributes): IKeyPair;
+    get keyPairOutputs(): KeyPairOutputs;
+    get outputs(): Record<string, any>;
+    /**
+     * The unique name of the key pair.
+     *
+     * @attribute
+     */
+    readonly keyPairName: string;
+    /**
+     * The fingerprint of the key pair.
+     *
+     * @attribute
+     */
+    readonly keyPairFingerprint: string;
+    /**
+     * The unique ID of the key pair.
+     *
+     * @attribute
+     */
+    readonly keyPairId: string;
+    /**
+     * The type of the key pair.
+     */
+    readonly type?: KeyPairType;
+    private _privateKey?;
+    private _privateKeySsm?;
+    private readonly _isImport;
+    readonly resource: tfKeyPair.KeyPair;
+    constructor(scope: Construct, id: string, props?: KeyPairProps);
+    /**
+     * Whether the key material was imported.
+     *
+     * Keys with imported material do not have their private key material stored
+     * or returned automatically.
+     */
+    get hasImportedMaterial(): boolean;
+    /**
+     * The Systems Manager Parameter Store parameter with the pair's private key material.
+     */
+    get privateKey(): IStringParameter;
+    /**
+     * Used internally to determine whether the key pair is compatible with an OS type.
+     *
+     * @internal
+     */
+    _isOsCompatible(osType: OperatingSystemType): boolean;
+}