token-injectable-docker-builder 1.13.3 → 2.0.0

package/lib/builder.js

@@ -0,0 +1,289 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenInjectableDockerBuilder = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const crypto = require("crypto");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_codebuild_1 = require("aws-cdk-lib/aws-codebuild");
+const aws_ecr_1 = require("aws-cdk-lib/aws-ecr");
+const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_kms_1 = require("aws-cdk-lib/aws-kms");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const aws_s3_assets_1 = require("aws-cdk-lib/aws-s3-assets");
+const constructs_1 = require("constructs");
+const build_spec_1 = require("./build-spec");
+const constants_1 = require("./constants");
+const ecr_1 = require("./ecr");
+const provider_1 = require("./provider");
+/**
+ * A CDK construct to build and push Docker images to an ECR repository using
+ * CodeBuild and Lambda custom resources, **then** retrieve the final image tag
+ * so that ECS/Lambda references use the exact built image.
+ */
+class TokenInjectableDockerBuilder extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { path: sourcePath, buildArgs, dockerLoginSecretArn, vpc, securityGroups, subnetSelection, installCommands, preBuildCommands, kmsEncryption = false, exclude, file: dockerFile, cacheDisabled = false, buildLogGroup, platform = 'linux/amd64', provider, ecrPullThroughCachePrefixes, retainBuildLogs = false, replicaRegions = [], } = props;
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        this.primaryRegion = stack.region;
+        this.accountId = stack.account;
+        this.replicaRegions = [...replicaRegions];
+        const encryptionKey = kmsEncryption
+            ? new aws_kms_1.Key(this, 'EcrEncryptionKey', { enableKeyRotation: true })
+            : undefined;
+        this.ecrRepository = (0, ecr_1.createBuilderEcrRepository)(this, 'ECRRepository', {
+            kmsEncryption,
+            encryptionKey,
+        });
+        const dockerFileName = dockerFile ?? 'Dockerfile';
+        const effectiveExclude = (0, build_spec_1.resolveExcludes)(sourcePath, dockerFileName, exclude);
+        const sourceAsset = new aws_s3_assets_1.Asset(this, 'SourceAsset', {
+            path: sourcePath,
+            exclude: effectiveExclude,
+        });
+        // Deterministic image tag: a hash of every input that materially affects
+        // the built image. Stable across synths → no spurious rebuilds, and
+        // cross-region SSM exports don't churn between deploys (which used to
+        // wedge the CDK CrossRegionExportReader/Writer when a deploy was retried
+        // after a rollback).
+        const imageTag = crypto.createHash('sha256').update(JSON.stringify({
+            assetHash: sourceAsset.assetHash,
+            dockerFile: dockerFileName,
+            buildArgs: buildArgs ?? {},
+            platform,
+            installCommands: installCommands ?? [],
+            preBuildCommands: preBuildCommands ?? [],
+            cacheDisabled,
+            dockerLoginSecretArn: dockerLoginSecretArn ?? null,
+            ecrPullThroughCachePrefixes: ecrPullThroughCachePrefixes ?? [],
+        })).digest('hex');
+        const buildSpecObj = (0, build_spec_1.buildBuildSpec)({
+            imageTag,
+            dockerFile,
+            buildArgs,
+            dockerLoginSecretArn,
+            installCommands,
+            preBuildCommands,
+            cacheDisabled,
+            platform,
+        });
+        const codeBuildImage = platform === 'linux/arm64'
+            ? aws_codebuild_1.LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0
+            : aws_codebuild_1.LinuxBuildImage.STANDARD_7_0;
+        const codeBuildProject = new aws_codebuild_1.Project(this, 'CodeBuildProject', {
+            source: aws_codebuild_1.Source.s3({
+                bucket: sourceAsset.bucket,
+                path: sourceAsset.s3ObjectKey,
+            }),
+            environment: {
+                buildImage: codeBuildImage,
+                privileged: true,
+            },
+            environmentVariables: {
+                ECR_REPO_URI: { value: this.ecrRepository.repositoryUri },
+            },
+            buildSpec: aws_codebuild_1.BuildSpec.fromObject(buildSpecObj),
+            ...(buildLogGroup && {
+                logging: { cloudWatch: { logGroup: buildLogGroup } },
+            }),
+            vpc,
+            securityGroups,
+            subnetSelection,
+        });
+        this.grantBuildLogsAccess(codeBuildProject, retainBuildLogs);
+        this.grantEcrAccess(codeBuildProject);
+        this.grantPullThroughCacheAccess(codeBuildProject, ecrPullThroughCachePrefixes);
+        if (dockerLoginSecretArn) {
+            codeBuildProject.addToRolePolicy(new aws_iam_1.PolicyStatement({
+                actions: ['secretsmanager:GetSecretValue'],
+                resources: [dockerLoginSecretArn],
+            }));
+        }
+        if (encryptionKey) {
+            encryptionKey.grantEncryptDecrypt(codeBuildProject.role);
+        }
+        const effectiveProvider = provider ?? provider_1.TokenInjectableDockerBuilderProvider.getOrCreate(this);
+        effectiveProvider.registerProject(codeBuildProject, this.ecrRepository, encryptionKey);
+        if (replicaRegions.length > 0) {
+            this.validateReplicaRegions(replicaRegions);
+            effectiveProvider.registerReplication(this.ecrRepository.repositoryName, replicaRegions);
+        }
+        // The CR's construct ID has a "V2" suffix so that a v1-deployed stack
+        // upgrading to v2 sees a NEW resource (Replace), not an in-place update
+        // of the old `BuildTriggerResource`. CloudFormation forbids modifying a
+        // custom resource's `ServiceToken` in-place ("Modifying service token is
+        // not allowed."), and the serviceToken changes from v1's per-instance
+        // provider to v2's singleton provider. Replace dodges the constraint:
+        // the old CR is deleted, and a new one is created with the singleton's
+        // serviceToken — at the cost of one fresh build per builder on upgrade.
+        const buildTriggerResource = new aws_cdk_lib_1.CustomResource(this, 'BuildTriggerResourceV2', {
+            serviceToken: effectiveProvider.serviceToken,
+            properties: {
+                ProjectName: codeBuildProject.projectName,
+                ImageTag: imageTag,
+                Trigger: sourceAsset.assetHash,
+                RetainBuildLogs: retainBuildLogs ? 'true' : 'false',
+                RepositoryName: this.ecrRepository.repositoryName,
+                ReplicaRegions: JSON.stringify(replicaRegions),
+            },
+        });
+        buildTriggerResource.node.addDependency(codeBuildProject);
+        // SAFETY: reference by tag, not digest. The lifecycle policy above never
+        // deletes tagged images, so the digest behind this tag is guaranteed to
+        // remain in ECR for the life of the repository.
+        const imageTagRef = buildTriggerResource.getAttString('ImageTag');
+        this.imageTag = imageTagRef;
+        this.repositoryName = this.ecrRepository.repositoryName;
+        this.containerImage = aws_ecs_1.ContainerImage.fromEcrRepository(this.ecrRepository, imageTagRef);
+        this.dockerImageCode = aws_lambda_1.DockerImageCode.fromEcr(this.ecrRepository, {
+            tagOrDigest: imageTagRef,
+        });
+    }
+    /**
+     * Format the ECR repository URI for a given region. The region must
+     * be either the primary region or one of `replicaRegions`.
+     */
+    repositoryUriFor(region) {
+        this.assertRegionIsKnown(region);
+        return `${this.accountId}.dkr.ecr.${region}.amazonaws.com/${this.repositoryName}`;
+    }
+    /**
+     * Import the replicated repository as an ECS-compatible
+     * `ContainerImage` in a consumer scope (typically a stack in `region`).
+     *
+     * The consumer's stack must have `crossRegionReferences: true` when
+     * `region` differs from the builder's region.
+     */
+    containerImageFor(scope, region) {
+        return aws_ecs_1.ContainerImage.fromEcrRepository(this.importRepoFor(scope, region), this.imageTag);
+    }
+    /**
+     * Import the replicated repository as a Lambda-compatible
+     * `DockerImageCode` in a consumer scope (typically a stack in `region`).
+     *
+     * The consumer's stack must have `crossRegionReferences: true` when
+     * `region` differs from the builder's region.
+     */
+    dockerImageCodeFor(scope, region) {
+        return aws_lambda_1.DockerImageCode.fromEcr(this.importRepoFor(scope, region), {
+            tagOrDigest: this.imageTag,
+        });
+    }
+    importRepoFor(scope, region) {
+        this.assertRegionIsKnown(region);
+        if (region === this.primaryRegion)
+            return this.ecrRepository;
+        // Include the builder's own node.addr in the import id so two different
+        // builders importing the same region into the same scope each get their
+        // own Repository child (otherwise the second call would collide with the
+        // first and return the wrong builder's repo).
+        const importId = `ImportedRepo${region}${this.node.addr}`;
+        const existing = scope.node.tryFindChild(importId);
+        if (existing)
+            return existing;
+        return aws_ecr_1.Repository.fromRepositoryAttributes(scope, importId, {
+            repositoryName: this.repositoryName,
+            repositoryArn: aws_cdk_lib_1.Stack.of(scope).formatArn({
+                service: 'ecr',
+                resource: 'repository',
+                resourceName: this.repositoryName,
+                region,
+                account: this.accountId,
+            }),
+        });
+    }
+    assertRegionIsKnown(region) {
+        if (region === this.primaryRegion)
+            return;
+        if (this.replicaRegions.includes(region))
+            return;
+        throw new Error(`Region "${region}" is not the primary region (${this.primaryRegion}) ` +
+            `or one of the configured replicaRegions (${this.replicaRegions.join(', ') || '<none>'}). ` +
+            'Add the region to the builder\'s replicaRegions prop to make it available.');
+    }
+    validateReplicaRegions(replicaRegions) {
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        const primaryPartition = stack.partition;
+        for (const region of replicaRegions) {
+            if (region === this.primaryRegion) {
+                throw new Error(`replicaRegions cannot include the primary region "${this.primaryRegion}". ` +
+                    'Remove it from the list.');
+            }
+            // Partition cannot be cleanly inferred from region alone at synth time
+            // (it's a CDK pseudo-parameter and may be a token). We do the best-effort
+            // check: if both partition values are concrete and they differ, fail.
+            // Cross-partition replication is unsupported by ECR.
+            if (!aws_cdk_lib_1.Token.isUnresolved(primaryPartition)) {
+                const expectedPartition = inferPartition(region);
+                if (expectedPartition && expectedPartition !== primaryPartition) {
+                    throw new Error('Cross-partition ECR replication is not supported. ' +
+                        `Primary partition is "${primaryPartition}" but replica region ` +
+                        `"${region}" appears to be in partition "${expectedPartition}".`);
+                }
+            }
+        }
+    }
+    grantEcrAccess(project) {
+        this.ecrRepository.grantPullPush(project);
+        project.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: [
+                'ecr:GetAuthorizationToken',
+                'ecr:GetDownloadUrlForLayer',
+                'ecr:BatchCheckLayerAvailability',
+                'ecr:BatchGetImage',
+            ],
+            resources: ['*'],
+        }));
+    }
+    grantPullThroughCacheAccess(project, prefixes) {
+        if (!prefixes || prefixes.length === 0)
+            return;
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        project.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: [
+                'ecr:BatchGetImage',
+                'ecr:GetDownloadUrlForLayer',
+                'ecr:BatchCheckLayerAvailability',
+                'ecr:BatchImportUpstreamImage',
+                'ecr:CreateRepository',
+            ],
+            resources: prefixes.map((prefix) => `arn:aws:ecr:${stack.region}:${stack.account}:repository/${prefix}/*`),
+        }));
+    }
+    grantBuildLogsAccess(project, retainBuildLogs) {
+        if (!retainBuildLogs)
+            return;
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        project.addToRolePolicy(new aws_iam_1.PolicyStatement({
+            actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],
+            resources: [
+                `arn:aws:logs:${stack.region}:${stack.account}:log-group:${constants_1.BUILD_LOG_GROUP_PREFIX}${project.projectName}`,
+                `arn:aws:logs:${stack.region}:${stack.account}:log-group:${constants_1.BUILD_LOG_GROUP_PREFIX}${project.projectName}:*`,
+            ],
+        }));
+    }
+}
+exports.TokenInjectableDockerBuilder = TokenInjectableDockerBuilder;
+_a = JSII_RTTI_SYMBOL_1;
+TokenInjectableDockerBuilder[_a] = { fqn: "token-injectable-docker-builder.TokenInjectableDockerBuilder", version: "2.0.0" };
+/**
+ * Best-effort partition inference from an AWS region name. Returns
+ * undefined if the region doesn't look like a known partition prefix —
+ * callers should treat that as "skip the partition check".
+ */
+function inferPartition(region) {
+    if (region.startsWith('cn-'))
+        return 'aws-cn';
+    if (region.startsWith('us-gov-'))
+        return 'aws-us-gov';
+    if (region.startsWith('us-iso-'))
+        return 'aws-iso';
+    if (region.startsWith('us-isob-'))
+        return 'aws-iso-b';
+    if (/^[a-z]{2}-[a-z]+-\d+$/.test(region))
+        return 'aws';
+    return undefined;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"builder.js","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\n\nimport { CustomResource, Stack, Token } from 'aws-cdk-lib';\nimport {\n  Project,\n  Source,\n  LinuxBuildImage,\n  LinuxArmBuildImage,\n  BuildSpec,\n} from 'aws-cdk-lib/aws-codebuild';\nimport { IVpc, ISecurityGroup, SubnetSelection } from 'aws-cdk-lib/aws-ec2';\nimport { Repository } from 'aws-cdk-lib/aws-ecr';\nimport { ContainerImage } from 'aws-cdk-lib/aws-ecs';\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Key } from 'aws-cdk-lib/aws-kms';\nimport { DockerImageCode } from 'aws-cdk-lib/aws-lambda';\nimport { ILogGroup } from 'aws-cdk-lib/aws-logs';\nimport { Asset } from 'aws-cdk-lib/aws-s3-assets';\nimport { Construct } from 'constructs';\n\nimport { buildBuildSpec, resolveExcludes } from './build-spec';\nimport { BUILD_LOG_GROUP_PREFIX } from './constants';\nimport { createBuilderEcrRepository } from './ecr';\nimport { TokenInjectableDockerBuilderProvider } from './provider';\n\n/**\n * Properties for the `TokenInjectableDockerBuilder` construct.\n */\nexport interface TokenInjectableDockerBuilderProps {\n  /**\n   * The path to the directory containing the Dockerfile or source code.\n   */\n  readonly path: string;\n\n  /**\n   * Build arguments to pass to the Docker build process.\n   * These are transformed into `--build-arg KEY=VALUE` flags.\n   * @example\n   * {\n   *   TOKEN: 'my-secret-token',\n   *   ENV: 'production'\n   * }\n   */\n  readonly buildArgs?: { [key: string]: string };\n\n  /**\n   * The ARN of the AWS Secrets Manager secret containing Docker login credentials.\n   * The secret must store a JSON object: `{\"username\":\"...\",\"password\":\"...\"}`.\n   * Must be in the same region as the stack.\n   *\n   * @default - No Docker Hub login.\n   */\n  readonly dockerLoginSecretArn?: string;\n\n  /**\n   * The VPC in which the CodeBuild project will be deployed.\n   *\n   * @default - CodeBuild uses public internet.\n   */\n  readonly vpc?: IVpc;\n\n  /**\n   * Security groups attached to the CodeBuild project.\n   *\n   * @default - No security groups attached.\n   */\n  readonly securityGroups?: ISecurityGroup[];\n\n  /**\n   * Subnet selection within the VPC.\n   *\n   * @default - All subnets in the VPC.\n   */\n  readonly subnetSelection?: SubnetSelection;\n\n  /**\n   * Custom commands to run during the install phase of CodeBuild.\n   *\n   * @default - No additional install commands.\n   */\n  readonly installCommands?: string[];\n\n  /**\n   * Custom commands to run during the pre_build phase of CodeBuild.\n   *\n   * @default - No additional pre-build commands.\n   */\n  readonly preBuildCommands?: string[];\n\n  /**\n   * Whether to enable KMS encryption for the ECR repository.\n   *\n   * @default false\n   */\n  readonly kmsEncryption?: boolean;\n\n  /**\n   * File paths in the Docker directory to exclude from the build asset.\n   * Falls back to `.dockerignore` if present.\n   *\n   * @default - No file path exclusions.\n   */\n  readonly exclude?: string[];\n\n  /**\n   * Name of the Dockerfile (passed as `-f`).\n   *\n   * @example 'Dockerfile.production'\n   * @default 'Dockerfile'\n   */\n  readonly file?: string;\n\n  /**\n   * When `true`, disables Docker layer caching.\n   *\n   * @default false\n   */\n  readonly cacheDisabled?: boolean;\n\n  /**\n   * CloudWatch log group for CodeBuild build logs.\n   *\n   * @default - CodeBuild default logging.\n   */\n  readonly buildLogGroup?: ILogGroup;\n\n  /**\n   * Target platform for the Docker image.\n   *\n   * @default 'linux/amd64'\n   */\n  readonly platform?: 'linux/amd64' | 'linux/arm64';\n\n  /**\n   * Shared provider for the custom resource Lambdas.\n   *\n   * Pass `TokenInjectableDockerBuilderProvider.getOrCreate(this, { queryInterval })`\n   * if you need a non-default query interval. Otherwise, the construct will\n   * call `getOrCreate(this)` itself and reuse the per-stack singleton.\n   *\n   * @default - Per-stack singleton provider, created on first use.\n   */\n  readonly provider?: TokenInjectableDockerBuilderProvider;\n\n  /**\n   * ECR pull-through cache repository prefixes to grant pull access to.\n   *\n   * @example ['docker-hub', 'ghcr']\n   * @default - No pull-through cache access.\n   */\n  readonly ecrPullThroughCachePrefixes?: string[];\n\n  /**\n   * When `true`, creates a CloudWatch log group outside of CloudFormation\n   * (`/docker-builder/<projectName>`) and directs CodeBuild output there.\n   * Survives stack rollbacks for debugging. 7-day retention.\n   *\n   * @default false\n   */\n  readonly retainBuildLogs?: boolean;\n\n  /**\n   * Additional AWS regions to replicate the built image to via ECR's\n   * native registry replication. The image is pushed to the primary\n   * region's ECR as usual; ECR asynchronously replicates the same\n   * `repositoryName` + `imageTag` to each region listed here.\n   *\n   * Consumers in another region (a Lambda in `us-west-2` referencing an\n   * image built in `us-east-1`) can use `dockerImageCodeFor(region)` or\n   * `containerImageFor(region)` to import the replicated image.\n   *\n   * The custom resource waits for replication to complete before\n   * signalling deploy-complete, so downstream stacks can safely deploy\n   * immediately after.\n   *\n   * **Caveats:**\n   * - Cross-region replication is not supported between AWS partitions.\n   * - Replicas do **not** inherit the primary's encryption (defaults to\n   *   AES-256), lifecycle policies, or repository policies.\n   * - Replicated repositories persist on stack deletion — AWS does not\n   *   auto-delete them. Clean up manually via the ECR console / CLI if\n   *   needed.\n   * - Both the builder stack and any consumer stack in another region\n   *   must set `crossRegionReferences: true` for the image tag to flow.\n   * - Stacks must have a concrete region (`env: { account, region }`),\n   *   not the env-agnostic default.\n   *\n   * @example ['us-west-2', 'eu-west-1']\n   * @default [] - no replication\n   */\n  readonly replicaRegions?: string[];\n}\n\n/**\n * A CDK construct to build and push Docker images to an ECR repository using\n * CodeBuild and Lambda custom resources, **then** retrieve the final image tag\n * so that ECS/Lambda references use the exact built image.\n */\nexport class TokenInjectableDockerBuilder extends Construct {\n  /** The ECR repository that stores the resulting Docker image. */\n  private readonly ecrRepository: Repository;\n\n  /** ECS-compatible container image reference (primary region). */\n  public readonly containerImage: ContainerImage;\n\n  /** Lambda-compatible DockerImageCode reference (primary region). */\n  public readonly dockerImageCode: DockerImageCode;\n\n  /** The ECR repository name — preserved across replica regions. */\n  public readonly repositoryName: string;\n\n  /** The resolved image tag (CFN token; available at deploy time). */\n  public readonly imageTag: string;\n\n  private readonly primaryRegion: string;\n  private readonly accountId: string;\n  private readonly replicaRegions: string[];\n\n  constructor(scope: Construct, id: string, props: TokenInjectableDockerBuilderProps) {\n    super(scope, id);\n\n    const {\n      path: sourcePath,\n      buildArgs,\n      dockerLoginSecretArn,\n      vpc,\n      securityGroups,\n      subnetSelection,\n      installCommands,\n      preBuildCommands,\n      kmsEncryption = false,\n      exclude,\n      file: dockerFile,\n      cacheDisabled = false,\n      buildLogGroup,\n      platform = 'linux/amd64',\n      provider,\n      ecrPullThroughCachePrefixes,\n      retainBuildLogs = false,\n      replicaRegions = [],\n    } = props;\n\n    const stack = Stack.of(this);\n    this.primaryRegion = stack.region;\n    this.accountId = stack.account;\n    this.replicaRegions = [...replicaRegions];\n\n    const encryptionKey = kmsEncryption\n      ? new Key(this, 'EcrEncryptionKey', { enableKeyRotation: true })\n      : undefined;\n\n    this.ecrRepository = createBuilderEcrRepository(this, 'ECRRepository', {\n      kmsEncryption,\n      encryptionKey,\n    });\n\n    const dockerFileName = dockerFile ?? 'Dockerfile';\n    const effectiveExclude = resolveExcludes(sourcePath, dockerFileName, exclude);\n\n    const sourceAsset = new Asset(this, 'SourceAsset', {\n      path: sourcePath,\n      exclude: effectiveExclude,\n    });\n\n    // Deterministic image tag: a hash of every input that materially affects\n    // the built image. Stable across synths → no spurious rebuilds, and\n    // cross-region SSM exports don't churn between deploys (which used to\n    // wedge the CDK CrossRegionExportReader/Writer when a deploy was retried\n    // after a rollback).\n    const imageTag = crypto.createHash('sha256').update(JSON.stringify({\n      assetHash: sourceAsset.assetHash,\n      dockerFile: dockerFileName,\n      buildArgs: buildArgs ?? {},\n      platform,\n      installCommands: installCommands ?? [],\n      preBuildCommands: preBuildCommands ?? [],\n      cacheDisabled,\n      dockerLoginSecretArn: dockerLoginSecretArn ?? null,\n      ecrPullThroughCachePrefixes: ecrPullThroughCachePrefixes ?? [],\n    })).digest('hex');\n\n    const buildSpecObj = buildBuildSpec({\n      imageTag,\n      dockerFile,\n      buildArgs,\n      dockerLoginSecretArn,\n      installCommands,\n      preBuildCommands,\n      cacheDisabled,\n      platform,\n    });\n\n    const codeBuildImage = platform === 'linux/arm64'\n      ? LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_3_0\n      : LinuxBuildImage.STANDARD_7_0;\n\n    const codeBuildProject = new Project(this, 'CodeBuildProject', {\n      source: Source.s3({\n        bucket: sourceAsset.bucket,\n        path: sourceAsset.s3ObjectKey,\n      }),\n      environment: {\n        buildImage: codeBuildImage,\n        privileged: true,\n      },\n      environmentVariables: {\n        ECR_REPO_URI: { value: this.ecrRepository.repositoryUri },\n      },\n      buildSpec: BuildSpec.fromObject(buildSpecObj),\n      ...(buildLogGroup && {\n        logging: { cloudWatch: { logGroup: buildLogGroup } },\n      }),\n      vpc,\n      securityGroups,\n      subnetSelection,\n    });\n\n    this.grantBuildLogsAccess(codeBuildProject, retainBuildLogs);\n    this.grantEcrAccess(codeBuildProject);\n    this.grantPullThroughCacheAccess(codeBuildProject, ecrPullThroughCachePrefixes);\n\n    if (dockerLoginSecretArn) {\n      codeBuildProject.addToRolePolicy(\n        new PolicyStatement({\n          actions: ['secretsmanager:GetSecretValue'],\n          resources: [dockerLoginSecretArn],\n        }),\n      );\n    }\n\n    if (encryptionKey) {\n      encryptionKey.grantEncryptDecrypt(codeBuildProject.role!);\n    }\n\n    const effectiveProvider = provider ?? TokenInjectableDockerBuilderProvider.getOrCreate(this);\n    effectiveProvider.registerProject(codeBuildProject, this.ecrRepository, encryptionKey);\n\n    if (replicaRegions.length > 0) {\n      this.validateReplicaRegions(replicaRegions);\n      effectiveProvider.registerReplication(this.ecrRepository.repositoryName, replicaRegions);\n    }\n\n    // The CR's construct ID has a \"V2\" suffix so that a v1-deployed stack\n    // upgrading to v2 sees a NEW resource (Replace), not an in-place update\n    // of the old `BuildTriggerResource`. CloudFormation forbids modifying a\n    // custom resource's `ServiceToken` in-place (\"Modifying service token is\n    // not allowed.\"), and the serviceToken changes from v1's per-instance\n    // provider to v2's singleton provider. Replace dodges the constraint:\n    // the old CR is deleted, and a new one is created with the singleton's\n    // serviceToken — at the cost of one fresh build per builder on upgrade.\n    const buildTriggerResource = new CustomResource(this, 'BuildTriggerResourceV2', {\n      serviceToken: effectiveProvider.serviceToken,\n      properties: {\n        ProjectName: codeBuildProject.projectName,\n        ImageTag: imageTag,\n        Trigger: sourceAsset.assetHash,\n        RetainBuildLogs: retainBuildLogs ? 'true' : 'false',\n        RepositoryName: this.ecrRepository.repositoryName,\n        ReplicaRegions: JSON.stringify(replicaRegions),\n      },\n    });\n    buildTriggerResource.node.addDependency(codeBuildProject);\n\n    // SAFETY: reference by tag, not digest. The lifecycle policy above never\n    // deletes tagged images, so the digest behind this tag is guaranteed to\n    // remain in ECR for the life of the repository.\n    const imageTagRef = buildTriggerResource.getAttString('ImageTag');\n    this.imageTag = imageTagRef;\n    this.repositoryName = this.ecrRepository.repositoryName;\n    this.containerImage = ContainerImage.fromEcrRepository(this.ecrRepository, imageTagRef);\n    this.dockerImageCode = DockerImageCode.fromEcr(this.ecrRepository, {\n      tagOrDigest: imageTagRef,\n    });\n  }\n\n  /**\n   * Format the ECR repository URI for a given region. The region must\n   * be either the primary region or one of `replicaRegions`.\n   */\n  public repositoryUriFor(region: string): string {\n    this.assertRegionIsKnown(region);\n    return `${this.accountId}.dkr.ecr.${region}.amazonaws.com/${this.repositoryName}`;\n  }\n\n  /**\n   * Import the replicated repository as an ECS-compatible\n   * `ContainerImage` in a consumer scope (typically a stack in `region`).\n   *\n   * The consumer's stack must have `crossRegionReferences: true` when\n   * `region` differs from the builder's region.\n   */\n  public containerImageFor(scope: Construct, region: string): ContainerImage {\n    return ContainerImage.fromEcrRepository(\n      this.importRepoFor(scope, region),\n      this.imageTag,\n    );\n  }\n\n  /**\n   * Import the replicated repository as a Lambda-compatible\n   * `DockerImageCode` in a consumer scope (typically a stack in `region`).\n   *\n   * The consumer's stack must have `crossRegionReferences: true` when\n   * `region` differs from the builder's region.\n   */\n  public dockerImageCodeFor(scope: Construct, region: string): DockerImageCode {\n    return DockerImageCode.fromEcr(this.importRepoFor(scope, region), {\n      tagOrDigest: this.imageTag,\n    });\n  }\n\n  private importRepoFor(scope: Construct, region: string): Repository {\n    this.assertRegionIsKnown(region);\n    if (region === this.primaryRegion) return this.ecrRepository;\n\n    // Include the builder's own node.addr in the import id so two different\n    // builders importing the same region into the same scope each get their\n    // own Repository child (otherwise the second call would collide with the\n    // first and return the wrong builder's repo).\n    const importId = `ImportedRepo${region}${this.node.addr}`;\n    const existing = scope.node.tryFindChild(importId);\n    if (existing) return existing as Repository;\n\n    return Repository.fromRepositoryAttributes(scope, importId, {\n      repositoryName: this.repositoryName,\n      repositoryArn: Stack.of(scope).formatArn({\n        service: 'ecr',\n        resource: 'repository',\n        resourceName: this.repositoryName,\n        region,\n        account: this.accountId,\n      }),\n    }) as Repository;\n  }\n\n  private assertRegionIsKnown(region: string): void {\n    if (region === this.primaryRegion) return;\n    if (this.replicaRegions.includes(region)) return;\n    throw new Error(\n      `Region \"${region}\" is not the primary region (${this.primaryRegion}) ` +\n      `or one of the configured replicaRegions (${this.replicaRegions.join(', ') || '<none>'}). ` +\n      'Add the region to the builder\\'s replicaRegions prop to make it available.',\n    );\n  }\n\n  private validateReplicaRegions(replicaRegions: string[]): void {\n    const stack = Stack.of(this);\n    const primaryPartition = stack.partition;\n    for (const region of replicaRegions) {\n      if (region === this.primaryRegion) {\n        throw new Error(\n          `replicaRegions cannot include the primary region \"${this.primaryRegion}\". ` +\n          'Remove it from the list.',\n        );\n      }\n      // Partition cannot be cleanly inferred from region alone at synth time\n      // (it's a CDK pseudo-parameter and may be a token). We do the best-effort\n      // check: if both partition values are concrete and they differ, fail.\n      // Cross-partition replication is unsupported by ECR.\n      if (!Token.isUnresolved(primaryPartition)) {\n        const expectedPartition = inferPartition(region);\n        if (expectedPartition && expectedPartition !== primaryPartition) {\n          throw new Error(\n            'Cross-partition ECR replication is not supported. ' +\n            `Primary partition is \"${primaryPartition}\" but replica region ` +\n            `\"${region}\" appears to be in partition \"${expectedPartition}\".`,\n          );\n        }\n      }\n    }\n  }\n\n  private grantEcrAccess(project: Project): void {\n    this.ecrRepository.grantPullPush(project);\n    project.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'ecr:GetAuthorizationToken',\n          'ecr:GetDownloadUrlForLayer',\n          'ecr:BatchCheckLayerAvailability',\n          'ecr:BatchGetImage',\n        ],\n        resources: ['*'],\n      }),\n    );\n  }\n\n  private grantPullThroughCacheAccess(project: Project, prefixes: string[] | undefined): void {\n    if (!prefixes || prefixes.length === 0) return;\n    const stack = Stack.of(this);\n    project.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'ecr:BatchGetImage',\n          'ecr:GetDownloadUrlForLayer',\n          'ecr:BatchCheckLayerAvailability',\n          'ecr:BatchImportUpstreamImage',\n          'ecr:CreateRepository',\n        ],\n        resources: prefixes.map(\n          (prefix) => `arn:aws:ecr:${stack.region}:${stack.account}:repository/${prefix}/*`,\n        ),\n      }),\n    );\n  }\n\n  private grantBuildLogsAccess(project: Project, retainBuildLogs: boolean): void {\n    if (!retainBuildLogs) return;\n    const stack = Stack.of(this);\n    project.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['logs:CreateLogGroup', 'logs:CreateLogStream', 'logs:PutLogEvents'],\n        resources: [\n          `arn:aws:logs:${stack.region}:${stack.account}:log-group:${BUILD_LOG_GROUP_PREFIX}${project.projectName}`,\n          `arn:aws:logs:${stack.region}:${stack.account}:log-group:${BUILD_LOG_GROUP_PREFIX}${project.projectName}:*`,\n        ],\n      }),\n    );\n  }\n}\n\n/**\n * Best-effort partition inference from an AWS region name. Returns\n * undefined if the region doesn't look like a known partition prefix —\n * callers should treat that as \"skip the partition check\".\n */\nfunction inferPartition(region: string): string | undefined {\n  if (region.startsWith('cn-')) return 'aws-cn';\n  if (region.startsWith('us-gov-')) return 'aws-us-gov';\n  if (region.startsWith('us-iso-')) return 'aws-iso';\n  if (region.startsWith('us-isob-')) return 'aws-iso-b';\n  if (/^[a-z]{2}-[a-z]+-\\d+$/.test(region)) return 'aws';\n  return undefined;\n}\n"]}

package/lib/constants.d.ts

@@ -0,0 +1,7 @@
+import { Duration } from 'aws-cdk-lib';
+import { Runtime } from 'aws-cdk-lib/aws-lambda';
+export declare const LAMBDA_RUNTIME: Runtime;
+export declare const LAMBDA_TIMEOUT: Duration;
+export declare const DEFAULT_QUERY_INTERVAL: Duration;
+export declare const BUILD_LOG_GROUP_PREFIX = "/docker-builder/";
+export declare const PROVIDER_SINGLETON_ID = "TokenInjectableDockerBuilderProvider";

package/lib/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROVIDER_SINGLETON_ID = exports.BUILD_LOG_GROUP_PREFIX = exports.DEFAULT_QUERY_INTERVAL = exports.LAMBDA_TIMEOUT = exports.LAMBDA_RUNTIME = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+exports.LAMBDA_RUNTIME = aws_lambda_1.Runtime.NODEJS_22_X;
+exports.LAMBDA_TIMEOUT = aws_cdk_lib_1.Duration.minutes(15);
+exports.DEFAULT_QUERY_INTERVAL = aws_cdk_lib_1.Duration.seconds(30);
+exports.BUILD_LOG_GROUP_PREFIX = '/docker-builder/';
+exports.PROVIDER_SINGLETON_ID = 'TokenInjectableDockerBuilderProvider';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL2NvbnN0YW50cy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSw2Q0FBdUM7QUFDdkMsdURBQWlEO0FBRXBDLFFBQUEsY0FBYyxHQUFHLG9CQUFPLENBQUMsV0FBVyxDQUFDO0FBQ3JDLFFBQUEsY0FBYyxHQUFHLHNCQUFRLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxDQUFDO0FBQ3RDLFFBQUEsc0JBQXNCLEdBQUcsc0JBQVEsQ0FBQyxPQUFPLENBQUMsRUFBRSxDQUFDLENBQUM7QUFDOUMsUUFBQSxzQkFBc0IsR0FBRyxrQkFBa0IsQ0FBQztBQUM1QyxRQUFBLHFCQUFxQixHQUFHLHNDQUFzQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgRHVyYXRpb24gfSBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgeyBSdW50aW1lIH0gZnJvbSAnYXdzLWNkay1saWIvYXdzLWxhbWJkYSc7XG5cbmV4cG9ydCBjb25zdCBMQU1CREFfUlVOVElNRSA9IFJ1bnRpbWUuTk9ERUpTXzIyX1g7XG5leHBvcnQgY29uc3QgTEFNQkRBX1RJTUVPVVQgPSBEdXJhdGlvbi5taW51dGVzKDE1KTtcbmV4cG9ydCBjb25zdCBERUZBVUxUX1FVRVJZX0lOVEVSVkFMID0gRHVyYXRpb24uc2Vjb25kcygzMCk7XG5leHBvcnQgY29uc3QgQlVJTERfTE9HX0dST1VQX1BSRUZJWCA9ICcvZG9ja2VyLWJ1aWxkZXIvJztcbmV4cG9ydCBjb25zdCBQUk9WSURFUl9TSU5HTEVUT05fSUQgPSAnVG9rZW5JbmplY3RhYmxlRG9ja2VyQnVpbGRlclByb3ZpZGVyJztcbiJdfQ==

package/lib/ecr.d.ts

@@ -0,0 +1,16 @@
+import { Repository } from 'aws-cdk-lib/aws-ecr';
+import { Key } from 'aws-cdk-lib/aws-kms';
+import { Construct } from 'constructs';
+export interface BuilderEcrRepositoryOptions {
+    readonly kmsEncryption: boolean;
+    readonly encryptionKey?: Key;
+}
+/**
+ * Create an ECR repository for a builder.
+ *
+ * SAFETY: tagged images are never deleted. Lambda pins images by digest
+ * internally, so deleting an in-use tagged image would make the next Lambda
+ * config update fail with "Image ID cannot be found". Untagged images are
+ * cleaned up after 30 days.
+ */
+export declare function createBuilderEcrRepository(scope: Construct, id: string, options: BuilderEcrRepositoryOptions): Repository;

package/lib/ecr.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuilderEcrRepository = createBuilderEcrRepository;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ecr_1 = require("aws-cdk-lib/aws-ecr");
+/**
+ * Create an ECR repository for a builder.
+ *
+ * SAFETY: tagged images are never deleted. Lambda pins images by digest
+ * internally, so deleting an in-use tagged image would make the next Lambda
+ * config update fail with "Image ID cannot be found". Untagged images are
+ * cleaned up after 30 days.
+ */
+function createBuilderEcrRepository(scope, id, options) {
+    const { kmsEncryption, encryptionKey } = options;
+    return new aws_ecr_1.Repository(scope, id, {
+        lifecycleRules: [
+            {
+                rulePriority: 1,
+                description: 'Remove untagged images after 30 days',
+                tagStatus: aws_ecr_1.TagStatus.UNTAGGED,
+                maxImageAge: aws_cdk_lib_1.Duration.days(30),
+            },
+        ],
+        encryption: kmsEncryption ? aws_ecr_1.RepositoryEncryption.KMS : aws_ecr_1.RepositoryEncryption.AES_256,
+        encryptionKey: kmsEncryption ? encryptionKey : undefined,
+        imageScanOnPush: true,
+    });
+}
+//# sourceMappingURL=data:application/json;base64,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