@cloudsnorkel/cdk-github-runners 0.1.1 → 0.3.1

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.1" };
+//# 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,5 +117,5 @@ export declare class LambdaRunner extends Construct implements IRunnerProvider {
      * @param parameters workflow job details
      */
     getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable;
+    private addImageUpdater;
 }
-//# sourceMappingURL=lambda.d.ts.map

package/lib/providers/lambda.js

@@ -8,7 +8,9 @@ const cdk = require("aws-cdk-lib");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
 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");
+const codebuild_1 = require("./image-builders/codebuild");
 /**
  * GitHub Actions runner provider using Lambda to execute the actions.
  *
@@ -22,13 +24,27 @@ class LambdaRunner extends constructs_1.Construct {
         this.label = props.label || 'lambda';
         this.vpc = props.vpc;
         this.securityGroup = props.securityGroup;
+        const imageBuilder = props.imageBuilder ?? new codebuild_1.CodeBuildImageBuilder(this, 'Image Builder', {
+            dockerfilePath: LambdaRunner.LINUX_X64_DOCKERFILE_PATH,
+        });
+        const image = imageBuilder.bind();
+        let architecture;
+        if (image.os.is(common_1.Os.LINUX)) {
+            if (image.architecture.is(common_1.Architecture.X86_64)) {
+                architecture = aws_cdk_lib_1.aws_lambda.Architecture.X86_64;
+            }
+            if (image.architecture.is(common_1.Architecture.ARM64)) {
+                architecture = aws_cdk_lib_1.aws_lambda.Architecture.ARM_64;
+            }
+        }
+        if (!architecture) {
+            throw new Error(`Unable to find support Lambda architecture for ${image.os.name}/${image.architecture.name}`);
+        }
         this.function = new aws_cdk_lib_1.aws_lambda.DockerImageFunction(this, 'Function', {
-            // https://docs.aws.amazon.com/lambda/latest/dg/images-create.html
-            code: aws_cdk_lib_1.aws_lambda.DockerImageCode.fromImageAsset(path.join(__dirname, 'docker-images', 'lambda'), {
-                buildArgs: {
-                    RUNNER_VERSION: props.runnerVersion ? props.runnerVersion.version : common_1.RunnerVersion.latest().version,
-                },
-            }),
+            description: `GitHub Actions runner for "${this.label}" label`,
+            // CDK requires "sha256:" literal prefix -- https://github.com/aws/aws-cdk/blob/ba91ca45ad759ab5db6da17a62333e2bc11e1075/packages/%40aws-cdk/aws-ecr/lib/repository.ts#L184
+            code: aws_cdk_lib_1.aws_lambda.DockerImageCode.fromEcr(image.imageRepository, { tagOrDigest: `sha256:${image.imageDigest}` }),
+            architecture,
             vpc: this.vpc,
             securityGroups: this.securityGroup && [this.securityGroup],
             vpcSubnets: props.subnetSelection,
@@ -38,6 +54,7 @@ class LambdaRunner extends constructs_1.Construct {
             logRetention: props.logRetention || aws_logs_1.RetentionDays.ONE_MONTH,
         });
         this.grantPrincipal = this.function.grantPrincipal;
+        this.addImageUpdater(image);
     }
     /**
      * The network connections associated with this resource.
@@ -53,7 +70,7 @@ class LambdaRunner extends constructs_1.Construct {
      * @param parameters workflow job details
      */
     getStepFunctionTask(parameters) {
-        return new aws_cdk_lib_1.aws_stepfunctions_tasks.LambdaInvoke(this, 'Lambda Runner', {
+        return new aws_cdk_lib_1.aws_stepfunctions_tasks.LambdaInvoke(this, this.label, {
             lambdaFunction: this.function,
             payload: aws_cdk_lib_1.aws_stepfunctions.TaskInput.fromObject({
                 token: parameters.runnerTokenPath,
@@ -65,8 +82,70 @@ class LambdaRunner extends constructs_1.Construct {
             }),
         });
     }
+    addImageUpdater(image) {
+        // Lambda needs to be pointing to a specific image digest and not just a tag.
+        // Whenever we update the tag to a new digest, we need to update the lambda.
+        let stack = cdk.Stack.of(this);
+        const updater = utils_1.BundledNodejsFunction.singleton(this, 'update-lambda', {
+            description: 'Function that updates a GitHub Actions runner function with the latest image digest after the image has been rebuilt',
+            timeout: cdk.Duration.seconds(30),
+            initialPolicy: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['lambda:UpdateFunctionCode'],
+                    resources: [this.function.functionArn],
+                }),
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['cloudformation:DescribeStacks'],
+                    resources: [stack.formatArn({
+                            service: 'cloudformation',
+                            resource: 'stack',
+                            resourceName: `${stack.stackName}/*`,
+                        })],
+                }),
+            ],
+        });
+        let lambdaTarget = new aws_cdk_lib_1.aws_events_targets.LambdaFunction(updater, {
+            event: aws_cdk_lib_1.aws_events.RuleTargetInput.fromObject({
+                lambdaName: this.function.functionName,
+                repositoryUri: image.imageRepository.repositoryUri,
+                repositoryTag: image.imageTag,
+                stackName: stack.stackName,
+            }),
+        });
+        const rule = image.imageRepository.onEvent('Push rule', {
+            description: 'Update GitHub Actions runner Lambda on ECR image push',
+            eventPattern: {
+                detailType: ['ECR Image Action'],
+                detail: {
+                    'action-type': ['PUSH'],
+                    'repository-name': [image.imageRepository.repositoryName],
+                    'image-tag': ['latest'],
+                    'result': ['SUCCESS'],
+                },
+            },
+            target: lambdaTarget,
+        });
+        // the event never triggers without this - not sure why
+        rule.node.defaultChild.addDeletionOverride('Properties.EventPattern.resources');
+    }
 }
 exports.LambdaRunner = LambdaRunner;
 _a = JSII_RTTI_SYMBOL_1;
-LambdaRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaRunner", version: "0.1.1" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda.js","sourceRoot":"","sources":["../../src/providers/lambda.ts"],"names":[],"mappings":";;;;;AAAA,6BAA6B;AAC7B,mCAAmC;AACnC,6CAMqB;AACrB,mDAAqD;AACrD,2CAAuC;AACvC,qCAAwG;AA0DxG;;;;;;GAMG;AACH,MAAa,YAAa,SAAQ,sBAAS;IA0BzC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAwB;QAChE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC;QACrC,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAEzC,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAM,CAAC,mBAAmB,CAC5C,IAAI,EACJ,UAAU,EACV;YACE,kEAAkE;YAClE,IAAI,EAAE,wBAAM,CAAC,eAAe,CAAC,cAAc,CACzC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,eAAe,EAAE,QAAQ,CAAC,EAC/C;gBACE,SAAS,EAAE;oBACT,cAAc,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAa,CAAC,MAAM,EAAE,CAAC,OAAO;iBACnG;aACF,CACF;YACD,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,cAAc,EAAE,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;YAC1D,UAAU,EAAE,KAAK,CAAC,eAAe;YACjC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAClD,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI;YACpC,oBAAoB,EAAE,KAAK,CAAC,oBAAoB,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1E,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,wBAAa,CAAC,SAAS;SAC5D,CACF,CAAC;QAEF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACH,mBAAmB,CAAC,UAAmC;QACrD,OAAO,IAAI,qCAAmB,CAAC,YAAY,CACzC,IAAI,EACJ,eAAe,EACf;YACE,cAAc,EAAE,IAAI,CAAC,QAAQ;YAC7B,OAAO,EAAE,+BAAa,CAAC,SAAS,CAAC,UAAU,CAAC;gBAC1C,KAAK,EAAE,UAAU,CAAC,eAAe;gBACjC,UAAU,EAAE,UAAU,CAAC,cAAc;gBACrC,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,YAAY,EAAE,UAAU,CAAC,gBAAgB;gBACzC,KAAK,EAAE,UAAU,CAAC,SAAS;gBAC3B,IAAI,EAAE,UAAU,CAAC,QAAQ;aAC1B,CAAC;SACH,CACF,CAAC;IACJ,CAAC;;AAzFH,oCA0FC","sourcesContent":["import * as path from 'path';\nimport * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_iam as iam,\n  aws_lambda as lambda,\n  aws_stepfunctions as stepfunctions,\n  aws_stepfunctions_tasks as stepfunctions_tasks,\n} from 'aws-cdk-lib';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { IRunnerProvider, RunnerRuntimeParameters, RunnerProviderProps, RunnerVersion } from './common';\n\nexport interface LambdaRunnerProps extends RunnerProviderProps {\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default 'lambda'\n   */\n  readonly label?: string;\n\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   *\n   * @default 2048\n   */\n  readonly memorySize?: number;\n\n  /**\n  * The size of the function’s /tmp directory in MiB.\n  *\n  * @default 10 GiB\n  */\n  readonly ephemeralStorageSize?: cdk.Size;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default Duration.minutes(15)\n   */\n  readonly timeout?: cdk.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 lambda 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/**\n * GitHub Actions runner provider using Lambda to execute the actions.\n *\n * Creates a Docker-based function that gets executed for each job.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class LambdaRunner extends Construct implements IRunnerProvider {\n  /**\n   * The function hosting the GitHub runner.\n   */\n  readonly function: lambda.Function;\n\n  /**\n   * Label associated with this provider.\n   */\n  readonly label: string;\n\n  /**\n   * VPC used for hosting the function.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group attached to the function.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Grant principal used to add permissions to the runner role.\n   */\n  readonly grantPrincipal: iam.IPrincipal;\n\n  constructor(scope: Construct, id: string, props: LambdaRunnerProps) {\n    super(scope, id);\n\n    this.label = props.label || 'lambda';\n    this.vpc = props.vpc;\n    this.securityGroup = props.securityGroup;\n\n    this.function = new lambda.DockerImageFunction(\n      this,\n      'Function',\n      {\n        // https://docs.aws.amazon.com/lambda/latest/dg/images-create.html\n        code: lambda.DockerImageCode.fromImageAsset(\n          path.join(__dirname, 'docker-images', 'lambda'),\n          {\n            buildArgs: {\n              RUNNER_VERSION: props.runnerVersion ? props.runnerVersion.version : RunnerVersion.latest().version,\n            },\n          },\n        ),\n        vpc: this.vpc,\n        securityGroups: this.securityGroup && [this.securityGroup],\n        vpcSubnets: props.subnetSelection,\n        timeout: props.timeout || cdk.Duration.minutes(15),\n        memorySize: props.memorySize || 2048,\n        ephemeralStorageSize: props.ephemeralStorageSize || cdk.Size.gibibytes(10),\n        logRetention: props.logRetention || RetentionDays.ONE_MONTH,\n      },\n    );\n\n    this.grantPrincipal = this.function.grantPrincipal;\n  }\n\n  /**\n   * The network connections associated with this resource.\n   */\n  public get connections(): ec2.Connections {\n    return this.function.connections;\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    return new stepfunctions_tasks.LambdaInvoke(\n      this,\n      'Lambda Runner',\n      {\n        lambdaFunction: this.function,\n        payload: stepfunctions.TaskInput.fromObject({\n          token: parameters.runnerTokenPath,\n          runnerName: parameters.runnerNamePath,\n          label: this.label,\n          githubDomain: parameters.githubDomainPath,\n          owner: parameters.ownerPath,\n          repo: parameters.repoPath,\n        }),\n      },\n    );\n  }\n}"]}
+LambdaRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaRunner", version: "0.3.1" };
+/**
+ * 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.
+ */
+LambdaRunner.LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-x64');
+/**
+ * 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.
+ */
+LambdaRunner.LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-arm64');
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda.js","sourceRoot":"","sources":["../../src/providers/lambda.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_events as events,\n  aws_events_targets as events_targets,\n  aws_iam as iam,\n  aws_lambda as lambda,\n  aws_stepfunctions as stepfunctions,\n  aws_stepfunctions_tasks as stepfunctions_tasks,\n} from 'aws-cdk-lib';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { BundledNodejsFunction } from '../utils';\nimport { IRunnerProvider, RunnerRuntimeParameters, RunnerProviderProps, IImageBuilder, Os, Architecture, RunnerImage } from './common';\nimport { CodeBuildImageBuilder } from './image-builders/codebuild';\n\nexport interface LambdaRunnerProps extends RunnerProviderProps {\n  /**\n   * Provider running an image to run inside CodeBuild with GitHub runner pre-configured.\n   *\n   * 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.\n   *\n   * @see https://github.com/CloudSnorkel/cdk-github-runners/tree/main/src/providers/docker-images/lambda\n   * @default image builder with LambdaRunner.LINUX_X64_DOCKERFILE_PATH as Dockerfile\n   */\n  readonly imageBuilder?: IImageBuilder;\n\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default 'lambda'\n   */\n  readonly label?: string;\n\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   *\n   * @default 2048\n   */\n  readonly memorySize?: number;\n\n  /**\n  * The size of the function’s /tmp directory in MiB.\n  *\n  * @default 10 GiB\n  */\n  readonly ephemeralStorageSize?: cdk.Size;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default Duration.minutes(15)\n   */\n  readonly timeout?: cdk.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 lambda 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/**\n * GitHub Actions runner provider using Lambda to execute the actions.\n *\n * Creates a Docker-based function that gets executed for each job.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class LambdaRunner extends Construct implements IRunnerProvider {\n  /**\n   * 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.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-x64');\n\n  /**\n   * 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.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be similar to public.ecr.aws/lambda/nodejs:14.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'lambda', 'linux-arm64');\n\n  /**\n   * The function hosting the GitHub runner.\n   */\n  readonly function: lambda.Function;\n\n  /**\n   * Label associated with this provider.\n   */\n  readonly label: string;\n\n  /**\n   * VPC used for hosting the function.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group attached to the function.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Grant principal used to add permissions to the runner role.\n   */\n  readonly grantPrincipal: iam.IPrincipal;\n\n  constructor(scope: Construct, id: string, props: LambdaRunnerProps) {\n    super(scope, id);\n\n    this.label = props.label || 'lambda';\n    this.vpc = props.vpc;\n    this.securityGroup = props.securityGroup;\n\n    const imageBuilder = props.imageBuilder ?? new CodeBuildImageBuilder(this, 'Image Builder', {\n      dockerfilePath: LambdaRunner.LINUX_X64_DOCKERFILE_PATH,\n    });\n    const image = imageBuilder.bind();\n\n    let architecture: lambda.Architecture | undefined;\n    if (image.os.is(Os.LINUX)) {\n      if (image.architecture.is(Architecture.X86_64)) {\n        architecture = lambda.Architecture.X86_64;\n      }\n      if (image.architecture.is(Architecture.ARM64)) {\n        architecture = lambda.Architecture.ARM_64;\n      }\n    }\n\n    if (!architecture) {\n      throw new Error(`Unable to find support Lambda architecture for ${image.os.name}/${image.architecture.name}`);\n    }\n\n    this.function = new lambda.DockerImageFunction(\n      this,\n      'Function',\n      {\n        description: `GitHub Actions runner for \"${this.label}\" label`,\n        // CDK requires \"sha256:\" literal prefix -- https://github.com/aws/aws-cdk/blob/ba91ca45ad759ab5db6da17a62333e2bc11e1075/packages/%40aws-cdk/aws-ecr/lib/repository.ts#L184\n        code: lambda.DockerImageCode.fromEcr(image.imageRepository, { tagOrDigest: `sha256:${image.imageDigest}` }),\n        architecture,\n        vpc: this.vpc,\n        securityGroups: this.securityGroup && [this.securityGroup],\n        vpcSubnets: props.subnetSelection,\n        timeout: props.timeout || cdk.Duration.minutes(15),\n        memorySize: props.memorySize || 2048,\n        ephemeralStorageSize: props.ephemeralStorageSize || cdk.Size.gibibytes(10),\n        logRetention: props.logRetention || RetentionDays.ONE_MONTH,\n      },\n    );\n\n    this.grantPrincipal = this.function.grantPrincipal;\n\n    this.addImageUpdater(image);\n  }\n\n  /**\n   * The network connections associated with this resource.\n   */\n  public get connections(): ec2.Connections {\n    return this.function.connections;\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    return new stepfunctions_tasks.LambdaInvoke(\n      this,\n      this.label,\n      {\n        lambdaFunction: this.function,\n        payload: stepfunctions.TaskInput.fromObject({\n          token: parameters.runnerTokenPath,\n          runnerName: parameters.runnerNamePath,\n          label: this.label,\n          githubDomain: parameters.githubDomainPath,\n          owner: parameters.ownerPath,\n          repo: parameters.repoPath,\n        }),\n      },\n    );\n  }\n\n  private addImageUpdater(image: RunnerImage) {\n    // Lambda needs to be pointing to a specific image digest and not just a tag.\n    // Whenever we update the tag to a new digest, we need to update the lambda.\n\n    let stack = cdk.Stack.of(this);\n\n    const updater = BundledNodejsFunction.singleton(this, 'update-lambda', {\n      description: 'Function that updates a GitHub Actions runner function with the latest image digest after the image has been rebuilt',\n      timeout: cdk.Duration.seconds(30),\n      initialPolicy: [\n        new iam.PolicyStatement({\n          actions: ['lambda:UpdateFunctionCode'],\n          resources: [this.function.functionArn],\n        }),\n        new iam.PolicyStatement({\n          actions: ['cloudformation:DescribeStacks'],\n          resources: [stack.formatArn({\n            service: 'cloudformation',\n            resource: 'stack',\n            resourceName: `${stack.stackName}/*`,\n          })],\n        }),\n      ],\n    });\n\n    let lambdaTarget = new events_targets.LambdaFunction(updater, {\n      event: events.RuleTargetInput.fromObject({\n        lambdaName: this.function.functionName,\n        repositoryUri: image.imageRepository.repositoryUri,\n        repositoryTag: image.imageTag,\n        stackName: stack.stackName,\n      }),\n    });\n\n    const rule = image.imageRepository.onEvent('Push rule', {\n      description: 'Update GitHub Actions runner Lambda on ECR image push',\n      eventPattern: {\n        detailType: ['ECR Image Action'],\n        detail: {\n          'action-type': ['PUSH'],\n          'repository-name': [image.imageRepository.repositoryName],\n          'image-tag': ['latest'],\n          'result': ['SUCCESS'],\n        },\n      },\n      target: lambdaTarget,\n    });\n\n    // the event never triggers without this - not sure why\n    (rule.node.defaultChild as events.CfnRule).addDeletionOverride('Properties.EventPattern.resources');\n  }\n}\n"]}

package/lib/runner.d.ts

@@ -1,3 +1,4 @@
+import { aws_ec2 as ec2 } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { IRunnerProvider } from './providers/common';
 import { Secrets } from './secrets';
@@ -5,18 +6,56 @@ import { Secrets } from './secrets';
  * Properties for GitHubRunners
  */
 export interface GitHubRunnersProps {
-    /**
-     * Label of default provider in case the workflow job doesn't specify any known label. A provider with that label must be configured.
-     *
-     * @default 'codebuild'
-     */
-    readonly defaultProviderLabel?: string;
     /**
      * List of runner providers to use. At least one provider is required. Provider will be selected when its label matches the labels requested by the workflow job.
      *
      * @default CodeBuild, Lambda and Fargate runners with all the defaults (no VPC or default account VPC)
      */
     readonly providers?: IRunnerProvider[];
+    /**
+     * VPC used for all management functions. Use this with GitHub Enterprise Server hosted that's inaccessible from outside the VPC.
+     */
+    readonly vpc?: ec2.IVpc;
+    /**
+     * VPC subnets used for all management functions. Use this with GitHub Enterprise Server hosted that's inaccessible from outside the VPC.
+     */
+    readonly vpcSubnets?: ec2.SubnetSelection;
+    /**
+     * Allow management functions to run in public subnets. Lambda Functions in a public subnet can NOT access the internet.
+     *
+     * @default false
+     */
+    readonly allowPublicSubnet?: boolean;
+    /**
+     * Security group attached to all management functions. Use this with to provide access to GitHub Enterprise Server hosted inside a VPC.
+     */
+    readonly securityGroup?: ec2.ISecurityGroup;
+    /**
+     * Path to a directory containing a file named certs.pem containing any additional certificates required to trust GitHub Enterprise Server. Use this when GitHub Enterprise Server certificates are self-signed.
+     *
+     * You may also want to use custom images for your runner providers that contain the same certificates. See {@link CodeBuildImageBuilder.addCertificates}.
+     *
+     * ```typescript
+     * const imageBuilder = new CodeBuildImageBuilder(this, 'Image Builder with Certs', {
+     *     dockerfilePath: CodeBuildRunner.LINUX_X64_DOCKERFILE_PATH,
+     * });
+     * imageBuilder.addExtraCertificates('path-to-my-extra-certs-folder');
+     *
+     * const provider = new CodeBuildRunner(this, 'CodeBuild', {
+     *     imageBuilder: imageBuilder,
+     * });
+     *
+     * new GitHubRunners(
+     *   this,
+     *   'runners',
+     *   {
+     *     providers: [provider],
+     *     extraCertificates: 'path-to-my-extra-certs-folder',
+     *   }
+     * );
+     * ```
+     */
+    readonly extraCertificates?: string;
 }
 /**
  * Create all the required infrastructure to provide self-hosted GitHub runners. It creates a webhook, secrets, and a step function to orchestrate all runs. Secrets are not automatically filled. See README.md for instructions on how to setup GitHub integration.
@@ -24,20 +63,20 @@ export interface GitHubRunnersProps {
  * By default, this will create a runner provider of each available type with the defaults. This is good enough for the initial setup stage when you just want to get GitHub integration working.
  *
  * ```typescript
- * new GitHubRunners(stack, 'runners', {});
+ * new GitHubRunners(this, 'runners');
  * ```
  *
  * Usually you'd want to configure the runner providers so the runners can run in a certain VPC or have certain permissions.
  *
  * ```typescript
- * const vpc = ec2.Vpc.fromLookup(stack, 'vpc', { vpcId: 'vpc-1234567' });
- * const runnerSg = new ec2.SecurityGroup(stack, 'runner security group', { vpc: vpc });
- * const dbSg = ec2.SecurityGroup.fromSecurityGroupId(stack, 'database security group', 'sg-1234567');
- * const bucket = new s3.Bucket(stack, 'runner bucket');
+ * const vpc = ec2.Vpc.fromLookup(this, 'vpc', { vpcId: 'vpc-1234567' });
+ * const runnerSg = new ec2.SecurityGroup(this, 'runner security group', { vpc: vpc });
+ * const dbSg = ec2.SecurityGroup.fromSecurityGroupId(this, 'database security group', 'sg-1234567');
+ * const bucket = new s3.Bucket(this, 'runner bucket');
  *
  * // create a custom CodeBuild provider
  * const myProvider = new CodeBuildRunner(
- *   stack, 'codebuild runner',
+ *   this, 'codebuild runner',
  *   {
  *      label: 'my-codebuild',
  *      vpc: vpc,
@@ -50,25 +89,20 @@ export interface GitHubRunnersProps {
  *
  * // create the runner infrastructure
  * new GitHubRunners(
- *   stack,
+ *   this,
  *   'runners',
  *   {
  *     providers: [myProvider],
- *     defaultProviderLabel: 'my-codebuild',
  *   }
  * );
  * ```
  */
 export declare class GitHubRunners extends Construct {
-    readonly props: GitHubRunnersProps;
+    private readonly props;
     /**
      * Configured runner providers.
      */
     readonly providers: IRunnerProvider[];
-    /**
-     * Default provider as set by {@link GitHubRunnersProps.defaultProviderLabel}.
-     */
-    readonly defaultProvider: IRunnerProvider;
     /**
      * Secrets for GitHub communication including webhook secret and runner authentication.
      */
@@ -76,12 +110,12 @@ export declare class GitHubRunners extends Construct {
     private readonly webhook;
     private readonly orchestrator;
     private readonly setupUrl;
-    constructor(scope: Construct, id: string, props: GitHubRunnersProps);
-    private getDefaultProvider;
+    private readonly extraLambdaEnv;
+    private readonly extraLambdaProps;
+    constructor(scope: Construct, id: string, props?: GitHubRunnersProps);
     private stateMachine;
     private tokenRetriever;
     private deleteRunner;
     private statusFunction;
     private setupFunction;
 }
-//# sourceMappingURL=runner.d.ts.map