@cloudsnorkel/cdk-github-runners 0.3.2 → 0.5.0

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

@@ -0,0 +1,509 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ContainerImageBuilder = exports.ImageBuilderComponent = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_ecr_1 = require("aws-cdk-lib/aws-ecr");
+const constructs_1 = require("constructs");
+const utils_1 = require("../../utils");
+const common_1 = require("../common");
+const dockerfileTemplate = `FROM {{{ imagebuilder:parentImage }}}
+{{{ imagebuilder:environments }}}
+{{{ imagebuilder:components }}}`;
+function uniqueName(scope) {
+    return cdk.Names.uniqueResourceName(scope, { maxLength: 126, separator: '-', allowedSpecialCharacters: '_-' });
+}
+class ImageBuilderObjectBase extends cdk.Resource {
+    constructor(scope, id) {
+        super(scope, id);
+    }
+    version(type, name, data) {
+        return new aws_cdk_lib_1.CustomResource(this, 'Version', {
+            serviceToken: this.versionFunction().functionArn,
+            resourceType: `Custom::ImageBuilder-${type}-Version`,
+            removalPolicy: cdk.RemovalPolicy.RETAIN,
+            properties: {
+                ObjectType: type,
+                ObjectName: name,
+                VersionedData: data,
+            },
+        }).ref;
+    }
+    versionFunction() {
+        return utils_1.BundledNodejsFunction.singleton(this, 'aws-image-builder-versioner', {
+            description: 'Custom resource handler that bumps up Image Builder versions',
+            initialPolicy: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: [
+                        'imagebuilder:ListComponents',
+                        'imagebuilder:ListContainerRecipes',
+                        'imagebuilder:ListImageRecipes',
+                    ],
+                    resources: ['*'],
+                }),
+            ],
+        });
+    }
+}
+/**
+ * Components are a set of commands to run and optional files to add to an image. Components are the building blocks of images built by Image Builder.
+ *
+ * Example:
+ *
+ * ```
+ * new ImageBuilderComponent(this, 'AWS CLI', {
+ *   platform: 'Windows',
+ *   displayName: 'AWS CLI',
+ *   description: 'Install latest version of AWS CLI',
+ *   commands: [
+ *     '$ErrorActionPreference = \'Stop\'',
+ *     'Start-Process msiexec.exe -Wait -ArgumentList \'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\'',
+ *   ],
+ * }
+ * ```
+ */
+class ImageBuilderComponent extends ImageBuilderObjectBase {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.assets = [];
+        this.platform = props.platform;
+        let steps = [];
+        if (props.assets) {
+            let inputs = [];
+            let extractCommands = [];
+            for (const asset of props.assets) {
+                this.assets.push(asset.asset);
+                if (asset.asset.isFile) {
+                    inputs.push({
+                        source: asset.asset.s3ObjectUrl,
+                        destination: asset.path,
+                    });
+                }
+                else if (asset.asset.isZipArchive) {
+                    inputs.push({
+                        source: asset.asset.s3ObjectUrl,
+                        destination: `${asset.path}.zip`,
+                    });
+                    if (props.platform === 'Windows') {
+                        extractCommands.push('$ErrorActionPreference = \'Stop\'');
+                        extractCommands.push(`Expand-Archive "${asset.path}.zip" -DestinationPath "${asset.path}"`);
+                        extractCommands.push(`del "${asset.path}.zip"`);
+                    }
+                    else {
+                        extractCommands.push(`unzip "${asset.path}.zip" -d "${asset.path}"`);
+                        extractCommands.push(`rm "${asset.path}.zip"`);
+                    }
+                }
+                else {
+                    throw new Error(`Unknown asset type: ${asset.asset}`);
+                }
+            }
+            steps.push({
+                name: 'Download',
+                action: 'S3Download',
+                inputs,
+            });
+            if (extractCommands.length > 0) {
+                steps.push({
+                    name: 'Extract',
+                    action: props.platform === 'Linux' ? 'ExecuteBash' : 'ExecutePowerShell',
+                    inputs: {
+                        commands: extractCommands,
+                    },
+                });
+            }
+        }
+        steps.push({
+            name: 'Run',
+            action: props.platform === 'Linux' ? 'ExecuteBash' : 'ExecutePowerShell',
+            inputs: {
+                commands: props.commands,
+            },
+        });
+        const data = {
+            name: props.displayName,
+            description: props.description,
+            schemaVersion: '1.0',
+            phases: [
+                {
+                    name: 'build',
+                    steps,
+                },
+            ],
+        };
+        const name = uniqueName(this);
+        const component = new aws_cdk_lib_1.aws_imagebuilder.CfnComponent(this, 'Component', {
+            name: name,
+            platform: props.platform,
+            version: this.version('Component', name, {
+                platform: props.platform,
+                data,
+            }),
+            data: JSON.stringify(data),
+        });
+        this.arn = component.attrArn;
+    }
+    /**
+     * Grants read permissions to the principal on the assets buckets.
+     *
+     * @param grantee
+     */
+    grantAssetsRead(grantee) {
+        for (const asset of this.assets) {
+            asset.grantRead(grantee);
+        }
+    }
+}
+exports.ImageBuilderComponent = ImageBuilderComponent;
+_a = JSII_RTTI_SYMBOL_1;
+ImageBuilderComponent[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.ImageBuilderComponent", version: "0.5.0" };
+/**
+ * Image builder recipe for a Docker container image.
+ */
+class ContainerRecipe extends ImageBuilderObjectBase {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const name = uniqueName(this);
+        let components = props.components.map(component => {
+            return {
+                componentArn: component.arn,
+            };
+        });
+        const recipe = new aws_cdk_lib_1.aws_imagebuilder.CfnContainerRecipe(this, 'Recipe', {
+            name: name,
+            version: this.version('ContainerRecipe', name, {
+                platform: props.platform,
+                components,
+            }),
+            // TODO mcr.microsoft.com/windows/servercore:ltsc2019
+            parentImage: 'arn:aws:imagebuilder:us-east-1:aws:image/windows-server-2019-x86-core-ltsc2019-amd64/2020.12.8',
+            components,
+            containerType: 'DOCKER',
+            targetRepository: {
+                service: 'ECR',
+                repositoryName: props.targetRepository.repositoryName,
+            },
+            dockerfileTemplateData: dockerfileTemplate,
+        });
+        this.arn = recipe.attrArn;
+        this.name = name;
+    }
+}
+/**
+ * An image builder that uses Image Builder to build Docker images pre-baked with all the GitHub Actions runner requirements. Builders can be used with runner providers.
+ *
+ * The CodeBuild builder is better and faster. Only use this one if you have no choice. For example, if you need Windows containers.
+ *
+ * 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. Some runner providers may require custom components. Check the runner provider documentation. The default components work with CodeBuild and Fargate.
+ *
+ * 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 ContainerImageBuilder(this, 'Builder', {
+ *     runnerVersion: RunnerVersion.specific('2.293.0'),
+ *     rebuildInterval: Duration.days(14),
+ * });
+ * new CodeBuildRunner(this, 'CodeBuild provider', {
+ *     label: 'windows-codebuild',
+ *     imageBuilder: builder,
+ * });
+ * ```
+ */
+class ContainerImageBuilder extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.components = [];
+        // set platform
+        this.architecture = props?.architecture ?? common_1.Architecture.X86_64;
+        if (!this.architecture.is(common_1.Architecture.X86_64)) {
+            throw new Error(`Unsupported architecture: ${this.architecture}. Consider CodeBuild for faster image builds.`);
+        }
+        this.os = props?.os ?? common_1.Os.LINUX;
+        if (this.os.is(common_1.Os.WINDOWS)) {
+            this.platform = 'Windows';
+        }
+        else {
+            throw new Error(`Unsupported OS: ${this.os}. Consider CodeBuild for faster image builds.`);
+        }
+        // set builder options
+        this.rebuildInterval = props?.rebuildInterval ?? aws_cdk_lib_1.Duration.days(7);
+        if (props?.vpc && props?.subnetSelection) {
+            this.subnetId = props.vpc.selectSubnets(props.subnetSelection).subnetIds[0];
+        }
+        if (props?.securityGroup) {
+            this.securityGroupIds = [props.securityGroup.securityGroupId];
+        }
+        this.instanceTypes = [props?.instanceType?.toString() ?? 'm5.large'];
+        this.description = `Build image for GitHub Actions runner ${this.node.path} (${this.os.name}/${this.architecture.name})`;
+        this.logRetention = props?.logRetention ?? aws_cdk_lib_1.aws_logs.RetentionDays.ONE_MONTH;
+        this.logRemovalPolicy = props?.logRemovalPolicy ?? aws_cdk_lib_1.RemovalPolicy.DESTROY;
+        // runner version
+        this.runnerVersion = props?.runnerVersion ?? common_1.RunnerVersion.latest();
+        // 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 all but the latest image',
+                    tagStatus: aws_ecr_1.TagStatus.ANY,
+                    maxImageCount: 1,
+                },
+            ],
+        });
+        // add all basic components
+        this.addBaseWindowsComponents();
+    }
+    addBaseWindowsComponents() {
+        this.addComponent(new ImageBuilderComponent(this, 'AWS CLI', {
+            platform: 'Windows',
+            displayName: 'AWS CLI',
+            description: 'Install latest version of AWS CLI',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                'Start-Process msiexec.exe -Wait -ArgumentList \'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\'',
+            ],
+        }));
+        this.addComponent(new ImageBuilderComponent(this, 'GitHub CLI', {
+            platform: 'Windows',
+            displayName: 'GitHub CLI',
+            description: 'Install latest version of gh',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                'cmd /c curl -w "%{redirect_url}" -fsS https://github.com/cli/cli/releases/latest > $Env:TEMP\\latest-gh',
+                '$LatestUrl = Get-Content $Env:TEMP\\latest-gh',
+                '$GH_VERSION = ($LatestUrl -Split \'/\')[-1].substring(1)',
+                '$ProgressPreference = \'SilentlyContinue\'',
+                'Invoke-WebRequest -UseBasicParsing -Uri "https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_windows_amd64.msi" -OutFile gh.msi',
+                'Start-Process msiexec.exe -Wait -ArgumentList \'/i gh.msi /qn\'',
+                'del gh.msi',
+            ],
+        }));
+        this.addComponent(new ImageBuilderComponent(this, 'git', {
+            platform: 'Windows',
+            displayName: 'Git',
+            description: 'Install latest version of git',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                '$ProgressPreference = \'SilentlyContinue\'',
+                'cmd /c curl -w "%{redirect_url}" -fsS https://github.com/git-for-windows/git/releases/latest > $Env:TEMP\\latest-git',
+                '$LatestUrl = Get-Content $Env:TEMP\\latest-git',
+                '$GIT_VERSION = ($LatestUrl -Split \'/\')[-1].substring(1)',
+                '$GIT_VERSION_SHORT = ($GIT_VERSION -Split \'.windows.\')[0]',
+                'Invoke-WebRequest -UseBasicParsing -Uri https://github.com/git-for-windows/git/releases/download/v${GIT_VERSION}/Git-${GIT_VERSION_SHORT}-64-bit.exe -OutFile git-setup.exe',
+                'Start-Process git-setup.exe -Wait -ArgumentList \'/VERYSILENT\'',
+                'del git-setup.exe',
+            ],
+        }));
+        let runnerCommands;
+        if (this.runnerVersion.version == common_1.RunnerVersion.latest().version) {
+            runnerCommands = [
+                'cmd /c curl -w "%{redirect_url}" -fsS https://github.com/actions/runner/releases/latest > $Env:TEMP\\latest-gha',
+                '$LatestUrl = Get-Content $Env:TEMP\\latest-gha',
+                '$RUNNER_VERSION = ($LatestUrl -Split \'/\')[-1].substring(1)',
+            ];
+        }
+        else {
+            runnerCommands = [`$RUNNER_VERSION = '${this.runnerVersion.version}'`];
+        }
+        this.addComponent(new ImageBuilderComponent(this, 'GitHub Actions Runner', {
+            platform: 'Windows',
+            displayName: 'GitHub Actions Runner',
+            description: 'Install latest version of GitHub Actions Runner',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                '$ProgressPreference = \'SilentlyContinue\'',
+            ].concat(runnerCommands, [
+                'Invoke-WebRequest -UseBasicParsing -Uri "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-win-x64-${RUNNER_VERSION}.zip" -OutFile actions.zip',
+                'Expand-Archive actions.zip -DestinationPath C:\\actions',
+                'del actions.zip',
+            ]),
+        }));
+    }
+    /**
+     * Add a component to be installed before any other components. Useful for required system settings like certificates or proxy settings.
+     * @param component
+     */
+    prependComponent(component) {
+        if (this.boundImage) {
+            throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');
+        }
+        if (component.platform != this.platform) {
+            throw new Error('Component platform doesn\'t match builder platform');
+        }
+        this.components = [component].concat(this.components);
+    }
+    /**
+     * Add a component to be installed.
+     * @param component
+     */
+    addComponent(component) {
+        if (this.boundImage) {
+            throw new Error('Image is already bound. Use this method before passing the builder to a runner provider.');
+        }
+        if (component.platform != this.platform) {
+            throw new Error('Component platform doesn\'t match builder platform');
+        }
+        this.components.push(component);
+    }
+    /**
+     * Add extra trusted certificates. This helps deal with self-signed certificates for GitHub Enterprise Server.
+     *
+     * All first party Dockerfiles support this. Others may not.
+     *
+     * @param path path to directory containing a file called certs.pem containing all the required certificates
+     */
+    addExtraCertificates(path) {
+        this.prependComponent(new ImageBuilderComponent(this, 'Extra Certs', {
+            platform: this.platform,
+            displayName: 'GitHub Actions Runner',
+            description: 'Install latest version of GitHub Actions Runner',
+            commands: [
+                '$ErrorActionPreference = \'Stop\'',
+                'Import-Certificate -FilePath certs\\certs.pem -CertStoreLocation Cert:\\LocalMachine\\Root',
+            ],
+            assets: [
+                {
+                    path: 'certs',
+                    asset: new aws_cdk_lib_1.aws_s3_assets.Asset(this, 'Extra Certs Asset', { path }),
+                },
+            ],
+        }));
+    }
+    /**
+     * Called by IRunnerProvider to finalize settings and create the image builder.
+     */
+    bind() {
+        if (this.boundImage) {
+            return this.boundImage;
+        }
+        const infra = this.infrastructure();
+        const dist = new aws_cdk_lib_1.aws_imagebuilder.CfnDistributionConfiguration(this, 'Distribution', {
+            name: uniqueName(this),
+            description: this.description,
+            distributions: [
+                {
+                    region: aws_cdk_lib_1.Stack.of(this).region,
+                    containerDistributionConfiguration: {
+                        ContainerTags: ['latest'],
+                        TargetRepository: {
+                            Service: 'ECR',
+                            RepositoryName: this.repository.repositoryName,
+                        },
+                    },
+                },
+            ],
+        });
+        const recipe = new ContainerRecipe(this, 'Container Recipe', {
+            platform: this.platform,
+            components: this.components,
+            targetRepository: this.repository,
+        });
+        const log = new aws_cdk_lib_1.aws_logs.LogGroup(this, 'Log', {
+            logGroupName: `/aws/imagebuilder/${recipe.name}`,
+            retention: this.logRetention,
+            removalPolicy: this.logRemovalPolicy,
+        });
+        const image = new aws_cdk_lib_1.aws_imagebuilder.CfnImage(this, 'Image', {
+            infrastructureConfigurationArn: infra.attrArn,
+            distributionConfigurationArn: dist.attrArn,
+            containerRecipeArn: recipe.arn,
+        });
+        image.node.addDependency(log);
+        this.imageCleaner(image, recipe.name);
+        let scheduleOptions;
+        if (this.rebuildInterval.toDays() > 0) {
+            scheduleOptions = {
+                scheduleExpression: aws_cdk_lib_1.aws_events.Schedule.rate(this.rebuildInterval).expressionString,
+                pipelineExecutionStartCondition: 'EXPRESSION_MATCH_ONLY',
+            };
+        }
+        const pipeline = new aws_cdk_lib_1.aws_imagebuilder.CfnImagePipeline(this, 'Pipeline', {
+            name: uniqueName(this),
+            description: this.description,
+            containerRecipeArn: recipe.arn,
+            infrastructureConfigurationArn: infra.attrArn,
+            distributionConfigurationArn: dist.attrArn,
+            schedule: scheduleOptions,
+        });
+        pipeline.node.addDependency(log);
+        this.boundImage = {
+            // There are simpler ways to get the ARN, but we want an image object that depends on the newly built image.
+            // We want whoever is using this image to automatically wait for Image Builder to finish building before using the image.
+            imageRepository: aws_cdk_lib_1.aws_ecr.Repository.fromRepositoryName(this, 'Dependable Image', 
+            // we can't use image.attrName because it comes up with upper case
+            cdk.Fn.split(':', cdk.Fn.split('/', image.attrImageUri, 2)[1], 2)[0]),
+            imageTag: 'latest',
+            os: this.os,
+            architecture: this.architecture,
+            logGroup: log,
+        };
+        return this.boundImage;
+    }
+    infrastructure() {
+        let role = new aws_cdk_lib_1.aws_iam.Role(this, 'Role', {
+            assumedBy: new aws_cdk_lib_1.aws_iam.ServicePrincipal('ec2.amazonaws.com'),
+            managedPolicies: [
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilderECRContainerBuilds'),
+            ],
+        });
+        for (const component of this.components) {
+            component.grantAssetsRead(role);
+        }
+        return new aws_cdk_lib_1.aws_imagebuilder.CfnInfrastructureConfiguration(this, 'Infrastructure', {
+            name: uniqueName(this),
+            description: this.description,
+            subnetId: this.subnetId,
+            securityGroupIds: this.securityGroupIds,
+            instanceTypes: this.instanceTypes,
+            instanceProfileName: new aws_cdk_lib_1.aws_iam.CfnInstanceProfile(this, 'Instance Profile', {
+                roles: [
+                    role.roleName,
+                ],
+            }).ref,
+        });
+    }
+    imageCleaner(image, recipeName) {
+        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.minutes(3),
+        });
+        const policy = new aws_cdk_lib_1.aws_iam.Policy(this, 'CR Policy', {
+            statements: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['ecr:BatchDeleteImage', 'ecr:ListImages'],
+                    resources: [this.repository.repositoryArn],
+                }),
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['imagebuilder:ListImages', 'imagebuilder:ListImageBuildVersions', 'imagebuilder:DeleteImage'],
+                    resources: ['*'],
+                }),
+            ],
+        });
+        crHandler.role?.attachInlinePolicy(policy);
+        const cr = new aws_cdk_lib_1.CustomResource(this, 'Deleter', {
+            serviceToken: crHandler.functionArn,
+            resourceType: 'Custom::ImageDeleter',
+            properties: {
+                RepoName: this.repository.repositoryName,
+                ImageBuilderName: recipeName,
+                DeleteOnly: true,
+            },
+        });
+        // add dependencies to make sure resources are there when we need them
+        cr.node.addDependency(image);
+        cr.node.addDependency(policy);
+        cr.node.addDependency(crHandler);
+        return cr;
+    }
+}
+exports.ContainerImageBuilder = ContainerImageBuilder;
+_b = JSII_RTTI_SYMBOL_1;
+ContainerImageBuilder[_b] = { fqn: "@cloudsnorkel/cdk-github-runners.ContainerImageBuilder", version: "0.5.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"container.js","sourceRoot":"","sources":["../../../src/providers/image-builders/container.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_ecr as ecr,\n  aws_events as events,\n  aws_iam as iam,\n  aws_imagebuilder as imagebuilder,\n  aws_logs as logs,\n  aws_s3_assets as s3_assets,\n  CustomResource,\n  Duration,\n  RemovalPolicy,\n  Stack,\n} from 'aws-cdk-lib';\nimport { TagMutability, TagStatus } from 'aws-cdk-lib/aws-ecr';\nimport { Construct } from 'constructs';\nimport { BundledNodejsFunction } from '../../utils';\nimport { Architecture, IImageBuilder, Os, RunnerImage, RunnerVersion } from '../common';\n\nconst dockerfileTemplate = `FROM {{{ imagebuilder:parentImage }}}\n{{{ imagebuilder:environments }}}\n{{{ imagebuilder:components }}}`;\n\n/**\n * Properties for ContainerImageBuilder construct.\n */\nexport interface ContainerImageBuilderProps {\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   * 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 default account VPC\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security Group to assign to this instance.\n   *\n   * @default default account security group\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Where to place the network interfaces within the VPC.\n   *\n   * @default default VPC subnet\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * The instance type used to build the image.\n   *\n   * @default m5.large\n   */\n  readonly instanceType?: ec2.InstanceType;\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\nfunction uniqueName(scope: Construct): string {\n  return cdk.Names.uniqueResourceName(scope, { maxLength: 126, separator: '-', allowedSpecialCharacters: '_-' });\n}\n\nabstract class ImageBuilderObjectBase extends cdk.Resource {\n  protected constructor(scope: Construct, id: string) {\n    super(scope, id);\n  }\n\n  protected version(type: 'Component' | 'ImageRecipe' | 'ContainerRecipe', name: string, data: any): string {\n    return new CustomResource(this, 'Version', {\n      serviceToken: this.versionFunction().functionArn,\n      resourceType: `Custom::ImageBuilder-${type}-Version`,\n      removalPolicy: cdk.RemovalPolicy.RETAIN, // no point in deleting as it doesn't even create anything\n      properties: {\n        ObjectType: type,\n        ObjectName: name,\n        VersionedData: data, // get a new version every time something changes, like Image Builder wants\n      },\n    }).ref;\n  }\n\n  private versionFunction(): BundledNodejsFunction {\n    return BundledNodejsFunction.singleton(this, 'aws-image-builder-versioner', {\n      description: 'Custom resource handler that bumps up Image Builder versions',\n      initialPolicy: [\n        new iam.PolicyStatement({\n          actions: [\n            'imagebuilder:ListComponents',\n            'imagebuilder:ListContainerRecipes',\n            'imagebuilder:ListImageRecipes',\n          ],\n          resources: ['*'],\n        }),\n      ],\n    });\n  }\n}\n\n/**\n * An asset including file or directory to place inside the built image.\n */\nexport interface ImageBuilderAsset {\n  /**\n   * Path to place asset in the image.\n   */\n  readonly path: string;\n\n  /**\n   * Asset to place in the image.\n   */\n  readonly asset: s3_assets.Asset;\n}\n\n/**\n * Properties for ImageBuilderComponent construct.\n */\nexport interface ImageBuilderComponentProperties {\n  /**\n   * Component platform. Must match the builder platform.\n   */\n  readonly platform: 'Linux' | 'Windows';\n\n  /**\n   * Component display name.\n   */\n  readonly displayName: string;\n\n  /**\n   * Component description.\n   */\n  readonly description: string;\n\n  /**\n   * Shell commands to run when adding this component to the image.\n   *\n   * On Linux, these are bash commands. On Windows, there are PowerShell commands.\n   */\n  readonly commands: string[];\n\n  /**\n   * Optional assets to add to the built image.\n   */\n  readonly assets?: ImageBuilderAsset[];\n}\n\n/**\n * Components are a set of commands to run and optional files to add to an image. Components are the building blocks of images built by Image Builder.\n *\n * Example:\n *\n * ```\n * new ImageBuilderComponent(this, 'AWS CLI', {\n *   platform: 'Windows',\n *   displayName: 'AWS CLI',\n *   description: 'Install latest version of AWS CLI',\n *   commands: [\n *     '$ErrorActionPreference = \\'Stop\\'',\n *     'Start-Process msiexec.exe -Wait -ArgumentList \\'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\\'',\n *   ],\n * }\n * ```\n */\nexport class ImageBuilderComponent extends ImageBuilderObjectBase {\n  /**\n   * Component ARN.\n   */\n  public readonly arn: string;\n\n  /**\n   * Supported platform for the component.\n   */\n  public readonly platform: 'Windows' | 'Linux';\n\n  private readonly assets: s3_assets.Asset[] = [];\n\n  constructor(scope: Construct, id: string, props: ImageBuilderComponentProperties) {\n    super(scope, id);\n\n    this.platform = props.platform;\n\n    let steps: any[] = [];\n\n    if (props.assets) {\n      let inputs: any[] = [];\n      let extractCommands: string[] = [];\n      for (const asset of props.assets) {\n        this.assets.push(asset.asset);\n\n        if (asset.asset.isFile) {\n          inputs.push({\n            source: asset.asset.s3ObjectUrl,\n            destination: asset.path,\n          });\n        } else if (asset.asset.isZipArchive) {\n          inputs.push({\n            source: asset.asset.s3ObjectUrl,\n            destination: `${asset.path}.zip`,\n          });\n          if (props.platform === 'Windows') {\n            extractCommands.push('$ErrorActionPreference = \\'Stop\\'');\n            extractCommands.push(`Expand-Archive \"${asset.path}.zip\" -DestinationPath \"${asset.path}\"`);\n            extractCommands.push(`del \"${asset.path}.zip\"`);\n          } else {\n            extractCommands.push(`unzip \"${asset.path}.zip\" -d \"${asset.path}\"`);\n            extractCommands.push(`rm \"${asset.path}.zip\"`);\n          }\n        } else {\n          throw new Error(`Unknown asset type: ${asset.asset}`);\n        }\n      }\n\n      steps.push({\n        name: 'Download',\n        action: 'S3Download',\n        inputs,\n      });\n\n      if (extractCommands.length > 0) {\n        steps.push({\n          name: 'Extract',\n          action: props.platform === 'Linux' ? 'ExecuteBash' : 'ExecutePowerShell',\n          inputs: {\n            commands: extractCommands,\n          },\n        });\n      }\n    }\n\n    steps.push({\n      name: 'Run',\n      action: props.platform === 'Linux' ? 'ExecuteBash' : 'ExecutePowerShell',\n      inputs: {\n        commands: props.commands,\n      },\n    });\n\n    const data = {\n      name: props.displayName,\n      description: props.description,\n      schemaVersion: '1.0',\n      phases: [\n        {\n          name: 'build',\n          steps,\n        },\n      ],\n    };\n\n    const name = uniqueName(this);\n    const component = new imagebuilder.CfnComponent(this, 'Component', {\n      name: name,\n      platform: props.platform,\n      version: this.version('Component', name, {\n        platform: props.platform,\n        data,\n      }),\n      data: JSON.stringify(data),\n    });\n\n    this.arn = component.attrArn;\n  }\n\n  /**\n   * Grants read permissions to the principal on the assets buckets.\n   *\n   * @param grantee\n   */\n  grantAssetsRead(grantee: iam.IGrantable) {\n    for (const asset of this.assets) {\n      asset.grantRead(grantee);\n    }\n  }\n}\n\n/**\n * Properties for ContainerRecipe construct.\n */\ninterface ContainerRecipeProperties {\n  /**\n   * Target platform. Must match builder platform.\n   */\n  readonly platform: 'Linux' | 'Windows';\n\n  /**\n   * Components to add to target container image.\n   */\n  readonly components: ImageBuilderComponent[];\n\n  /**\n   * ECR repository where resulting conatiner image will be uploaded.\n   */\n  readonly targetRepository: ecr.IRepository;\n}\n\n/**\n * Image builder recipe for a Docker container image.\n */\nclass ContainerRecipe extends ImageBuilderObjectBase {\n  public readonly arn: string;\n  public readonly name: string;\n\n  constructor(scope: Construct, id: string, props: ContainerRecipeProperties) {\n    super(scope, id);\n\n    const name = uniqueName(this);\n\n    let components = props.components.map(component => {\n      return {\n        componentArn: component.arn,\n      };\n    });\n\n    const recipe = new imagebuilder.CfnContainerRecipe(this, 'Recipe', {\n      name: name,\n      version: this.version('ContainerRecipe', name, {\n        platform: props.platform,\n        components,\n      }),\n      // TODO mcr.microsoft.com/windows/servercore:ltsc2019\n      parentImage: 'arn:aws:imagebuilder:us-east-1:aws:image/windows-server-2019-x86-core-ltsc2019-amd64/2020.12.8',\n      components,\n      containerType: 'DOCKER',\n      targetRepository: {\n        service: 'ECR',\n        repositoryName: props.targetRepository.repositoryName,\n      },\n      dockerfileTemplateData: dockerfileTemplate,\n    });\n\n    this.arn = recipe.attrArn;\n    this.name = name;\n  }\n}\n\n/**\n * An image builder that uses Image Builder to build Docker images pre-baked with all the GitHub Actions runner requirements. Builders can be used with runner providers.\n *\n * The CodeBuild builder is better and faster. Only use this one if you have no choice. For example, if you need Windows containers.\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. Some runner providers may require custom components. Check the runner provider documentation. The default components work with CodeBuild and Fargate.\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 ContainerImageBuilder(this, 'Builder', {\n *     runnerVersion: RunnerVersion.specific('2.293.0'),\n *     rebuildInterval: Duration.days(14),\n * });\n * new CodeBuildRunner(this, 'CodeBuild provider', {\n *     label: 'windows-codebuild',\n *     imageBuilder: builder,\n * });\n * ```\n */\nexport class ContainerImageBuilder extends Construct implements IImageBuilder {\n  readonly architecture: Architecture;\n  readonly os: Os;\n  readonly platform: 'Windows' | 'Linux';\n\n  readonly description: string;\n\n  readonly runnerVersion: RunnerVersion;\n\n  readonly repository: ecr.IRepository;\n  private components: ImageBuilderComponent[] = [];\n  private boundImage?: RunnerImage;\n\n  readonly subnetId: string | undefined;\n  readonly securityGroupIds: string[] | undefined;\n  readonly instanceTypes: string[];\n  readonly rebuildInterval: Duration;\n  readonly logRetention: logs.RetentionDays;\n  readonly logRemovalPolicy: cdk.RemovalPolicy;\n\n  constructor(scope: Construct, id: string, props?: ContainerImageBuilderProps) {\n    super(scope, id);\n\n    // set platform\n    this.architecture = props?.architecture ?? Architecture.X86_64;\n    if (!this.architecture.is(Architecture.X86_64)) {\n      throw new Error(`Unsupported architecture: ${this.architecture}. Consider CodeBuild for faster image builds.`);\n    }\n\n    this.os = props?.os ?? Os.LINUX;\n    if (this.os.is(Os.WINDOWS)) {\n      this.platform = 'Windows';\n    } else {\n      throw new Error(`Unsupported OS: ${this.os}. Consider CodeBuild for faster image builds.`);\n    }\n\n    // set builder options\n    this.rebuildInterval = props?.rebuildInterval ?? Duration.days(7);\n    if (props?.vpc && props?.subnetSelection) {\n      this.subnetId = props.vpc.selectSubnets(props.subnetSelection).subnetIds[0];\n    }\n\n    if (props?.securityGroup) {\n      this.securityGroupIds = [props.securityGroup.securityGroupId];\n    }\n\n    this.instanceTypes = [props?.instanceType?.toString() ?? 'm5.large'];\n\n    this.description = `Build image for GitHub Actions runner ${this.node.path} (${this.os.name}/${this.architecture.name})`;\n\n    this.logRetention = props?.logRetention ?? logs.RetentionDays.ONE_MONTH;\n    this.logRemovalPolicy = props?.logRemovalPolicy ?? RemovalPolicy.DESTROY;\n\n    // runner version\n    this.runnerVersion = props?.runnerVersion ?? RunnerVersion.latest();\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 all but the latest image',\n          tagStatus: TagStatus.ANY,\n          maxImageCount: 1,\n        },\n      ],\n    });\n\n    // add all basic components\n    this.addBaseWindowsComponents();\n  }\n\n  private addBaseWindowsComponents() {\n    this.addComponent(new ImageBuilderComponent(this, 'AWS CLI', {\n      platform: 'Windows',\n      displayName: 'AWS CLI',\n      description: 'Install latest version of AWS CLI',\n      commands: [\n        '$ErrorActionPreference = \\'Stop\\'',\n        'Start-Process msiexec.exe -Wait -ArgumentList \\'/i https://awscli.amazonaws.com/AWSCLIV2.msi /qn\\'',\n      ],\n    }));\n\n    this.addComponent(new ImageBuilderComponent(this, 'GitHub CLI', {\n      platform: 'Windows',\n      displayName: 'GitHub CLI',\n      description: 'Install latest version of gh',\n      commands: [\n        '$ErrorActionPreference = \\'Stop\\'',\n        'cmd /c curl -w \"%{redirect_url}\" -fsS https://github.com/cli/cli/releases/latest > $Env:TEMP\\\\latest-gh',\n        '$LatestUrl = Get-Content $Env:TEMP\\\\latest-gh',\n        '$GH_VERSION = ($LatestUrl -Split \\'/\\')[-1].substring(1)',\n        '$ProgressPreference = \\'SilentlyContinue\\'',\n        'Invoke-WebRequest -UseBasicParsing -Uri \"https://github.com/cli/cli/releases/download/v${GH_VERSION}/gh_${GH_VERSION}_windows_amd64.msi\" -OutFile gh.msi',\n        'Start-Process msiexec.exe -Wait -ArgumentList \\'/i gh.msi /qn\\'',\n        'del gh.msi',\n      ],\n    }));\n\n    this.addComponent(new ImageBuilderComponent(this, 'git', {\n      platform: 'Windows',\n      displayName: 'Git',\n      description: 'Install latest version of git',\n      commands: [\n        '$ErrorActionPreference = \\'Stop\\'',\n        '$ProgressPreference = \\'SilentlyContinue\\'',\n        'cmd /c curl -w \"%{redirect_url}\" -fsS https://github.com/git-for-windows/git/releases/latest > $Env:TEMP\\\\latest-git',\n        '$LatestUrl = Get-Content $Env:TEMP\\\\latest-git',\n        '$GIT_VERSION = ($LatestUrl -Split \\'/\\')[-1].substring(1)',\n        '$GIT_VERSION_SHORT = ($GIT_VERSION -Split \\'.windows.\\')[0]',\n        'Invoke-WebRequest -UseBasicParsing -Uri https://github.com/git-for-windows/git/releases/download/v${GIT_VERSION}/Git-${GIT_VERSION_SHORT}-64-bit.exe -OutFile git-setup.exe',\n        'Start-Process git-setup.exe -Wait -ArgumentList \\'/VERYSILENT\\'',\n        'del git-setup.exe',\n      ],\n    }));\n\n    let runnerCommands: string[];\n    if (this.runnerVersion.version == RunnerVersion.latest().version) {\n      runnerCommands = [\n        'cmd /c curl -w \"%{redirect_url}\" -fsS https://github.com/actions/runner/releases/latest > $Env:TEMP\\\\latest-gha',\n        '$LatestUrl = Get-Content $Env:TEMP\\\\latest-gha',\n        '$RUNNER_VERSION = ($LatestUrl -Split \\'/\\')[-1].substring(1)',\n      ];\n    } else {\n      runnerCommands = [`$RUNNER_VERSION = '${this.runnerVersion.version}'`];\n    }\n\n    this.addComponent(new ImageBuilderComponent(this, 'GitHub Actions Runner', {\n      platform: 'Windows',\n      displayName: 'GitHub Actions Runner',\n      description: 'Install latest version of GitHub Actions Runner',\n      commands: [\n        '$ErrorActionPreference = \\'Stop\\'',\n        '$ProgressPreference = \\'SilentlyContinue\\'',\n      ].concat(runnerCommands, [\n        'Invoke-WebRequest -UseBasicParsing -Uri \"https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-win-x64-${RUNNER_VERSION}.zip\" -OutFile actions.zip',\n        'Expand-Archive actions.zip -DestinationPath C:\\\\actions',\n        'del actions.zip',\n      ]),\n    }));\n  }\n\n  /**\n   * Add a component to be installed before any other components. Useful for required system settings like certificates or proxy settings.\n   * @param component\n   */\n  prependComponent(component: ImageBuilderComponent) {\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    if (component.platform != this.platform) {\n      throw new Error('Component platform doesn\\'t match builder platform');\n    }\n    this.components = [component].concat(this.components);\n  }\n\n  /**\n   * Add a component to be installed.\n   * @param component\n   */\n  addComponent(component: ImageBuilderComponent) {\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    if (component.platform != this.platform) {\n      throw new Error('Component platform doesn\\'t match builder platform');\n    }\n    this.components.push(component);\n  }\n\n  /**\n   * Add extra trusted certificates. This helps deal with self-signed certificates for GitHub Enterprise Server.\n   *\n   * All first party Dockerfiles support this. Others may not.\n   *\n   * @param path path to directory containing a file called certs.pem containing all the required certificates\n   */\n  public addExtraCertificates(path: string) {\n    this.prependComponent(new ImageBuilderComponent(this, 'Extra Certs', {\n      platform: this.platform,\n      displayName: 'GitHub Actions Runner',\n      description: 'Install latest version of GitHub Actions Runner',\n      commands: [\n        '$ErrorActionPreference = \\'Stop\\'',\n        'Import-Certificate -FilePath certs\\\\certs.pem -CertStoreLocation Cert:\\\\LocalMachine\\\\Root',\n      ],\n      assets: [\n        {\n          path: 'certs',\n          asset: new s3_assets.Asset(this, 'Extra Certs Asset', { path }),\n        },\n      ],\n    }));\n  }\n\n  /**\n   * Called by IRunnerProvider to finalize settings and create the image builder.\n   */\n  bind(): RunnerImage {\n    if (this.boundImage) {\n      return this.boundImage;\n    }\n\n    const infra = this.infrastructure();\n\n    const dist = new imagebuilder.CfnDistributionConfiguration(this, 'Distribution', {\n      name: uniqueName(this),\n      description: this.description,\n      distributions: [\n        {\n          region: Stack.of(this).region,\n          containerDistributionConfiguration: {\n            ContainerTags: ['latest'],\n            TargetRepository: {\n              Service: 'ECR',\n              RepositoryName: this.repository.repositoryName,\n            },\n          },\n        },\n      ],\n    });\n\n    const recipe = new ContainerRecipe(this, 'Container Recipe', {\n      platform: this.platform,\n      components: this.components,\n      targetRepository: this.repository,\n    });\n\n    const log = new logs.LogGroup(this, 'Log', {\n      logGroupName: `/aws/imagebuilder/${recipe.name}`,\n      retention: this.logRetention,\n      removalPolicy: this.logRemovalPolicy,\n    });\n\n    const image = new imagebuilder.CfnImage(this, 'Image', {\n      infrastructureConfigurationArn: infra.attrArn,\n      distributionConfigurationArn: dist.attrArn,\n      containerRecipeArn: recipe.arn,\n    });\n    image.node.addDependency(log);\n\n    this.imageCleaner(image, recipe.name);\n\n    let scheduleOptions: imagebuilder.CfnImagePipeline.ScheduleProperty | undefined;\n    if (this.rebuildInterval.toDays() > 0) {\n      scheduleOptions = {\n        scheduleExpression: events.Schedule.rate(this.rebuildInterval).expressionString,\n        pipelineExecutionStartCondition: 'EXPRESSION_MATCH_ONLY',\n      };\n    }\n    const pipeline = new imagebuilder.CfnImagePipeline(this, 'Pipeline', {\n      name: uniqueName(this),\n      description: this.description,\n      containerRecipeArn: recipe.arn,\n      infrastructureConfigurationArn: infra.attrArn,\n      distributionConfigurationArn: dist.attrArn,\n      schedule: scheduleOptions,\n    });\n    pipeline.node.addDependency(log);\n\n    this.boundImage = {\n      // There are simpler ways to get the ARN, but we want an image object that depends on the newly built image.\n      // We want whoever is using this image to automatically wait for Image Builder to finish building before using the image.\n      imageRepository: ecr.Repository.fromRepositoryName(\n        this, 'Dependable Image',\n        // we can't use image.attrName because it comes up with upper case\n        cdk.Fn.split(':', cdk.Fn.split('/', image.attrImageUri, 2)[1], 2)[0],\n      ),\n      imageTag: 'latest',\n      os: this.os,\n      architecture: this.architecture,\n      logGroup: log,\n    };\n\n    return this.boundImage;\n  }\n\n  private infrastructure(): imagebuilder.CfnInfrastructureConfiguration {\n    let role = new iam.Role(this, 'Role', {\n      assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),\n        iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilderECRContainerBuilds'),\n      ],\n    });\n\n    for (const component of this.components) {\n      component.grantAssetsRead(role);\n    }\n\n    return new imagebuilder.CfnInfrastructureConfiguration(this, 'Infrastructure', {\n      name: uniqueName(this),\n      description: this.description,\n      subnetId: this.subnetId,\n      securityGroupIds: this.securityGroupIds,\n      instanceTypes: this.instanceTypes,\n      instanceProfileName: new iam.CfnInstanceProfile(this, 'Instance Profile', {\n        roles: [\n          role.roleName,\n        ],\n      }).ref,\n    });\n  }\n\n  private imageCleaner(image: imagebuilder.CfnImage, recipeName: string) {\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.minutes(3),\n    });\n\n    const policy = new iam.Policy(this, 'CR Policy', {\n      statements: [\n        new iam.PolicyStatement({\n          actions: ['ecr:BatchDeleteImage', 'ecr:ListImages'],\n          resources: [this.repository.repositoryArn],\n        }),\n        new iam.PolicyStatement({\n          actions: ['imagebuilder:ListImages', 'imagebuilder:ListImageBuildVersions', 'imagebuilder:DeleteImage'],\n          resources: ['*'], // Image Builder doesn't support scoping this :(\n        }),\n      ],\n    });\n    crHandler.role?.attachInlinePolicy(policy);\n\n    const cr = new CustomResource(this, 'Deleter', {\n      serviceToken: crHandler.functionArn,\n      resourceType: 'Custom::ImageDeleter',\n      properties: {\n        RepoName: this.repository.repositoryName,\n        ImageBuilderName: recipeName, // we don't use image.name because CloudFormation complains if it was deleted already\n        DeleteOnly: true,\n      },\n    });\n\n    // add dependencies to make sure resources are there when we need them\n    cr.node.addDependency(image);\n    cr.node.addDependency(policy);\n    cr.node.addDependency(crHandler);\n\n    return cr;\n  }\n}\n"]}

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

@@ -24,7 +24,6 @@ class StaticRunnerImage {
                 return {
                     imageRepository: repository,
                     imageTag: tag,
-                    imageDigest: 'unknown',
                     architecture,
                     os,
                 };
@@ -54,5 +53,5 @@ class StaticRunnerImage {
 }
 exports.StaticRunnerImage = StaticRunnerImage;
 _a = JSII_RTTI_SYMBOL_1;
-StaticRunnerImage[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.StaticRunnerImage", version: "0.3.2" };
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhdGljLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL3Byb3ZpZGVycy9pbWFnZS1idWlsZGVycy9zdGF0aWMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7QUFFQSw0Q0FBK0M7QUFDL0Msc0NBQXlFO0FBQ3pFLDJDQUFvRDtBQUVwRDs7R0FFRztBQUNILE1BQWEsaUJBQWlCO0lBQzVCOzs7Ozs7O09BT0c7SUFDSSxNQUFNLENBQUMsaUJBQWlCLENBQUMsVUFBMkIsRUFBRSxNQUFjLFFBQVEsRUFBRSxZQUFZLEdBQUcscUJBQVksQ0FBQyxNQUFNLEVBQUUsRUFBRSxHQUFHLFdBQUUsQ0FBQyxLQUFLO1FBQ3BJLE9BQU87WUFDTCxJQUFJO2dCQUNGLE9BQU87b0JBQ0wsZUFBZSxFQUFFLFVBQVU7b0JBQzNCLFFBQVEsRUFBRSxHQUFHO29CQUNiLFdBQVcsRUFBRSxTQUFTO29CQUN0QixZQUFZO29CQUNaLEVBQUU7aUJBQ0gsQ0FBQztZQUNKLENBQUM7U0FDRixDQUFDO0lBQ0osQ0FBQztJQUVEOzs7Ozs7Ozs7O09BVUc7SUFDSSxNQUFNLENBQUMsYUFBYSxDQUFDLEtBQWdCLEVBQUUsRUFBVSxFQUFFLEtBQWEsRUFBRSxZQUFZLEdBQUcscUJBQVksQ0FBQyxNQUFNLEVBQUUsRUFBRSxHQUFHLFdBQUUsQ0FBQyxLQUFLO1FBQ3hILE1BQU0sT0FBTyxHQUFHLElBQUksaUNBQXFCLENBQUMsS0FBSyxFQUFFLEVBQUUsRUFBRTtZQUNuRCxjQUFjLEVBQUUsMkJBQWUsQ0FBQyx5QkFBeUI7WUFDekQsWUFBWTtZQUNaLEVBQUU7U0FDSCxDQUFDLENBQUM7UUFFSCxPQUFPLENBQUMsa0JBQWtCLENBQUMsY0FBYyxLQUFLLGdCQUFnQixDQUFDLENBQUM7UUFFaEUsT0FBTyxPQUFPLENBQUM7SUFDakIsQ0FBQzs7QUE1Q0gsOENBNkNDIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgYXdzX2VjciBhcyBlY3IgfSBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcbmltcG9ydCB7IENvZGVCdWlsZFJ1bm5lciB9IGZyb20gJy4uL2NvZGVidWlsZCc7XG5pbXBvcnQgeyBBcmNoaXRlY3R1cmUsIElJbWFnZUJ1aWxkZXIsIE9zLCBSdW5uZXJJbWFnZSB9IGZyb20gJy4uL2NvbW1vbic7XG5pbXBvcnQgeyBDb2RlQnVpbGRJbWFnZUJ1aWxkZXIgfSBmcm9tICcuL2NvZGVidWlsZCc7XG5cbi8qKlxuICogSGVscGVyIGNsYXNzIHdpdGggbWV0aG9kcyB0byB1c2Ugc3RhdGljIGltYWdlcyB0aGF0IGFyZSBidWlsdCBvdXRzaWRlIHRoZSBjb250ZXh0IG9mIHRoaXMgcHJvamVjdC5cbiAqL1xuZXhwb3J0IGNsYXNzIFN0YXRpY1J1bm5lckltYWdlIHtcbiAgLyoqXG4gICAqIENyZWF0ZSBhIGJ1aWxkZXIgKHRoYXQgZG9lc24ndCBhY3R1YWxseSBidWlsZCBhbnl0aGluZykgZnJvbSBhbiBleGlzdGluZyBpbWFnZSBpbiBhbiBleGlzdGluZyByZXBvc2l0b3J5LiBUaGUgaW1hZ2UgbXVzdCBhbHJlYWR5IGhhdmUgR2l0SHViIEFjdGlvbnMgcnVubmVyIGluc3RhbGxlZC4gWW91IGFyZSByZXNwb25zaWJsZSB0byB1cGRhdGUgaXQgYW5kIHJlbW92ZSBpdCB3aGVuIGRvbmUuXG4gICAqXG4gICAqIEBwYXJhbSByZXBvc2l0b3J5IEVDUiByZXBvc2l0b3J5XG4gICAqIEBwYXJhbSB0YWcgaW1hZ2UgdGFnXG4gICAqIEBwYXJhbSBhcmNoaXRlY3R1cmUgaW1hZ2UgYXJjaGl0ZWN0dXJlXG4gICAqIEBwYXJhbSBvcyBpbWFnZSBPU1xuICAgKi9cbiAgcHVibGljIHN0YXRpYyBmcm9tRWNyUmVwb3NpdG9yeShyZXBvc2l0b3J5OiBlY3IuSVJlcG9zaXRvcnksIHRhZzogc3RyaW5nID0gJ2xhdGVzdCcsIGFyY2hpdGVjdHVyZSA9IEFyY2hpdGVjdHVyZS5YODZfNjQsIG9zID0gT3MuTElOVVgpOiBJSW1hZ2VCdWlsZGVyIHtcbiAgICByZXR1cm4ge1xuICAgICAgYmluZCgpOiBSdW5uZXJJbWFnZSB7XG4gICAgICAgIHJldHVybiB7XG4gICAgICAgICAgaW1hZ2VSZXBvc2l0b3J5OiByZXBvc2l0b3J5LFxuICAgICAgICAgIGltYWdlVGFnOiB0YWcsXG4gICAgICAgICAgaW1hZ2VEaWdlc3Q6ICd1bmtub3duJyxcbiAgICAgICAgICBhcmNoaXRlY3R1cmUsXG4gICAgICAgICAgb3MsXG4gICAgICAgIH07XG4gICAgICB9LFxuICAgIH07XG4gIH1cblxuICAvKipcbiAgICogQ3JlYXRlIGEgYnVpbGRlciBmcm9tIGFuIGV4aXN0aW5nIERvY2tlciBIdWIgaW1hZ2UuIFRoZSBpbWFnZSBtdXN0IGFscmVhZHkgaGF2ZSBHaXRIdWIgQWN0aW9ucyBydW5uZXIgaW5zdGFsbGVkLiBZb3UgYXJlIHJlc3BvbnNpYmxlIHRvIHVwZGF0ZSBpdCBhbmQgcmVtb3ZlIGl0IHdoZW4gZG9uZS5cbiAgICpcbiAgICogV2UgY3JlYXRlIGEgQ29kZUJ1aWxkIGltYWdlIGJ1aWxkZXIgYmVoaW5kIHRoZSBzY2VuZXMgdG8gY29weSB0aGUgaW1hZ2Ugb3ZlciB0byBFQ1IuIFRoaXMgaGVscHMgYXZvaWQgRG9ja2VyIEh1YiByYXRlIGxpbWl0cyBhbmQgcHJldmVudCBmYWlsdXJlcy5cbiAgICpcbiAgICogQHBhcmFtIHNjb3BlXG4gICAqIEBwYXJhbSBpZFxuICAgKiBAcGFyYW0gaW1hZ2UgRG9ja2VyIEh1YiBpbWFnZSB3aXRoIG9wdGlvbmFsIHRhZ1xuICAgKiBAcGFyYW0gYXJjaGl0ZWN0dXJlIGltYWdlIGFyY2hpdGVjdHVyZVxuICAgKiBAcGFyYW0gb3MgaW1hZ2UgT1NcbiAgICovXG4gIHB1YmxpYyBzdGF0aWMgZnJvbURvY2tlckh1YihzY29wZTogQ29uc3RydWN0LCBpZDogc3RyaW5nLCBpbWFnZTogc3RyaW5nLCBhcmNoaXRlY3R1cmUgPSBBcmNoaXRlY3R1cmUuWDg2XzY0LCBvcyA9IE9zLkxJTlVYKTogSUltYWdlQnVpbGRlciB7XG4gICAgY29uc3QgYnVpbGRlciA9IG5ldyBDb2RlQnVpbGRJbWFnZUJ1aWxkZXIoc2NvcGUsIGlkLCB7XG4gICAgICBkb2NrZXJmaWxlUGF0aDogQ29kZUJ1aWxkUnVubmVyLkxJTlVYX1g2NF9ET0NLRVJGSUxFX1BBVEgsIC8vIGZha2UgRG9ja2VyZmlsZSB0aGF0IGdldHMgb3ZlcnJpZGRlbiBiZWxvd1xuICAgICAgYXJjaGl0ZWN0dXJlLFxuICAgICAgb3MsXG4gICAgfSk7XG5cbiAgICBidWlsZGVyLmFkZFByZUJ1aWxkQ29tbWFuZChgZWNobyBcIkZST00gJHtpbWFnZX1cIiA+IERvY2tlcmZpbGVgKTtcblxuICAgIHJldHVybiBidWlsZGVyO1xuICB9XG59Il19
+StaticRunnerImage[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.StaticRunnerImage", version: "0.5.0" };
+//# sourceMappingURL=data:application/json;base64,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