token-injectable-docker-builder 1.13.4 → 2.0.0

package/isComplete/isComplete.js

@@ -6,6 +6,35 @@ const {
     CloudWatchLogsClient,
     GetLogEventsCommand,
 } = require('@aws-sdk/client-cloudwatch-logs');
+const {
+    ECRClient,
+    BatchGetImageCommand,
+} = require('@aws-sdk/client-ecr');
+
+async function checkReplicaAvailability(repositoryName, imageTag, replicaRegions) {
+    for (const region of replicaRegions) {
+        const ecr = new ECRClient({ region });
+        try {
+            const resp = await ecr.send(new BatchGetImageCommand({
+                repositoryName,
+                imageIds: [{ imageTag }],
+            }));
+            const images = resp.images || [];
+            if (images.length === 0) {
+                console.log(`Replica ${region}: repo exists but tag ${imageTag} not yet present.`);
+                return false;
+            }
+            console.log(`Replica ${region}: image present.`);
+        } catch (err) {
+            if (err.name === 'RepositoryNotFoundException') {
+                console.log(`Replica ${region}: destination repo not yet created by ECR replication.`);
+                return false;
+            }
+            throw err;
+        }
+    }
+    return true;
+}
 
 exports.handler = async (event) => {
     console.log('--- isComplete Handler Invoked ---');
@@ -86,9 +115,24 @@ exports.handler = async (event) => {
             return { IsComplete: false };
         }
 
-        // If build succeeded, return the image tag from the custom resource properties
+        // If build succeeded, optionally wait for cross-region replicas to land
+        // before signalling complete. ECR replication is async (most images
+        // <30 min, rare cases longer) — without this, a consumer stack in
+        // another region may try to pull the image before it's been
+        // replicated and fail with "Source image does not exist".
         if (buildStatus === 'SUCCEEDED') {
             const imageTag = event.ResourceProperties?.ImageTag || process.env.IMAGE_TAG;
+            const repositoryName = event.ResourceProperties?.RepositoryName;
+            const replicaRegions = JSON.parse(event.ResourceProperties?.ReplicaRegions || '[]');
+
+            if (replicaRegions.length > 0 && repositoryName) {
+                const ready = await checkReplicaAvailability(repositoryName, imageTag, replicaRegions);
+                if (!ready) {
+                    console.log('Build succeeded; waiting for replicas to catch up.');
+                    return { IsComplete: false };
+                }
+            }
+
             return {
                 IsComplete: true,
                 Data: {

package/lib/build-spec.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Parse a .dockerignore file at `sourcePath` (if present) and combine it with
+ * a user-supplied exclude list. The Dockerfile itself is never excluded —
+ * `.dockerignore` patterns matching `dockerFile` are filtered out so the
+ * S3 asset always contains the Dockerfile.
+ */
+export declare function resolveExcludes(sourcePath: string, dockerFile: string, exclude: string[] | undefined): string[] | undefined;
+export interface BuildSpecOptions {
+    readonly imageTag: string;
+    readonly dockerFile?: string;
+    readonly buildArgs?: {
+        [key: string]: string;
+    };
+    readonly dockerLoginSecretArn?: string;
+    readonly installCommands?: string[];
+    readonly preBuildCommands?: string[];
+    readonly cacheDisabled: boolean;
+    readonly platform: 'linux/amd64' | 'linux/arm64';
+}
+/**
+ * Assemble the plain buildspec object that the construct passes to
+ * `BuildSpec.fromObject`. Pure function — easy to unit test.
+ */
+export declare function buildBuildSpec(opts: BuildSpecOptions): Record<string, unknown>;

package/lib/build-spec.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveExcludes = resolveExcludes;
+exports.buildBuildSpec = buildBuildSpec;
+const fs = require("fs");
+const path = require("path");
+/**
+ * Parse a .dockerignore file at `sourcePath` (if present) and combine it with
+ * a user-supplied exclude list. The Dockerfile itself is never excluded —
+ * `.dockerignore` patterns matching `dockerFile` are filtered out so the
+ * S3 asset always contains the Dockerfile.
+ */
+function resolveExcludes(sourcePath, dockerFile, exclude) {
+    let effective = exclude;
+    if (!effective) {
+        const dockerignorePath = path.join(sourcePath, '.dockerignore');
+        if (fs.existsSync(dockerignorePath)) {
+            const fileContent = fs.readFileSync(dockerignorePath, 'utf8');
+            effective = fileContent
+                .split('\n')
+                .map((line) => line.trim())
+                .filter((line) => line.length > 0 && !line.startsWith('#'));
+        }
+    }
+    if (!effective)
+        return undefined;
+    return effective.filter((pattern) => {
+        const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        const regex = new RegExp(`^${escaped.replace(/\*/g, '.*').replace(/\?/g, '.')}$`, 'i');
+        return !regex.test(dockerFile);
+    });
+}
+/**
+ * Assemble the plain buildspec object that the construct passes to
+ * `BuildSpec.fromObject`. Pure function — easy to unit test.
+ */
+function buildBuildSpec(opts) {
+    const { imageTag, dockerFile, buildArgs, dockerLoginSecretArn, installCommands, preBuildCommands, cacheDisabled, platform, } = opts;
+    const buildArgsString = buildArgs
+        ? Object.entries(buildArgs)
+            .map(([k, v]) => `--build-arg ${k}=${v}`)
+            .join(' ')
+        : '';
+    const dockerFileFlag = dockerFile ? `-f $CODEBUILD_SRC_DIR/${dockerFile}` : '';
+    const dockerLoginCommands = dockerLoginSecretArn
+        ? [
+            'echo "Retrieving Docker credentials..."',
+            'apt-get update -y && apt-get install -y jq',
+            `DOCKER_USERNAME=$(aws secretsmanager get-secret-value --secret-id ${dockerLoginSecretArn} --query SecretString --output text | jq -r .username)`,
+            `DOCKER_PASSWORD=$(aws secretsmanager get-secret-value --secret-id ${dockerLoginSecretArn} --query SecretString --output text | jq -r .password)`,
+            'echo "Logging in to Docker Hub..."',
+            'echo $DOCKER_PASSWORD | docker login --username $DOCKER_USERNAME --password-stdin',
+        ]
+        : ['echo "No Docker credentials. Skipping Docker Hub login."'];
+    const buildxInstallCommands = cacheDisabled
+        ? []
+        : [
+            'echo "Setting up Docker buildx for ECR layer cache..."',
+            'docker buildx create --driver docker-container --name ecr-cache-builder --use 2>/dev/null || docker buildx use ecr-cache-builder',
+        ];
+    const platformFlag = `--platform ${platform}`;
+    // --provenance=false --sbom=false: Docker Buildx v0.10+ adds attestations by default,
+    // producing OCI image indexes that AWS Lambda does not support.
+    const buildCommand = cacheDisabled
+        ? `docker build ${platformFlag} ${dockerFileFlag} ${buildArgsString} -t $ECR_REPO_URI:${imageTag} $CODEBUILD_SRC_DIR`
+        : `docker buildx build --push ${platformFlag} --provenance=false --sbom=false --cache-from type=registry,ref=$ECR_REPO_URI:cache --cache-to type=registry,ref=$ECR_REPO_URI:cache,mode=max,image-manifest=true ${dockerFileFlag} ${buildArgsString} -t $ECR_REPO_URI:${imageTag} $CODEBUILD_SRC_DIR`;
+    return {
+        version: '0.2',
+        phases: {
+            install: {
+                commands: [
+                    'echo "Beginning install phase..."',
+                    ...(installCommands ?? []),
+                    ...buildxInstallCommands,
+                ],
+            },
+            pre_build: {
+                commands: [
+                    ...(preBuildCommands ?? []),
+                    ...dockerLoginCommands,
+                    'echo "Retrieving AWS Account ID..."',
+                    'export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)',
+                    'echo "Logging into Amazon ECR..."',
+                    'aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com',
+                ],
+            },
+            build: {
+                commands: [
+                    `echo "Building Docker image with tag ${imageTag}..."`,
+                    buildCommand,
+                ],
+            },
+            ...(cacheDisabled && {
+                post_build: {
+                    commands: [
+                        `echo "Pushing Docker image with tag ${imageTag}..."`,
+                        `docker push $ECR_REPO_URI:${imageTag}`,
+                    ],
+                },
+            }),
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-spec.js","sourceRoot":"","sources":["../src/build-spec.ts"],"names":[],"mappings":"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","sourcesContent":["import * as fs from 'fs';\nimport * as path from 'path';\n\n/**\n * Parse a .dockerignore file at `sourcePath` (if present) and combine it with\n * a user-supplied exclude list. The Dockerfile itself is never excluded —\n * `.dockerignore` patterns matching `dockerFile` are filtered out so the\n * S3 asset always contains the Dockerfile.\n */\nexport function resolveExcludes(\n  sourcePath: string,\n  dockerFile: string,\n  exclude: string[] | undefined,\n): string[] | undefined {\n  let effective = exclude;\n  if (!effective) {\n    const dockerignorePath = path.join(sourcePath, '.dockerignore');\n    if (fs.existsSync(dockerignorePath)) {\n      const fileContent = fs.readFileSync(dockerignorePath, 'utf8');\n      effective = fileContent\n        .split('\\n')\n        .map((line) => line.trim())\n        .filter((line) => line.length > 0 && !line.startsWith('#'));\n    }\n  }\n\n  if (!effective) return undefined;\n\n  return effective.filter((pattern) => {\n    const escaped = pattern.replace(/[.+^${}()|[\\]\\\\]/g, '\\\\$&');\n    const regex = new RegExp(`^${escaped.replace(/\\*/g, '.*').replace(/\\?/g, '.')}$`, 'i');\n    return !regex.test(dockerFile);\n  });\n}\n\nexport interface BuildSpecOptions {\n  readonly imageTag: string;\n  readonly dockerFile?: string;\n  readonly buildArgs?: { [key: string]: string };\n  readonly dockerLoginSecretArn?: string;\n  readonly installCommands?: string[];\n  readonly preBuildCommands?: string[];\n  readonly cacheDisabled: boolean;\n  readonly platform: 'linux/amd64' | 'linux/arm64';\n}\n\n/**\n * Assemble the plain buildspec object that the construct passes to\n * `BuildSpec.fromObject`. Pure function — easy to unit test.\n */\nexport function buildBuildSpec(opts: BuildSpecOptions): Record<string, unknown> {\n  const {\n    imageTag,\n    dockerFile,\n    buildArgs,\n    dockerLoginSecretArn,\n    installCommands,\n    preBuildCommands,\n    cacheDisabled,\n    platform,\n  } = opts;\n\n  const buildArgsString = buildArgs\n    ? Object.entries(buildArgs)\n      .map(([k, v]) => `--build-arg ${k}=${v}`)\n      .join(' ')\n    : '';\n\n  const dockerFileFlag = dockerFile ? `-f $CODEBUILD_SRC_DIR/${dockerFile}` : '';\n\n  const dockerLoginCommands = dockerLoginSecretArn\n    ? [\n      'echo \"Retrieving Docker credentials...\"',\n      'apt-get update -y && apt-get install -y jq',\n      `DOCKER_USERNAME=$(aws secretsmanager get-secret-value --secret-id ${dockerLoginSecretArn} --query SecretString --output text | jq -r .username)`,\n      `DOCKER_PASSWORD=$(aws secretsmanager get-secret-value --secret-id ${dockerLoginSecretArn} --query SecretString --output text | jq -r .password)`,\n      'echo \"Logging in to Docker Hub...\"',\n      'echo $DOCKER_PASSWORD | docker login --username $DOCKER_USERNAME --password-stdin',\n    ]\n    : ['echo \"No Docker credentials. Skipping Docker Hub login.\"'];\n\n  const buildxInstallCommands = cacheDisabled\n    ? []\n    : [\n      'echo \"Setting up Docker buildx for ECR layer cache...\"',\n      'docker buildx create --driver docker-container --name ecr-cache-builder --use 2>/dev/null || docker buildx use ecr-cache-builder',\n    ];\n\n  const platformFlag = `--platform ${platform}`;\n\n  // --provenance=false --sbom=false: Docker Buildx v0.10+ adds attestations by default,\n  // producing OCI image indexes that AWS Lambda does not support.\n  const buildCommand = cacheDisabled\n    ? `docker build ${platformFlag} ${dockerFileFlag} ${buildArgsString} -t $ECR_REPO_URI:${imageTag} $CODEBUILD_SRC_DIR`\n    : `docker buildx build --push ${platformFlag} --provenance=false --sbom=false --cache-from type=registry,ref=$ECR_REPO_URI:cache --cache-to type=registry,ref=$ECR_REPO_URI:cache,mode=max,image-manifest=true ${dockerFileFlag} ${buildArgsString} -t $ECR_REPO_URI:${imageTag} $CODEBUILD_SRC_DIR`;\n\n  return {\n    version: '0.2',\n    phases: {\n      install: {\n        commands: [\n          'echo \"Beginning install phase...\"',\n          ...(installCommands ?? []),\n          ...buildxInstallCommands,\n        ],\n      },\n      pre_build: {\n        commands: [\n          ...(preBuildCommands ?? []),\n          ...dockerLoginCommands,\n          'echo \"Retrieving AWS Account ID...\"',\n          'export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)',\n          'echo \"Logging into Amazon ECR...\"',\n          'aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com',\n        ],\n      },\n      build: {\n        commands: [\n          `echo \"Building Docker image with tag ${imageTag}...\"`,\n          buildCommand,\n        ],\n      },\n      ...(cacheDisabled && {\n        post_build: {\n          commands: [\n            `echo \"Pushing Docker image with tag ${imageTag}...\"`,\n            `docker push $ECR_REPO_URI:${imageTag}`,\n          ],\n        },\n      }),\n    },\n  };\n}\n"]}

package/lib/builder.d.ts

@@ -0,0 +1,206 @@
+import { IVpc, ISecurityGroup, SubnetSelection } from 'aws-cdk-lib/aws-ec2';
+import { ContainerImage } from 'aws-cdk-lib/aws-ecs';
+import { DockerImageCode } from 'aws-cdk-lib/aws-lambda';
+import { ILogGroup } from 'aws-cdk-lib/aws-logs';
+import { Construct } from 'constructs';
+import { TokenInjectableDockerBuilderProvider } from './provider';
+/**
+ * Properties for the `TokenInjectableDockerBuilder` construct.
+ */
+export interface TokenInjectableDockerBuilderProps {
+    /**
+     * The path to the directory containing the Dockerfile or source code.
+     */
+    readonly path: string;
+    /**
+     * Build arguments to pass to the Docker build process.
+     * These are transformed into `--build-arg KEY=VALUE` flags.
+     * @example
+     * {
+     *   TOKEN: 'my-secret-token',
+     *   ENV: 'production'
+     * }
+     */
+    readonly buildArgs?: {
+        [key: string]: string;
+    };
+    /**
+     * The ARN of the AWS Secrets Manager secret containing Docker login credentials.
+     * The secret must store a JSON object: `{"username":"...","password":"..."}`.
+     * Must be in the same region as the stack.
+     *
+     * @default - No Docker Hub login.
+     */
+    readonly dockerLoginSecretArn?: string;
+    /**
+     * The VPC in which the CodeBuild project will be deployed.
+     *
+     * @default - CodeBuild uses public internet.
+     */
+    readonly vpc?: IVpc;
+    /**
+     * Security groups attached to the CodeBuild project.
+     *
+     * @default - No security groups attached.
+     */
+    readonly securityGroups?: ISecurityGroup[];
+    /**
+     * Subnet selection within the VPC.
+     *
+     * @default - All subnets in the VPC.
+     */
+    readonly subnetSelection?: SubnetSelection;
+    /**
+     * Custom commands to run during the install phase of CodeBuild.
+     *
+     * @default - No additional install commands.
+     */
+    readonly installCommands?: string[];
+    /**
+     * Custom commands to run during the pre_build phase of CodeBuild.
+     *
+     * @default - No additional pre-build commands.
+     */
+    readonly preBuildCommands?: string[];
+    /**
+     * Whether to enable KMS encryption for the ECR repository.
+     *
+     * @default false
+     */
+    readonly kmsEncryption?: boolean;
+    /**
+     * File paths in the Docker directory to exclude from the build asset.
+     * Falls back to `.dockerignore` if present.
+     *
+     * @default - No file path exclusions.
+     */
+    readonly exclude?: string[];
+    /**
+     * Name of the Dockerfile (passed as `-f`).
+     *
+     * @example 'Dockerfile.production'
+     * @default 'Dockerfile'
+     */
+    readonly file?: string;
+    /**
+     * When `true`, disables Docker layer caching.
+     *
+     * @default false
+     */
+    readonly cacheDisabled?: boolean;
+    /**
+     * CloudWatch log group for CodeBuild build logs.
+     *
+     * @default - CodeBuild default logging.
+     */
+    readonly buildLogGroup?: ILogGroup;
+    /**
+     * Target platform for the Docker image.
+     *
+     * @default 'linux/amd64'
+     */
+    readonly platform?: 'linux/amd64' | 'linux/arm64';
+    /**
+     * Shared provider for the custom resource Lambdas.
+     *
+     * Pass `TokenInjectableDockerBuilderProvider.getOrCreate(this, { queryInterval })`
+     * if you need a non-default query interval. Otherwise, the construct will
+     * call `getOrCreate(this)` itself and reuse the per-stack singleton.
+     *
+     * @default - Per-stack singleton provider, created on first use.
+     */
+    readonly provider?: TokenInjectableDockerBuilderProvider;
+    /**
+     * ECR pull-through cache repository prefixes to grant pull access to.
+     *
+     * @example ['docker-hub', 'ghcr']
+     * @default - No pull-through cache access.
+     */
+    readonly ecrPullThroughCachePrefixes?: string[];
+    /**
+     * When `true`, creates a CloudWatch log group outside of CloudFormation
+     * (`/docker-builder/<projectName>`) and directs CodeBuild output there.
+     * Survives stack rollbacks for debugging. 7-day retention.
+     *
+     * @default false
+     */
+    readonly retainBuildLogs?: boolean;
+    /**
+     * Additional AWS regions to replicate the built image to via ECR's
+     * native registry replication. The image is pushed to the primary
+     * region's ECR as usual; ECR asynchronously replicates the same
+     * `repositoryName` + `imageTag` to each region listed here.
+     *
+     * Consumers in another region (a Lambda in `us-west-2` referencing an
+     * image built in `us-east-1`) can use `dockerImageCodeFor(region)` or
+     * `containerImageFor(region)` to import the replicated image.
+     *
+     * The custom resource waits for replication to complete before
+     * signalling deploy-complete, so downstream stacks can safely deploy
+     * immediately after.
+     *
+     * **Caveats:**
+     * - Cross-region replication is not supported between AWS partitions.
+     * - Replicas do **not** inherit the primary's encryption (defaults to
+     *   AES-256), lifecycle policies, or repository policies.
+     * - Replicated repositories persist on stack deletion — AWS does not
+     *   auto-delete them. Clean up manually via the ECR console / CLI if
+     *   needed.
+     * - Both the builder stack and any consumer stack in another region
+     *   must set `crossRegionReferences: true` for the image tag to flow.
+     * - Stacks must have a concrete region (`env: { account, region }`),
+     *   not the env-agnostic default.
+     *
+     * @example ['us-west-2', 'eu-west-1']
+     * @default [] - no replication
+     */
+    readonly replicaRegions?: string[];
+}
+/**
+ * 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.
+ */
+export declare class TokenInjectableDockerBuilder extends Construct {
+    /** The ECR repository that stores the resulting Docker image. */
+    private readonly ecrRepository;
+    /** ECS-compatible container image reference (primary region). */
+    readonly containerImage: ContainerImage;
+    /** Lambda-compatible DockerImageCode reference (primary region). */
+    readonly dockerImageCode: DockerImageCode;
+    /** The ECR repository name — preserved across replica regions. */
+    readonly repositoryName: string;
+    /** The resolved image tag (CFN token; available at deploy time). */
+    readonly imageTag: string;
+    private readonly primaryRegion;
+    private readonly accountId;
+    private readonly replicaRegions;
+    constructor(scope: Construct, id: string, props: TokenInjectableDockerBuilderProps);
+    /**
+     * Format the ECR repository URI for a given region. The region must
+     * be either the primary region or one of `replicaRegions`.
+     */
+    repositoryUriFor(region: string): string;
+    /**
+     * 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: Construct, region: string): ContainerImage;
+    /**
+     * 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: Construct, region: string): DockerImageCode;
+    private importRepoFor;
+    private assertRegionIsKnown;
+    private validateReplicaRegions;
+    private grantEcrAccess;
+    private grantPullThroughCacheAccess;
+    private grantBuildLogsAccess;
+}