@aws-cdk/aws-imagebuilder-alpha 2.227.0-alpha.0 → 2.229.0-alpha.0

package/lib/container-recipe.js

@@ -0,0 +1,451 @@
+"use strict";
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerRecipe = exports.ContainerRecipeBase = exports.S3DockerfileData = exports.DockerfileData = exports.ContainerType = void 0;
+const jsiiDeprecationWarnings = require("../.warnings.jsii.js");
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+const iam = require("aws-cdk-lib/aws-iam");
+const aws_imagebuilder_1 = require("aws-cdk-lib/aws-imagebuilder");
+const s3assets = require("aws-cdk-lib/aws-s3-assets");
+const metadata_resource_1 = require("aws-cdk-lib/core/lib/metadata-resource");
+const prop_injectable_1 = require("aws-cdk-lib/core/lib/prop-injectable");
+const CONTAINER_RECIPE_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.ContainerRecipe');
+/**
+ * Represents the latest version of a container recipe. When using the recipe in a pipeline, the pipeline will use the
+ * latest recipe at the time of execution.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html
+ */
+const LATEST_VERSION = 'x.x.x';
+/**
+ * The default version to use in the container recipe. When the recipe is updated, the `x` will be incremented off from
+ * the latest recipe version that exists.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-image-recipes.html
+ */
+const DEFAULT_RECIPE_VERSION = '1.0.x';
+/**
+ * The type of the container being used in the container recipe
+ */
+var ContainerType;
+(function (ContainerType) {
+    /**
+     * Indicates the container recipe uses a Docker container
+     */
+    ContainerType["DOCKER"] = "DOCKER";
+})(ContainerType || (exports.ContainerType = ContainerType = {}));
+/**
+ * Helper class for referencing and uploading dockerfile data for the container recipe
+ */
+class DockerfileData {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.DockerfileData", version: "2.229.0-alpha.0" };
+    /**
+     * Uploads dockerfile data from a local file to S3 to use as the dockerfile data
+     *
+     * @param scope The construct scope
+     * @param id Identifier of the construct
+     * @param path The local path to the dockerfile data file
+     * @param options S3 asset upload options
+     */
+    static fromAsset(scope, id, path, options = {}) {
+        const asset = new s3assets.Asset(scope, id, { ...options, path });
+        return new S3DockerfileDataFromAsset(asset);
+    }
+    /**
+     * References dockerfile data from a pre-existing S3 object
+     *
+     * @param bucket The S3 bucket where the dockerfile data is stored
+     * @param key The S3 key of the dockerfile data file
+     */
+    static fromS3(bucket, key) {
+        return new S3DockerfileDataFromBucketKey(bucket, key);
+    }
+    /**
+     * Uses an inline string as the dockerfile data
+     *
+     * @param data An inline string representing the dockerfile data
+     */
+    static fromInline(data) {
+        return new InlineDockerfileData(data);
+    }
+}
+exports.DockerfileData = DockerfileData;
+/**
+ * Helper class for S3-based dockerfile data references, containing additional permission grant methods on the S3 object
+ */
+class S3DockerfileData extends DockerfileData {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.S3DockerfileData", version: "2.229.0-alpha.0" };
+    bucket;
+    key;
+    constructor(bucket, key) {
+        super();
+        this.bucket = bucket;
+        this.key = key;
+    }
+    /**
+     * The rendered Dockerfile S3 URL, for use in CloudFormation
+     */
+    render() {
+        return { dockerfileTemplateUri: this.bucket.s3UrlForObject(this.key) };
+    }
+    /**
+     * Grant put permissions to the given grantee for the dockerfile data in S3
+     *
+     * @param grantee The principal
+     */
+    grantPut(grantee) {
+        return this.bucket.grantPut(grantee, this.key);
+    }
+    /**
+     * Grant read permissions to the given grantee for the dockerfile data in S3
+     *
+     * @param grantee The principal
+     */
+    grantRead(grantee) {
+        return this.bucket.grantRead(grantee, this.key);
+    }
+}
+exports.S3DockerfileData = S3DockerfileData;
+class InlineDockerfileData extends DockerfileData {
+    data;
+    constructor(data) {
+        super();
+        this.data = data;
+    }
+    /**
+     * The rendered Dockerfile text, for use in CloudFormation
+     */
+    render() {
+        return { dockerfileTemplateData: this.data };
+    }
+}
+class S3DockerfileDataFromBucketKey extends S3DockerfileData {
+    constructor(bucket, key) {
+        super(bucket, key);
+    }
+}
+class S3DockerfileDataFromAsset extends S3DockerfileData {
+    constructor(asset) {
+        super(asset.bucket, asset.s3ObjectKey);
+    }
+}
+/**
+ * A new or imported Container Recipe
+ */
+class ContainerRecipeBase extends cdk.Resource {
+    static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.ContainerRecipeBase", version: "2.229.0-alpha.0" };
+    /**
+     * Grant custom actions to the given grantee for the container recipe
+     *
+     * @param grantee The principal
+     * @param actions The list of actions
+     */
+    grant(grantee, ...actions) {
+        return iam.Grant.addToPrincipal({
+            grantee,
+            actions,
+            resourceArns: [this.containerRecipeArn],
+            scope: this,
+        });
+    }
+    /**
+     * Grant read permissions to the given grantee for the container recipe
+     *
+     * @param grantee The principal
+     */
+    grantRead(grantee) {
+        return this.grant(grantee, 'imagebuilder:GetContainerRecipe');
+    }
+    /**
+     * Indicates whether the recipe is a Container Recipe
+     *
+     * @internal
+     */
+    _isContainerRecipe() {
+        return true;
+    }
+    /**
+     * Indicates whether the recipe is an Image Recipe
+     *
+     * @internal
+     */
+    _isImageRecipe() {
+        return false;
+    }
+}
+exports.ContainerRecipeBase = ContainerRecipeBase;
+/**
+ * Represents an EC2 Image Builder Container Recipe.
+ *
+ * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-recipes.html
+ */
+let ContainerRecipe = (() => {
+    let _classDecorators = [prop_injectable_1.propertyInjectable];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = ContainerRecipeBase;
+    let _instanceExtraInitializers = [];
+    let _addInstanceBlockDevice_decorators;
+    var ContainerRecipe = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _addInstanceBlockDevice_decorators = [(0, metadata_resource_1.MethodMetadata)()];
+            __esDecorate(this, null, _addInstanceBlockDevice_decorators, { kind: "method", name: "addInstanceBlockDevice", static: false, private: false, access: { has: obj => "addInstanceBlockDevice" in obj, get: obj => obj.addInstanceBlockDevice }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ContainerRecipe = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        static [JSII_RTTI_SYMBOL_1] = { fqn: "@aws-cdk/aws-imagebuilder-alpha.ContainerRecipe", version: "2.229.0-alpha.0" };
+        /** Uniquely identifies this class. */
+        static PROPERTY_INJECTION_ID = '@aws-cdk.aws-imagebuilder-alpha.ContainerRecipe';
+        /**
+         * Import an existing container recipe given its ARN.
+         */
+        static fromContainerRecipeArn(scope, id, containerRecipeArn) {
+            return this.fromContainerRecipeAttributes(scope, id, { containerRecipeArn });
+        }
+        /**
+         * Import the latest version of an existing container recipe given its name. The provided name must be normalized by
+         * converting all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.
+         */
+        static fromContainerRecipeName(scope, id, containerRecipeName) {
+            return this.fromContainerRecipeAttributes(scope, id, { containerRecipeName });
+        }
+        /**
+         * Import an existing container recipe by providing its attributes. If the container recipe name is provided as an
+         * attribute, it must be normalized by converting all alphabetical characters to lowercase, and replacing all spaces
+         * and underscores with hyphens.
+         */
+        static fromContainerRecipeAttributes(scope, id, attrs) {
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_ContainerRecipeAttributes(attrs);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, this.fromContainerRecipeAttributes);
+                }
+                throw error;
+            }
+            if (!attrs.containerRecipeArn && !attrs.containerRecipeName) {
+                throw new cdk.ValidationError('either either containerRecipeArn or containerRecipeName must be provided to import a container recipe', scope);
+            }
+            const containerRecipeArn = attrs.containerRecipeArn ??
+                cdk.Stack.of(scope).formatArn({
+                    service: 'imagebuilder',
+                    resource: 'container-recipe',
+                    resourceName: `${attrs.containerRecipeName}/${attrs.containerRecipeVersion ?? LATEST_VERSION}`,
+                });
+            const [containerRecipeName, containerRecipeVersion] = (() => {
+                if (attrs.containerRecipeName) {
+                    return [attrs.containerRecipeName, attrs.containerRecipeVersion ?? LATEST_VERSION];
+                }
+                const containerRecipeNameVersion = cdk.Stack.of(scope).splitArn(containerRecipeArn, cdk.ArnFormat.SLASH_RESOURCE_NAME).resourceName;
+                const containerRecipeNameVersionSplit = cdk.Fn.split('/', containerRecipeNameVersion);
+                return [cdk.Fn.select(0, containerRecipeNameVersionSplit), cdk.Fn.select(1, containerRecipeNameVersionSplit)];
+            })();
+            class Import extends ContainerRecipeBase {
+                containerRecipeArn = containerRecipeArn;
+                containerRecipeName = containerRecipeName;
+                containerRecipeVersion = containerRecipeVersion;
+            }
+            return new Import(scope, id);
+        }
+        /**
+         * Return whether the given object is a ContainerRecipe.
+         */
+        static isContainerRecipe(x) {
+            return x !== null && typeof x === 'object' && CONTAINER_RECIPE_SYMBOL in x;
+        }
+        /**
+         * The ARN of the container recipe
+         */
+        containerRecipeArn = __runInitializers(this, _instanceExtraInitializers);
+        /**
+         * The name of the container recipe
+         */
+        containerRecipeName;
+        /**
+         * The version of the container recipe
+         */
+        containerRecipeVersion;
+        instanceBlockDevices = [];
+        constructor(scope, id, props) {
+            super(scope, id, {
+                physicalName: props.containerRecipeName ??
+                    cdk.Lazy.string({
+                        produce: () => cdk.Names.uniqueResourceName(this, {
+                            maxLength: 128,
+                            separator: '-',
+                            allowedSpecialCharacters: '-',
+                        }).toLowerCase(), // Enforce lowercase for the auto-generated fallback
+                    }),
+            });
+            try {
+                jsiiDeprecationWarnings._aws_cdk_aws_imagebuilder_alpha_ContainerRecipeProps(props);
+            }
+            catch (error) {
+                if (process.env.JSII_DEBUG !== "1" && error.name === "DeprecationError") {
+                    Error.captureStackTrace(error, ContainerRecipe);
+                }
+                throw error;
+            }
+            // Enhanced CDK Analytics Telemetry
+            (0, metadata_resource_1.addConstructMetadata)(this, props);
+            Object.defineProperty(this, CONTAINER_RECIPE_SYMBOL, { value: true });
+            this.validateContainerRecipeName();
+            this.addInstanceBlockDevice(...(props.instanceBlockDevices ?? []));
+            const components = props.components?.map((component) => ({
+                componentArn: component.component.componentArn,
+                ...(component.parameters && {
+                    parameters: Object.entries(component.parameters).map(([name, param]) => ({
+                        name,
+                        value: param.value,
+                    })),
+                }),
+            }));
+            const dockerfile = props.dockerfile ??
+                DockerfileData.fromInline('FROM {{{ imagebuilder:parentImage }}}\n{{{ imagebuilder:environments }}}\n{{{ imagebuilder:components }}}');
+            const containerRecipeVersion = props.containerRecipeVersion ?? DEFAULT_RECIPE_VERSION;
+            const containerRecipe = new aws_imagebuilder_1.CfnContainerRecipe(this, 'Resource', {
+                name: this.physicalName,
+                version: containerRecipeVersion,
+                description: props.description,
+                parentImage: props.baseImage.image,
+                containerType: ContainerType.DOCKER,
+                targetRepository: {
+                    repositoryName: props.targetRepository.repositoryName,
+                    service: props.targetRepository.service,
+                },
+                platformOverride: props.osVersion?.platform,
+                imageOsVersionOverride: props.osVersion?.osVersion,
+                kmsKeyId: props.kmsKey?.keyArn,
+                instanceConfiguration: cdk.Lazy.any({ produce: () => this.buildInstanceConfiguration(props) }),
+                workingDirectory: props.workingDirectory,
+                tags: props.tags,
+                ...dockerfile.render(),
+                ...(components?.length && { components }),
+            });
+            this.containerRecipeName = this.getResourceNameAttribute(containerRecipe.attrName);
+            this.containerRecipeArn = this.getResourceArnAttribute(containerRecipe.attrArn, {
+                service: 'imagebuilder',
+                resource: 'container-recipe',
+                resourceName: `${this.physicalName}/${containerRecipeVersion}`,
+            });
+            this.containerRecipeVersion = containerRecipe.getAtt('Version').toString();
+        }
+        /**
+         * Adds block devices to attach to the instance used for building, testing, and distributing the container image.
+         *
+         * @param instanceBlockDevices - The list of block devices to attach
+         */
+        addInstanceBlockDevice(...instanceBlockDevices) {
+            this.instanceBlockDevices.push(...instanceBlockDevices);
+        }
+        /**
+         * Renders the block devices provided as input to the construct, into the block device mapping structure that
+         * CfnContainerRecipe expects to receive.
+         *
+         * This is rendered at synthesis time, as users can add additional block devices with `addInstanceBlockDevice`, after
+         * the construct has been instantiated.
+         *
+         * @private
+         */
+        renderBlockDevices() {
+            const blockDevices = this.instanceBlockDevices.map((blockDevice) => {
+                const ebsDevice = blockDevice.volume.ebsDevice;
+                const ebs = {
+                    ...(ebsDevice?.deleteOnTermination !== undefined && { deleteOnTermination: ebsDevice.deleteOnTermination }),
+                    ...(ebsDevice?.encrypted !== undefined && { encrypted: ebsDevice.encrypted }),
+                    ...(ebsDevice?.iops !== undefined && { iops: ebsDevice.iops }),
+                    ...(ebsDevice?.kmsKey !== undefined && { kmsKeyId: ebsDevice.kmsKey.keyArn }),
+                    ...(ebsDevice?.snapshotId !== undefined && { snapshotId: ebsDevice.snapshotId }),
+                    ...(ebsDevice?.throughput !== undefined && { throughput: ebsDevice.throughput }),
+                    ...(ebsDevice?.volumeSize !== undefined && { volumeSize: ebsDevice.volumeSize }),
+                    ...(ebsDevice?.volumeType !== undefined && { volumeType: ebsDevice.volumeType }),
+                };
+                const mappingEnabled = blockDevice.mappingEnabled ?? true;
+                return {
+                    deviceName: blockDevice.deviceName,
+                    virtualName: blockDevice.volume.virtualName,
+                    ...(!mappingEnabled && { noDevice: '' }),
+                    ...(Object.keys(ebs).length && { ebs }),
+                };
+            });
+            return blockDevices.length ? blockDevices : undefined;
+        }
+        /**
+         * Generates the instance configuration property into the `InstanceConfiguration` type in the  CloudFormation L1
+         * definition.
+         *
+         * @param props The props passed as input to the construct
+         * @private
+         */
+        buildInstanceConfiguration(props) {
+            const blockDevices = this.renderBlockDevices();
+            const instanceConfiguration = {
+                ...(blockDevices?.length && { blockDeviceMappings: blockDevices }),
+                ...(props.instanceImage !== undefined && { image: props.instanceImage.image }),
+            };
+            return Object.keys(instanceConfiguration).length ? instanceConfiguration : undefined;
+        }
+        validateContainerRecipeName() {
+            if (cdk.Token.isUnresolved(this.physicalName)) {
+                return; // Cannot validate unresolved tokens, given their actual value is rendered at deployment time
+            }
+            if (this.physicalName.length > 128) {
+                throw new cdk.ValidationError(`the containerRecipeName cannot be longer than 128 characters, got: '${this.physicalName}'`, this);
+            }
+            if (this.physicalName.includes(' ')) {
+                throw new cdk.ValidationError(`the containerRecipeName cannot contain spaces, got: '${this.physicalName}'`, this);
+            }
+            if (this.physicalName.includes('_')) {
+                throw new cdk.ValidationError(`the containerRecipeName cannot contain underscores, got: '${this.physicalName}'`, this);
+            }
+            if (this.physicalName !== this.physicalName.toLowerCase()) {
+                throw new cdk.ValidationError(`the containerRecipeName must be lowercase, got: '${this.physicalName}'`, this);
+            }
+        }
+        static {
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+    };
+    return ContainerRecipe = _classThis;
+})();
+exports.ContainerRecipe = ContainerRecipe;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container-recipe.js","sourceRoot":"","sources":["container-recipe.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as iam from 'aws-cdk-lib/aws-iam';\nimport { CfnContainerRecipe } from 'aws-cdk-lib/aws-imagebuilder';\nimport * as kms from 'aws-cdk-lib/aws-kms';\nimport * as s3 from 'aws-cdk-lib/aws-s3';\nimport * as s3assets from 'aws-cdk-lib/aws-s3-assets';\nimport { addConstructMetadata, MethodMetadata } from 'aws-cdk-lib/core/lib/metadata-resource';\nimport { propertyInjectable } from 'aws-cdk-lib/core/lib/prop-injectable';\nimport { Construct } from 'constructs';\nimport { BaseContainerImage, ContainerInstanceImage } from './base-image';\nimport { Repository } from './distribution-configuration';\nimport { IImageRecipe } from './image-recipe';\nimport { OSVersion } from './os-version';\nimport { ComponentConfiguration, IRecipeBase } from './recipe-base';\n\nconst CONTAINER_RECIPE_SYMBOL = Symbol.for('@aws-cdk/aws-imagebuilder-alpha.ContainerRecipe');\n\n/**\n * Represents the latest version of a container recipe. When using the recipe in a pipeline, the pipeline will use the\n * latest recipe at the time of execution.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/ibhow-semantic-versioning.html\n */\nconst LATEST_VERSION = 'x.x.x';\n\n/**\n * The default version to use in the container recipe. When the recipe is updated, the `x` will be incremented off from\n * the latest recipe version that exists.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/create-image-recipes.html\n */\nconst DEFAULT_RECIPE_VERSION = '1.0.x';\n\n/**\n * An EC2 Image Builder Container Recipe.\n */\nexport interface IContainerRecipe extends IRecipeBase {\n  /**\n   * The ARN of the container recipe\n   *\n   * @attribute\n   */\n  readonly containerRecipeArn: string;\n\n  /**\n   * The name of the container recipe\n   *\n   * @attribute\n   */\n  readonly containerRecipeName: string;\n\n  /**\n   * The version of the container recipe\n   *\n   * @attribute\n   */\n  readonly containerRecipeVersion: string;\n}\n\n/**\n * Properties for creating a Container Recipe resource\n */\nexport interface ContainerRecipeProps {\n  /**\n   * The base image for customizations specified in the container recipe.\n   */\n  readonly baseImage: BaseContainerImage;\n\n  /**\n   * The container repository where the output container image is stored.\n   */\n  readonly targetRepository: Repository;\n\n  /**\n   * The name of the container recipe.\n   *\n   * @default a name is generated\n   */\n  readonly containerRecipeName?: string;\n\n  /**\n   * The version of the container recipe.\n   *\n   * @default 1.0.x\n   */\n  readonly containerRecipeVersion?: string;\n\n  /**\n   * The description of the container recipe.\n   *\n   * @default None\n   */\n  readonly description?: string;\n\n  /**\n   * The dockerfile template used to build the container image.\n   *\n   * @default - a standard dockerfile template will be generated to pull the base image, perform environment setup, and\n   * run all components in the recipe\n   */\n  readonly dockerfile?: DockerfileData;\n\n  /**\n   * The list of component configurations to apply in the image build.\n   *\n   * @default None\n   */\n  readonly components?: ComponentConfiguration[];\n\n  /**\n   * The KMS key used to encrypt the dockerfile template.\n   *\n   * @default None\n   */\n  readonly kmsKey?: kms.IKey;\n\n  /**\n   * The working directory for use during build and test workflows.\n   *\n   * @default - the Image Builder default working directory is used. For Linux and macOS builds, this would be /tmp. For\n   * Windows builds, this would be C:/\n   */\n  readonly workingDirectory?: string;\n\n  /**\n   * The operating system (OS) version of the base image.\n   *\n   * @default - Image Builder will determine the OS version of the base image, if sourced from a third-party container\n   * registry. Otherwise, the OS version of the base image is required.\n   */\n  readonly osVersion?: OSVersion;\n\n  /**\n   * The block devices to attach to the instance used for building, testing, and distributing the container image.\n   *\n   * @default the block devices of the instance image will be used\n   */\n  readonly instanceBlockDevices?: ec2.BlockDevice[];\n\n  /**\n   * The image to use to launch the instance used for building, testing, and distributing the container image.\n   *\n   * @default Image Builder will use the appropriate ECS-optimized AMI\n   */\n  readonly instanceImage?: ContainerInstanceImage;\n\n  /**\n   * The tags to apply to the container recipe\n   *\n   * @default None\n   */\n  readonly tags?: { [key: string]: string };\n}\n\n/**\n * The type of the container being used in the container recipe\n */\nexport enum ContainerType {\n  /**\n   * Indicates the container recipe uses a Docker container\n   */\n  DOCKER = 'DOCKER',\n}\n\n/**\n * The rendered Dockerfile value, for use in CloudFormation.\n * - For inline dockerfiles, dockerfileTemplateData is the Dockerfile template text\n * - For S3-backed dockerfiles, dockerfileTemplateUri is the S3 URL\n */\nexport interface DockerfileTemplateConfig {\n  /**\n   * The rendered Dockerfile data, for use in CloudFormation\n   *\n   * @default - none if dockerfileTemplateUri is set\n   */\n  readonly dockerfileTemplateData?: string;\n\n  /**\n   * The rendered Dockerfile URI, for use in CloudFormation\n   *\n   * @default - none if dockerfileTemplateData is set\n   */\n  readonly dockerfileTemplateUri?: string;\n}\n\n/**\n * Helper class for referencing and uploading dockerfile data for the container recipe\n */\nexport abstract class DockerfileData {\n  /**\n   * Uploads dockerfile data from a local file to S3 to use as the dockerfile data\n   *\n   * @param scope The construct scope\n   * @param id Identifier of the construct\n   * @param path The local path to the dockerfile data file\n   * @param options S3 asset upload options\n   */\n  public static fromAsset(\n    scope: Construct,\n    id: string,\n    path: string,\n    options: s3assets.AssetOptions = {},\n  ): S3DockerfileData {\n    const asset = new s3assets.Asset(scope, id, { ...options, path });\n    return new S3DockerfileDataFromAsset(asset);\n  }\n\n  /**\n   * References dockerfile data from a pre-existing S3 object\n   *\n   * @param bucket The S3 bucket where the dockerfile data is stored\n   * @param key The S3 key of the dockerfile data file\n   */\n  public static fromS3(bucket: s3.IBucket, key: string): S3DockerfileData {\n    return new S3DockerfileDataFromBucketKey(bucket, key);\n  }\n\n  /**\n   * Uses an inline string as the dockerfile data\n   *\n   * @param data An inline string representing the dockerfile data\n   */\n  public static fromInline(data: string): DockerfileData {\n    return new InlineDockerfileData(data);\n  }\n\n  /**\n   * The rendered Dockerfile value, for use in CloudFormation.\n   * - For inline dockerfiles, dockerfileTemplateData is the Dockerfile template text\n   * - For S3-backed dockerfiles, dockerfileTemplateUri is the S3 URL\n   */\n  abstract render(): DockerfileTemplateConfig;\n}\n\n/**\n * Helper class for S3-based dockerfile data references, containing additional permission grant methods on the S3 object\n */\nexport abstract class S3DockerfileData extends DockerfileData {\n  protected readonly bucket: s3.IBucket;\n  protected readonly key: string;\n\n  protected constructor(bucket: s3.IBucket, key: string) {\n    super();\n\n    this.bucket = bucket;\n    this.key = key;\n  }\n\n  /**\n   * The rendered Dockerfile S3 URL, for use in CloudFormation\n   */\n  public render(): DockerfileTemplateConfig {\n    return { dockerfileTemplateUri: this.bucket.s3UrlForObject(this.key) };\n  }\n\n  /**\n   * Grant put permissions to the given grantee for the dockerfile data in S3\n   *\n   * @param grantee The principal\n   */\n  public grantPut(grantee: iam.IGrantable): iam.Grant {\n    return this.bucket.grantPut(grantee, this.key);\n  }\n\n  /**\n   * Grant read permissions to the given grantee for the dockerfile data in S3\n   *\n   * @param grantee The principal\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.bucket.grantRead(grantee, this.key);\n  }\n}\n\nclass InlineDockerfileData extends DockerfileData {\n  protected readonly data: string;\n\n  public constructor(data: string) {\n    super();\n\n    this.data = data;\n  }\n\n  /**\n   * The rendered Dockerfile text, for use in CloudFormation\n   */\n  public render(): DockerfileTemplateConfig {\n    return { dockerfileTemplateData: this.data };\n  }\n}\n\nclass S3DockerfileDataFromBucketKey extends S3DockerfileData {\n  public constructor(bucket: s3.IBucket, key: string) {\n    super(bucket, key);\n  }\n}\n\nclass S3DockerfileDataFromAsset extends S3DockerfileData {\n  public constructor(asset: s3assets.Asset) {\n    super(asset.bucket, asset.s3ObjectKey);\n  }\n}\n\n/**\n * Properties for an EC2 Image Builder container recipe\n */\nexport interface ContainerRecipeAttributes {\n  /**\n   * The ARN of the container recipe\n   *\n   * @default - derived from containerRecipeName\n   */\n  readonly containerRecipeArn?: string;\n\n  /**\n   * The name of the container recipe\n   *\n   * @default - derived from containerRecipeArn\n   */\n  readonly containerRecipeName?: string;\n\n  /**\n   * The version of the container recipe\n   *\n   * @default - derived from containerRecipeArn. if a containerRecipeName is provided, the latest version, x.x.x, will\n   * be used.\n   */\n  readonly containerRecipeVersion?: string;\n}\n\n/**\n * A new or imported Container Recipe\n */\nexport abstract class ContainerRecipeBase extends cdk.Resource implements IContainerRecipe {\n  /**\n   * The ARN of the container recipe\n   */\n  abstract readonly containerRecipeArn: string;\n\n  /**\n   * The name of the container recipe\n   */\n  abstract readonly containerRecipeName: string;\n\n  /**\n   * The version of the container recipe\n   */\n  abstract readonly containerRecipeVersion: string;\n\n  /**\n   * Grant custom actions to the given grantee for the container recipe\n   *\n   * @param grantee The principal\n   * @param actions The list of actions\n   */\n  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {\n    return iam.Grant.addToPrincipal({\n      grantee,\n      actions,\n      resourceArns: [this.containerRecipeArn],\n      scope: this,\n    });\n  }\n\n  /**\n   * Grant read permissions to the given grantee for the container recipe\n   *\n   * @param grantee The principal\n   */\n  public grantRead(grantee: iam.IGrantable): iam.Grant {\n    return this.grant(grantee, 'imagebuilder:GetContainerRecipe');\n  }\n\n  /**\n   * Indicates whether the recipe is a Container Recipe\n   *\n   * @internal\n   */\n  public _isContainerRecipe(): this is IContainerRecipe {\n    return true;\n  }\n\n  /**\n   * Indicates whether the recipe is an Image Recipe\n   *\n   * @internal\n   */\n  public _isImageRecipe(): this is IImageRecipe {\n    return false;\n  }\n}\n\n/**\n * Represents an EC2 Image Builder Container Recipe.\n *\n * @see https://docs.aws.amazon.com/imagebuilder/latest/userguide/manage-recipes.html\n */\n@propertyInjectable\nexport class ContainerRecipe extends ContainerRecipeBase {\n  /** Uniquely identifies this class. */\n  public static readonly PROPERTY_INJECTION_ID: string = '@aws-cdk.aws-imagebuilder-alpha.ContainerRecipe';\n\n  /**\n   * Import an existing container recipe given its ARN.\n   */\n  public static fromContainerRecipeArn(scope: Construct, id: string, containerRecipeArn: string): IContainerRecipe {\n    return this.fromContainerRecipeAttributes(scope, id, { containerRecipeArn });\n  }\n\n  /**\n   * Import the latest version of an existing container recipe given its name. The provided name must be normalized by\n   * converting all alphabetical characters to lowercase, and replacing all spaces and underscores with hyphens.\n   */\n  public static fromContainerRecipeName(scope: Construct, id: string, containerRecipeName: string): IContainerRecipe {\n    return this.fromContainerRecipeAttributes(scope, id, { containerRecipeName });\n  }\n\n  /**\n   * Import an existing container recipe by providing its attributes. If the container recipe name is provided as an\n   * attribute, it must be normalized by converting all alphabetical characters to lowercase, and replacing all spaces\n   * and underscores with hyphens.\n   */\n  public static fromContainerRecipeAttributes(\n    scope: Construct,\n    id: string,\n    attrs: ContainerRecipeAttributes,\n  ): IContainerRecipe {\n    if (!attrs.containerRecipeArn && !attrs.containerRecipeName) {\n      throw new cdk.ValidationError(\n        'either either containerRecipeArn or containerRecipeName must be provided to import a container recipe',\n        scope,\n      );\n    }\n\n    const containerRecipeArn =\n      attrs.containerRecipeArn ??\n      cdk.Stack.of(scope).formatArn({\n        service: 'imagebuilder',\n        resource: 'container-recipe',\n        resourceName: `${attrs.containerRecipeName}/${attrs.containerRecipeVersion ?? LATEST_VERSION}`,\n      });\n\n    const [containerRecipeName, containerRecipeVersion] = (() => {\n      if (attrs.containerRecipeName) {\n        return [attrs.containerRecipeName, attrs.containerRecipeVersion ?? LATEST_VERSION];\n      }\n\n      const containerRecipeNameVersion = cdk.Stack.of(scope).splitArn(\n        containerRecipeArn,\n        cdk.ArnFormat.SLASH_RESOURCE_NAME,\n      ).resourceName!;\n\n      const containerRecipeNameVersionSplit = cdk.Fn.split('/', containerRecipeNameVersion);\n      return [cdk.Fn.select(0, containerRecipeNameVersionSplit), cdk.Fn.select(1, containerRecipeNameVersionSplit)];\n    })();\n\n    class Import extends ContainerRecipeBase {\n      public readonly containerRecipeArn = containerRecipeArn;\n      public readonly containerRecipeName = containerRecipeName;\n      public readonly containerRecipeVersion = containerRecipeVersion;\n    }\n\n    return new Import(scope, id);\n  }\n\n  /**\n   * Return whether the given object is a ContainerRecipe.\n   */\n  public static isContainerRecipe(x: any): x is ContainerRecipe {\n    return x !== null && typeof x === 'object' && CONTAINER_RECIPE_SYMBOL in x;\n  }\n\n  /**\n   * The ARN of the container recipe\n   */\n  public readonly containerRecipeArn: string;\n\n  /**\n   * The name of the container recipe\n   */\n  public readonly containerRecipeName: string;\n\n  /**\n   * The version of the container recipe\n   */\n  public readonly containerRecipeVersion: string;\n\n  private readonly instanceBlockDevices: ec2.BlockDevice[] = [];\n\n  public constructor(scope: Construct, id: string, props: ContainerRecipeProps) {\n    super(scope, id, {\n      physicalName:\n        props.containerRecipeName ??\n        cdk.Lazy.string({\n          produce: () =>\n            cdk.Names.uniqueResourceName(this, {\n              maxLength: 128,\n              separator: '-',\n              allowedSpecialCharacters: '-',\n            }).toLowerCase(), // Enforce lowercase for the auto-generated fallback\n        }),\n    });\n    // Enhanced CDK Analytics Telemetry\n    addConstructMetadata(this, props);\n\n    Object.defineProperty(this, CONTAINER_RECIPE_SYMBOL, { value: true });\n\n    this.validateContainerRecipeName();\n\n    this.addInstanceBlockDevice(...(props.instanceBlockDevices ?? []));\n\n    const components: CfnContainerRecipe.ComponentConfigurationProperty[] | undefined = props.components?.map(\n      (component) => ({\n        componentArn: component.component.componentArn,\n        ...(component.parameters && {\n          parameters: Object.entries(component.parameters).map(\n            ([name, param]): CfnContainerRecipe.ComponentParameterProperty => ({\n              name,\n              value: param.value,\n            }),\n          ),\n        }),\n      }),\n    );\n\n    const dockerfile =\n      props.dockerfile ??\n      DockerfileData.fromInline(\n        'FROM {{{ imagebuilder:parentImage }}}\\n{{{ imagebuilder:environments }}}\\n{{{ imagebuilder:components }}}',\n      );\n\n    const containerRecipeVersion = props.containerRecipeVersion ?? DEFAULT_RECIPE_VERSION;\n    const containerRecipe = new CfnContainerRecipe(this, 'Resource', {\n      name: this.physicalName,\n      version: containerRecipeVersion,\n      description: props.description,\n      parentImage: props.baseImage.image,\n      containerType: ContainerType.DOCKER,\n      targetRepository: {\n        repositoryName: props.targetRepository.repositoryName,\n        service: props.targetRepository.service,\n      },\n      platformOverride: props.osVersion?.platform,\n      imageOsVersionOverride: props.osVersion?.osVersion,\n      kmsKeyId: props.kmsKey?.keyArn,\n      instanceConfiguration: cdk.Lazy.any({ produce: () => this.buildInstanceConfiguration(props) }),\n      workingDirectory: props.workingDirectory,\n      tags: props.tags,\n      ...dockerfile.render(),\n      ...(components?.length && { components }),\n    });\n\n    this.containerRecipeName = this.getResourceNameAttribute(containerRecipe.attrName);\n    this.containerRecipeArn = this.getResourceArnAttribute(containerRecipe.attrArn, {\n      service: 'imagebuilder',\n      resource: 'container-recipe',\n      resourceName: `${this.physicalName}/${containerRecipeVersion}`,\n    });\n    this.containerRecipeVersion = containerRecipe.getAtt('Version').toString();\n  }\n\n  /**\n   * Adds block devices to attach to the instance used for building, testing, and distributing the container image.\n   *\n   * @param instanceBlockDevices - The list of block devices to attach\n   */\n  @MethodMetadata()\n  public addInstanceBlockDevice(...instanceBlockDevices: ec2.BlockDevice[]): void {\n    this.instanceBlockDevices.push(...instanceBlockDevices);\n  }\n\n  /**\n   * Renders the block devices provided as input to the construct, into the block device mapping structure that\n   * CfnContainerRecipe expects to receive.\n   *\n   * This is rendered at synthesis time, as users can add additional block devices with `addInstanceBlockDevice`, after\n   * the construct has been instantiated.\n   *\n   * @private\n   */\n  private renderBlockDevices(): CfnContainerRecipe.InstanceBlockDeviceMappingProperty[] | undefined {\n    const blockDevices = this.instanceBlockDevices.map(\n      (blockDevice): CfnContainerRecipe.InstanceBlockDeviceMappingProperty => {\n        const ebsDevice = blockDevice.volume.ebsDevice;\n        const ebs: CfnContainerRecipe.EbsInstanceBlockDeviceSpecificationProperty = {\n          ...(ebsDevice?.deleteOnTermination !== undefined && { deleteOnTermination: ebsDevice.deleteOnTermination }),\n          ...(ebsDevice?.encrypted !== undefined && { encrypted: ebsDevice.encrypted }),\n          ...(ebsDevice?.iops !== undefined && { iops: ebsDevice.iops }),\n          ...(ebsDevice?.kmsKey !== undefined && { kmsKeyId: ebsDevice.kmsKey.keyArn }),\n          ...(ebsDevice?.snapshotId !== undefined && { snapshotId: ebsDevice.snapshotId }),\n          ...(ebsDevice?.throughput !== undefined && { throughput: ebsDevice.throughput }),\n          ...(ebsDevice?.volumeSize !== undefined && { volumeSize: ebsDevice.volumeSize }),\n          ...(ebsDevice?.volumeType !== undefined && { volumeType: ebsDevice.volumeType }),\n        };\n\n        const mappingEnabled = blockDevice.mappingEnabled ?? true;\n        return {\n          deviceName: blockDevice.deviceName,\n          virtualName: blockDevice.volume.virtualName,\n          ...(!mappingEnabled && { noDevice: '' }),\n          ...(Object.keys(ebs).length && { ebs }),\n        };\n      },\n    );\n\n    return blockDevices.length ? blockDevices : undefined;\n  }\n\n  /**\n   * Generates the instance configuration property into the `InstanceConfiguration` type in the  CloudFormation L1\n   * definition.\n   *\n   * @param props The props passed as input to the construct\n   * @private\n   */\n  private buildInstanceConfiguration(\n    props: ContainerRecipeProps,\n  ): CfnContainerRecipe.InstanceConfigurationProperty | undefined {\n    const blockDevices = this.renderBlockDevices();\n\n    const instanceConfiguration: CfnContainerRecipe.InstanceConfigurationProperty = {\n      ...(blockDevices?.length && { blockDeviceMappings: blockDevices }),\n      ...(props.instanceImage !== undefined && { image: props.instanceImage.image }),\n    };\n\n    return Object.keys(instanceConfiguration).length ? instanceConfiguration : undefined;\n  }\n\n  private validateContainerRecipeName() {\n    if (cdk.Token.isUnresolved(this.physicalName)) {\n      return; // Cannot validate unresolved tokens, given their actual value is rendered at deployment time\n    }\n\n    if (this.physicalName.length > 128) {\n      throw new cdk.ValidationError(\n        `the containerRecipeName cannot be longer than 128 characters, got: '${this.physicalName}'`,\n        this,\n      );\n    }\n\n    if (this.physicalName.includes(' ')) {\n      throw new cdk.ValidationError(`the containerRecipeName cannot contain spaces, got: '${this.physicalName}'`, this);\n    }\n\n    if (this.physicalName.includes('_')) {\n      throw new cdk.ValidationError(\n        `the containerRecipeName cannot contain underscores, got: '${this.physicalName}'`,\n        this,\n      );\n    }\n\n    if (this.physicalName !== this.physicalName.toLowerCase()) {\n      throw new cdk.ValidationError(`the containerRecipeName must be lowercase, got: '${this.physicalName}'`, this);\n    }\n  }\n}\n"]}

package/lib/distribution-configuration.d.ts

@@ -398,6 +398,17 @@ export declare class DistributionConfiguration extends DistributionConfiguration
      */
     addContainerDistributions(...containerDistributions: ContainerDistribution[]): void;
     private validateDistributionConfigurationName;
+    /**
+     * Renders the AMI and container distributions provided as input to the construct, into the `Distribution[]` structure
+     * that CfnDistributionConfiguration expects to receive. Distributions provided to CfnDistributionConfiguration must
+     * map to a unique region per entry in the list - this render function also handles combining AMI and container
+     * distributions in the same region into a single entry.
+     *
+     * This is rendered at synthesis time, as users can add additional AMI and container distributions with
+     * `addAmiDistributions` and `addContainerDistributions`, after the construct has been instantiated.
+     *
+     * @private
+     */
     private renderDistributions;
     private buildAmiDistribution;
     private buildContainerDistribution;