@cloudsnorkel/cdk-github-runners 0.14.18 → 0.14.20

package/README.md

@@ -447,9 +447,39 @@ const providerSelector = new Function(this, 'provider-selector', {
 
 ## Examples
 
-Beyond the code snippets above, the fullest example available is the [integration test](test/default.integ.ts).
+We provide comprehensive examples in the [`examples/`](examples/) folder to help you get started quickly:
 
-If you have more to share, please open a PR adding them to the `examples` folder.
+### Getting Started
+- **[Simple CodeBuild](examples/typescript/simple-codebuild/)** - Basic setup with just a CodeBuild provider (also available in [Python](examples/python/simple-codebuild/))
+
+### Provider Configuration
+- **[Composite Provider](examples/typescript/composite-provider/)** - Fallback and weighted distribution strategies (also available in [Python](examples/python/composite-provider/))
+- **[Provider Selector](examples/typescript/provider-selector/)** - Custom provider selection with Lambda function (also available in [Python](examples/python/provider-selector/))
+- **[EC2 Windows Provider](examples/typescript/ec2-windows-provider/)** - EC2 configuration for Windows runners (also available in [Python](examples/python/ec2-windows-provider/))
+
+### Compute & Performance
+- **[Compute Options](examples/typescript/compute-options/)** - Configure CPU, memory, and instance types for different providers (also available in [Python](examples/python/compute-options/))
+- **[Spot Instances](examples/typescript/spot-instances/)** - Use spot instances for cost savings across EC2, Fargate, and ECS (also available in [Python](examples/python/spot-instances/))
+- **[Storage Options](examples/typescript/storage-options/)** - Custom EBS storage options for EC2 runners (also available in [Python](examples/python/storage-options/))
+- **[ECS Scaling](examples/typescript/ecs-scaling/)** - Custom autoscaling group scaling policies for ECS providers (also available in [Python](examples/python/ecs-scaling/))
+
+### Security & Access
+- **[IAM Permissions](examples/typescript/iam-permissions/)** - Grant AWS IAM permissions to runners (also available in [Python](examples/python/iam-permissions/))
+- **[Network Access](examples/typescript/network-access/)** - Configure network access with VPCs and security groups (also available in [Python](examples/python/network-access/))
+- **[Access Control](examples/typescript/access-control/)** - Configure access control for webhook and setup functions (also available in [Python](examples/python/access-control/))
+
+### Customization
+- **[Add Software](examples/typescript/add-software/)** - Add custom software to runner images (also available in [Python](examples/python/add-software/))
+
+### Enterprise & Monitoring
+- **[GHES](examples/typescript/ghes/)** - Configure runners for GitHub Enterprise Server (also available in [Python](examples/python/ghes/))
+- **[Monitoring](examples/typescript/monitoring/)** - Set up CloudWatch alarms and SNS notifications (also available in [Python](examples/python/monitoring/))
+
+Each example is self-contained with its own dependencies and README. Start with the simple examples and work your way up to more advanced configurations.
+
+Another good and very full example is the [integration test](test/default.integ.ts).
+
+If you have more to share, please open a PR adding examples to the `examples` folder.
 
 ## Architecture
 
@@ -506,13 +536,13 @@ If you use and love this project, please consider contributing.
 
 ## Other Options
 
-1. [philips-labs/terraform-aws-github-runner][3] if you're using Terraform
+1. [github-aws-runners/terraform-aws-github-runner][3] if you're using Terraform
 2. [actions/actions-runner-controller][4] if you're using Kubernetes
 
 
 [1]: https://docs.github.com/en/actions/hosting-your-own-runners/about-self-hosted-runners
 [2]: https://github.com/marketplace/actions/configure-aws-credentials-action-for-github-actions
-[3]: https://github.com/philips-labs/terraform-aws-github-runner
+[3]: https://github.com/github-aws-runners/terraform-aws-github-runner
 [4]: https://github.com/actions/actions-runner-controller
 [5]: https://github.com/actions/runner
 [6]: https://pypi.org/project/cloudsnorkel.cdk-github-runners

package/assets/providers/ami-root-device.lambda/index.js

@@ -106,6 +106,17 @@ async function handler(event, context) {
           await handleAmi(event, ssmValue);
           break;
         }
+        if (ami.startsWith("ssm:")) {
+          const ssmParam = ami.substring("ssm:".length);
+          console.log(`Checking SSM ${ssmParam}`);
+          const ssmValue = (await ssm.send(new import_client_ssm.GetParameterCommand({ Name: ssmParam }))).Parameter?.Value;
+          if (!ssmValue) {
+            await customResourceRespond(event, "FAILED", `${ami} has no value`, "ERROR", {});
+            break;
+          }
+          await handleAmi(event, ssmValue);
+          break;
+        }
         if (ami.startsWith("lt-")) {
           console.log(`Checking Launch Template ${ami}`);
           const lts = await ec2.send(new import_client_ec2.DescribeLaunchTemplateVersionsCommand({ LaunchTemplateId: ami, Versions: ["$Latest"] }));

package/lib/access.js

@@ -59,7 +59,7 @@ class LambdaAccess {
 }
 exports.LambdaAccess = LambdaAccess;
 _a = JSII_RTTI_SYMBOL_1;
-LambdaAccess[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaAccess", version: "0.14.18" };
+LambdaAccess[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaAccess", version: "0.14.20" };
 /**
  * @internal
  */

package/lib/image-builders/api.js

@@ -43,5 +43,5 @@ class RunnerImageBuilder extends common_1.RunnerImageBuilderBase {
 }
 exports.RunnerImageBuilder = RunnerImageBuilder;
 _a = JSII_RTTI_SYMBOL_1;
-RunnerImageBuilder[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.RunnerImageBuilder", version: "0.14.18" };
+RunnerImageBuilder[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.RunnerImageBuilder", version: "0.14.20" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/image-builders/aws-image-builder/ami.d.ts

@@ -1,5 +1,6 @@
 import * as cdk from 'aws-cdk-lib';
 import { Construct } from 'constructs';
+import { BaseImage } from './base-image';
 import { ImageBuilderComponent } from './builder';
 import { Architecture, Os } from '../../providers';
 /**
@@ -19,7 +20,7 @@ interface AmiRecipeProperties {
     /**
      * Base AMI to use for the new runner AMI.
      */
-    readonly baseAmi: string;
+    readonly baseAmi: BaseImage;
     /**
      * Storage size for the builder.
      */
@@ -51,5 +52,5 @@ export declare class AmiRecipe extends cdk.Resource {
  *
  * @internal
  */
-export declare function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture): string;
+export declare function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture): BaseImage;
 export {};

package/lib/image-builders/aws-image-builder/ami.js

@@ -4,6 +4,7 @@ exports.AmiRecipe = void 0;
 exports.defaultBaseAmi = defaultBaseAmi;
 const cdk = require("aws-cdk-lib");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
+const base_image_1 = require("./base-image");
 const providers_1 = require("../../providers");
 const common_1 = require("../common");
 /**
@@ -21,7 +22,7 @@ class AmiRecipe extends cdk.Resource {
         });
         const blockDeviceMappings = props.storageSize ? [
             {
-                deviceName: (0, providers_1.amiRootDevice)(this, props.baseAmi).ref,
+                deviceName: (0, providers_1.amiRootDevice)(this, props.baseAmi.image).ref,
                 ebs: {
                     volumeSize: props.storageSize.toGibibytes(),
                     deleteOnTermination: true,
@@ -42,7 +43,7 @@ class AmiRecipe extends cdk.Resource {
         const recipe = new aws_cdk_lib_1.aws_imagebuilder.CfnImageRecipe(this, 'Recipe', {
             name: this.name,
             version: '1.0.x',
-            parentImage: props.baseAmi,
+            parentImage: props.baseAmi.image,
             components,
             workingDirectory,
             tags: props.tags,
@@ -59,7 +60,6 @@ exports.AmiRecipe = AmiRecipe;
  * @internal
  */
 function defaultBaseAmi(scope, os, architecture) {
-    const stack = cdk.Stack.of(scope);
     let arch;
     if (architecture.is(providers_1.Architecture.X86_64)) {
         arch = 'x86';
@@ -71,45 +71,20 @@ function defaultBaseAmi(scope, os, architecture) {
         throw new Error(`Unsupported architecture for base AMI: ${architecture.name}`);
     }
     if (os.is(providers_1.Os.LINUX_UBUNTU) || os.is(providers_1.Os.LINUX_UBUNTU_2204) || os.is(providers_1.Os.LINUX)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `ubuntu-server-22-lts-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `ubuntu-server-22-lts-${arch}`);
     }
     if (os.is(providers_1.Os.LINUX_UBUNTU_2404)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `ubuntu-server-24-lts-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `ubuntu-server-24-lts-${arch}`);
     }
     if (os.is(providers_1.Os.LINUX_AMAZON_2)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `amazon-linux-2-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `amazon-linux-2-${arch}`);
     }
     if (os.is(providers_1.Os.LINUX_AMAZON_2023)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `amazon-linux-2023-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `amazon-linux-2023-${arch}`);
     }
     if (os.is(providers_1.Os.WINDOWS)) {
-        return stack.formatArn({
-            service: 'imagebuilder',
-            resource: 'image',
-            account: 'aws',
-            resourceName: `windows-server-2022-english-full-base-${arch}/x.x.x`,
-        });
+        return base_image_1.BaseImage.fromImageBuilder(scope, `windows-server-2022-english-full-base-${arch}`);
     }
     throw new Error(`OS ${os.name} not supported for AMI runner image`);
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ami.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/ami.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { aws_imagebuilder as imagebuilder } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { ImageBuilderComponent } from './builder';\nimport { amiRootDevice, Architecture, Os } from '../../providers';\nimport { uniqueImageBuilderName } from '../common';\n\n/**\n * Properties for AmiRecipe construct.\n *\n * @internal\n */\ninterface AmiRecipeProperties {\n  /**\n   * Target platform. Must match builder platform.\n   */\n  readonly platform: 'Linux' | 'Windows';\n\n  /**\n   * Target architecture. Must match builder platform.\n   */\n  readonly architecture: Architecture;\n\n  /**\n   * Base AMI to use for the new runner AMI.\n   */\n  readonly baseAmi: string;\n\n  /**\n   * Storage size for the builder.\n   */\n  readonly storageSize?: cdk.Size;\n\n  /**\n   * Components to add to target container image.\n   */\n  readonly components: ImageBuilderComponent[];\n\n  /**\n   * Tags to apply to the recipe and image.\n   */\n  readonly tags: { [key: string]: string };\n}\n\n/**\n * Image builder recipe for Amazon Machine Image (AMI).\n *\n * @internal\n */\nexport class AmiRecipe extends cdk.Resource {\n  public readonly arn: string;\n  public readonly name: string;\n  public readonly version: string;\n\n  constructor(scope: Construct, id: string, props: AmiRecipeProperties) {\n    super(scope, id);\n\n    let components = props.components.map(component => {\n      return {\n        componentArn: component.arn,\n      };\n    });\n\n    const blockDeviceMappings = props.storageSize ? [\n      {\n        deviceName: amiRootDevice(this, props.baseAmi).ref,\n        ebs: {\n          volumeSize: props.storageSize.toGibibytes(),\n          deleteOnTermination: true,\n        },\n      },\n    ] : undefined;\n\n    this.name = uniqueImageBuilderName(this);\n\n    let workingDirectory;\n    if (props.platform == 'Linux') {\n      workingDirectory = '/home/runner';\n    } else if (props.platform == 'Windows') {\n      workingDirectory = 'C:/'; // must exist or Image Builder fails and must not be empty or git will stall installing from the default windows\\system32\n    } else {\n      throw new Error(`Unsupported AMI recipe platform: ${props.platform}`);\n    }\n\n    const recipe = new imagebuilder.CfnImageRecipe(this, 'Recipe', {\n      name: this.name,\n      version: '1.0.x',\n      parentImage: props.baseAmi,\n      components,\n      workingDirectory,\n      tags: props.tags,\n      blockDeviceMappings,\n    });\n\n    this.arn = recipe.attrArn;\n    this.version = recipe.getAtt('Version', cdk.ResolutionTypeHint.STRING).toString();\n  }\n}\n\n/**\n * Default base AMI for given OS and architecture.\n *\n * @internal\n */\nexport function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture) {\n  const stack = cdk.Stack.of(scope);\n\n  let arch;\n  if (architecture.is(Architecture.X86_64)) {\n    arch = 'x86';\n  } else if (architecture.is(Architecture.ARM64)) {\n    arch = 'arm64';\n  } else {\n    throw new Error(`Unsupported architecture for base AMI: ${architecture.name}`);\n  }\n\n  if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_UBUNTU_2204) || os.is(Os.LINUX)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `ubuntu-server-22-lts-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.LINUX_UBUNTU_2404)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `ubuntu-server-24-lts-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `amazon-linux-2-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2023)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `amazon-linux-2023-${arch}/x.x.x`,\n    });\n  }\n\n  if (os.is(Os.WINDOWS)) {\n    return stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `windows-server-2022-english-full-base-${arch}/x.x.x`,\n    });\n  }\n\n  throw new Error(`OS ${os.name} not supported for AMI runner image`);\n}\n\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ami.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/ami.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { aws_imagebuilder as imagebuilder } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { BaseImage } from './base-image';\nimport { ImageBuilderComponent } from './builder';\nimport { amiRootDevice, Architecture, Os } from '../../providers';\nimport { uniqueImageBuilderName } from '../common';\n\n/**\n * Properties for AmiRecipe construct.\n *\n * @internal\n */\ninterface AmiRecipeProperties {\n  /**\n   * Target platform. Must match builder platform.\n   */\n  readonly platform: 'Linux' | 'Windows';\n\n  /**\n   * Target architecture. Must match builder platform.\n   */\n  readonly architecture: Architecture;\n\n  /**\n   * Base AMI to use for the new runner AMI.\n   */\n  readonly baseAmi: BaseImage;\n\n  /**\n   * Storage size for the builder.\n   */\n  readonly storageSize?: cdk.Size;\n\n  /**\n   * Components to add to target container image.\n   */\n  readonly components: ImageBuilderComponent[];\n\n  /**\n   * Tags to apply to the recipe and image.\n   */\n  readonly tags: { [key: string]: string };\n}\n\n/**\n * Image builder recipe for Amazon Machine Image (AMI).\n *\n * @internal\n */\nexport class AmiRecipe extends cdk.Resource {\n  public readonly arn: string;\n  public readonly name: string;\n  public readonly version: string;\n\n  constructor(scope: Construct, id: string, props: AmiRecipeProperties) {\n    super(scope, id);\n\n    let components = props.components.map(component => {\n      return {\n        componentArn: component.arn,\n      };\n    });\n\n    const blockDeviceMappings = props.storageSize ? [\n      {\n        deviceName: amiRootDevice(this, props.baseAmi.image).ref,\n        ebs: {\n          volumeSize: props.storageSize.toGibibytes(),\n          deleteOnTermination: true,\n        },\n      },\n    ] : undefined;\n\n    this.name = uniqueImageBuilderName(this);\n\n    let workingDirectory;\n    if (props.platform == 'Linux') {\n      workingDirectory = '/home/runner';\n    } else if (props.platform == 'Windows') {\n      workingDirectory = 'C:/'; // must exist or Image Builder fails and must not be empty or git will stall installing from the default windows\\system32\n    } else {\n      throw new Error(`Unsupported AMI recipe platform: ${props.platform}`);\n    }\n\n    const recipe = new imagebuilder.CfnImageRecipe(this, 'Recipe', {\n      name: this.name,\n      version: '1.0.x',\n      parentImage: props.baseAmi.image,\n      components,\n      workingDirectory,\n      tags: props.tags,\n      blockDeviceMappings,\n    });\n\n    this.arn = recipe.attrArn;\n    this.version = recipe.getAtt('Version', cdk.ResolutionTypeHint.STRING).toString();\n  }\n}\n\n/**\n * Default base AMI for given OS and architecture.\n *\n * @internal\n */\nexport function defaultBaseAmi(scope: Construct, os: Os, architecture: Architecture): BaseImage {\n  let arch;\n  if (architecture.is(Architecture.X86_64)) {\n    arch = 'x86';\n  } else if (architecture.is(Architecture.ARM64)) {\n    arch = 'arm64';\n  } else {\n    throw new Error(`Unsupported architecture for base AMI: ${architecture.name}`);\n  }\n\n  if (os.is(Os.LINUX_UBUNTU) || os.is(Os.LINUX_UBUNTU_2204) || os.is(Os.LINUX)) {\n    return BaseImage.fromImageBuilder(scope, `ubuntu-server-22-lts-${arch}`);\n  }\n\n  if (os.is(Os.LINUX_UBUNTU_2404)) {\n    return BaseImage.fromImageBuilder(scope, `ubuntu-server-24-lts-${arch}`);\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2)) {\n    return BaseImage.fromImageBuilder(scope, `amazon-linux-2-${arch}`);\n  }\n\n  if (os.is(Os.LINUX_AMAZON_2023)) {\n    return BaseImage.fromImageBuilder(scope, `amazon-linux-2023-${arch}`);\n  }\n\n  if (os.is(Os.WINDOWS)) {\n    return BaseImage.fromImageBuilder(scope, `windows-server-2022-english-full-base-${arch}`);\n  }\n\n  throw new Error(`OS ${os.name} not supported for AMI runner image`);\n}\n\n"]}

package/lib/image-builders/aws-image-builder/base-image.d.ts

@@ -0,0 +1,118 @@
+import * as ecr from 'aws-cdk-lib/aws-ecr';
+import * as ssm from 'aws-cdk-lib/aws-ssm';
+import { Construct } from 'constructs';
+/**
+ * Type that can be used to specify a base image - either a string (deprecated) or a BaseImage object.
+ *
+ * To create a BaseImage object, use the static factory methods like BaseImage.fromAmiId().
+ *
+ * Note: String support is deprecated and will be removed in a future version. Use BaseImage static factory methods instead.
+ */
+export type BaseImageInput = string | BaseImage;
+/**
+ * Represents a base image that is used to start from in EC2 Image Builder image builds.
+ *
+ * This class is adapted from AWS CDK's BaseImage class to support both string and object inputs.
+ */
+export declare class BaseImage {
+    /**
+     * The AMI ID to use as a base image in an image recipe
+     *
+     * @param amiId The AMI ID to use as the base image
+     */
+    static fromAmiId(amiId: string): BaseImage;
+    /**
+     * An AWS-provided EC2 Image Builder image to use as a base image in an image recipe.
+     *
+     * This constructs an Image Builder ARN for AWS-provided images like `ubuntu-server-22-lts-x86/x.x.x`.
+     *
+     * @param scope The construct scope (used to determine the stack and region)
+     * @param resourceName The Image Builder resource name pattern (e.g., `ubuntu-server-22-lts-x86` or `ubuntu-server-22-lts-${arch}`)
+     * @param version The version pattern (defaults to `x.x.x` to use the latest version)
+     */
+    static fromImageBuilder(scope: Construct, resourceName: string, version?: string): BaseImage;
+    /**
+     * The marketplace product ID for an AMI product to use as the base image in an image recipe
+     *
+     * @param productId The Marketplace AMI product ID to use as the base image
+     */
+    static fromMarketplaceProductId(productId: string): BaseImage;
+    /**
+     * The SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameter The SSM parameter to use as the base image
+     */
+    static fromSsmParameter(parameter: ssm.IParameter): BaseImage;
+    /**
+     * The parameter name for the SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameterName The name of the SSM parameter to use as the base image
+     */
+    static fromSsmParameterName(parameterName: string): BaseImage;
+    /**
+     * The direct string value of the base image to use in an image recipe. This can be an EC2 Image Builder image ARN,
+     * an SSM parameter, an AWS Marketplace product ID, or an AMI ID.
+     *
+     * @param baseImageString The base image as a direct string value
+     */
+    static fromString(baseImageString: string): BaseImage;
+    /**
+     * The rendered base image to use
+     */
+    readonly image: string;
+    protected constructor(image: string);
+}
+/**
+ * Type that can be used to specify a base container image - either a string (deprecated) or a BaseContainerImage object.
+ *
+ * To create a BaseContainerImage object, use the static factory methods like BaseContainerImage.fromEcr().
+ *
+ * Note: String support is deprecated and will be removed in a future version. Use BaseContainerImage static factory methods instead.
+ */
+export type BaseContainerImageInput = string | BaseContainerImage;
+/**
+ * Represents a base container image that is used to start from in EC2 Image Builder container builds.
+ *
+ * This class is adapted from AWS CDK's BaseContainerImage class to support both string and object inputs.
+ */
+export declare class BaseContainerImage {
+    /**
+     * The DockerHub image to use as the base image in a container recipe
+     *
+     * @param repository The DockerHub repository where the base image resides in
+     * @param tag The tag of the base image in the DockerHub repository
+     */
+    static fromDockerHub(repository: string, tag: string): BaseContainerImage;
+    /**
+     * The ECR container image to use as the base image in a container recipe
+     *
+     * @param repository The ECR repository where the base image resides in
+     * @param tag The tag of the base image in the ECR repository
+     */
+    static fromEcr(repository: ecr.IRepository, tag: string): BaseContainerImage;
+    /**
+     * The ECR public container image to use as the base image in a container recipe
+     *
+     * @param registryAlias The alias of the ECR public registry where the base image resides in
+     * @param repositoryName The name of the ECR public repository, where the base image resides in
+     * @param tag The tag of the base image in the ECR public repository
+     */
+    static fromEcrPublic(registryAlias: string, repositoryName: string, tag: string): BaseContainerImage;
+    /**
+     * The string value of the base image to use in a container recipe. This can be an EC2 Image Builder image ARN,
+     * an ECR or ECR public image, or a container URI sourced from a third-party container registry such as DockerHub.
+     *
+     * @param baseContainerImageString The base image as a direct string value
+     */
+    static fromString(baseContainerImageString: string): BaseContainerImage;
+    /**
+     * The rendered base image to use
+     */
+    readonly image: string;
+    /**
+     * The ECR repository if this image was created from an ECR repository.
+     * This allows automatic permission granting for CodeBuild.
+     */
+    readonly ecrRepository?: ecr.IRepository;
+    protected constructor(image: string, ecrRepository?: ecr.IRepository);
+}

package/lib/image-builders/aws-image-builder/base-image.js

@@ -0,0 +1,130 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseContainerImage = exports.BaseImage = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+/**
+ * Represents a base image that is used to start from in EC2 Image Builder image builds.
+ *
+ * This class is adapted from AWS CDK's BaseImage class to support both string and object inputs.
+ */
+class BaseImage {
+    /**
+     * The AMI ID to use as a base image in an image recipe
+     *
+     * @param amiId The AMI ID to use as the base image
+     */
+    static fromAmiId(amiId) {
+        return new BaseImage(amiId);
+    }
+    /**
+     * An AWS-provided EC2 Image Builder image to use as a base image in an image recipe.
+     *
+     * This constructs an Image Builder ARN for AWS-provided images like `ubuntu-server-22-lts-x86/x.x.x`.
+     *
+     * @param scope The construct scope (used to determine the stack and region)
+     * @param resourceName The Image Builder resource name pattern (e.g., `ubuntu-server-22-lts-x86` or `ubuntu-server-22-lts-${arch}`)
+     * @param version The version pattern (defaults to `x.x.x` to use the latest version)
+     */
+    static fromImageBuilder(scope, resourceName, version = 'x.x.x') {
+        const stack = cdk.Stack.of(scope);
+        return new BaseImage(stack.formatArn({
+            service: 'imagebuilder',
+            resource: 'image',
+            account: 'aws',
+            resourceName: `${resourceName}/${version}`,
+        }));
+    }
+    /**
+     * The marketplace product ID for an AMI product to use as the base image in an image recipe
+     *
+     * @param productId The Marketplace AMI product ID to use as the base image
+     */
+    static fromMarketplaceProductId(productId) {
+        return new BaseImage(productId);
+    }
+    /**
+     * The SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameter The SSM parameter to use as the base image
+     */
+    static fromSsmParameter(parameter) {
+        return new BaseImage(`ssm:${parameter.parameterArn}`);
+    }
+    /**
+     * The parameter name for the SSM parameter to use as the base image in an image recipe
+     *
+     * @param parameterName The name of the SSM parameter to use as the base image
+     */
+    static fromSsmParameterName(parameterName) {
+        return new BaseImage(`ssm:${parameterName}`);
+    }
+    /**
+     * The direct string value of the base image to use in an image recipe. This can be an EC2 Image Builder image ARN,
+     * an SSM parameter, an AWS Marketplace product ID, or an AMI ID.
+     *
+     * @param baseImageString The base image as a direct string value
+     */
+    static fromString(baseImageString) {
+        return new BaseImage(baseImageString);
+    }
+    constructor(image) {
+        this.image = image;
+    }
+}
+exports.BaseImage = BaseImage;
+_a = JSII_RTTI_SYMBOL_1;
+BaseImage[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.BaseImage", version: "0.14.20" };
+/**
+ * Represents a base container image that is used to start from in EC2 Image Builder container builds.
+ *
+ * This class is adapted from AWS CDK's BaseContainerImage class to support both string and object inputs.
+ */
+class BaseContainerImage {
+    /**
+     * The DockerHub image to use as the base image in a container recipe
+     *
+     * @param repository The DockerHub repository where the base image resides in
+     * @param tag The tag of the base image in the DockerHub repository
+     */
+    static fromDockerHub(repository, tag) {
+        return new BaseContainerImage(`${repository}:${tag}`);
+    }
+    /**
+     * The ECR container image to use as the base image in a container recipe
+     *
+     * @param repository The ECR repository where the base image resides in
+     * @param tag The tag of the base image in the ECR repository
+     */
+    static fromEcr(repository, tag) {
+        return new BaseContainerImage(repository.repositoryUriForTag(tag), repository);
+    }
+    /**
+     * The ECR public container image to use as the base image in a container recipe
+     *
+     * @param registryAlias The alias of the ECR public registry where the base image resides in
+     * @param repositoryName The name of the ECR public repository, where the base image resides in
+     * @param tag The tag of the base image in the ECR public repository
+     */
+    static fromEcrPublic(registryAlias, repositoryName, tag) {
+        return new BaseContainerImage(`public.ecr.aws/${registryAlias}/${repositoryName}:${tag}`);
+    }
+    /**
+     * The string value of the base image to use in a container recipe. This can be an EC2 Image Builder image ARN,
+     * an ECR or ECR public image, or a container URI sourced from a third-party container registry such as DockerHub.
+     *
+     * @param baseContainerImageString The base image as a direct string value
+     */
+    static fromString(baseContainerImageString) {
+        return new BaseContainerImage(baseContainerImageString);
+    }
+    constructor(image, ecrRepository) {
+        this.image = image;
+        this.ecrRepository = ecrRepository;
+    }
+}
+exports.BaseContainerImage = BaseContainerImage;
+_b = JSII_RTTI_SYMBOL_1;
+BaseContainerImage[_b] = { fqn: "@cloudsnorkel/cdk-github-runners.BaseContainerImage", version: "0.14.20" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"base-image.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/base-image.ts"],"names":[],"mappings":";;;;;AAAA,mCAAmC;AAcnC;;;;GAIG;AACH,MAAa,SAAS;IACpB;;;;OAIG;IACI,MAAM,CAAC,SAAS,CAAC,KAAa;QACnC,OAAO,IAAI,SAAS,CAAC,KAAK,CAAC,CAAC;IAC9B,CAAC;IAED;;;;;;;;OAQG;IACI,MAAM,CAAC,gBAAgB,CAAC,KAAgB,EAAE,YAAoB,EAAE,UAAkB,OAAO;QAC9F,MAAM,KAAK,GAAG,GAAG,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC;QAClC,OAAO,IAAI,SAAS,CAAC,KAAK,CAAC,SAAS,CAAC;YACnC,OAAO,EAAE,cAAc;YACvB,QAAQ,EAAE,OAAO;YACjB,OAAO,EAAE,KAAK;YACd,YAAY,EAAE,GAAG,YAAY,IAAI,OAAO,EAAE;SAC3C,CAAC,CAAC,CAAC;IACN,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,wBAAwB,CAAC,SAAiB;QACtD,OAAO,IAAI,SAAS,CAAC,SAAS,CAAC,CAAC;IAClC,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,gBAAgB,CAAC,SAAyB;QACtD,OAAO,IAAI,SAAS,CAAC,OAAO,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,oBAAoB,CAAC,aAAqB;QACtD,OAAO,IAAI,SAAS,CAAC,OAAO,aAAa,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,UAAU,CAAC,eAAuB;QAC9C,OAAO,IAAI,SAAS,CAAC,eAAe,CAAC,CAAC;IACxC,CAAC;IAOD,YAAsB,KAAa;QACjC,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;IACrB,CAAC;;AAzEH,8BA0EC;;;AAWD;;;;GAIG;AACH,MAAa,kBAAkB;IAC7B;;;;;OAKG;IACI,MAAM,CAAC,aAAa,CAAC,UAAkB,EAAE,GAAW;QACzD,OAAO,IAAI,kBAAkB,CAAC,GAAG,UAAU,IAAI,GAAG,EAAE,CAAC,CAAC;IACxD,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,OAAO,CAAC,UAA2B,EAAE,GAAW;QAC5D,OAAO,IAAI,kBAAkB,CAAC,UAAU,CAAC,mBAAmB,CAAC,GAAG,CAAC,EAAE,UAAU,CAAC,CAAC;IACjF,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,aAAa,CAAC,aAAqB,EAAE,cAAsB,EAAE,GAAW;QACpF,OAAO,IAAI,kBAAkB,CAAC,kBAAkB,aAAa,IAAI,cAAc,IAAI,GAAG,EAAE,CAAC,CAAC;IAC5F,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,UAAU,CAAC,wBAAgC;QACvD,OAAO,IAAI,kBAAkB,CAAC,wBAAwB,CAAC,CAAC;IAC1D,CAAC;IAaD,YAAsB,KAAa,EAAE,aAA+B;QAClE,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;;AAxDH,gDAyDC","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport * as ecr from 'aws-cdk-lib/aws-ecr';\nimport * as ssm from 'aws-cdk-lib/aws-ssm';\nimport { Construct } from 'constructs';\n\n/**\n * Type that can be used to specify a base image - either a string (deprecated) or a BaseImage object.\n *\n * To create a BaseImage object, use the static factory methods like BaseImage.fromAmiId().\n *\n * Note: String support is deprecated and will be removed in a future version. Use BaseImage static factory methods instead.\n */\nexport type BaseImageInput = string | BaseImage;\n\n/**\n * Represents a base image that is used to start from in EC2 Image Builder image builds.\n *\n * This class is adapted from AWS CDK's BaseImage class to support both string and object inputs.\n */\nexport class BaseImage {\n  /**\n   * The AMI ID to use as a base image in an image recipe\n   *\n   * @param amiId The AMI ID to use as the base image\n   */\n  public static fromAmiId(amiId: string): BaseImage {\n    return new BaseImage(amiId);\n  }\n\n  /**\n   * An AWS-provided EC2 Image Builder image to use as a base image in an image recipe.\n   *\n   * This constructs an Image Builder ARN for AWS-provided images like `ubuntu-server-22-lts-x86/x.x.x`.\n   *\n   * @param scope The construct scope (used to determine the stack and region)\n   * @param resourceName The Image Builder resource name pattern (e.g., `ubuntu-server-22-lts-x86` or `ubuntu-server-22-lts-${arch}`)\n   * @param version The version pattern (defaults to `x.x.x` to use the latest version)\n   */\n  public static fromImageBuilder(scope: Construct, resourceName: string, version: string = 'x.x.x'): BaseImage {\n    const stack = cdk.Stack.of(scope);\n    return new BaseImage(stack.formatArn({\n      service: 'imagebuilder',\n      resource: 'image',\n      account: 'aws',\n      resourceName: `${resourceName}/${version}`,\n    }));\n  }\n\n  /**\n   * The marketplace product ID for an AMI product to use as the base image in an image recipe\n   *\n   * @param productId The Marketplace AMI product ID to use as the base image\n   */\n  public static fromMarketplaceProductId(productId: string): BaseImage {\n    return new BaseImage(productId);\n  }\n\n  /**\n   * The SSM parameter to use as the base image in an image recipe\n   *\n   * @param parameter The SSM parameter to use as the base image\n   */\n  public static fromSsmParameter(parameter: ssm.IParameter): BaseImage {\n    return new BaseImage(`ssm:${parameter.parameterArn}`);\n  }\n\n  /**\n   * The parameter name for the SSM parameter to use as the base image in an image recipe\n   *\n   * @param parameterName The name of the SSM parameter to use as the base image\n   */\n  public static fromSsmParameterName(parameterName: string): BaseImage {\n    return new BaseImage(`ssm:${parameterName}`);\n  }\n\n  /**\n   * The direct string value of the base image to use in an image recipe. This can be an EC2 Image Builder image ARN,\n   * an SSM parameter, an AWS Marketplace product ID, or an AMI ID.\n   *\n   * @param baseImageString The base image as a direct string value\n   */\n  public static fromString(baseImageString: string): BaseImage {\n    return new BaseImage(baseImageString);\n  }\n\n  /**\n   * The rendered base image to use\n   */\n  public readonly image: string;\n\n  protected constructor(image: string) {\n    this.image = image;\n  }\n}\n\n/**\n * Type that can be used to specify a base container image - either a string (deprecated) or a BaseContainerImage object.\n *\n * To create a BaseContainerImage object, use the static factory methods like BaseContainerImage.fromEcr().\n *\n * Note: String support is deprecated and will be removed in a future version. Use BaseContainerImage static factory methods instead.\n */\nexport type BaseContainerImageInput = string | BaseContainerImage;\n\n/**\n * Represents a base container image that is used to start from in EC2 Image Builder container builds.\n *\n * This class is adapted from AWS CDK's BaseContainerImage class to support both string and object inputs.\n */\nexport class BaseContainerImage {\n  /**\n   * The DockerHub image to use as the base image in a container recipe\n   *\n   * @param repository The DockerHub repository where the base image resides in\n   * @param tag The tag of the base image in the DockerHub repository\n   */\n  public static fromDockerHub(repository: string, tag: string): BaseContainerImage {\n    return new BaseContainerImage(`${repository}:${tag}`);\n  }\n\n  /**\n   * The ECR container image to use as the base image in a container recipe\n   *\n   * @param repository The ECR repository where the base image resides in\n   * @param tag The tag of the base image in the ECR repository\n   */\n  public static fromEcr(repository: ecr.IRepository, tag: string): BaseContainerImage {\n    return new BaseContainerImage(repository.repositoryUriForTag(tag), repository);\n  }\n\n  /**\n   * The ECR public container image to use as the base image in a container recipe\n   *\n   * @param registryAlias The alias of the ECR public registry where the base image resides in\n   * @param repositoryName The name of the ECR public repository, where the base image resides in\n   * @param tag The tag of the base image in the ECR public repository\n   */\n  public static fromEcrPublic(registryAlias: string, repositoryName: string, tag: string): BaseContainerImage {\n    return new BaseContainerImage(`public.ecr.aws/${registryAlias}/${repositoryName}:${tag}`);\n  }\n\n  /**\n   * The string value of the base image to use in a container recipe. This can be an EC2 Image Builder image ARN,\n   * an ECR or ECR public image, or a container URI sourced from a third-party container registry such as DockerHub.\n   *\n   * @param baseContainerImageString The base image as a direct string value\n   */\n  public static fromString(baseContainerImageString: string): BaseContainerImage {\n    return new BaseContainerImage(baseContainerImageString);\n  }\n\n  /**\n   * The rendered base image to use\n   */\n  public readonly image: string;\n\n  /**\n   * The ECR repository if this image was created from an ECR repository.\n   * This allows automatic permission granting for CodeBuild.\n   */\n  public readonly ecrRepository?: ecr.IRepository;\n\n  protected constructor(image: string, ecrRepository?: ecr.IRepository) {\n    this.image = image;\n    this.ecrRepository = ecrRepository;\n  }\n}\n"]}