terraconstructs 0.0.11 → 0.0.12

package/lib/aws/compute/volume.js

@@ -0,0 +1,426 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Volume = exports.EbsDeviceVolumeType = exports.BlockDeviceVolume = 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/volume.ts
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const iam_1 = require("../iam");
+const helpers_internal_1 = require("../../helpers-internal");
+const size_1 = require("../../size");
+const aws_construct_1 = require("../aws-construct");
+const aws_stack_1 = require("../aws-stack");
+// TODO: Use TagManager and tag-aspect instead
+const aws_tags_1 = require("../aws-tags");
+// import { Tags } from "../tag-aspect";
+const encryption_1 = require("../encryption");
+/**
+ * Describes a block device mapping for an EC2 instance or Auto Scaling group.
+ */
+class BlockDeviceVolume {
+    /**
+     * Creates a new Elastic Block Storage device
+     *
+     * @param volumeSize The volume size, in Gibibytes (GiB)
+     * @param options additional device options
+     */
+    static ebs(volumeSize, options = {}) {
+        return new this({ ...options, volumeSize });
+    }
+    /**
+     * Creates a new Elastic Block Storage device from an existing snapshot
+     *
+     * @param snapshotId The snapshot ID of the volume to use
+     * @param options additional device options
+     */
+    static ebsFromSnapshot(snapshotId, options = {}) {
+        return new this({ ...options, snapshotId });
+    }
+    /**
+     * Creates a virtual, ephemeral device.
+     * The name will be in the form ephemeral{volumeIndex}.
+     *
+     * @param volumeIndex the volume index. Must be equal or greater than 0
+     */
+    static ephemeral(volumeIndex) {
+        if (volumeIndex < 0) {
+            throw new Error(`volumeIndex must be a number starting from 0, got "${volumeIndex}"`);
+        }
+        return new this(undefined, `ephemeral${volumeIndex}`);
+    }
+    /**
+     * @param ebsDevice EBS device info
+     * @param virtualName Virtual device name
+     */
+    constructor(ebsDevice, virtualName) {
+        this.ebsDevice = ebsDevice;
+        this.virtualName = virtualName;
+    }
+    isEphemeral() {
+        return this.virtualName !== undefined;
+    }
+}
+exports.BlockDeviceVolume = BlockDeviceVolume;
+_a = JSII_RTTI_SYMBOL_1;
+BlockDeviceVolume[_a] = { fqn: "terraconstructs.aws.compute.BlockDeviceVolume", version: "0.0.12" };
+/**
+ * Supported EBS volume types for blockDevices
+ */
+var EbsDeviceVolumeType;
+(function (EbsDeviceVolumeType) {
+    /**
+     * Magnetic
+     */
+    EbsDeviceVolumeType["STANDARD"] = "standard";
+    /**
+     *  Provisioned IOPS SSD - IO1
+     */
+    EbsDeviceVolumeType["IO1"] = "io1";
+    /**
+     *  Provisioned IOPS SSD - IO2
+     */
+    EbsDeviceVolumeType["IO2"] = "io2";
+    /**
+     * General Purpose SSD - GP2
+     */
+    EbsDeviceVolumeType["GP2"] = "gp2";
+    /**
+     * General Purpose SSD - GP3
+     */
+    EbsDeviceVolumeType["GP3"] = "gp3";
+    /**
+     * Throughput Optimized HDD
+     */
+    EbsDeviceVolumeType["ST1"] = "st1";
+    /**
+     * Cold HDD
+     */
+    EbsDeviceVolumeType["SC1"] = "sc1";
+    /**
+     * General purpose SSD volume (GP2) that balances price and performance for a wide variety of workloads.
+     */
+    EbsDeviceVolumeType["GENERAL_PURPOSE_SSD"] = "gp2";
+    /**
+     * General purpose SSD volume (GP3) that balances price and performance for a wide variety of workloads.
+     */
+    EbsDeviceVolumeType["GENERAL_PURPOSE_SSD_GP3"] = "gp3";
+    /**
+     * Highest-performance SSD volume (IO1) for mission-critical low-latency or high-throughput workloads.
+     */
+    EbsDeviceVolumeType["PROVISIONED_IOPS_SSD"] = "io1";
+    /**
+     * Highest-performance SSD volume (IO2) for mission-critical low-latency or high-throughput workloads.
+     */
+    EbsDeviceVolumeType["PROVISIONED_IOPS_SSD_IO2"] = "io2";
+    /**
+     * Low-cost HDD volume designed for frequently accessed, throughput-intensive workloads.
+     */
+    EbsDeviceVolumeType["THROUGHPUT_OPTIMIZED_HDD"] = "st1";
+    /**
+     * Lowest cost HDD volume designed for less frequently accessed workloads.
+     */
+    EbsDeviceVolumeType["COLD_HDD"] = "sc1";
+    /**
+     * Magnetic volumes are backed by magnetic drives and are suited for workloads where data is accessed infrequently, and scenarios where low-cost
+     * storage for small volume sizes is important.
+     */
+    EbsDeviceVolumeType["MAGNETIC"] = "standard";
+})(EbsDeviceVolumeType || (exports.EbsDeviceVolumeType = EbsDeviceVolumeType = {}));
+/**
+ * Common behavior of Volumes. Users should not use this class directly, and instead use ``Volume``.
+ */
+class VolumeBase extends aws_construct_1.AwsConstructBase {
+    get volumeOutputs() {
+        return {
+            volumeId: this.volumeId,
+            availabilityZone: this.availabilityZone,
+            encryptionKeyId: this.encryptionKey?.keyId,
+        };
+    }
+    get outputs() {
+        return this.volumeOutputs;
+    }
+    grantAttachVolume(grantee, instances) {
+        const result = iam_1.Grant.addToPrincipal({
+            grantee,
+            actions: ["ec2:AttachVolume"],
+            resourceArns: this.collectGrantResourceArns(instances),
+        });
+        if (this.encryptionKey) {
+            // When attaching a volume, the EC2 Service will need to grant to itself permission
+            // to be able to decrypt the encryption key. We restrict the CreateGrant for principle
+            // of least privilege, in accordance with best practices.
+            // See: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#ebs-encryption-permissions
+            const kmsGrant = this.encryptionKey.grant(grantee, "kms:CreateGrant");
+            kmsGrant.principalStatement.addConditions({
+                test: "Bool",
+                variable: "kms:GrantIsForAWSResource",
+                values: ["true"],
+            }, {
+                test: "StringEquals",
+                variable: "kms:ViaService",
+                values: [`ec2.${aws_stack_1.AwsStack.ofAwsConstruct(this).region}.amazonaws.com`],
+            }, {
+                test: "StringEquals",
+                variable: "kms:GrantConstraintType",
+                values: ["EncryptionContextSubset"],
+            });
+        }
+        return result;
+    }
+    grantAttachVolumeByResourceTag(grantee, constructs, tagKeySuffix) {
+        const tagValue = this.calculateResourceTagValue([this, ...constructs]);
+        const tagKey = `VolumeGrantAttach-${tagKeySuffix ?? tagValue.slice(0, 10).toUpperCase()}`;
+        const result = this.grantAttachVolume(grantee);
+        result.principalStatement.addCondition({
+            test: "ForAnyValue:StringEquals",
+            variable: `ec2:ResourceTag/${tagKey}`,
+            values: [tagValue],
+        });
+        // The ResourceTag condition requires that all resources involved in the operation have
+        // the given tag, so we tag this and all constructs given.
+        aws_tags_1.Tags.of(this).add(tagKey, tagValue);
+        constructs.forEach((construct) => aws_tags_1.Tags.of(construct).add(tagKey, tagValue));
+        return result;
+    }
+    grantDetachVolume(grantee, instances) {
+        const result = iam_1.Grant.addToPrincipal({
+            grantee,
+            actions: ["ec2:DetachVolume"],
+            resourceArns: this.collectGrantResourceArns(instances),
+        });
+        // Note: No encryption key permissions are required to detach an encrypted volume.
+        return result;
+    }
+    grantDetachVolumeByResourceTag(grantee, constructs, tagKeySuffix) {
+        const tagValue = this.calculateResourceTagValue([this, ...constructs]);
+        const tagKey = `VolumeGrantDetach-${tagKeySuffix ?? tagValue.slice(0, 10).toUpperCase()}`;
+        const result = this.grantDetachVolume(grantee);
+        result.principalStatement.addCondition({
+            test: "ForAnyValue:StringEquals",
+            variable: `ec2:ResourceTag/${tagKey}`,
+            values: [tagValue],
+        });
+        // The ResourceTag condition requires that all resources involved in the operation have
+        // the given tag, so we tag this and all constructs given.
+        aws_tags_1.Tags.of(this).add(tagKey, tagValue);
+        constructs.forEach((construct) => aws_tags_1.Tags.of(construct).add(tagKey, tagValue));
+        return result;
+    }
+    collectGrantResourceArns(instances) {
+        const stack = aws_stack_1.AwsStack.ofAwsConstruct(this);
+        const resourceArns = [
+            `arn:${stack.partition}:ec2:${stack.region}:${stack.account}:volume/${this.volumeId}`,
+        ];
+        const instanceArnPrefix = `arn:${stack.partition}:ec2:${stack.region}:${stack.account}:instance`;
+        if (instances) {
+            instances.forEach((instance) => resourceArns.push(`${instanceArnPrefix}/${instance?.instanceId}`));
+        }
+        else {
+            resourceArns.push(`${instanceArnPrefix}/*`);
+        }
+        return resourceArns;
+    }
+    calculateResourceTagValue(constructs) {
+        return (0, helpers_internal_1.md5hash)(constructs.map((c) => aws_stack_1.AwsStack.uniqueId(c)).join(""));
+    }
+}
+/**
+ * Creates a new EBS Volume in AWS EC2.
+ */
+class Volume extends VolumeBase {
+    /**
+     * Import an existing EBS Volume into the Stack.
+     *
+     * @param scope the scope of the import.
+     * @param id    the ID of the imported Volume in the construct tree.
+     * @param attrs the attributes of the imported Volume
+     */
+    static fromVolumeAttributes(scope, id, attrs) {
+        class Import extends VolumeBase {
+            constructor() {
+                super(...arguments);
+                this.volumeId = attrs.volumeId;
+                this.availabilityZone = attrs.availabilityZone;
+                this.encryptionKey = attrs.encryptionKey;
+            }
+        }
+        // Check that the provided volumeId looks like it could be valid.
+        if (!cdktf_1.Token.isUnresolved(attrs.volumeId) &&
+            !/^vol-[0-9a-fA-F]+$/.test(attrs.volumeId)) {
+            throw new Error("`volumeId` does not match expected pattern. Expected `vol-<hexadecmial value>` (ex: `vol-05abe246af`) or a Token");
+        }
+        return new Import(scope, id);
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const volumeName = props.volumeName ||
+            this.stack.uniqueResourceName(this, {
+                prefix: this.gridUUID,
+            });
+        this.validateProps(props);
+        this.resource = new provider_aws_1.ebsVolume.EbsVolume(this, "Resource", {
+            availabilityZone: props.availabilityZone,
+            // autoEnableIo: props.autoEnableIo,
+            encrypted: props.encrypted,
+            kmsKeyId: props.encryptionKey?.keyArn,
+            iops: props.iops,
+            multiAttachEnabled: props.enableMultiAttach ?? false,
+            size: props.size?.toGibibytes({ rounding: size_1.SizeRoundingBehavior.FAIL }),
+            snapshotId: props.snapshotId,
+            throughput: props.throughput,
+            type: props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3,
+        });
+        if (props.volumeName)
+            aws_tags_1.Tags.of(this.resource).add("Name", volumeName);
+        this.volumeId = this.resource.id;
+        this.availabilityZone = props.availabilityZone;
+        this.encryptionKey = props.encryptionKey;
+        if (this.encryptionKey) {
+            // Per: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#ebs-encryption-requirements
+            const principal = new encryption_1.ViaServicePrincipal(`ec2.${aws_stack_1.AwsStack.ofAwsConstruct(this).region}.amazonaws.com`, new iam_1.AccountRootPrincipal()).withConditions({
+                test: "StringEquals",
+                variable: "kms:CallerAccount",
+                values: [aws_stack_1.AwsStack.ofAwsConstruct(this).account],
+            });
+            const grant = this.encryptionKey.grant(principal, 
+            // Describe & Generate are required to be able to create the CMK-encrypted Volume.
+            "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText");
+            if (props.snapshotId) {
+                // ReEncrypt is required for when re-encrypting from an encrypted snapshot.
+                grant.principalStatement?.addActions("kms:ReEncrypt*");
+            }
+        }
+    }
+    validateProps(props) {
+        if (!(props.size || props.snapshotId)) {
+            throw new Error("Must provide at least one of `size` or `snapshotId`");
+        }
+        if (props.snapshotId &&
+            !cdktf_1.Token.isUnresolved(props.snapshotId) &&
+            !/^snap-[0-9a-fA-F]+$/.test(props.snapshotId)) {
+            throw new Error("`snapshotId` does match expected pattern. Expected `snap-<hexadecmial value>` (ex: `snap-05abe246af`) or Token");
+        }
+        if (props.encryptionKey && !props.encrypted) {
+            throw new Error("`encrypted` must be true when providing an `encryptionKey`.");
+        }
+        if (props.volumeType &&
+            [
+                EbsDeviceVolumeType.PROVISIONED_IOPS_SSD,
+                EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2,
+            ].includes(props.volumeType) &&
+            !props.iops) {
+            throw new Error("`iops` must be specified if the `volumeType` is `PROVISIONED_IOPS_SSD` or `PROVISIONED_IOPS_SSD_IO2`.");
+        }
+        if (props.iops) {
+            const volumeType = props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD;
+            if (![
+                EbsDeviceVolumeType.PROVISIONED_IOPS_SSD,
+                EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2,
+                EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3,
+            ].includes(volumeType)) {
+                throw new Error("`iops` may only be specified if the `volumeType` is `PROVISIONED_IOPS_SSD`, `PROVISIONED_IOPS_SSD_IO2` or `GENERAL_PURPOSE_SSD_GP3`.");
+            }
+            // Enforce minimum & maximum IOPS:
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html
+            const iopsRanges = {};
+            iopsRanges[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3] = {
+                Min: 3000,
+                Max: 16000,
+            };
+            iopsRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD] = {
+                Min: 100,
+                Max: 64000,
+            };
+            iopsRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2] = {
+                Min: 100,
+                Max: 256000,
+            };
+            const { Min, Max } = iopsRanges[volumeType];
+            if (props.iops < Min || props.iops > Max) {
+                throw new Error(`\`${volumeType}\` volumes iops must be between ${Min} and ${Max}.`);
+            }
+            // Enforce maximum ratio of IOPS/GiB:
+            // https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html
+            const maximumRatios = {};
+            maximumRatios[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3] = 500;
+            maximumRatios[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD] = 50;
+            maximumRatios[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2] = 500;
+            const maximumRatio = maximumRatios[volumeType];
+            if (props.size &&
+                props.iops >
+                    maximumRatio *
+                        props.size.toGibibytes({ rounding: size_1.SizeRoundingBehavior.FAIL })) {
+                throw new Error(`\`${volumeType}\` volumes iops has a maximum ratio of ${maximumRatio} IOPS/GiB.`);
+            }
+            const maximumThroughputRatios = {};
+            maximumThroughputRatios[EbsDeviceVolumeType.GP3] = 0.25;
+            const maximumThroughputRatio = maximumThroughputRatios[volumeType];
+            if (props.throughput && props.iops) {
+                const iopsRatio = props.throughput / props.iops;
+                if (iopsRatio > maximumThroughputRatio) {
+                    throw new Error(`Throughput (MiBps) to iops ratio of ${iopsRatio} is too high; maximum is ${maximumThroughputRatio} MiBps per iops`);
+                }
+            }
+        }
+        if (props.enableMultiAttach) {
+            const volumeType = props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD;
+            if (![
+                EbsDeviceVolumeType.PROVISIONED_IOPS_SSD,
+                EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2,
+            ].includes(volumeType)) {
+                throw new Error("multi-attach is supported exclusively on `PROVISIONED_IOPS_SSD` and `PROVISIONED_IOPS_SSD_IO2` volumes.");
+            }
+        }
+        if (props.size) {
+            const size = props.size.toGibibytes({
+                rounding: size_1.SizeRoundingBehavior.FAIL,
+            });
+            // Enforce minimum & maximum volume size:
+            // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html
+            const sizeRanges = {};
+            sizeRanges[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD] = {
+                Min: 1,
+                Max: 16384,
+            };
+            sizeRanges[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3] = {
+                Min: 1,
+                Max: 16384,
+            };
+            sizeRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD] = {
+                Min: 4,
+                Max: 16384,
+            };
+            sizeRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2] = {
+                Min: 4,
+                Max: 16384,
+            };
+            sizeRanges[EbsDeviceVolumeType.THROUGHPUT_OPTIMIZED_HDD] = {
+                Min: 125,
+                Max: 16384,
+            };
+            sizeRanges[EbsDeviceVolumeType.COLD_HDD] = { Min: 125, Max: 16384 };
+            sizeRanges[EbsDeviceVolumeType.MAGNETIC] = { Min: 1, Max: 1024 };
+            const volumeType = props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD;
+            const { Min, Max } = sizeRanges[volumeType];
+            if (size < Min || size > Max) {
+                throw new Error(`\`${volumeType}\` volumes must be between ${Min} GiB and ${Max} GiB in size.`);
+            }
+        }
+        if (props.throughput) {
+            const throughputRange = { Min: 125, Max: 1000 };
+            const { Min, Max } = throughputRange;
+            if (props.volumeType != EbsDeviceVolumeType.GP3) {
+                throw new Error("throughput property requires volumeType: EbsDeviceVolumeType.GP3");
+            }
+            if (props.throughput < Min || props.throughput > Max) {
+                throw new Error(`throughput property takes a minimum of ${Min} and a maximum of ${Max}`);
+            }
+        }
+    }
+}
+exports.Volume = Volume;
+_b = JSII_RTTI_SYMBOL_1;
+Volume[_b] = { fqn: "terraconstructs.aws.compute.Volume", version: "0.0.12" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"volume.js","sourceRoot":"","sources":["../../../src/aws/compute/volume.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/volume.ts\n\nimport { ebsVolume } from \"@cdktf/provider-aws\";\nimport { Token } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { AccountRootPrincipal, Grant, IGrantable } from \"../iam\";\nimport { IInstance } from \"./instance\";\nimport { md5hash } from \"../../helpers-internal\";\nimport { Size, SizeRoundingBehavior } from \"../../size\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\nimport { AwsStack } from \"../aws-stack\";\n// TODO: Use TagManager and tag-aspect instead\nimport { Tags } from \"../aws-tags\";\n// import { Tags } from \"../tag-aspect\";\nimport { IKey, ViaServicePrincipal } from \"../encryption\";\n\n/**\n * Block device\n */\nexport interface BlockDevice {\n  /**\n   * The device name exposed to the EC2 instance\n   *\n   * For example, a value like `/dev/sdh`, `xvdh`.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/device_naming.html\n   */\n  readonly deviceName: string;\n\n  /**\n   * Defines the block device volume, to be either an Amazon EBS volume or an ephemeral instance store volume\n   *\n   * For example, a value like `BlockDeviceVolume.ebs(15)`, `BlockDeviceVolume.ephemeral(0)`.\n   */\n  readonly volume: BlockDeviceVolume;\n\n  /**\n   * If false, the device mapping will be suppressed.\n   * If set to false for the root device, the instance might fail the Amazon EC2 health check.\n   * Amazon EC2 Auto Scaling launches a replacement instance if the instance fails the health check.\n   *\n   * NOTE: Terraform Provider AWS does not support this for aws_instance non-ephemeral Block Devices\n   *\n   * @default true - device mapping is left untouched\n   */\n  readonly mappingEnabled?: boolean;\n}\n\n/**\n * Base block device options for an EBS volume\n */\nexport interface EbsDeviceOptionsBase {\n  /**\n   * Indicates whether to delete the volume when the instance is terminated.\n   *\n   * @default - true for Amazon EC2 Auto Scaling, false otherwise (e.g. EBS)\n   */\n  readonly deleteOnTermination?: boolean;\n\n  /**\n   * The number of I/O operations per second (IOPS) to provision for the volume.\n   *\n   * Must only be set for `volumeType`: `EbsDeviceVolumeType.IO1`\n   *\n   * The maximum ratio of IOPS to volume size (in GiB) is 50:1, so for 5,000 provisioned IOPS,\n   * you need at least 100 GiB storage on the volume.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html\n   *\n   * @default - none, required for `EbsDeviceVolumeType.IO1`\n   */\n  readonly iops?: number;\n\n  /**\n   * The EBS volume type\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html\n   *\n   * @default `EbsDeviceVolumeType.GENERAL_PURPOSE_SSD` or `EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3` if\n   * `@aws-cdk/aws-ec2:ebsDefaultGp3Volume` is enabled.\n   */\n  readonly volumeType?: EbsDeviceVolumeType;\n\n  /**\n   * The throughput to provision for a `gp3` volume.\n   *\n   * Valid Range: Minimum value of 125. Maximum value of 1000.\n   *\n   * `gp3` volumes deliver a consistent baseline throughput performance of 125 MiB/s.\n   * You can provision additional throughput for an additional cost at a ratio of 0.25 MiB/s per provisioned IOPS.\n   *\n   * @see https://docs.aws.amazon.com/ebs/latest/userguide/general-purpose.html#gp3-performance\n   *\n   * @default - 125 MiB/s.\n   */\n  readonly throughput?: number;\n}\n\n/**\n * Block device options for an EBS volume\n */\nexport interface EbsDeviceOptions extends EbsDeviceOptionsBase {\n  /**\n   * Specifies whether the EBS volume is encrypted.\n   * Encrypted EBS volumes can only be attached to instances that support Amazon EBS encryption\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances\n   *\n   * @default false\n   */\n  readonly encrypted?: boolean;\n\n  /**\n   * The ARN of the AWS Key Management Service (AWS KMS) CMK used for encryption.\n   *\n   * You have to ensure that the KMS CMK has the correct permissions to be used by the service launching the ec2 instances.\n   *\n   * @see https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#ebs-encryption-requirements\n   *\n   * @default - If encrypted is true, the default aws/ebs KMS key will be used.\n   */\n  readonly kmsKey?: IKey;\n}\n\n/**\n * Block device options for an EBS volume created from a snapshot\n */\nexport interface EbsDeviceSnapshotOptions extends EbsDeviceOptionsBase {\n  /**\n   * The volume size, in Gibibytes (GiB)\n   *\n   * If you specify volumeSize, it must be equal or greater than the size of the snapshot.\n   *\n   * @default - The snapshot size\n   */\n  readonly volumeSize?: number;\n}\n\n/**\n * Properties of an EBS block device\n */\nexport interface EbsDeviceProps\n  extends EbsDeviceSnapshotOptions,\n    EbsDeviceOptions {\n  /**\n   * The snapshot ID of the volume to use\n   *\n   * @default - No snapshot will be used\n   */\n  readonly snapshotId?: string;\n}\n\n/**\n * Describes a block device mapping for an EC2 instance or Auto Scaling group.\n */\nexport class BlockDeviceVolume {\n  /**\n   * Creates a new Elastic Block Storage device\n   *\n   * @param volumeSize The volume size, in Gibibytes (GiB)\n   * @param options additional device options\n   */\n  public static ebs(\n    volumeSize: number,\n    options: EbsDeviceOptions = {},\n  ): BlockDeviceVolume {\n    return new this({ ...options, volumeSize });\n  }\n\n  /**\n   * Creates a new Elastic Block Storage device from an existing snapshot\n   *\n   * @param snapshotId The snapshot ID of the volume to use\n   * @param options additional device options\n   */\n  public static ebsFromSnapshot(\n    snapshotId: string,\n    options: EbsDeviceSnapshotOptions = {},\n  ): BlockDeviceVolume {\n    return new this({ ...options, snapshotId });\n  }\n\n  /**\n   * Creates a virtual, ephemeral device.\n   * The name will be in the form ephemeral{volumeIndex}.\n   *\n   * @param volumeIndex the volume index. Must be equal or greater than 0\n   */\n  public static ephemeral(volumeIndex: number) {\n    if (volumeIndex < 0) {\n      throw new Error(\n        `volumeIndex must be a number starting from 0, got \"${volumeIndex}\"`,\n      );\n    }\n\n    return new this(undefined, `ephemeral${volumeIndex}`);\n  }\n\n  /**\n   * @param ebsDevice EBS device info\n   * @param virtualName Virtual device name\n   */\n  protected constructor(\n    public readonly ebsDevice?: EbsDeviceProps,\n    public readonly virtualName?: string,\n  ) {}\n\n  public isEphemeral(): this is BlockDeviceVolume & { virtualName: string } {\n    return this.virtualName !== undefined;\n  }\n}\n\n/**\n * Supported EBS volume types for blockDevices\n */\nexport enum EbsDeviceVolumeType {\n  /**\n   * Magnetic\n   */\n  STANDARD = \"standard\",\n\n  /**\n   *  Provisioned IOPS SSD - IO1\n   */\n  IO1 = \"io1\",\n\n  /**\n   *  Provisioned IOPS SSD - IO2\n   */\n  IO2 = \"io2\",\n\n  /**\n   * General Purpose SSD - GP2\n   */\n  GP2 = \"gp2\",\n\n  /**\n   * General Purpose SSD - GP3\n   */\n  GP3 = \"gp3\",\n\n  /**\n   * Throughput Optimized HDD\n   */\n  ST1 = \"st1\",\n\n  /**\n   * Cold HDD\n   */\n  SC1 = \"sc1\",\n\n  /**\n   * General purpose SSD volume (GP2) that balances price and performance for a wide variety of workloads.\n   */\n  GENERAL_PURPOSE_SSD = GP2,\n\n  /**\n   * General purpose SSD volume (GP3) that balances price and performance for a wide variety of workloads.\n   */\n  GENERAL_PURPOSE_SSD_GP3 = GP3,\n\n  /**\n   * Highest-performance SSD volume (IO1) for mission-critical low-latency or high-throughput workloads.\n   */\n  PROVISIONED_IOPS_SSD = IO1,\n\n  /**\n   * Highest-performance SSD volume (IO2) for mission-critical low-latency or high-throughput workloads.\n   */\n  PROVISIONED_IOPS_SSD_IO2 = IO2,\n\n  /**\n   * Low-cost HDD volume designed for frequently accessed, throughput-intensive workloads.\n   */\n  THROUGHPUT_OPTIMIZED_HDD = ST1,\n\n  /**\n   * Lowest cost HDD volume designed for less frequently accessed workloads.\n   */\n  COLD_HDD = SC1,\n\n  /**\n   * Magnetic volumes are backed by magnetic drives and are suited for workloads where data is accessed infrequently, and scenarios where low-cost\n   * storage for small volume sizes is important.\n   */\n  MAGNETIC = STANDARD,\n}\n\n/**\n * Outputs which may be registered for output via the Grid.\n */\nexport interface VolumeOutputs {\n  /**\n   * The EBS Volume's ID\n   *\n   * @attribute\n   */\n  readonly volumeId: string;\n\n  /**\n   * The availability zone that the EBS Volume is contained within (ex: us-west-2a)\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * The customer-managed encryption key that is used to encrypt the Volume.\n   *\n   * @attribute\n   */\n  readonly encryptionKeyId?: string;\n}\n\n/**\n * An EBS Volume in AWS EC2.\n */\nexport interface IVolume extends IAwsConstruct {\n  /** Strongly typed outputs */\n  readonly volumeOutputs: VolumeOutputs;\n  /**\n   * The EBS Volume's ID\n   *\n   * @attribute\n   */\n  readonly volumeId: string;\n\n  /**\n   * The availability zone that the EBS Volume is contained within (ex: us-west-2a)\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * The customer-managed encryption key that is used to encrypt the Volume.\n   *\n   * @attribute\n   */\n  readonly encryptionKey?: IKey;\n\n  /**\n   * Grants permission to attach this Volume to an instance.\n   * CAUTION: Granting an instance permission to attach to itself using this method will lead to\n   * an unresolvable circular reference between the instance role and the instance.\n   * Use `IVolume.grantAttachVolumeToSelf` to grant an instance permission to attach this\n   * volume to itself.\n   *\n   * @param grantee  the principal being granted permission.\n   * @param instances the instances to which permission is being granted to attach this\n   *                 volume to. If not specified, then permission is granted to attach\n   *                 to all instances in this account.\n   */\n  grantAttachVolume(grantee: IGrantable, instances?: IInstance[]): Grant;\n\n  /**\n   * Grants permission to attach the Volume by a ResourceTag condition. If you are looking to\n   * grant an Instance, AutoScalingGroup, EC2-Fleet, SpotFleet, ECS host, etc the ability to attach\n   * this volume to **itself** then this is the method you want to use.\n   *\n   * This is implemented by adding a Tag with key `VolumeGrantAttach-<suffix>` to the given\n   * constructs and this Volume, and then conditioning the Grant such that the grantee is only\n   * given the ability to AttachVolume if both the Volume and the destination Instance have that\n   * tag applied to them.\n   *\n   * @param grantee    the principal being granted permission.\n   * @param constructs The list of constructs that will have the generated resource tag applied to them.\n   * @param tagKeySuffix A suffix to use on the generated Tag key in place of the generated hash value.\n   *                     Defaults to a hash calculated from this volume and list of constructs. (DEPRECATED)\n   */\n  grantAttachVolumeByResourceTag(\n    grantee: IGrantable,\n    constructs: Construct[],\n    tagKeySuffix?: string,\n  ): Grant;\n\n  /**\n   * Grants permission to detach this Volume from an instance\n   * CAUTION: Granting an instance permission to detach from itself using this method will lead to\n   * an unresolvable circular reference between the instance role and the instance.\n   * Use `IVolume.grantDetachVolumeFromSelf` to grant an instance permission to detach this\n   * volume from itself.\n   *\n   * @param grantee  the principal being granted permission.\n   * @param instances the instances to which permission is being granted to detach this\n   *                 volume from. If not specified, then permission is granted to detach\n   *                 from all instances in this account.\n   */\n  grantDetachVolume(grantee: IGrantable, instances?: IInstance[]): Grant;\n\n  /**\n   * Grants permission to detach the Volume by a ResourceTag condition.\n   *\n   * This is implemented via the same mechanism as `IVolume.grantAttachVolumeByResourceTag`,\n   * and is subject to the same conditions.\n   *\n   * @param grantee    the principal being granted permission.\n   * @param constructs The list of constructs that will have the generated resource tag applied to them.\n   * @param tagKeySuffix A suffix to use on the generated Tag key in place of the generated hash value.\n   *                     Defaults to a hash calculated from this volume and list of constructs. (DEPRECATED)\n   */\n  grantDetachVolumeByResourceTag(\n    grantee: IGrantable,\n    constructs: Construct[],\n    tagKeySuffix?: string,\n  ): Grant;\n}\n\n/**\n * Properties of an EBS Volume\n */\nexport interface VolumeProps extends AwsConstructProps {\n  /**\n   * The value of the physicalName property of this resource.\n   *\n   * @default The physical name will be allocated by CloudFormation at deployment time\n   */\n  readonly volumeName?: string;\n\n  /**\n   * The Availability Zone in which to create the volume.\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size.\n   * See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html\n   * for details on the allowable size for each type of volume.\n   *\n   * @default If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.\n   */\n  readonly size?: Size;\n\n  /**\n   * The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size.\n   *\n   * @default The EBS volume is not created from a snapshot.\n   */\n  readonly snapshotId?: string;\n\n  /**\n   * Indicates whether Amazon EBS Multi-Attach is enabled.\n   * See [Considerations and limitations](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations)\n   * for the constraints of multi-attach.\n   *\n   * @default false\n   */\n  readonly enableMultiAttach?: boolean;\n\n  /**\n   * Specifies whether the volume should be encrypted. The effect of setting the encryption state to true depends on the volume origin\n   * (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information,\n   * see [Encryption by Default](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default)\n   * in the Amazon Elastic Compute Cloud User Guide.\n   *\n   * Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see\n   * [Supported Instance Types](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances).\n   *\n   * @default false\n   */\n  readonly encrypted?: boolean;\n\n  /**\n   * The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must\n   * be true if this is provided.\n   *\n   * Note: If using an `aws-kms.IKey` created from a `aws-kms.Key.fromKeyArn()` here,\n   * then the KMS key **must** have the following in its Key policy; otherwise, the Volume\n   * will fail to create.\n   *\n   *     {\n   *       \"Effect\": \"Allow\",\n   *       \"Principal\": { \"AWS\": \"<arn for your account-user> ex: arn:aws:iam::00000000000:root\" },\n   *       \"Resource\": \"*\",\n   *       \"Action\": [\n   *         \"kms:DescribeKey\",\n   *         \"kms:GenerateDataKeyWithoutPlainText\",\n   *       ],\n   *       \"Condition\": {\n   *         \"StringEquals\": {\n   *           \"kms:ViaService\": \"ec2.<Region>.amazonaws.com\", (eg: ec2.us-east-1.amazonaws.com)\n   *           \"kms:CallerAccount\": \"0000000000\" (your account ID)\n   *         }\n   *       }\n   *     }\n   *\n   * @default The default KMS key for the account, region, and EC2 service is used.\n   */\n  readonly encryptionKey?: IKey;\n\n  // TODO: Support for autoEnableIo\n  // https://github.com/hashicorp/terraform-provider-aws/issues/34110\n  // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-autoenableio\n  // /**\n  //  * Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2\n  //  * instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and\n  //  * you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O.\n  //  *\n  //  * @default false\n  //  */\n  // readonly autoEnableIo?: boolean;\n\n  /**\n   * The type of the volume; what type of storage to use to form the EBS Volume.\n   *\n   * @default `EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3`\n   */\n  readonly volumeType?: EbsDeviceVolumeType;\n\n  /**\n   * The number of I/O operations per second (IOPS) to provision for the volume. The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD,\n   * and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3.\n   * See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html\n   * for more information.\n   *\n   * This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes.\n   *\n   * @default None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.\n   */\n  readonly iops?: number;\n\n  /**\n   * The throughput that the volume supports, in MiB/s\n   * Takes a minimum of 125 and maximum of 1000.\n   * @see https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html#cfn-ec2-volume-throughput\n   * @default - 125 MiB/s. Only valid on gp3 volumes.\n   */\n  readonly throughput?: number;\n}\n\n/**\n * Attributes required to import an existing EBS Volume into the Stack.\n */\nexport interface VolumeAttributes {\n  /**\n   * The EBS Volume's ID\n   */\n  readonly volumeId: string;\n\n  /**\n   * The availability zone that the EBS Volume is contained within (ex: us-west-2a)\n   */\n  readonly availabilityZone: string;\n\n  /**\n   * The customer-managed encryption key that is used to encrypt the Volume.\n   *\n   * @default None -- The EBS Volume is not using a customer-managed KMS key for encryption.\n   */\n  readonly encryptionKey?: IKey;\n}\n\n/**\n * Common behavior of Volumes. Users should not use this class directly, and instead use ``Volume``.\n */\nabstract class VolumeBase extends AwsConstructBase implements IVolume {\n  public abstract readonly volumeId: string;\n  public abstract readonly availabilityZone: string;\n  public abstract readonly encryptionKey?: IKey;\n  public get volumeOutputs(): VolumeOutputs {\n    return {\n      volumeId: this.volumeId,\n      availabilityZone: this.availabilityZone,\n      encryptionKeyId: this.encryptionKey?.keyId,\n    };\n  }\n  public get outputs(): Record<string, any> {\n    return this.volumeOutputs;\n  }\n\n  public grantAttachVolume(\n    grantee: IGrantable,\n    instances?: IInstance[],\n  ): Grant {\n    const result = Grant.addToPrincipal({\n      grantee,\n      actions: [\"ec2:AttachVolume\"],\n      resourceArns: this.collectGrantResourceArns(instances),\n    });\n\n    if (this.encryptionKey) {\n      // When attaching a volume, the EC2 Service will need to grant to itself permission\n      // to be able to decrypt the encryption key. We restrict the CreateGrant for principle\n      // of least privilege, in accordance with best practices.\n      // See: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#ebs-encryption-permissions\n      const kmsGrant: Grant = this.encryptionKey.grant(\n        grantee,\n        \"kms:CreateGrant\",\n      );\n      kmsGrant.principalStatement!.addConditions(\n        {\n          test: \"Bool\",\n          variable: \"kms:GrantIsForAWSResource\",\n          values: [\"true\"],\n        },\n        {\n          test: \"StringEquals\",\n          variable: \"kms:ViaService\",\n          values: [`ec2.${AwsStack.ofAwsConstruct(this).region}.amazonaws.com`],\n        },\n        {\n          test: \"StringEquals\",\n          variable: \"kms:GrantConstraintType\",\n          values: [\"EncryptionContextSubset\"],\n        },\n      );\n    }\n\n    return result;\n  }\n\n  public grantAttachVolumeByResourceTag(\n    grantee: IGrantable,\n    constructs: Construct[],\n    tagKeySuffix?: string,\n  ): Grant {\n    const tagValue = this.calculateResourceTagValue([this, ...constructs]);\n    const tagKey = `VolumeGrantAttach-${tagKeySuffix ?? tagValue.slice(0, 10).toUpperCase()}`;\n    const result = this.grantAttachVolume(grantee);\n    result.principalStatement!.addCondition({\n      test: \"ForAnyValue:StringEquals\",\n      variable: `ec2:ResourceTag/${tagKey}`,\n      values: [tagValue],\n    });\n\n    // The ResourceTag condition requires that all resources involved in the operation have\n    // the given tag, so we tag this and all constructs given.\n    Tags.of(this).add(tagKey, tagValue);\n    constructs.forEach((construct) => Tags.of(construct).add(tagKey, tagValue));\n\n    return result;\n  }\n\n  public grantDetachVolume(\n    grantee: IGrantable,\n    instances?: IInstance[],\n  ): Grant {\n    const result = Grant.addToPrincipal({\n      grantee,\n      actions: [\"ec2:DetachVolume\"],\n      resourceArns: this.collectGrantResourceArns(instances),\n    });\n    // Note: No encryption key permissions are required to detach an encrypted volume.\n    return result;\n  }\n\n  public grantDetachVolumeByResourceTag(\n    grantee: IGrantable,\n    constructs: Construct[],\n    tagKeySuffix?: string,\n  ): Grant {\n    const tagValue = this.calculateResourceTagValue([this, ...constructs]);\n    const tagKey = `VolumeGrantDetach-${tagKeySuffix ?? tagValue.slice(0, 10).toUpperCase()}`;\n    const result = this.grantDetachVolume(grantee);\n    result.principalStatement!.addCondition({\n      test: \"ForAnyValue:StringEquals\",\n      variable: `ec2:ResourceTag/${tagKey}`,\n      values: [tagValue],\n    });\n\n    // The ResourceTag condition requires that all resources involved in the operation have\n    // the given tag, so we tag this and all constructs given.\n    Tags.of(this).add(tagKey, tagValue);\n    constructs.forEach((construct) => Tags.of(construct).add(tagKey, tagValue));\n\n    return result;\n  }\n\n  private collectGrantResourceArns(instances?: IInstance[]): string[] {\n    const stack = AwsStack.ofAwsConstruct(this);\n    const resourceArns: string[] = [\n      `arn:${stack.partition}:ec2:${stack.region}:${stack.account}:volume/${this.volumeId}`,\n    ];\n    const instanceArnPrefix = `arn:${stack.partition}:ec2:${stack.region}:${stack.account}:instance`;\n    if (instances) {\n      instances.forEach((instance) =>\n        resourceArns.push(`${instanceArnPrefix}/${instance?.instanceId}`),\n      );\n    } else {\n      resourceArns.push(`${instanceArnPrefix}/*`);\n    }\n    return resourceArns;\n  }\n\n  private calculateResourceTagValue(constructs: Construct[]): string {\n    return md5hash(constructs.map((c) => AwsStack.uniqueId(c)).join(\"\"));\n  }\n}\n\n/**\n * Creates a new EBS Volume in AWS EC2.\n */\nexport class Volume extends VolumeBase {\n  /**\n   * Import an existing EBS Volume into the Stack.\n   *\n   * @param scope the scope of the import.\n   * @param id    the ID of the imported Volume in the construct tree.\n   * @param attrs the attributes of the imported Volume\n   */\n  public static fromVolumeAttributes(\n    scope: Construct,\n    id: string,\n    attrs: VolumeAttributes,\n  ): IVolume {\n    class Import extends VolumeBase {\n      public readonly volumeId = attrs.volumeId;\n      public readonly availabilityZone = attrs.availabilityZone;\n      public readonly encryptionKey = attrs.encryptionKey;\n    }\n    // Check that the provided volumeId looks like it could be valid.\n    if (\n      !Token.isUnresolved(attrs.volumeId) &&\n      !/^vol-[0-9a-fA-F]+$/.test(attrs.volumeId)\n    ) {\n      throw new Error(\n        \"`volumeId` does not match expected pattern. Expected `vol-<hexadecmial value>` (ex: `vol-05abe246af`) or a Token\",\n      );\n    }\n    return new Import(scope, id);\n  }\n\n  public readonly volumeId: string;\n  public readonly availabilityZone: string;\n  public readonly encryptionKey?: IKey;\n\n  public readonly resource: ebsVolume.EbsVolume;\n\n  constructor(scope: Construct, id: string, props: VolumeProps) {\n    super(scope, id, props);\n    const volumeName =\n      props.volumeName ||\n      this.stack.uniqueResourceName(this, {\n        prefix: this.gridUUID,\n      });\n\n    this.validateProps(props);\n\n    this.resource = new ebsVolume.EbsVolume(this, \"Resource\", {\n      availabilityZone: props.availabilityZone,\n      // autoEnableIo: props.autoEnableIo,\n      encrypted: props.encrypted,\n      kmsKeyId: props.encryptionKey?.keyArn,\n      iops: props.iops,\n      multiAttachEnabled: props.enableMultiAttach ?? false,\n      size: props.size?.toGibibytes({ rounding: SizeRoundingBehavior.FAIL }),\n      snapshotId: props.snapshotId,\n      throughput: props.throughput,\n      type: props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3,\n    });\n\n    if (props.volumeName) Tags.of(this.resource).add(\"Name\", volumeName);\n\n    this.volumeId = this.resource.id;\n    this.availabilityZone = props.availabilityZone;\n    this.encryptionKey = props.encryptionKey;\n\n    if (this.encryptionKey) {\n      // Per: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#ebs-encryption-requirements\n      const principal = new ViaServicePrincipal(\n        `ec2.${AwsStack.ofAwsConstruct(this).region}.amazonaws.com`,\n        new AccountRootPrincipal(),\n      ).withConditions({\n        test: \"StringEquals\",\n        variable: \"kms:CallerAccount\",\n        values: [AwsStack.ofAwsConstruct(this).account],\n      });\n      const grant = this.encryptionKey.grant(\n        principal,\n        // Describe & Generate are required to be able to create the CMK-encrypted Volume.\n        \"kms:DescribeKey\",\n        \"kms:GenerateDataKeyWithoutPlainText\",\n      );\n      if (props.snapshotId) {\n        // ReEncrypt is required for when re-encrypting from an encrypted snapshot.\n        grant.principalStatement?.addActions(\"kms:ReEncrypt*\");\n      }\n    }\n  }\n\n  protected validateProps(props: VolumeProps) {\n    if (!(props.size || props.snapshotId)) {\n      throw new Error(\"Must provide at least one of `size` or `snapshotId`\");\n    }\n\n    if (\n      props.snapshotId &&\n      !Token.isUnresolved(props.snapshotId) &&\n      !/^snap-[0-9a-fA-F]+$/.test(props.snapshotId)\n    ) {\n      throw new Error(\n        \"`snapshotId` does match expected pattern. Expected `snap-<hexadecmial value>` (ex: `snap-05abe246af`) or Token\",\n      );\n    }\n\n    if (props.encryptionKey && !props.encrypted) {\n      throw new Error(\n        \"`encrypted` must be true when providing an `encryptionKey`.\",\n      );\n    }\n\n    if (\n      props.volumeType &&\n      [\n        EbsDeviceVolumeType.PROVISIONED_IOPS_SSD,\n        EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2,\n      ].includes(props.volumeType) &&\n      !props.iops\n    ) {\n      throw new Error(\n        \"`iops` must be specified if the `volumeType` is `PROVISIONED_IOPS_SSD` or `PROVISIONED_IOPS_SSD_IO2`.\",\n      );\n    }\n\n    if (props.iops) {\n      const volumeType =\n        props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD;\n      if (\n        ![\n          EbsDeviceVolumeType.PROVISIONED_IOPS_SSD,\n          EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2,\n          EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3,\n        ].includes(volumeType)\n      ) {\n        throw new Error(\n          \"`iops` may only be specified if the `volumeType` is `PROVISIONED_IOPS_SSD`, `PROVISIONED_IOPS_SSD_IO2` or `GENERAL_PURPOSE_SSD_GP3`.\",\n        );\n      }\n      // Enforce minimum & maximum IOPS:\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html\n      const iopsRanges: { [key: string]: { Min: number; Max: number } } = {};\n      iopsRanges[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3] = {\n        Min: 3000,\n        Max: 16000,\n      };\n      iopsRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD] = {\n        Min: 100,\n        Max: 64000,\n      };\n      iopsRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2] = {\n        Min: 100,\n        Max: 256000,\n      };\n      const { Min, Max } = iopsRanges[volumeType];\n      if (props.iops < Min || props.iops > Max) {\n        throw new Error(\n          `\\`${volumeType}\\` volumes iops must be between ${Min} and ${Max}.`,\n        );\n      }\n\n      // Enforce maximum ratio of IOPS/GiB:\n      // https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volume-types.html\n      const maximumRatios: { [key: string]: number } = {};\n      maximumRatios[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3] = 500;\n      maximumRatios[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD] = 50;\n      maximumRatios[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2] = 500;\n      const maximumRatio = maximumRatios[volumeType];\n      if (\n        props.size &&\n        props.iops >\n          maximumRatio *\n            props.size.toGibibytes({ rounding: SizeRoundingBehavior.FAIL })\n      ) {\n        throw new Error(\n          `\\`${volumeType}\\` volumes iops has a maximum ratio of ${maximumRatio} IOPS/GiB.`,\n        );\n      }\n\n      const maximumThroughputRatios: { [key: string]: number } = {};\n      maximumThroughputRatios[EbsDeviceVolumeType.GP3] = 0.25;\n      const maximumThroughputRatio = maximumThroughputRatios[volumeType];\n      if (props.throughput && props.iops) {\n        const iopsRatio = props.throughput / props.iops;\n        if (iopsRatio > maximumThroughputRatio) {\n          throw new Error(\n            `Throughput (MiBps) to iops ratio of ${iopsRatio} is too high; maximum is ${maximumThroughputRatio} MiBps per iops`,\n          );\n        }\n      }\n    }\n\n    if (props.enableMultiAttach) {\n      const volumeType =\n        props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD;\n      if (\n        ![\n          EbsDeviceVolumeType.PROVISIONED_IOPS_SSD,\n          EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2,\n        ].includes(volumeType)\n      ) {\n        throw new Error(\n          \"multi-attach is supported exclusively on `PROVISIONED_IOPS_SSD` and `PROVISIONED_IOPS_SSD_IO2` volumes.\",\n        );\n      }\n    }\n\n    if (props.size) {\n      const size = props.size.toGibibytes({\n        rounding: SizeRoundingBehavior.FAIL,\n      });\n      // Enforce minimum & maximum volume size:\n      // https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html\n      const sizeRanges: { [key: string]: { Min: number; Max: number } } = {};\n      sizeRanges[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD] = {\n        Min: 1,\n        Max: 16384,\n      };\n      sizeRanges[EbsDeviceVolumeType.GENERAL_PURPOSE_SSD_GP3] = {\n        Min: 1,\n        Max: 16384,\n      };\n      sizeRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD] = {\n        Min: 4,\n        Max: 16384,\n      };\n      sizeRanges[EbsDeviceVolumeType.PROVISIONED_IOPS_SSD_IO2] = {\n        Min: 4,\n        Max: 16384,\n      };\n      sizeRanges[EbsDeviceVolumeType.THROUGHPUT_OPTIMIZED_HDD] = {\n        Min: 125,\n        Max: 16384,\n      };\n      sizeRanges[EbsDeviceVolumeType.COLD_HDD] = { Min: 125, Max: 16384 };\n      sizeRanges[EbsDeviceVolumeType.MAGNETIC] = { Min: 1, Max: 1024 };\n      const volumeType =\n        props.volumeType ?? EbsDeviceVolumeType.GENERAL_PURPOSE_SSD;\n      const { Min, Max } = sizeRanges[volumeType];\n      if (size < Min || size > Max) {\n        throw new Error(\n          `\\`${volumeType}\\` volumes must be between ${Min} GiB and ${Max} GiB in size.`,\n        );\n      }\n    }\n\n    if (props.throughput) {\n      const throughputRange = { Min: 125, Max: 1000 };\n      const { Min, Max } = throughputRange;\n      if (props.volumeType != EbsDeviceVolumeType.GP3) {\n        throw new Error(\n          \"throughput property requires volumeType: EbsDeviceVolumeType.GP3\",\n        );\n      }\n      if (props.throughput < Min || props.throughput > Max) {\n        throw new Error(\n          `throughput property takes a minimum of ${Min} and a maximum of ${Max}`,\n        );\n      }\n    }\n  }\n}\n"]}