cdk-ecr-deployment 4.2.7 → 4.2.9

package/README.md

@@ -19,7 +19,7 @@ CDK construct to synchronize single docker image between docker registries.
 - Copy image or multi-architecture image index from ECR/external registry to (another) ECR/external registry
 - Copy an archive tarball image from s3 to ECR/external registry
 
-## Examples
+## Usage
 
 ```ts
 import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets';
@@ -82,52 +82,43 @@ new ecrdeploy.ECRDeployment(this, 'DeployDockerImage5', {
 });
 ```
 
-## Sample: [test/example.ecr-deployment.ts](./test/example.ecr-deployment.ts)
+## Examples: [examples/](./examples)
+
+The [examples/](./examples) directory contains a runnable CDK app per scenario
+(local image asset, specific architecture, multi-arch index, retry config, S3
+archive, and private-registry credentials). See [examples/README.md](./examples/README.md).
 
 After cloning the repository, install dependencies and run a full build:
 
 ```console
-yarn --frozen-lockfile --check-files
+yarn install --immutable
 yarn build
 ```
 
-Then run the example like this:
+Then synth or deploy any example:
 
 ```shell
-# Run the following command to try the sample.
-npx cdk deploy -a "npx ts-node -P tsconfig.dev.json --prefer-ts-exts test/example.ecr-deployment.ts"
+npx cdk synth --app "npx ts-node examples/docker-image-asset.ts"
+npx cdk deploy --app "npx ts-node examples/docker-image-asset.ts"
 ```
 
-To run the DockerHub example you will first need to setup a Secret in AWS Secrets Manager to provide DockerHub credentials.
-Replace `username:access-token` with your credentials.
-**Please note that Secrets will occur a cost.**
+The [private-registry-credentials](./examples/private-registry-credentials.ts) example needs a
+Secret in AWS Secrets Manager with your DockerHub credentials (**note: secrets incur a cost**):
 
 ```console
 aws secretsmanager create-secret --name DockerHubCredentials --secret-string "username:access-token"
-```
-
-From the output, copy the ARN of your new secret and export it as env variable
-
-```console
 export DOCKERHUB_SECRET_ARN="<ARN>"
 ```
 
-Finally run:
-
-```shell
-# Run the following command to try the sample.
-npx cdk deploy -a "npx ts-node -P tsconfig.dev.json --prefer-ts-exts test/dockerhub-example.ecr-deployment.ts"
-```
-
-If your Secret is encrypted, you might have to adjust the example to also grant decrypt permissions.
+If your secret is encrypted, you might have to adjust the example to also grant decrypt permissions.
 
 ## [API](./API.md)
 
-## Tech Details & Contribution
+## Tech Details & Contributions
 
-The core of this project relies on [containers/image](https://github.com/containers/image) which is used by [Skopeo](https://github.com/containers/skopeo).
-Please take a look at those projects before contribution.
+The core of this project relies on [containers/image](https://github.com/containers/container-libs/tree/main/image) (published as the Go module `go.podman.io/image/v5`) which is used by [Skopeo](https://github.com/containers/skopeo).
+Please take a look at those projects before contributing.
 
-To support a new docker image source(like docker tarball in s3), you need to implement [image transport interface](https://github.com/containers/image/blob/master/types/types.go). You could take a look at [docker-archive](https://github.com/containers/image/blob/ccb87a8d0f45cf28846e307eb0ec2b9d38a458c2/docker/archive/transport.go) transport for a good start.
+To support a new docker image source (like docker tarball in s3), you need to implement [image transport interface](https://github.com/containers/container-libs/blob/main/image/types/types.go). You could take a look at [docker-archive](https://github.com/containers/container-libs/blob/main/image/docker/archive/transport.go) transport for a good start.
 
 Any error in the custom resource provider will show up in the CloudFormation error log as `Invalid PhysicalResourceId`, because of this: <https://github.com/aws/aws-lambda-go/issues/107>. You need to go into the CloudWatch Log Group to find the real error.

package/examples/Dockerfile

@@ -0,0 +1,5 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+# Tiny base used by the Docker image asset examples.
+FROM public.ecr.aws/nginx/nginx:alpine-slim@sha256:5b52c95c8eeda19dfa9dae708c4e66dce9f0910a6ac5e85dc19779160615b5b2

package/examples/README.md

@@ -0,0 +1,40 @@
+# cdk-ecr-deployment examples
+
+Each file is a self-contained CDK app demonstrating one `ECRDeployment` scenario.
+The header comment in each file explains what it does.
+
+| Example                                                              | Scenario                                                                         |
+| -------------------------------------------------------------------- | -------------------------------------------------------------------------------- |
+| [docker-image-asset.ts](./docker-image-asset.ts)                     | Copy a local Docker image asset (built from [`Dockerfile`](./Dockerfile)) to ECR |
+| [specific-architecture.ts](./specific-architecture.ts)               | Copy a single architecture with `imageArch`                                      |
+| [multi-arch-index.ts](./multi-arch-index.ts)                         | Copy a full multi-arch image index with `copyImageIndex` + `archImageTags`       |
+| [retry-config.ts](./retry-config.ts)                                 | Tune ECR PutImage retry/backoff with `retryConfigs`                              |
+| [s3-archive.ts](./s3-archive.ts)                                     | Copy from a `docker save` tarball stored in S3 via `S3ArchiveName`               |
+| [private-registry-credentials.ts](./private-registry-credentials.ts) | Copy from a private registry (DockerHub) using a Secrets Manager secret          |
+
+## Running
+
+First build the project from the repo root:
+
+```console
+yarn install --immutable
+yarn build
+```
+
+Synthesize any example:
+
+```console
+npx cdk synth --app "npx ts-node examples/docker-image-asset.ts"
+```
+
+Deploy it (creates real resources):
+
+```console
+npx cdk deploy --app "npx ts-node examples/docker-image-asset.ts"
+```
+
+## Prerequisites
+
+- **Docker** must be running for the asset-based examples (`docker-image-asset.ts`, `specific-architecture.ts`).
+- **`private-registry-credentials.ts`** needs a Secrets Manager secret with DockerHub credentials. Set `DOCKERHUB_SECRET_ARN` to synth or deploy (the example fails fast without it). Secrets incur a cost.
+- **`s3-archive.ts`** needs a `docker save` tarball uploaded to the referenced S3 bucket/key before deploying.

package/examples/docker-image-asset.ts

@@ -0,0 +1,36 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Example: copy a local Docker image asset into your own ECR repository.
+ *
+ * The Dockerfile in this directory is built as a CDK `DockerImageAsset` (CDK
+ * pushes it to the bootstrapped CDK assets repo), then `ECRDeployment` copies
+ * that image into the `TargetRepo` under the `latest` tag.
+ *
+ * Run:
+ *   npx cdk synth --app "npx ts-node examples/docker-image-asset.ts"
+ */
+import * as path from 'path';
+import { App, RemovalPolicy, Stack, aws_ecr as ecr, aws_ecr_assets as assets } from 'aws-cdk-lib';
+import * as ecrDeploy from '../src/index';
+
+const app = new App();
+const stack = new Stack(app, 'ecr-deploy-docker-image-asset');
+
+const repo = new ecr.Repository(stack, 'TargetRepo', {
+  removalPolicy: RemovalPolicy.DESTROY,
+  emptyOnDelete: true,
+});
+
+const image = new assets.DockerImageAsset(stack, 'Image', {
+  directory: path.join(__dirname),
+  file: 'Dockerfile',
+});
+
+new ecrDeploy.ECRDeployment(stack, 'DeployImage', {
+  src: new ecrDeploy.DockerImageName(image.imageUri),
+  dest: new ecrDeploy.DockerImageName(`${repo.repositoryUri}:latest`),
+});
+
+app.synth();

package/examples/multi-arch-index.ts

@@ -0,0 +1,35 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Example: copy a full multi-architecture image index (manifest list).
+ *
+ * `copyImageIndex: true` copies every architecture referenced by the source
+ * manifest list rather than a single platform. `archImageTags` additionally
+ * tags each per-architecture image so they can be pulled individually.
+ *
+ * Run:
+ *   npx cdk synth --app "npx ts-node examples/multi-arch-index.ts"
+ */
+import { App, RemovalPolicy, Stack, aws_ecr as ecr } from 'aws-cdk-lib';
+import * as ecrDeploy from '../src/index';
+
+const app = new App();
+const stack = new Stack(app, 'ecr-deploy-multi-arch-index');
+
+const repo = new ecr.Repository(stack, 'TargetRepo', {
+  removalPolicy: RemovalPolicy.DESTROY,
+  emptyOnDelete: true,
+});
+
+new ecrDeploy.ECRDeployment(stack, 'DeployImageIndex', {
+  src: new ecrDeploy.DockerImageName('public.ecr.aws/nginx/nginx:latest'),
+  dest: new ecrDeploy.DockerImageName(`${repo.repositoryUri}:nginx-manifest`),
+  copyImageIndex: true,
+  archImageTags: {
+    amd64: 'nginx-amd64',
+    arm64: 'nginx-arm64',
+  },
+});
+
+app.synth();

package/examples/private-registry-credentials.ts

@@ -0,0 +1,45 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Example: copy from a private registry (DockerHub) using credentials stored in
+ * AWS Secrets Manager.
+ *
+ * Pass the secret ARN as the second `DockerImageName` argument. The secret must
+ * be either plain text `username:password` or JSON
+ * `{"username":"...","password":"..."}`. The deployment lambda is granted
+ * `secretsmanager:GetSecretValue` on that secret via `addToPrincipalPolicy`.
+ *
+ * Provide a real secret (required to synth or deploy):
+ *   export DOCKERHUB_SECRET_ARN=arn:aws:secretsmanager:<region>:<account>:secret:<name>
+ *
+ * Run:
+ *   npx cdk synth --app "npx ts-node examples/private-registry-credentials.ts"
+ */
+import { App, RemovalPolicy, Stack, aws_ecr as ecr, aws_iam as iam, aws_secretsmanager as sm } from 'aws-cdk-lib';
+import * as ecrDeploy from '../src/index';
+
+const app = new App();
+const stack = new Stack(app, 'ecr-deploy-private-registry-credentials');
+
+const repo = new ecr.Repository(stack, 'TargetRepo', {
+  removalPolicy: RemovalPolicy.DESTROY,
+  emptyOnDelete: true,
+});
+
+const secretArn = process.env.DOCKERHUB_SECRET_ARN;
+if (!secretArn) {
+  throw new Error('DOCKERHUB_SECRET_ARN is required; see examples/README.md');
+}
+const dockerHubSecret = sm.Secret.fromSecretCompleteArn(stack, 'DockerHubSecret', secretArn);
+
+new ecrDeploy.ECRDeployment(stack, 'DeployFromDockerHub', {
+  src: new ecrDeploy.DockerImageName('alpine:latest', dockerHubSecret.secretFullArn),
+  dest: new ecrDeploy.DockerImageName(`${repo.repositoryUri}:alpine-from-dockerhub`),
+}).addToPrincipalPolicy(new iam.PolicyStatement({
+  effect: iam.Effect.ALLOW,
+  actions: ['secretsmanager:GetSecretValue'],
+  resources: [dockerHubSecret.secretArn],
+}));
+
+app.synth();

package/examples/retry-config.ts

@@ -0,0 +1,35 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Example: tune retry behaviour for ECR PutImage throttling.
+ *
+ * ECR allows ~10 PutImage TPS by default, so copying many images in parallel
+ * can hit rate limits. `retryConfigs` adds exponential backoff with jitter:
+ * `numAttempts` total tries, `baseDelay`/`maxDelay` (seconds) bound the wait.
+ *
+ * Run:
+ *   npx cdk synth --app "npx ts-node examples/retry-config.ts"
+ */
+import { App, RemovalPolicy, Stack, aws_ecr as ecr } from 'aws-cdk-lib';
+import * as ecrDeploy from '../src/index';
+
+const app = new App();
+const stack = new Stack(app, 'ecr-deploy-retry-config');
+
+const repo = new ecr.Repository(stack, 'TargetRepo', {
+  removalPolicy: RemovalPolicy.DESTROY,
+  emptyOnDelete: true,
+});
+
+new ecrDeploy.ECRDeployment(stack, 'DeployImage', {
+  src: new ecrDeploy.DockerImageName('public.ecr.aws/nginx/nginx:latest'),
+  dest: new ecrDeploy.DockerImageName(`${repo.repositoryUri}:latest`),
+  retryConfigs: {
+    numAttempts: 3,
+    baseDelay: 1,
+    maxDelay: 30,
+  },
+});
+
+app.synth();

package/examples/s3-archive.ts

@@ -0,0 +1,38 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Example: copy an image from a docker-archive tarball stored in S3.
+ *
+ * `S3ArchiveName(path, ref)` references a `docker save`-format tarball at
+ * `s3://<path>`; `ref` selects an image by RepoTag inside the archive (omit it
+ * to copy the only image). The deployment lambda needs `s3:GetObject` on the
+ * object, granted here via `addToPrincipalPolicy`.
+ *
+ * Run:
+ *   npx cdk synth --app "npx ts-node examples/s3-archive.ts"
+ */
+import { App, RemovalPolicy, Stack, aws_ecr as ecr, aws_iam as iam } from 'aws-cdk-lib';
+import * as ecrDeploy from '../src/index';
+
+const app = new App();
+const stack = new Stack(app, 'ecr-deploy-s3-archive');
+
+const repo = new ecr.Repository(stack, 'TargetRepo', {
+  removalPolicy: RemovalPolicy.DESTROY,
+  emptyOnDelete: true,
+});
+
+const bucket = 'my-bucket';
+const key = 'nginx.tar';
+
+new ecrDeploy.ECRDeployment(stack, 'DeployFromS3', {
+  src: new ecrDeploy.S3ArchiveName(`${bucket}/${key}`, 'nginx:latest'),
+  dest: new ecrDeploy.DockerImageName(`${repo.repositoryUri}:latest`),
+}).addToPrincipalPolicy(new iam.PolicyStatement({
+  effect: iam.Effect.ALLOW,
+  actions: ['s3:GetObject'],
+  resources: [`arn:aws:s3:::${bucket}/${key}`],
+}));
+
+app.synth();

package/examples/specific-architecture.ts

@@ -0,0 +1,38 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+/**
+ * Example: copy a single, specific architecture of an image.
+ *
+ * When a source reference points at a multi-architecture image, `imageArch`
+ * selects exactly one platform to copy (here `arm64`). The arm64 asset is
+ * copied to ECR under the `latest-arm64` tag.
+ *
+ * Run:
+ *   npx cdk synth --app "npx ts-node examples/specific-architecture.ts"
+ */
+import * as path from 'path';
+import { App, RemovalPolicy, Stack, aws_ecr as ecr, aws_ecr_assets as assets } from 'aws-cdk-lib';
+import * as ecrDeploy from '../src/index';
+
+const app = new App();
+const stack = new Stack(app, 'ecr-deploy-specific-architecture');
+
+const repo = new ecr.Repository(stack, 'TargetRepo', {
+  removalPolicy: RemovalPolicy.DESTROY,
+  emptyOnDelete: true,
+});
+
+const imageArm = new assets.DockerImageAsset(stack, 'ImageArm', {
+  directory: path.join(__dirname),
+  file: 'Dockerfile',
+  platform: assets.Platform.LINUX_ARM64,
+});
+
+new ecrDeploy.ECRDeployment(stack, 'DeployImageArm', {
+  src: new ecrDeploy.DockerImageName(imageArm.imageUri),
+  dest: new ecrDeploy.DockerImageName(`${repo.repositoryUri}:latest-arm64`),
+  imageArch: ['arm64'],
+});
+
+app.synth();

package/lib/index.js

@@ -25,7 +25,7 @@ class DockerImageName {
 }
 exports.DockerImageName = DockerImageName;
 _a = JSII_RTTI_SYMBOL_1;
-DockerImageName[_a] = { fqn: "cdk-ecr-deployment.DockerImageName", version: "4.2.7" };
+DockerImageName[_a] = { fqn: "cdk-ecr-deployment.DockerImageName", version: "4.2.9" };
 class S3ArchiveName {
     /**
      * @param p - the S3 bucket name and path of the archive (a S3 URI without the s3://)
@@ -46,7 +46,7 @@ class S3ArchiveName {
 }
 exports.S3ArchiveName = S3ArchiveName;
 _b = JSII_RTTI_SYMBOL_1;
-S3ArchiveName[_b] = { fqn: "cdk-ecr-deployment.S3ArchiveName", version: "4.2.7" };
+S3ArchiveName[_b] = { fqn: "cdk-ecr-deployment.S3ArchiveName", version: "4.2.9" };
 class ECRDeployment extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -191,5 +191,5 @@ class ECRDeployment extends constructs_1.Construct {
 }
 exports.ECRDeployment = ECRDeployment;
 _c = JSII_RTTI_SYMBOL_1;
-ECRDeployment[_c] = { fqn: "cdk-ecr-deployment.ECRDeployment", version: "4.2.7" };
+ECRDeployment[_c] = { fqn: "cdk-ecr-deployment.ECRDeployment", version: "4.2.9" };
 //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.\n// SPDX-License-Identifier: Apache-2.0\n\nimport * as path from 'path';\nimport { aws_ec2 as ec2, aws_iam as iam, aws_lambda as lambda, Arn, Aws, Duration, CustomResource, Stack, Token } from 'aws-cdk-lib';\nimport { PolicyStatement, AddToPrincipalPolicyResult } from 'aws-cdk-lib/aws-iam';\nimport { RuntimeFamily } from 'aws-cdk-lib/aws-lambda';\nimport { Construct } from 'constructs';\n\nexport interface ECRDeploymentProps {\n  /**\n   * The source of the docker image.\n   */\n  readonly src: IImageName;\n\n  /**\n   * The destination of the docker image.\n   */\n  readonly dest: IImageName;\n\n  /**\n   * The image architecture to be copied.\n   *\n   * The 'amd64' architecture will be copied by default. Specify the\n   * architecture or architectures to copy here.\n   *\n   * It is currently not possible to copy more than one architecture\n   * at a time: the array you specify must contain exactly one string.\n   *\n   * @default ['amd64']\n   */\n  readonly imageArch?: string[];\n\n  /**\n   * Whether to copy a source docker image index (multi-arch manifest) to the destination.\n   *\n   * When true, copies the image index and all underlying architecture-specific\n   * images in a single operation.\n   *\n   * @default False\n   */\n  readonly copyImageIndex?: boolean;\n\n  /**\n   * Tags to apply to individual architecture-specific images when\n   * copyImageIndex is true.\n   *\n   * Can only be specified when copyImageIndex is true. Maps architecture names to\n   * their respective tags. This makes individual architectures discoverable\n   * by human-readable tags in addition to the image index tag.\n   *\n   * For example, { 'arm64': 'image-arm64', 'amd64': 'image-amd64' }.\n   */\n  readonly archImageTags?: { [architecture: string]: string };\n\n  /**\n   * Retry configuration to apply to when copying images such as the number of retry attemtps,\n   * the base amount of delay (in seconds) between each retry, and the max amount of delay (in seconds)\n   * between each retry.\n   *\n   * For example, { 'numAttempts': 3, 'baseDelay': 1, 'maxDelay': 5 }\n   */\n  readonly retryConfigs?: { [fields: string]: number };\n\n  /**\n   * The amount of memory (in MiB) to allocate to the AWS Lambda function which\n   * replicates the files from the CDK bucket to the destination bucket.\n   *\n   * If you are deploying large files, you will need to increase this number\n   * accordingly.\n   *\n   * @default - 512\n   */\n  readonly memoryLimit?: number;\n\n  /**\n   * Execution role associated with this function\n   *\n   * @default - A role is automatically created\n   */\n  readonly role?: iam.IRole;\n\n  /**\n   * The VPC network to place the deployment lambda handler in.\n   *\n   * @default - None\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Where in the VPC to place the deployment lambda handler.\n   * Only used if 'vpc' is supplied.\n   *\n   * @default - the Vpc default strategy if not specified\n   */\n  readonly vpcSubnets?: ec2.SubnetSelection;\n\n  /**\n   * The list of security groups to associate with the Lambda's network interfaces.\n   *\n   * Only used if 'vpc' is supplied.\n   *\n   * @default - If the function is placed within a VPC and a security group is\n   * not specified, either by this or securityGroup prop, a dedicated security\n   * group will be created for this function.\n   */\n  readonly securityGroups?: ec2.SecurityGroup[];\n}\n\nexport interface IImageName {\n  /**\n   *  The uri of the docker image.\n   *\n   *  The uri spec follows https://github.com/containers/skopeo\n   */\n  readonly uri: string;\n\n  /**\n   * The credentials of the docker image. Format `user:password` or `AWS Secrets Manager secret arn` or `AWS Secrets Manager secret name`.\n   *\n   * If specifying an AWS Secrets Manager secret, the format of the secret should be either plain text (`user:password`) or\n   * JSON (`{\"username\":\"<username>\",\"password\":\"<password>\"}`).\n   *\n   * For more details on JSON format, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html\n   */\n  creds?: string;\n}\n\nexport class DockerImageName implements IImageName {\n  /**\n   * @param name - The name of the image, e.g. retrieved from `DockerImageAsset.imageUri`\n   * @param creds - The credentials of the docker image. Format `user:password` or `AWS Secrets Manager secret arn` or `AWS Secrets Manager secret name`.\n   *     If specifying an AWS Secrets Manager secret, the format of the secret should be either plain text (`user:password`) or\n   *     JSON (`{\"username\":\"<username>\",\"password\":\"<password>\"}`).\n   *     For more details on JSON format, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html\n   */\n  public constructor(private name: string, public creds?: string) { }\n  public get uri(): string { return `docker://${this.name}`; }\n}\n\nexport class S3ArchiveName implements IImageName {\n  private name: string;\n\n  /**\n   * @param p - the S3 bucket name and path of the archive (a S3 URI without the s3://)\n   * @param ref - appended to the end of the name with a `:`, e.g. `:latest`\n   * @param creds - The credentials of the docker image. Format `user:password` or `AWS Secrets Manager secret arn` or `AWS Secrets Manager secret name`.\n   *     If specifying an AWS Secrets Manager secret, the format of the secret should be either plain text (`user:password`) or\n   *     JSON (`{\"username\":\"<username>\",\"password\":\"<password>\"}`).\n   *     For more details on JSON format, see https://docs.aws.amazon.com/AmazonECS/latest/developerguide/private-auth.html\n   */\n  public constructor(p: string, ref?: string, public creds?: string) {\n    this.name = p;\n    if (ref) {\n      this.name += ':' + ref;\n    }\n  }\n  public get uri(): string { return `s3://${this.name}`; }\n}\n\nexport class ECRDeployment extends Construct {\n  private handler: lambda.SingletonFunction;\n\n  constructor(scope: Construct, id: string, props: ECRDeploymentProps) {\n    super(scope, id);\n    const memoryLimit = props.memoryLimit ?? 512;\n    this.handler = new lambda.SingletonFunction(this, 'CustomResourceHandler', {\n      uuid: this.renderSingletonUuid(memoryLimit),\n      code: lambda.Code.fromAsset(path.join(__dirname, '../lambda-bin')),\n      runtime: new lambda.Runtime('provided.al2023', RuntimeFamily.OTHER), // not using Runtime.PROVIDED_AL2023 to support older CDK versions (< 2.105.0)\n      handler: 'bootstrap',\n      lambdaPurpose: 'Custom::CDKECRDeployment',\n      description: 'Custom resource handler for copying Docker images between docker registries.',\n      timeout: Duration.minutes(15),\n      role: props.role,\n      memorySize: memoryLimit,\n      vpc: props.vpc,\n      vpcSubnets: props.vpcSubnets,\n      securityGroups: props.securityGroups,\n    });\n\n    const handlerRole = this.handler.role;\n    if (!handlerRole) { throw new Error('lambda.SingletonFunction should have created a Role'); }\n\n    handlerRole.addToPrincipalPolicy(\n      new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'ecr:GetAuthorizationToken',\n          'ecr:BatchCheckLayerAvailability',\n          'ecr:GetDownloadUrlForLayer',\n          'ecr:GetRepositoryPolicy',\n          'ecr:DescribeRepositories',\n          'ecr:ListImages',\n          'ecr:DescribeImages',\n          'ecr:BatchGetImage',\n          'ecr:ListTagsForResource',\n          'ecr:DescribeImageScanFindings',\n          'ecr:InitiateLayerUpload',\n          'ecr:UploadLayerPart',\n          'ecr:CompleteLayerUpload',\n          'ecr:PutImage',\n        ],\n        resources: ['*'],\n      }));\n    handlerRole.addToPrincipalPolicy(new iam.PolicyStatement({\n      effect: iam.Effect.ALLOW,\n      actions: [\n        's3:GetObject',\n      ],\n      resources: ['*'],\n    }));\n\n    // Auto-attach public ECR permissions when the destination is a public ECR registry.\n    // When dest is public ECR, the auth token permissions also cover source-side auth\n    // if the source happens to be public ECR too.\n    if (props.dest.uri.includes('public.ecr.aws')) {\n      handlerRole.addToPrincipalPolicy(new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'ecr-public:GetAuthorizationToken',\n          'sts:GetServiceBearerToken',\n        ],\n        resources: ['*'],\n      }));\n\n      handlerRole.addToPrincipalPolicy(new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'ecr-public:BatchCheckLayerAvailability',\n          'ecr-public:InitiateLayerUpload',\n          'ecr-public:UploadLayerPart',\n          'ecr-public:CompleteLayerUpload',\n          'ecr-public:PutImage',\n        ],\n        resources: [\n          // Public ECR is only available in the 'aws' partition (not aws-cn or aws-us-gov)\n          Arn.format({\n            partition: 'aws',\n            service: 'ecr-public',\n            region: '',\n            account: Aws.ACCOUNT_ID,\n            resource: 'repository',\n            resourceName: '*',\n          }, Stack.of(this)),\n        ],\n      }));\n    } else if (props.src.uri.includes('public.ecr.aws')) {\n      // When reading from public ECR, the Lambda still authenticates via\n      // ecr-public:GetAuthorizationToken. Grant the minimal read-auth permissions.\n      handlerRole.addToPrincipalPolicy(new iam.PolicyStatement({\n        effect: iam.Effect.ALLOW,\n        actions: [\n          'ecr-public:GetAuthorizationToken',\n          'sts:GetServiceBearerToken',\n        ],\n        resources: ['*'],\n      }));\n    }\n\n    if (props.imageArch && props.copyImageIndex) {\n      throw new Error('imageArch and copyImageIndex cannot both be set');\n    }\n    if (!props.copyImageIndex && props.archImageTags) {\n      throw new Error('archImageTags can only be specified when copyImageIndex is true');\n    }\n    if (props.imageArch && props.imageArch.length !== 1) {\n      throw new Error(`imageArch must contain exactly 1 element, got ${JSON.stringify(props.imageArch)}`);\n    }\n    const imageArch = props.imageArch ? props.imageArch[0] : '';\n\n    new CustomResource(this, 'CustomResource', {\n      serviceToken: this.handler.functionArn,\n      // This has been copy/pasted and is a pure lie, but changing it is going to change people's infra!! X(\n      resourceType: 'Custom::CDKECRDeployment',\n      properties: {\n        SrcImage: props.src.uri,\n        SrcCreds: props.src.creds,\n        DestImage: props.dest.uri,\n        DestCreds: props.dest.creds,\n        ...imageArch ? { ImageArch: imageArch } : {},\n        ...props.copyImageIndex ? { CopyImageIndex: props.copyImageIndex } : {},\n        ...props.archImageTags ? { ArchImageTags: JSON.stringify(props.archImageTags) } : {},\n        ...props.retryConfigs ? { RetryConfigs: JSON.stringify(props.retryConfigs) } : {},\n      },\n    });\n  }\n\n  public addToPrincipalPolicy(statement: PolicyStatement): AddToPrincipalPolicyResult {\n    const handlerRole = this.handler.role;\n    if (!handlerRole) { throw new Error('lambda.SingletonFunction should have created a Role'); }\n\n    return handlerRole.addToPrincipalPolicy(statement);\n  }\n\n  private renderSingletonUuid(memoryLimit?: number) {\n    let uuid = 'bd07c930-edb9-4112-a20f-03f096f53666';\n\n    // if user specify a custom memory limit, define another singleton handler\n    // with this configuration. otherwise, it won't be possible to use multiple\n    // configurations since we have a singleton.\n    if (memoryLimit) {\n      if (Token.isUnresolved(memoryLimit)) {\n        throw new Error('Can\\'t use tokens when specifying \"memoryLimit\" since we use it to identify the singleton custom resource handler');\n      }\n\n      uuid += `-${memoryLimit.toString()}MiB`;\n    }\n\n    return uuid;\n  }\n}\n"]}

package/package.json

@@ -74,6 +74,10 @@
     "aws-cdk-lib": "^2.80.0",
     "constructs": "^10.5.1"
   },
+  "resolutions": {
+    "@aws-cdk/integ-tests-alpha": "2.257.0-alpha.0",
+    "aws-cdk-lib": "2.257.0"
+  },
   "keywords": [
     "cdk"
   ],
@@ -89,7 +93,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "4.2.7",
+  "version": "4.2.9",
   "packageManager": "yarn@4.13.0",
   "jest": {
     "coverageProvider": "v8",