@cloudsnorkel/cdk-github-runners 0.9.4 → 0.9.5

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageBuilderObjectBase = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const versioner_function_1 = require("./versioner-function");
+const utils_1 = require("../../utils");
+/**
+ * @internal
+ */
+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, // get a new version every time something changes, like Image Builder wants
+            },
+        }).ref;
+    }
+    versionFunction() {
+        return (0, utils_1.singletonLambda)(versioner_function_1.VersionerFunction, 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: ['*'],
+                }),
+            ],
+            logRetention: aws_cdk_lib_1.aws_logs.RetentionDays.ONE_MONTH,
+            timeout: cdk.Duration.minutes(5),
+        });
+    }
+}
+exports.ImageBuilderObjectBase = ImageBuilderObjectBase;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{providers/image-builders → image-builders}/aws-image-builder/container.d.ts

@@ -2,7 +2,7 @@ import { aws_ecr as ecr } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { ImageBuilderComponent } from './builder';
 import { ImageBuilderObjectBase } from './common';
-import { Os } from '../../common';
+import { Os } from '../../providers/common';
 /**
  * Properties for ContainerRecipe construct.
  *

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultBaseDockerImage = exports.ContainerRecipe = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const common_1 = require("./common");
+const common_2 = require("../../providers/common");
+const common_3 = require("../common");
+/**
+ * Image builder recipe for a Docker container image.
+ *
+ * @internal
+ */
+class ContainerRecipe extends common_1.ImageBuilderObjectBase {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const name = (0, common_3.uniqueImageBuilderName)(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,
+                dockerfileTemplate: props.dockerfileTemplate,
+            }),
+            parentImage: props.parentImage ?? 'mcr.microsoft.com/windows/servercore:ltsc2019-amd64',
+            components,
+            containerType: 'DOCKER',
+            targetRepository: {
+                service: 'ECR',
+                repositoryName: props.targetRepository.repositoryName,
+            },
+            dockerfileTemplateData: props.dockerfileTemplate,
+        });
+        this.arn = recipe.attrArn;
+        this.name = name;
+    }
+}
+exports.ContainerRecipe = ContainerRecipe;
+/**
+ * Default base Docker image for given OS.
+ *
+ * @internal
+ */
+function defaultBaseDockerImage(os) {
+    if (os.is(common_2.Os.WINDOWS)) {
+        return 'mcr.microsoft.com/windows/servercore:ltsc2019-amd64';
+    }
+    else if (os.is(common_2.Os.LINUX_UBUNTU)) {
+        return 'public.ecr.aws/lts/ubuntu:22.04';
+    }
+    else if (os.is(common_2.Os.LINUX_AMAZON_2)) {
+        return 'public.ecr.aws/amazonlinux/amazonlinux:2';
+    }
+    else {
+        throw new Error(`OS ${os.name} not supported for Docker runner image`);
+    }
+}
+exports.defaultBaseDockerImage = defaultBaseDockerImage;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{providers/image-builders → image-builders}/aws-image-builder/delete-ami-function.d.ts

@@ -6,7 +6,7 @@ import { Construct } from 'constructs';
 export interface DeleteAmiFunctionProps extends lambda.FunctionOptions {
 }
 /**
- * An AWS Lambda function which executes src/providers/image-builders/aws-image-builder/delete-ami.
+ * An AWS Lambda function which executes src/image-builders/aws-image-builder/delete-ami.
  */
 export declare class DeleteAmiFunction extends lambda.Function {
     constructor(scope: Construct, id: string, props?: DeleteAmiFunctionProps);

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeleteAmiFunction = void 0;
+// ~~ Generated by projen. To modify, edit .projenrc.js and run "npx projen".
+const path = require("path");
+const lambda = require("aws-cdk-lib/aws-lambda");
+/**
+ * An AWS Lambda function which executes src/image-builders/aws-image-builder/delete-ami.
+ */
+class DeleteAmiFunction extends lambda.Function {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            description: 'src/image-builders/aws-image-builder/delete-ami.lambda.ts',
+            ...props,
+            runtime: new lambda.Runtime('nodejs16.x', lambda.RuntimeFamily.NODEJS),
+            handler: 'index.handler',
+            code: lambda.Code.fromAsset(path.join(__dirname, '../../../assets/image-builders/aws-image-builder/delete-ami.lambda')),
+        });
+        this.addEnvironment('AWS_NODEJS_CONNECTION_REUSE_ENABLED', '1', { removeInEdge: true });
+    }
+}
+exports.DeleteAmiFunction = DeleteAmiFunction;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable-next-line import/no-extraneous-dependencies */
+const AWS = require("aws-sdk");
+const lambda_helpers_1 = require("../../lambda-helpers");
+const ec2 = new AWS.EC2();
+async function deleteAmis(launchTemplateId, stackName, builderName, deleteAll) {
+    // this runs daily and images are built once a week, so there shouldn't be a need for pagination
+    const images = await ec2.describeImages({
+        Owners: ['self'],
+        Filters: [
+            {
+                Name: 'tag:GitHubRunners:Stack',
+                Values: [stackName],
+            },
+            {
+                Name: 'tag:GitHubRunners:Builder',
+                Values: [builderName],
+            },
+        ],
+    }).promise();
+    let imagesToDelete = images.Images ?? [];
+    console.log(`Found ${imagesToDelete.length} AMIs`);
+    console.log(JSON.stringify(imagesToDelete.map(i => i.ImageId)));
+    if (!deleteAll) {
+        // get launch template information to filter out the active image
+        const launchTemplates = await ec2.describeLaunchTemplateVersions({
+            LaunchTemplateId: launchTemplateId,
+            Versions: ['$Default'],
+        }).promise();
+        if (!launchTemplates.LaunchTemplateVersions) {
+            console.error(`Unable to describe launch template ${launchTemplateId}`);
+            return;
+        }
+        const launchTemplate = launchTemplates.LaunchTemplateVersions[0];
+        // non-active images
+        imagesToDelete = imagesToDelete.filter(i => i.ImageId != launchTemplate.LaunchTemplateData?.ImageId);
+        // images older than two days to avoid race conditions where an image is created while we're cleaning up
+        imagesToDelete = imagesToDelete.filter(i => i.CreationDate && Date.parse(i.CreationDate) < (Date.now() - 1000 * 60 * 60 * 48));
+        console.log(`${imagesToDelete.length} AMIs left after filtering by date and excluding AMI used by launch template`);
+    }
+    // delete all that we found
+    for (const image of imagesToDelete) {
+        if (!image.ImageId) {
+            console.warn(`No image id? ${JSON.stringify(image)}`);
+            continue;
+        }
+        console.log(`Deregistering ${image.ImageId}`);
+        await ec2.deregisterImage({
+            ImageId: image.ImageId,
+        }).promise();
+        for (const blockMapping of image.BlockDeviceMappings ?? []) {
+            if (blockMapping.Ebs?.SnapshotId) {
+                console.log(`Deleting ${blockMapping.Ebs.SnapshotId}`);
+                await ec2.deleteSnapshot({
+                    SnapshotId: blockMapping.Ebs.SnapshotId,
+                }).promise();
+            }
+        }
+    }
+}
+/* eslint-disable @typescript-eslint/no-require-imports, import/no-extraneous-dependencies */
+exports.handler = async function (event, context) {
+    try {
+        console.log(JSON.stringify({ ...event, ResponseURL: '...' }));
+        switch (event.RequestType) {
+            case 'Scheduled':
+                await deleteAmis(event.LaunchTemplateId, event.StackName, event.BuilderName, false);
+                return;
+            case 'Create':
+            case 'Update':
+                await (0, lambda_helpers_1.customResourceRespond)(event, 'SUCCESS', 'OK', 'DeleteAmis', {});
+                break;
+            case 'Delete':
+                await deleteAmis('', event.ResourceProperties.StackName, event.ResourceProperties.BuilderName, true);
+                await (0, lambda_helpers_1.customResourceRespond)(event, 'SUCCESS', 'OK', event.PhysicalResourceId, {});
+                break;
+        }
+    }
+    catch (e) {
+        console.error(e);
+        if (event.RequestType != 'Scheduled') {
+            await (0, lambda_helpers_1.customResourceRespond)(event, 'FAILED', e.message || 'Internal Error', context.logStreamName, {});
+        }
+    }
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"delete-ami.lambda.js","sourceRoot":"","sources":["../../../src/image-builders/aws-image-builder/delete-ami.lambda.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable-next-line import/no-extraneous-dependencies,import/no-unresolved */\nimport * as AWSLambda from 'aws-lambda';\n/* eslint-disable-next-line import/no-extraneous-dependencies */\nimport * as AWS from 'aws-sdk';\nimport { customResourceRespond } from '../../lambda-helpers';\n\n\nconst ec2 = new AWS.EC2();\n\ntype DeleteAmiInput = {\n  RequestType: 'Scheduled';\n  StackName: string;\n  BuilderName: string;\n  LaunchTemplateId: string;\n}\n\nasync function deleteAmis(launchTemplateId: string, stackName: string, builderName: string, deleteAll: boolean) {\n  // this runs daily and images are built once a week, so there shouldn't be a need for pagination\n  const images = await ec2.describeImages({\n    Owners: ['self'],\n    Filters: [\n      {\n        Name: 'tag:GitHubRunners:Stack',\n        Values: [stackName],\n      },\n      {\n        Name: 'tag:GitHubRunners:Builder',\n        Values: [builderName],\n      },\n    ],\n  }).promise();\n\n  let imagesToDelete = images.Images ?? [];\n\n  console.log(`Found ${imagesToDelete.length} AMIs`);\n  console.log(JSON.stringify(imagesToDelete.map(i => i.ImageId)));\n\n  if (!deleteAll) {\n    // get launch template information to filter out the active image\n    const launchTemplates = await ec2.describeLaunchTemplateVersions({\n      LaunchTemplateId: launchTemplateId,\n      Versions: ['$Default'],\n    }).promise();\n    if (!launchTemplates.LaunchTemplateVersions) {\n      console.error(`Unable to describe launch template ${launchTemplateId}`);\n      return;\n    }\n    const launchTemplate = launchTemplates.LaunchTemplateVersions[0];\n\n    // non-active images\n    imagesToDelete = imagesToDelete.filter(i => i.ImageId != launchTemplate.LaunchTemplateData?.ImageId);\n    // images older than two days to avoid race conditions where an image is created while we're cleaning up\n    imagesToDelete = imagesToDelete.filter(i => i.CreationDate && Date.parse(i.CreationDate) < (Date.now() - 1000 * 60 * 60 * 48));\n\n    console.log(`${imagesToDelete.length} AMIs left after filtering by date and excluding AMI used by launch template`);\n  }\n\n  // delete all that we found\n  for (const image of imagesToDelete) {\n    if (!image.ImageId) {\n      console.warn(`No image id? ${JSON.stringify(image)}`);\n      continue;\n    }\n\n    console.log(`Deregistering ${image.ImageId}`);\n\n    await ec2.deregisterImage({\n      ImageId: image.ImageId,\n    }).promise();\n\n    for (const blockMapping of image.BlockDeviceMappings ?? []) {\n      if (blockMapping.Ebs?.SnapshotId) {\n        console.log(`Deleting ${blockMapping.Ebs.SnapshotId}`);\n\n        await ec2.deleteSnapshot({\n          SnapshotId: blockMapping.Ebs.SnapshotId,\n        }).promise();\n      }\n    }\n  }\n}\n\n/* eslint-disable @typescript-eslint/no-require-imports, import/no-extraneous-dependencies */\nexports.handler = async function (event: DeleteAmiInput | AWSLambda.CloudFormationCustomResourceEvent, context: AWSLambda.Context) {\n  try {\n    console.log(JSON.stringify({ ...event, ResponseURL: '...' }));\n\n    switch (event.RequestType) {\n      case 'Scheduled':\n        await deleteAmis(event.LaunchTemplateId, event.StackName, event.BuilderName, false);\n        return;\n      case 'Create':\n      case 'Update':\n        await customResourceRespond(event, 'SUCCESS', 'OK', 'DeleteAmis', {});\n        break;\n      case 'Delete':\n        await deleteAmis('', event.ResourceProperties.StackName, event.ResourceProperties.BuilderName, true);\n        await customResourceRespond(event, 'SUCCESS', 'OK', event.PhysicalResourceId, {});\n        break;\n    }\n  } catch (e) {\n    console.error(e);\n    if (event.RequestType != 'Scheduled') {\n      await customResourceRespond(event, 'FAILED', (e as Error).message || 'Internal Error', context.logStreamName, {});\n    }\n  }\n};\n"]}

package/lib/{providers/image-builders → image-builders}/aws-image-builder/deprecated/ami.d.ts

@@ -1,7 +1,7 @@
 import { aws_ec2 as ec2, aws_logs as logs, Duration, RemovalPolicy } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { ImageBuilderBase } from './common';
-import { Architecture, Os, RunnerAmi, RunnerImage, RunnerVersion } from '../../../common';
+import { Architecture, Os, RunnerAmi, RunnerImage, RunnerVersion } from '../../../providers/common';
 import { ImageBuilderComponent } from '../builder';
 /**
  * Properties for {@link AmiBuilder} construct.
@@ -82,7 +82,7 @@ export interface AmiBuilderProps {
      */
     readonly logRemovalPolicy?: RemovalPolicy;
     /**
-     * Install Docker inside the image, so it can be used by the runner. You may want to disable this if you are building a Windows image and don't have a Docker Desktop license.
+     * Install Docker inside the image, so it can be used by the runner.
      *
      * @default true
      */

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

@@ -0,0 +1,240 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmiBuilder = 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 common_1 = require("./common");
+const linux_components_1 = require("./linux-components");
+const windows_components_1 = require("./windows-components");
+const common_2 = require("../../../providers/common");
+const utils_1 = require("../../../utils");
+const common_3 = require("../../common");
+const ami_1 = require("../ami");
+const delete_ami_function_1 = require("../delete-ami-function");
+/**
+ * An AMI builder that uses AWS Image Builder to build AMIs pre-baked with all the GitHub Actions runner requirements. Builders can be used with {@link Ec2Runner}.
+ *
+ * Each builder re-runs automatically at a set interval to make sure the AMIs contain the latest versions of everything.
+ *
+ * You can create an instance of this construct to customize the AMI used to spin-up runners. Some runner providers may require custom components. Check the runner provider documentation.
+ *
+ * For example, to set a specific runner version, rebuild the image every 2 weeks, and add a few packages for the EC2 provider, use:
+ *
+ * ```
+ * const builder = new AmiBuilder(this, 'Builder', {
+ *     runnerVersion: RunnerVersion.specific('2.293.0'),
+ *     rebuildInterval: Duration.days(14),
+ * });
+ * builder.addComponent(new ImageBuilderComponent(scope, id, {
+ *   platform: 'Linux',
+ *   displayName: 'p7zip',
+ *   description: 'Install some more packages',
+ *   commands: [
+ *     'apt-get install p7zip',
+ *   ],
+ * }));
+ * new Ec2Runner(this, 'EC2 provider', {
+ *     label: 'custom-ec2',
+ *     amiBuilder: builder,
+ * });
+ * ```
+ *
+ * @deprecated use RunnerImageBuilder
+ */
+class AmiBuilder extends common_1.ImageBuilderBase {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            os: props?.os,
+            supportedOs: [common_2.Os.LINUX, common_2.Os.LINUX_UBUNTU, common_2.Os.LINUX_AMAZON_2, common_2.Os.WINDOWS],
+            architecture: props?.architecture,
+            supportedArchitectures: [common_2.Architecture.X86_64, common_2.Architecture.ARM64],
+            instanceType: props?.instanceType,
+            vpc: props?.vpc,
+            securityGroups: props?.securityGroup ? [props.securityGroup] : props?.securityGroups,
+            subnetSelection: props?.subnetSelection,
+            logRemovalPolicy: props?.logRemovalPolicy,
+            logRetention: props?.logRetention,
+            runnerVersion: props?.runnerVersion,
+            rebuildInterval: props?.rebuildInterval,
+            imageTypeName: 'AMI',
+        });
+        // add all basic components
+        if (this.os.is(common_2.Os.WINDOWS)) {
+            this.addBaseWindowsComponents(props?.installDocker ?? true);
+        }
+        else if (this.os.is(common_2.Os.LINUX) || this.os.is(common_2.Os.LINUX_UBUNTU)) {
+            this.addBaseLinuxComponents(props?.installDocker ?? true);
+        }
+        else {
+            throw new Error(`Unsupported OS for AMI builder: ${this.os.name}`);
+        }
+    }
+    addBaseWindowsComponents(installDocker) {
+        this.addComponent(windows_components_1.WindowsComponents.cloudwatchAgent(this, 'CloudWatch agent'));
+        this.addComponent(windows_components_1.WindowsComponents.awsCli(this, 'AWS CLI'));
+        this.addComponent(windows_components_1.WindowsComponents.githubCli(this, 'GitHub CLI'));
+        this.addComponent(windows_components_1.WindowsComponents.git(this, 'git'));
+        this.addComponent(windows_components_1.WindowsComponents.githubRunner(this, 'GitHub Actions Runner', this.runnerVersion));
+        if (installDocker) {
+            this.addComponent(windows_components_1.WindowsComponents.docker(this, 'Docker'));
+        }
+    }
+    addBaseLinuxComponents(installDocker) {
+        this.addComponent(linux_components_1.LinuxUbuntuComponents.requiredPackages(this, 'Upgrade packages and install basics', this.architecture));
+        this.addComponent(linux_components_1.LinuxUbuntuComponents.runnerUser(this, 'User', this.architecture));
+        this.addComponent(linux_components_1.LinuxUbuntuComponents.awsCli(this, 'AWS CLI', this.architecture));
+        this.addComponent(linux_components_1.LinuxUbuntuComponents.githubCli(this, 'GitHub CLI', this.architecture));
+        this.addComponent(linux_components_1.LinuxUbuntuComponents.git(this, 'git', this.architecture));
+        this.addComponent(linux_components_1.LinuxUbuntuComponents.githubRunner(this, 'GitHub Actions Runner', this.runnerVersion, this.architecture));
+        if (installDocker) {
+            this.addComponent(linux_components_1.LinuxUbuntuComponents.docker(this, 'Docker', this.architecture));
+        }
+    }
+    /**
+     * 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.boundAmi) {
+            throw new Error('AMI 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.boundAmi) {
+            throw new Error('AMI 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.
+     *
+     * @param path path to directory containing a file called certs.pem containing all the required certificates
+     */
+    addExtraCertificates(path) {
+        if (this.platform == 'Linux') {
+            this.prependComponent(linux_components_1.LinuxUbuntuComponents.extraCertificates(this, 'Extra Certs', path));
+        }
+        else if (this.platform == 'Windows') {
+            this.prependComponent(windows_components_1.WindowsComponents.extraCertificates(this, 'Extra Certs', path));
+        }
+        else {
+            throw new Error(`Unknown platform: ${this.platform}`);
+        }
+    }
+    /**
+     * Called by IRunnerProvider to finalize settings and create the AMI builder.
+     */
+    bindAmi() {
+        if (this.boundAmi) {
+            return this.boundAmi;
+        }
+        const launchTemplate = new aws_cdk_lib_1.aws_ec2.LaunchTemplate(this, 'Launch template', {
+            requireImdsv2: true,
+        });
+        const stackName = cdk.Stack.of(this).stackName;
+        const builderName = this.node.path;
+        const dist = new aws_cdk_lib_1.aws_imagebuilder.CfnDistributionConfiguration(this, 'Distribution', {
+            name: (0, common_3.uniqueImageBuilderName)(this),
+            description: this.description,
+            distributions: [
+                {
+                    region: aws_cdk_lib_1.Stack.of(this).region,
+                    amiDistributionConfiguration: {
+                        Name: `${cdk.Names.uniqueResourceName(this, {
+                            maxLength: 100,
+                            separator: '-',
+                            allowedSpecialCharacters: '_-',
+                        })}-{{ imagebuilder:buildDate }}`,
+                        AmiTags: {
+                            'Name': this.node.id,
+                            'GitHubRunners:Stack': stackName,
+                            'GitHubRunners:Builder': builderName,
+                        },
+                    },
+                    launchTemplateConfigurations: [
+                        {
+                            launchTemplateId: launchTemplate.launchTemplateId,
+                        },
+                    ],
+                },
+            ],
+        });
+        const recipe = new ami_1.AmiRecipe(this, 'Ami Recipe', {
+            platform: this.platform,
+            components: this.components,
+            architecture: this.architecture,
+            baseAmi: (0, ami_1.defaultBaseAmi)(this, this.os, this.architecture),
+        });
+        const log = this.createLog(recipe.name);
+        const infra = this.createInfrastructure([
+            aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+            aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilder'),
+        ]);
+        this.createImage(infra, dist, log, recipe.arn, undefined);
+        this.createPipeline(infra, dist, log, recipe.arn, undefined);
+        this.boundAmi = {
+            launchTemplate: launchTemplate,
+            architecture: this.architecture,
+            os: this.os,
+            logGroup: log,
+            runnerVersion: this.runnerVersion,
+        };
+        this.imageCleaner(launchTemplate, stackName, builderName);
+        return this.boundAmi;
+    }
+    imageCleaner(launchTemplate, stackName, builderName) {
+        const deleter = (0, utils_1.singletonLambda)(delete_ami_function_1.DeleteAmiFunction, this, 'delete-ami', {
+            description: 'Delete old GitHub Runner AMIs',
+            initialPolicy: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['ec2:DescribeLaunchTemplateVersions', 'ec2:DescribeImages', 'ec2:DeregisterImage', 'ec2:DeleteSnapshot'],
+                    resources: ['*'],
+                }),
+            ],
+            timeout: cdk.Duration.minutes(5),
+            logRetention: aws_cdk_lib_1.aws_logs.RetentionDays.ONE_MONTH,
+        });
+        // delete old AMIs on schedule
+        const eventRule = new aws_cdk_lib_1.aws_events.Rule(this, 'Delete AMI Schedule', {
+            schedule: aws_cdk_lib_1.aws_events.Schedule.rate(cdk.Duration.days(1)),
+            description: `Delete old AMIs for ${builderName}`,
+        });
+        eventRule.addTarget(new aws_cdk_lib_1.aws_events_targets.LambdaFunction(deleter, {
+            event: aws_cdk_lib_1.aws_events.RuleTargetInput.fromObject({
+                RequestType: 'Scheduled',
+                LaunchTemplateId: launchTemplate.launchTemplateId,
+                StackName: stackName,
+                BuilderName: builderName,
+            }),
+        }));
+        // delete all AMIs when this construct is removed
+        new aws_cdk_lib_1.CustomResource(this, 'AMI Deleter', {
+            serviceToken: deleter.functionArn,
+            resourceType: 'Custom::AmiDeleter',
+            properties: {
+                StackName: stackName,
+                BuilderName: builderName,
+            },
+        });
+    }
+    bindDockerImage() {
+        throw new Error('AmiBuilder cannot be used to build Docker images');
+    }
+}
+_a = JSII_RTTI_SYMBOL_1;
+AmiBuilder[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.AmiBuilder", version: "0.9.5" };
+exports.AmiBuilder = AmiBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ami.js","sourceRoot":"","sources":["../../../../src/image-builders/aws-image-builder/deprecated/ami.ts"],"names":[],"mappings":"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","sourcesContent":["import * 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_imagebuilder as imagebuilder,\n  aws_logs as logs,\n  CustomResource,\n  Duration,\n  RemovalPolicy,\n  Stack,\n} from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { ImageBuilderBase } from './common';\nimport { LinuxUbuntuComponents } from './linux-components';\nimport { WindowsComponents } from './windows-components';\nimport { Architecture, Os, RunnerAmi, RunnerImage, RunnerVersion } from '../../../providers/common';\nimport { singletonLambda } from '../../../utils';\nimport { uniqueImageBuilderName } from '../../common';\nimport { AmiRecipe, defaultBaseAmi } from '../ami';\nimport { ImageBuilderComponent } from '../builder';\nimport { DeleteAmiFunction } from '../delete-ami-function';\n\n/**\n * Properties for {@link AmiBuilder} construct.\n */\nexport interface AmiBuilderProps {\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 AMI to be rebuilt every given interval. Useful for keeping the AMI 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 where builder instances will be launched.\n   *\n   * @default default account VPC\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group to assign to launched builder instances.\n   *\n   * @default new security group\n   *\n   * @deprecated use {@link securityGroups}\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Security groups to assign to launched builder instances.\n   *\n   * @default new security group\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n\n  /**\n   * Where to place the network interfaces within the VPC. Only the first matched subnet will be used.\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 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   * Install Docker inside the image, so it can be used by the runner.\n   *\n   * @default true\n   */\n  readonly installDocker?: boolean;\n}\n\n/**\n * An AMI builder that uses AWS Image Builder to build AMIs pre-baked with all the GitHub Actions runner requirements. Builders can be used with {@link Ec2Runner}.\n *\n * Each builder re-runs automatically at a set interval to make sure the AMIs contain the latest versions of everything.\n *\n * You can create an instance of this construct to customize the AMI used to spin-up runners. Some runner providers may require custom components. Check the runner provider documentation.\n *\n * For example, to set a specific runner version, rebuild the image every 2 weeks, and add a few packages for the EC2 provider, use:\n *\n * ```\n * const builder = new AmiBuilder(this, 'Builder', {\n *     runnerVersion: RunnerVersion.specific('2.293.0'),\n *     rebuildInterval: Duration.days(14),\n * });\n * builder.addComponent(new ImageBuilderComponent(scope, id, {\n *   platform: 'Linux',\n *   displayName: 'p7zip',\n *   description: 'Install some more packages',\n *   commands: [\n *     'apt-get install p7zip',\n *   ],\n * }));\n * new Ec2Runner(this, 'EC2 provider', {\n *     label: 'custom-ec2',\n *     amiBuilder: builder,\n * });\n * ```\n *\n * @deprecated use RunnerImageBuilder\n */\nexport class AmiBuilder extends ImageBuilderBase {\n  private boundAmi?: RunnerAmi;\n\n  constructor(scope: Construct, id: string, props?: AmiBuilderProps) {\n    super(scope, id, {\n      os: props?.os,\n      supportedOs: [Os.LINUX, Os.LINUX_UBUNTU, Os.LINUX_AMAZON_2, Os.WINDOWS],\n      architecture: props?.architecture,\n      supportedArchitectures: [Architecture.X86_64, Architecture.ARM64],\n      instanceType: props?.instanceType,\n      vpc: props?.vpc,\n      securityGroups: props?.securityGroup ? [props.securityGroup] : props?.securityGroups,\n      subnetSelection: props?.subnetSelection,\n      logRemovalPolicy: props?.logRemovalPolicy,\n      logRetention: props?.logRetention,\n      runnerVersion: props?.runnerVersion,\n      rebuildInterval: props?.rebuildInterval,\n      imageTypeName: 'AMI',\n    });\n\n    // add all basic components\n    if (this.os.is(Os.WINDOWS)) {\n      this.addBaseWindowsComponents(props?.installDocker ?? true);\n    } else if (this.os.is(Os.LINUX) || this.os.is(Os.LINUX_UBUNTU)) {\n      this.addBaseLinuxComponents(props?.installDocker ?? true);\n    } else {\n      throw new Error(`Unsupported OS for AMI builder: ${this.os.name}`);\n    }\n  }\n\n  private addBaseWindowsComponents(installDocker: boolean) {\n    this.addComponent(WindowsComponents.cloudwatchAgent(this, 'CloudWatch agent'));\n    this.addComponent(WindowsComponents.awsCli(this, 'AWS CLI'));\n    this.addComponent(WindowsComponents.githubCli(this, 'GitHub CLI'));\n    this.addComponent(WindowsComponents.git(this, 'git'));\n    this.addComponent(WindowsComponents.githubRunner(this, 'GitHub Actions Runner', this.runnerVersion));\n    if (installDocker) {\n      this.addComponent(WindowsComponents.docker(this, 'Docker'));\n    }\n  }\n\n  private addBaseLinuxComponents(installDocker: boolean) {\n    this.addComponent(LinuxUbuntuComponents.requiredPackages(this, 'Upgrade packages and install basics', this.architecture));\n    this.addComponent(LinuxUbuntuComponents.runnerUser(this, 'User', this.architecture));\n    this.addComponent(LinuxUbuntuComponents.awsCli(this, 'AWS CLI', this.architecture));\n    this.addComponent(LinuxUbuntuComponents.githubCli(this, 'GitHub CLI', this.architecture));\n    this.addComponent(LinuxUbuntuComponents.git(this, 'git', this.architecture));\n    this.addComponent(LinuxUbuntuComponents.githubRunner(this, 'GitHub Actions Runner', this.runnerVersion, this.architecture));\n    if (installDocker) {\n      this.addComponent(LinuxUbuntuComponents.docker(this, 'Docker', this.architecture));\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.boundAmi) {\n      throw new Error('AMI 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.boundAmi) {\n      throw new Error('AMI 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   * @param path path to directory containing a file called certs.pem containing all the required certificates\n   */\n  public addExtraCertificates(path: string) {\n    if (this.platform == 'Linux') {\n      this.prependComponent(LinuxUbuntuComponents.extraCertificates(this, 'Extra Certs', path));\n    } else if (this.platform == 'Windows') {\n      this.prependComponent(WindowsComponents.extraCertificates(this, 'Extra Certs', path));\n    } else {\n      throw new Error(`Unknown platform: ${this.platform}`);\n    }\n  }\n\n  /**\n   * Called by IRunnerProvider to finalize settings and create the AMI builder.\n   */\n  bindAmi(): RunnerAmi {\n    if (this.boundAmi) {\n      return this.boundAmi;\n    }\n\n    const launchTemplate = new ec2.LaunchTemplate(this, 'Launch template', {\n      requireImdsv2: true,\n    });\n\n    const stackName = cdk.Stack.of(this).stackName;\n    const builderName = this.node.path;\n\n    const dist = new imagebuilder.CfnDistributionConfiguration(this, 'Distribution', {\n      name: uniqueImageBuilderName(this),\n      description: this.description,\n      distributions: [\n        {\n          region: Stack.of(this).region,\n          amiDistributionConfiguration: {\n            Name: `${cdk.Names.uniqueResourceName(this, {\n              maxLength: 100,\n              separator: '-',\n              allowedSpecialCharacters: '_-',\n            })}-{{ imagebuilder:buildDate }}`,\n            AmiTags: {\n              'Name': this.node.id,\n              'GitHubRunners:Stack': stackName,\n              'GitHubRunners:Builder': builderName,\n            },\n          },\n          launchTemplateConfigurations: [\n            {\n              launchTemplateId: launchTemplate.launchTemplateId,\n            },\n          ],\n        },\n      ],\n    });\n\n    const recipe = new AmiRecipe(this, 'Ami Recipe', {\n      platform: this.platform,\n      components: this.components,\n      architecture: this.architecture,\n      baseAmi: defaultBaseAmi(this, this.os, this.architecture),\n    });\n\n    const log = this.createLog(recipe.name);\n    const infra = this.createInfrastructure([\n      iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),\n      iam.ManagedPolicy.fromAwsManagedPolicyName('EC2InstanceProfileForImageBuilder'),\n    ]);\n    this.createImage(infra, dist, log, recipe.arn, undefined);\n    this.createPipeline(infra, dist, log, recipe.arn, undefined);\n\n    this.boundAmi = {\n      launchTemplate: launchTemplate,\n      architecture: this.architecture,\n      os: this.os,\n      logGroup: log,\n      runnerVersion: this.runnerVersion,\n    };\n\n    this.imageCleaner(launchTemplate, stackName, builderName);\n\n    return this.boundAmi;\n  }\n\n  private imageCleaner(launchTemplate: ec2.LaunchTemplate, stackName: string, builderName: string) {\n    const deleter = singletonLambda(DeleteAmiFunction, this, 'delete-ami', {\n      description: 'Delete old GitHub Runner AMIs',\n      initialPolicy: [\n        new iam.PolicyStatement({\n          actions: ['ec2:DescribeLaunchTemplateVersions', 'ec2:DescribeImages', 'ec2:DeregisterImage', 'ec2:DeleteSnapshot'],\n          resources: ['*'],\n        }),\n      ],\n      timeout: cdk.Duration.minutes(5),\n      logRetention: logs.RetentionDays.ONE_MONTH,\n    });\n\n    // delete old AMIs on schedule\n    const eventRule = new events.Rule(this, 'Delete AMI Schedule', {\n      schedule: events.Schedule.rate(cdk.Duration.days(1)),\n      description: `Delete old AMIs for ${builderName}`,\n    });\n    eventRule.addTarget(new events_targets.LambdaFunction(deleter, {\n      event: events.RuleTargetInput.fromObject({\n        RequestType: 'Scheduled',\n        LaunchTemplateId: launchTemplate.launchTemplateId,\n        StackName: stackName,\n        BuilderName: builderName,\n      }),\n    }));\n\n    // delete all AMIs when this construct is removed\n    new CustomResource(this, 'AMI Deleter', {\n      serviceToken: deleter.functionArn,\n      resourceType: 'Custom::AmiDeleter',\n      properties: {\n        StackName: stackName,\n        BuilderName: builderName,\n      },\n    });\n  }\n\n  bindDockerImage(): RunnerImage {\n    throw new Error('AmiBuilder cannot be used to build Docker images');\n  }\n}\n"]}

package/lib/{providers/image-builders → image-builders}/aws-image-builder/deprecated/common.d.ts

@@ -1,6 +1,6 @@
 import { aws_ec2 as ec2, aws_iam as iam, aws_imagebuilder as imagebuilder, aws_logs as logs } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import { Architecture, Os, RunnerAmi, RunnerImage, RunnerVersion } from '../../../common';
+import { Architecture, Os, RunnerAmi, RunnerImage, RunnerVersion } from '../../../providers/common';
 import { ImageBuilderBaseProps, IRunnerImageBuilder } from '../../common';
 import { ImageBuilderComponent } from '../builder';
 /**