@cloudsnorkel/cdk-github-runners 0.2.0 → 0.3.0

package/lib/providers/image-builders/codebuild.js

@@ -0,0 +1,340 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeBuildImageBuilder = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const crypto = require("crypto");
+const cdk = require("aws-cdk-lib");
+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_logs_1 = require("aws-cdk-lib/aws-logs");
+const constructs_1 = require("constructs");
+const utils_1 = require("../../utils");
+const common_1 = require("../common");
+/**
+ * An image builder that uses CodeBuild to build Docker images pre-baked with all the GitHub Actions runner requirements. Builders can be used with runner providers.
+ *
+ * Each builder re-runs automatically at a set interval to make sure the images contain the latest versions of everything.
+ *
+ * You can create an instance of this construct to customize the image used to spin-up runners. Each provider has its own requirements for what an image should do. That's why they each provide their own Dockerfile.
+ *
+ * For example, to set a specific runner version, rebuild the image every 2 weeks, and add a few packages for the Fargate provider, use:
+ *
+ * ```
+ * const builder = new CodeBuildImageBuilder(this, 'Builder', {
+ *     dockerfilePath: FargateProvider.LINUX_X64_DOCKERFILE_PATH,
+ *     runnerVersion: RunnerVersion.specific('2.293.0'),
+ *     rebuildInterval: Duration.days(14),
+ * });
+ * builder.setBuildArg('EXTRA_PACKAGES', 'nginx xz-utils');
+ * new FargateProvider(this, 'Fargate provider', {
+ *     label: 'customized-fargate',
+ *     imageBuilder: builder,
+ * });
+ * ```
+ */
+class CodeBuildImageBuilder extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.props = props;
+        this.preBuild = [];
+        this.postBuild = [];
+        this.buildArgs = new Map();
+        this.policyStatements = [];
+        this.secondaryAssets = new Map();
+        if (props.subnetSelection?.subnetType == aws_cdk_lib_1.aws_ec2.SubnetType.PRIVATE_ISOLATED) {
+            aws_cdk_lib_1.Annotations.of(this).addWarning('Private isolated subnets cannot pull from public ECR and VPC endpoint is not supported yet. ' +
+                'See https://github.com/aws/containers-roadmap/issues/1160');
+        }
+        // set platform
+        this.architecture = props.architecture ?? common_1.Architecture.X86_64;
+        this.os = props.os ?? common_1.Os.LINUX;
+        // create repository that only keeps one tag
+        this.repository = new aws_cdk_lib_1.aws_ecr.Repository(this, 'Repository', {
+            imageScanOnPush: true,
+            imageTagMutability: aws_ecr_1.TagMutability.MUTABLE,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+            lifecycleRules: [
+                {
+                    description: 'Remove untagged images that have been replaced by CodeBuild',
+                    tagStatus: aws_ecr_1.TagStatus.UNTAGGED,
+                    maxImageAge: aws_cdk_lib_1.Duration.days(1),
+                },
+            ],
+        });
+        // upload Dockerfile to S3 as an asset
+        this.dockerfile = new aws_cdk_lib_1.aws_s3_assets.Asset(this, 'Dockerfile', {
+            path: props.dockerfilePath,
+        });
+        // choose build image
+        this.buildImage = this.getBuildImage();
+    }
+    /**
+     * Uploads a folder to the build server at a given folder name.
+     *
+     * @param sourcePath path to source directory
+     * @param destName name of destination folder
+     */
+    addFiles(sourcePath, destName) {
+        if (this.boundImage) {
+            throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');
+        }
+        const asset = new aws_cdk_lib_1.aws_s3_assets.Asset(this, destName, { path: sourcePath });
+        this.secondaryAssets.set(destName, asset);
+        this.preBuild.push(`ln -s "$CODEBUILD_SRC_DIR_${destName}" "${destName}"`);
+    }
+    /**
+     * Adds a command that runs before `docker build`.
+     *
+     * @param command command to add
+     */
+    addPreBuildCommand(command) {
+        if (this.boundImage) {
+            throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');
+        }
+        this.preBuild.push(command);
+    }
+    /**
+     * Adds a command that runs after `docker build` and `docker push`.
+     *
+     * @param command command to add
+     */
+    addPostBuildCommand(command) {
+        if (this.boundImage) {
+            throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');
+        }
+        this.postBuild.push(command);
+    }
+    /**
+     * Adds a build argument for Docker. See the documentation for the Dockerfile you're using for a list of supported build arguments.
+     *
+     * @param name build argument name
+     * @param value build argument value
+     */
+    setBuildArg(name, value) {
+        if (this.boundImage) {
+            throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');
+        }
+        this.buildArgs.set(name, value);
+    }
+    /**
+     * Add a policy statement to the builder to access resources required to the image build.
+     *
+     * @param statement IAM policy statement
+     */
+    addPolicyStatement(statement) {
+        if (this.boundImage) {
+            throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');
+        }
+        this.policyStatements.push(statement);
+    }
+    /**
+     * Called by IRunnerProvider to finalize settings and create the image builder.
+     */
+    bind() {
+        if (this.boundImage) {
+            return this.boundImage;
+        }
+        // log group for the image builds
+        const logGroup = new aws_cdk_lib_1.aws_logs.LogGroup(this, 'Logs', {
+            retention: this.props.logRetention ?? aws_logs_1.RetentionDays.ONE_MONTH,
+            removalPolicy: this.props.logRemovalPolicy ?? aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        });
+        // generate buildSpec
+        const buildSpec = this.getBuildSpec(this.repository, logGroup, this.props.runnerVersion);
+        // create CodeBuild project that builds Dockerfile and pushes to repository
+        const project = new aws_cdk_lib_1.aws_codebuild.Project(this, 'CodeBuild', {
+            description: `Build docker image for self-hosted GitHub runner ${this.node.path} (${this.os.name}/${this.architecture.name})`,
+            buildSpec: aws_cdk_lib_1.aws_codebuild.BuildSpec.fromObject(buildSpec),
+            source: aws_cdk_lib_1.aws_codebuild.Source.s3({
+                bucket: this.dockerfile.bucket,
+                path: this.dockerfile.s3ObjectKey,
+            }),
+            vpc: this.props.vpc,
+            securityGroups: this.props.securityGroup ? [this.props.securityGroup] : undefined,
+            subnetSelection: this.props.subnetSelection,
+            timeout: this.props.timeout ?? aws_cdk_lib_1.Duration.hours(1),
+            environment: {
+                buildImage: this.buildImage,
+                computeType: this.props.computeType ?? aws_codebuild_1.ComputeType.SMALL,
+                privileged: true,
+            },
+            logging: {
+                cloudWatch: {
+                    logGroup,
+                },
+            },
+        });
+        // permissions
+        this.repository.grantPullPush(project);
+        this.policyStatements.forEach(project.addToRolePolicy);
+        // call CodeBuild during deployment and delete all images from repository during destruction
+        const cr = this.customResource(project);
+        // rebuild image on a schedule
+        this.rebuildImageOnSchedule(project, this.props.rebuildInterval);
+        for (const [assetPath, asset] of this.secondaryAssets.entries()) {
+            project.addSecondarySource(aws_cdk_lib_1.aws_codebuild.Source.s3({
+                identifier: assetPath,
+                bucket: asset.bucket,
+                path: asset.s3ObjectKey,
+            }));
+        }
+        this.boundImage = {
+            imageRepository: aws_cdk_lib_1.aws_ecr.Repository.fromRepositoryAttributes(this, 'Dependable Image', {
+                repositoryName: this.repository.repositoryName,
+                // There are simpler ways to get the ARN, but we want an image object that depends on the custom resource.
+                // We want whoever is using this image to automatically wait for CodeBuild to start and finish through the custom resource.
+                repositoryArn: cr.ref,
+            }),
+            imageTag: 'latest',
+            imageDigest: cr.getAtt('Digest').toString(),
+            architecture: this.architecture,
+            os: this.os,
+        };
+        return this.boundImage;
+    }
+    getBuildImage() {
+        if (this.os.is(common_1.Os.LINUX)) {
+            if (this.architecture.is(common_1.Architecture.X86_64)) {
+                return aws_cdk_lib_1.aws_codebuild.LinuxBuildImage.STANDARD_4_0;
+            }
+            else if (this.architecture.is(common_1.Architecture.ARM64)) {
+                return aws_cdk_lib_1.aws_codebuild.LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_2_0;
+            }
+        }
+        if (this.os.is(common_1.Os.WINDOWS)) {
+            throw new Error('CodeBuild cannot be used to build Windows Docker images https://github.com/docker-library/docker/issues/49');
+        }
+        throw new Error(`Unable to find CodeBuild image for ${this.os.name}/${this.architecture.name}`);
+    }
+    getBuildSpec(repository, logGroup, runnerVersion) {
+        // don't forget to change BUILDSPEC_VERSION when the buildSpec changes, and you want to trigger a rebuild on deploy
+        let buildArgs = '';
+        for (const [name, value] of this.buildArgs.entries()) {
+            buildArgs += ` --build-arg "${name}"="${value}"`;
+        }
+        buildArgs += ` --build-arg RUNNER_VERSION="${runnerVersion ? runnerVersion.version : common_1.RunnerVersion.latest().version}"`;
+        return {
+            version: '0.2',
+            env: {
+                variables: {
+                    REPO_ARN: repository.repositoryArn,
+                    REPO_URI: repository.repositoryUri,
+                    STACK_ID: 'unspecified',
+                    REQUEST_ID: 'unspecified',
+                    LOGICAL_RESOURCE_ID: 'unspecified',
+                    RESPONSE_URL: 'unspecified',
+                    RUNNER_VERSION: runnerVersion ? runnerVersion.version : common_1.RunnerVersion.latest().version,
+                },
+            },
+            phases: {
+                pre_build: {
+                    commands: this.preBuild.concat([
+                        '$(aws ecr get-login --no-include-email --region "$AWS_DEFAULT_REGION")',
+                    ]),
+                },
+                build: {
+                    commands: [
+                        `docker build . -t "$REPO_URI" ${buildArgs}`,
+                        'docker push "$REPO_URI"',
+                    ],
+                },
+                post_build: {
+                    commands: this.postBuild.concat([
+                        'STATUS="SUCCESS"',
+                        'DIGEST="UNKNOWN"',
+                        'if [ $CODEBUILD_BUILD_SUCCEEDING -ne 1 ]; then STATUS="FAILED"; else DIGEST=`docker inspect "$REPO_URI" | jq -r \'.[0].RepoDigests[0] | split("@")[1] | split(":")[1]\'`; fi',
+                        'cat <<EOF > /tmp/payload.json\n' +
+                            '{\n' +
+                            '  "StackId": "$STACK_ID",\n' +
+                            '  "RequestId": "$REQUEST_ID",\n' +
+                            '  "LogicalResourceId": "$LOGICAL_RESOURCE_ID",\n' +
+                            '  "PhysicalResourceId": "$REPO_ARN",\n' +
+                            '  "Status": "$STATUS",\n' +
+                            `  "Reason": "See logs in ${logGroup.logGroupName}/$CODEBUILD_LOG_PATH (deploy again with \'cdk deploy -R\' or logRemovalPolicy=RemovalPolicy.RETAIN if they are already deleted)",\n` +
+                            '  "Data": {"Digest": "$DIGEST"}\n' + // include the digest to mark the resource updated so the runner providers get updated with the latest digest too (specifically Lambda)
+                            '}\n' +
+                            'EOF',
+                        'if [ "$RESPONSE_URL" != "unspecified" ]; then jq . /tmp/payload.json; curl -fsSL -X PUT -H "Content-Type:" -d "@/tmp/payload.json" "$RESPONSE_URL"; fi',
+                    ]),
+                },
+            },
+        };
+    }
+    customResource(project) {
+        const crHandler = utils_1.BundledNodejsFunction.singleton(this, 'build-image', {
+            description: 'Custom resource handler that triggers CodeBuild to build runner images, and cleans-up images on deletion',
+            timeout: cdk.Duration.seconds(30),
+        });
+        const policy = new aws_cdk_lib_1.aws_iam.Policy(this, 'CR Policy', {
+            statements: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['codebuild:StartBuild'],
+                    resources: [project.projectArn],
+                }),
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['ecr:BatchDeleteImage', 'ecr:ListImages'],
+                    resources: [this.repository.repositoryArn],
+                }),
+            ],
+        });
+        crHandler.role?.attachInlinePolicy(policy);
+        const cr = new aws_cdk_lib_1.CustomResource(this, 'Builder', {
+            serviceToken: crHandler.functionArn,
+            resourceType: 'Custom::ImageBuilder',
+            properties: {
+                RepoName: this.repository.repositoryName,
+                ProjectName: project.projectName,
+                // We include a hash so the image is built immediately on changes, and we don't have to wait for its scheduled build.
+                // This also helps make sure the changes are good. If they have a bug, the deployment will fail instead of just the scheduled build.
+                BuildHash: this.hashBuildSettings(),
+            },
+        });
+        // add dependencies to make sure resources are there when we need them
+        cr.node.addDependency(project);
+        cr.node.addDependency(policy);
+        cr.node.addDependency(crHandler);
+        return cr;
+    }
+    /**
+     * Return hash of all settings that can affect the result image so we can trigger the build when it changes.
+     * @private
+     */
+    hashBuildSettings() {
+        // main Dockerfile
+        let components = [this.dockerfile.assetHash];
+        // all additional files
+        for (const [name, asset] of this.secondaryAssets.entries()) {
+            components.push(name);
+            components.push(asset.assetHash);
+        }
+        // buildspec.yml version
+        components.push(`v${CodeBuildImageBuilder.BUILDSPEC_VERSION}`);
+        // user commands
+        components = components.concat(this.preBuild);
+        components = components.concat(this.postBuild);
+        for (const [name, value] of this.buildArgs.entries()) {
+            components.push(name);
+            components.push(value);
+        }
+        // hash it
+        const all = components.join('-');
+        return crypto.createHash('md5').update(all).digest('hex');
+    }
+    rebuildImageOnSchedule(project, rebuildInterval) {
+        rebuildInterval = rebuildInterval ?? aws_cdk_lib_1.Duration.days(7);
+        if (rebuildInterval.toMilliseconds() != 0) {
+            const scheduleRule = new aws_cdk_lib_1.aws_events.Rule(this, 'Build Schedule', {
+                description: `Rebuild runner image for ${this.repository.repositoryName}`,
+                schedule: aws_cdk_lib_1.aws_events.Schedule.rate(rebuildInterval),
+            });
+            scheduleRule.addTarget(new aws_cdk_lib_1.aws_events_targets.CodeBuildProject(project));
+        }
+    }
+}
+exports.CodeBuildImageBuilder = CodeBuildImageBuilder;
+_a = JSII_RTTI_SYMBOL_1;
+CodeBuildImageBuilder[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.CodeBuildImageBuilder", version: "0.3.0" };
+CodeBuildImageBuilder.BUILDSPEC_VERSION = 1;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"codebuild.js","sourceRoot":"","sources":["../../../src/providers/image-builders/codebuild.ts"],"names":[],"mappings":"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","sourcesContent":["import * as crypto from 'crypto';\nimport * as cdk from 'aws-cdk-lib';\nimport {\n  Annotations,\n  aws_codebuild as codebuild,\n  aws_ec2 as ec2,\n  aws_ecr as ecr,\n  aws_events as events,\n  aws_events_targets as events_targets,\n  aws_iam as iam,\n  aws_logs as logs,\n  aws_s3_assets as s3_assets,\n  CustomResource,\n  Duration,\n  RemovalPolicy,\n} from 'aws-cdk-lib';\nimport { ComputeType } from 'aws-cdk-lib/aws-codebuild';\nimport { TagMutability, TagStatus } from 'aws-cdk-lib/aws-ecr';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { BundledNodejsFunction } from '../../utils';\nimport { Architecture, IImageBuilder, Os, RunnerImage, RunnerVersion } from '../common';\n\n/*\nAWS Image Builder was not used because:\n  1. It's too slow. It has weird 15 minutes overhead where it seems to just be waiting.\n  2. No easy log visibility.\n  3. Versions need to be bumped manually.\n */\n\n/**\n * Properties for CodeBuildImageBuilder construct.\n */\nexport interface CodeBuildImageBuilderProps {\n  /**\n   * Image architecture.\n   *\n   * @default Architecture.X86_64\n   */\n  readonly architecture?: Architecture;\n\n  /**\n   * Image OS.\n   *\n   * @default OS.LINUX\n   */\n  readonly os?: Os;\n\n  /**\n   * Path to Dockerfile to be built. It can be a path to a Dockerfile, a folder containing a Dockerfile, or a zip file containing a Dockerfile.\n   */\n  readonly dockerfilePath: string;\n\n  /**\n   * Version of GitHub Runners to install.\n   *\n   * @default latest version available\n   */\n  readonly runnerVersion?: RunnerVersion;\n\n  /**\n   * Schedule the image to be rebuilt every given interval. Useful for keeping the image up-do-date with the latest GitHub runner version and latest OS updates.\n   *\n   * Set to zero to disable.\n   *\n   * @default Duration.days(7)\n   */\n  readonly rebuildInterval?: Duration;\n\n  /**\n   * VPC to launch the runners in.\n   *\n   * @default no VPC\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security Group to assign to this instance.\n   *\n   * @default public project with no security group\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Where to place the network interfaces within the VPC.\n   *\n   * @default no subnet\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * The type of compute to use for this build.\n   * See the {@link ComputeType} enum for the possible values.\n   *\n   * @default {@link ComputeType#SMALL}\n   */\n  readonly computeType?: codebuild.ComputeType;\n\n  /**\n   * The number of minutes after which AWS CodeBuild stops the build if it's\n   * not complete. For valid values, see the timeoutInMinutes field in the AWS\n   * CodeBuild User Guide.\n   *\n   * @default Duration.hours(1)\n   */\n  readonly timeout?: Duration;\n\n  /**\n   * The number of days log events are kept in CloudWatch Logs. When updating\n   * this property, unsetting it doesn't remove the log retention policy. To\n   * remove the retention policy, set the value to `INFINITE`.\n   *\n   * @default logs.RetentionDays.ONE_MONTH\n   */\n  readonly logRetention?: logs.RetentionDays;\n\n  /**\n   * Removal policy for logs of image builds. If deployment fails on the custom resource, try setting this to `RemovalPolicy.RETAIN`. This way the CodeBuild logs can still be viewed, and you can see why the build failed.\n   *\n   * We try to not leave anything behind when removed. But sometimes a log staying behind is useful.\n   *\n   * @default RemovalPolicy.DESTROY\n   */\n  readonly logRemovalPolicy?: RemovalPolicy;\n}\n\n/**\n * An image builder that uses CodeBuild to build Docker images pre-baked with all the GitHub Actions runner requirements. Builders can be used with runner providers.\n *\n * Each builder re-runs automatically at a set interval to make sure the images contain the latest versions of everything.\n *\n * You can create an instance of this construct to customize the image used to spin-up runners. Each provider has its own requirements for what an image should do. That's why they each provide their own Dockerfile.\n *\n * For example, to set a specific runner version, rebuild the image every 2 weeks, and add a few packages for the Fargate provider, use:\n *\n * ```\n * const builder = new CodeBuildImageBuilder(this, 'Builder', {\n *     dockerfilePath: FargateProvider.LINUX_X64_DOCKERFILE_PATH,\n *     runnerVersion: RunnerVersion.specific('2.293.0'),\n *     rebuildInterval: Duration.days(14),\n * });\n * builder.setBuildArg('EXTRA_PACKAGES', 'nginx xz-utils');\n * new FargateProvider(this, 'Fargate provider', {\n *     label: 'customized-fargate',\n *     imageBuilder: builder,\n * });\n * ```\n */\nexport class CodeBuildImageBuilder extends Construct implements IImageBuilder {\n  private static BUILDSPEC_VERSION = 1;\n\n  private readonly architecture: Architecture;\n  private readonly os: Os;\n  private readonly repository: ecr.Repository;\n  private readonly dockerfile: s3_assets.Asset;\n  private preBuild: string[] = [];\n  private postBuild: string[] = [];\n  private buildArgs: Map<string, string> = new Map();\n  private policyStatements: iam.PolicyStatement[] = [];\n  private secondaryAssets: Map<string, s3_assets.Asset> = new Map();\n  private readonly buildImage: codebuild.IBuildImage;\n  private boundImage?: RunnerImage;\n\n  constructor(scope: Construct, id: string, readonly props: CodeBuildImageBuilderProps) {\n    super(scope, id);\n\n    if (props.subnetSelection?.subnetType == ec2.SubnetType.PRIVATE_ISOLATED) {\n      Annotations.of(this).addWarning('Private isolated subnets cannot pull from public ECR and VPC endpoint is not supported yet. ' +\n          'See https://github.com/aws/containers-roadmap/issues/1160');\n    }\n\n    // set platform\n    this.architecture = props.architecture ?? Architecture.X86_64;\n    this.os = props.os ?? Os.LINUX;\n\n    // create repository that only keeps one tag\n    this.repository = new ecr.Repository(this, 'Repository', {\n      imageScanOnPush: true,\n      imageTagMutability: TagMutability.MUTABLE,\n      removalPolicy: RemovalPolicy.DESTROY,\n      lifecycleRules: [\n        {\n          description: 'Remove untagged images that have been replaced by CodeBuild',\n          tagStatus: TagStatus.UNTAGGED,\n          maxImageAge: Duration.days(1),\n        },\n      ],\n    });\n\n    // upload Dockerfile to S3 as an asset\n    this.dockerfile = new s3_assets.Asset(this, 'Dockerfile', {\n      path: props.dockerfilePath,\n    });\n\n    // choose build image\n    this.buildImage = this.getBuildImage();\n  }\n\n  /**\n   * Uploads a folder to the build server at a given folder name.\n   *\n   * @param sourcePath path to source directory\n   * @param destName name of destination folder\n   */\n  public addFiles(sourcePath: string, destName: string) {\n    if (this.boundImage) {\n      throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');\n    }\n\n    const asset = new s3_assets.Asset(this, destName, { path: sourcePath });\n    this.secondaryAssets.set(destName, asset);\n    this.preBuild.push(`ln -s \"$CODEBUILD_SRC_DIR_${destName}\" \"${destName}\"`);\n  }\n\n  /**\n   * Adds a command that runs before `docker build`.\n   *\n   * @param command command to add\n   */\n  public addPreBuildCommand(command: string) {\n    if (this.boundImage) {\n      throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');\n    }\n    this.preBuild.push(command);\n  }\n\n  /**\n   * Adds a command that runs after `docker build` and `docker push`.\n   *\n   * @param command command to add\n   */\n  public addPostBuildCommand(command: string) {\n    if (this.boundImage) {\n      throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');\n    }\n    this.postBuild.push(command);\n  }\n\n  /**\n   * Adds a build argument for Docker. See the documentation for the Dockerfile you're using for a list of supported build arguments.\n   *\n   * @param name build argument name\n   * @param value build argument value\n   */\n  public setBuildArg(name: string, value: string) {\n    if (this.boundImage) {\n      throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');\n    }\n    this.buildArgs.set(name, value);\n  }\n\n  /**\n   * Add a policy statement to the builder to access resources required to the image build.\n   *\n   * @param statement IAM policy statement\n   */\n  public addPolicyStatement(statement: iam.PolicyStatement) {\n    if (this.boundImage) {\n      throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');\n    }\n    this.policyStatements.push(statement);\n  }\n\n  /**\n   * Called by IRunnerProvider to finalize settings and create the image builder.\n   */\n  public bind(): RunnerImage {\n    if (this.boundImage) {\n      return this.boundImage;\n    }\n\n    // log group for the image builds\n    const logGroup = new logs.LogGroup(\n      this,\n      'Logs',\n      {\n        retention: this.props.logRetention ?? RetentionDays.ONE_MONTH,\n        removalPolicy: this.props.logRemovalPolicy ?? RemovalPolicy.DESTROY,\n      },\n    );\n\n    // generate buildSpec\n    const buildSpec = this.getBuildSpec(this.repository, logGroup, this.props.runnerVersion);\n\n    // create CodeBuild project that builds Dockerfile and pushes to repository\n    const project = new codebuild.Project(this, 'CodeBuild', {\n      description: `Build docker image for self-hosted GitHub runner ${this.node.path} (${this.os.name}/${this.architecture.name})`,\n      buildSpec: codebuild.BuildSpec.fromObject(buildSpec),\n      source: codebuild.Source.s3({\n        bucket: this.dockerfile.bucket,\n        path: this.dockerfile.s3ObjectKey,\n      }),\n      vpc: this.props.vpc,\n      securityGroups: this.props.securityGroup ? [this.props.securityGroup] : undefined,\n      subnetSelection: this.props.subnetSelection,\n      timeout: this.props.timeout ?? Duration.hours(1),\n      environment: {\n        buildImage: this.buildImage,\n        computeType: this.props.computeType ?? ComputeType.SMALL,\n        privileged: true,\n      },\n      logging: {\n        cloudWatch: {\n          logGroup,\n        },\n      },\n    });\n\n    // permissions\n    this.repository.grantPullPush(project);\n    this.policyStatements.forEach(project.addToRolePolicy);\n\n    // call CodeBuild during deployment and delete all images from repository during destruction\n    const cr = this.customResource(project);\n\n    // rebuild image on a schedule\n    this.rebuildImageOnSchedule(project, this.props.rebuildInterval);\n\n    for (const [assetPath, asset] of this.secondaryAssets.entries()) {\n      project.addSecondarySource(codebuild.Source.s3({\n        identifier: assetPath,\n        bucket: asset.bucket,\n        path: asset.s3ObjectKey,\n      }));\n    }\n\n    this.boundImage = {\n      imageRepository: ecr.Repository.fromRepositoryAttributes(this, 'Dependable Image', {\n        repositoryName: this.repository.repositoryName,\n        // There are simpler ways to get the ARN, but we want an image object that depends on the custom resource.\n        // We want whoever is using this image to automatically wait for CodeBuild to start and finish through the custom resource.\n        repositoryArn: cr.ref,\n      }),\n      imageTag: 'latest',\n      imageDigest: cr.getAtt('Digest').toString(),\n      architecture: this.architecture,\n      os: this.os,\n    };\n    return this.boundImage;\n  }\n\n  private getBuildImage(): codebuild.IBuildImage {\n    if (this.os.is(Os.LINUX)) {\n      if (this.architecture.is(Architecture.X86_64)) {\n        return codebuild.LinuxBuildImage.STANDARD_4_0;\n      } else if (this.architecture.is(Architecture.ARM64)) {\n        return codebuild.LinuxArmBuildImage.AMAZON_LINUX_2_STANDARD_2_0;\n      }\n    }\n    if (this.os.is(Os.WINDOWS)) {\n      throw new Error('CodeBuild cannot be used to build Windows Docker images https://github.com/docker-library/docker/issues/49');\n    }\n\n    throw new Error(`Unable to find CodeBuild image for ${this.os.name}/${this.architecture.name}`);\n  }\n\n  private getBuildSpec(repository: ecr.Repository, logGroup: logs.LogGroup, runnerVersion?: RunnerVersion): any {\n    // don't forget to change BUILDSPEC_VERSION when the buildSpec changes, and you want to trigger a rebuild on deploy\n    let buildArgs = '';\n    for (const [name, value] of this.buildArgs.entries()) {\n      buildArgs += ` --build-arg \"${name}\"=\"${value}\"`;\n    }\n    buildArgs += ` --build-arg RUNNER_VERSION=\"${runnerVersion ? runnerVersion.version : RunnerVersion.latest().version}\"`;\n\n    return {\n      version: '0.2',\n      env: {\n        variables: {\n          REPO_ARN: repository.repositoryArn,\n          REPO_URI: repository.repositoryUri,\n          STACK_ID: 'unspecified',\n          REQUEST_ID: 'unspecified',\n          LOGICAL_RESOURCE_ID: 'unspecified',\n          RESPONSE_URL: 'unspecified',\n          RUNNER_VERSION: runnerVersion ? runnerVersion.version : RunnerVersion.latest().version,\n        },\n      },\n      phases: {\n        pre_build: {\n          commands: this.preBuild.concat([\n            '$(aws ecr get-login --no-include-email --region \"$AWS_DEFAULT_REGION\")',\n          ]),\n        },\n        build: {\n          commands: [\n            `docker build . -t \"$REPO_URI\" ${buildArgs}`,\n            'docker push \"$REPO_URI\"',\n          ],\n        },\n        post_build: {\n          commands: this.postBuild.concat([\n            'STATUS=\"SUCCESS\"',\n            'DIGEST=\"UNKNOWN\"',\n            'if [ $CODEBUILD_BUILD_SUCCEEDING -ne 1 ]; then STATUS=\"FAILED\"; else DIGEST=`docker inspect \"$REPO_URI\" | jq -r \\'.[0].RepoDigests[0] | split(\"@\")[1] | split(\":\")[1]\\'`; fi',\n            'cat <<EOF > /tmp/payload.json\\n' +\n            '{\\n' +\n            '  \"StackId\": \"$STACK_ID\",\\n' +\n            '  \"RequestId\": \"$REQUEST_ID\",\\n' +\n            '  \"LogicalResourceId\": \"$LOGICAL_RESOURCE_ID\",\\n' +\n            '  \"PhysicalResourceId\": \"$REPO_ARN\",\\n' +\n            '  \"Status\": \"$STATUS\",\\n' +\n            `  \"Reason\": \"See logs in ${logGroup.logGroupName}/$CODEBUILD_LOG_PATH (deploy again with \\'cdk deploy -R\\' or logRemovalPolicy=RemovalPolicy.RETAIN if they are already deleted)\",\\n` +\n            '  \"Data\": {\"Digest\": \"$DIGEST\"}\\n' + // include the digest to mark the resource updated so the runner providers get updated with the latest digest too (specifically Lambda)\n            '}\\n' +\n            'EOF',\n            'if [ \"$RESPONSE_URL\" != \"unspecified\" ]; then jq . /tmp/payload.json; curl -fsSL -X PUT -H \"Content-Type:\" -d \"@/tmp/payload.json\" \"$RESPONSE_URL\"; fi',\n          ]),\n        },\n      },\n    };\n  }\n\n  private customResource(project: codebuild.Project) {\n    const crHandler = BundledNodejsFunction.singleton(this, 'build-image', {\n      description: 'Custom resource handler that triggers CodeBuild to build runner images, and cleans-up images on deletion',\n      timeout: cdk.Duration.seconds(30),\n    });\n\n    const policy = new iam.Policy(this, 'CR Policy', {\n      statements: [\n        new iam.PolicyStatement({\n          actions: ['codebuild:StartBuild'],\n          resources: [project.projectArn],\n        }),\n        new iam.PolicyStatement({\n          actions: ['ecr:BatchDeleteImage', 'ecr:ListImages'],\n          resources: [this.repository.repositoryArn],\n        }),\n      ],\n    });\n    crHandler.role?.attachInlinePolicy(policy);\n\n    const cr = new CustomResource(this, 'Builder', {\n      serviceToken: crHandler.functionArn,\n      resourceType: 'Custom::ImageBuilder',\n      properties: {\n        RepoName: this.repository.repositoryName,\n        ProjectName: project.projectName,\n        // We include a hash so the image is built immediately on changes, and we don't have to wait for its scheduled build.\n        // This also helps make sure the changes are good. If they have a bug, the deployment will fail instead of just the scheduled build.\n        BuildHash: this.hashBuildSettings(),\n      },\n    });\n\n    // add dependencies to make sure resources are there when we need them\n    cr.node.addDependency(project);\n    cr.node.addDependency(policy);\n    cr.node.addDependency(crHandler);\n\n    return cr;\n  }\n\n  /**\n   * Return hash of all settings that can affect the result image so we can trigger the build when it changes.\n   * @private\n   */\n  private hashBuildSettings(): string {\n    // main Dockerfile\n    let components: string[] = [this.dockerfile.assetHash];\n    // all additional files\n    for (const [name, asset] of this.secondaryAssets.entries()) {\n      components.push(name);\n      components.push(asset.assetHash);\n    }\n    // buildspec.yml version\n    components.push(`v${CodeBuildImageBuilder.BUILDSPEC_VERSION}`);\n    // user commands\n    components = components.concat(this.preBuild);\n    components = components.concat(this.postBuild);\n    for (const [name, value] of this.buildArgs.entries()) {\n      components.push(name);\n      components.push(value);\n    }\n    // hash it\n    const all = components.join('-');\n    return crypto.createHash('md5').update(all).digest('hex');\n  }\n\n  private rebuildImageOnSchedule(project: codebuild.Project, rebuildInterval?: Duration) {\n    rebuildInterval = rebuildInterval ?? Duration.days(7);\n    if (rebuildInterval.toMilliseconds() != 0) {\n      const scheduleRule = new events.Rule(this, 'Build Schedule', {\n        description: `Rebuild runner image for ${this.repository.repositoryName}`,\n        schedule: events.Schedule.rate(rebuildInterval),\n      });\n      scheduleRule.addTarget(new events_targets.CodeBuildProject(project));\n    }\n  }\n}\n"]}

package/lib/providers/image-builders/static.d.ts

@@ -0,0 +1,29 @@
+import { aws_ecr as ecr } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { Architecture, IImageBuilder, Os } from '../common';
+/**
+ * Helper class with methods to use static images that are built outside the context of this project.
+ */
+export declare class StaticRunnerImage {
+    /**
+     * Create a builder (that doesn't actually build anything) from an existing image in an existing repository. The image must already have GitHub Actions runner installed. You are responsible to update it and remove it when done.
+     *
+     * @param repository ECR repository
+     * @param tag image tag
+     * @param architecture image architecture
+     * @param os image OS
+     */
+    static fromEcrRepository(repository: ecr.IRepository, tag?: string, architecture?: Architecture, os?: Os): IImageBuilder;
+    /**
+     * Create a builder from an existing Docker Hub image. The image must already have GitHub Actions runner installed. You are responsible to update it and remove it when done.
+     *
+     * We create a CodeBuild image builder behind the scenes to copy the image over to ECR. This helps avoid Docker Hub rate limits and prevent failures.
+     *
+     * @param scope
+     * @param id
+     * @param image Docker Hub image with optional tag
+     * @param architecture image architecture
+     * @param os image OS
+     */
+    static fromDockerHub(scope: Construct, id: string, image: string, architecture?: Architecture, os?: Os): IImageBuilder;
+}

package/lib/providers/image-builders/static.js

@@ -0,0 +1,58 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRunnerImage = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const codebuild_1 = require("../codebuild");
+const common_1 = require("../common");
+const codebuild_2 = require("./codebuild");
+/**
+ * Helper class with methods to use static images that are built outside the context of this project.
+ */
+class StaticRunnerImage {
+    /**
+     * Create a builder (that doesn't actually build anything) from an existing image in an existing repository. The image must already have GitHub Actions runner installed. You are responsible to update it and remove it when done.
+     *
+     * @param repository ECR repository
+     * @param tag image tag
+     * @param architecture image architecture
+     * @param os image OS
+     */
+    static fromEcrRepository(repository, tag = 'latest', architecture = common_1.Architecture.X86_64, os = common_1.Os.LINUX) {
+        return {
+            bind() {
+                return {
+                    imageRepository: repository,
+                    imageTag: tag,
+                    imageDigest: 'unknown',
+                    architecture,
+                    os,
+                };
+            },
+        };
+    }
+    /**
+     * Create a builder from an existing Docker Hub image. The image must already have GitHub Actions runner installed. You are responsible to update it and remove it when done.
+     *
+     * We create a CodeBuild image builder behind the scenes to copy the image over to ECR. This helps avoid Docker Hub rate limits and prevent failures.
+     *
+     * @param scope
+     * @param id
+     * @param image Docker Hub image with optional tag
+     * @param architecture image architecture
+     * @param os image OS
+     */
+    static fromDockerHub(scope, id, image, architecture = common_1.Architecture.X86_64, os = common_1.Os.LINUX) {
+        const builder = new codebuild_2.CodeBuildImageBuilder(scope, id, {
+            dockerfilePath: codebuild_1.CodeBuildRunner.LINUX_X64_DOCKERFILE_PATH,
+            architecture,
+            os,
+        });
+        builder.addPreBuildCommand(`echo "FROM ${image}" > Dockerfile`);
+        return builder;
+    }
+}
+exports.StaticRunnerImage = StaticRunnerImage;
+_a = JSII_RTTI_SYMBOL_1;
+StaticRunnerImage[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.StaticRunnerImage", version: "0.3.0" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/providers/lambda.d.ts

@@ -1,8 +1,17 @@
 import * as cdk from 'aws-cdk-lib';
 import { aws_ec2 as ec2, aws_iam as iam, aws_lambda as lambda, aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import { IRunnerProvider, RunnerRuntimeParameters, RunnerProviderProps } from './common';
+import { IRunnerProvider, RunnerRuntimeParameters, RunnerProviderProps, IImageBuilder } from './common';
 export interface LambdaRunnerProps extends RunnerProviderProps {
+    /**
+     * Provider running an image to run inside CodeBuild with GitHub runner pre-configured.
+     *
+     * The default command (`CMD`) should be `["runner.handler"]` which points to an included `runner.js` with a function named `handler`. The function should start the GitHub runner.
+     *
+     * @see https://github.com/CloudSnorkel/cdk-github-runners/tree/main/src/providers/docker-images/lambda
+     * @default image builder with LambdaRunner.LINUX_X64_DOCKERFILE_PATH as Dockerfile
+     */
+    readonly imageBuilder?: IImageBuilder;
     /**
      * GitHub Actions label used for this provider.
      *
@@ -59,6 +68,22 @@ export interface LambdaRunnerProps extends RunnerProviderProps {
  * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.
  */
 export declare class LambdaRunner extends Construct implements IRunnerProvider {
+    /**
+     * Path to Dockerfile for Linux x64 with all the requirement for Lambda runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.
+     *
+     * Available build arguments that can be set in the image builder:
+     * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.
+     * * `EXTRA_PACKAGES` can be used to install additional packages.
+     */
+    static readonly LINUX_X64_DOCKERFILE_PATH: string;
+    /**
+     * Path to Dockerfile for Linux ARM64 with all the requirement for Lambda runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.
+     *
+     * Available build arguments that can be set in the image builder:
+     * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.
+     * * `EXTRA_PACKAGES` can be used to install additional packages.
+     */
+    static readonly LINUX_ARM64_DOCKERFILE_PATH: string;
     /**
      * The function hosting the GitHub runner.
      */
@@ -92,4 +117,5 @@ export declare class LambdaRunner extends Construct implements IRunnerProvider {
      * @param parameters workflow job details
      */
     getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable;
+    private addImageUpdater;
 }