@cloudsnorkel/cdk-github-runners 0.5.8 → 0.6.1

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

@@ -0,0 +1,131 @@
+import { aws_ec2 as ec2, aws_logs as logs, Duration, RemovalPolicy } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { Architecture, IAmiBuilder, Os, RunnerAmi, RunnerVersion } from '../common';
+import { ImageBuilderBase, ImageBuilderComponent } from './common';
+/**
+ * Properties for {@link AmiBuilder} construct.
+ */
+export interface AmiBuilderProps {
+    /**
+     * Image architecture.
+     *
+     * @default Architecture.X86_64
+     */
+    readonly architecture?: Architecture;
+    /**
+     * Image OS.
+     *
+     * @default OS.LINUX
+     */
+    readonly os?: Os;
+    /**
+     * Version of GitHub Runners to install.
+     *
+     * @default latest version available
+     */
+    readonly runnerVersion?: RunnerVersion;
+    /**
+     * 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.
+     *
+     * Set to zero to disable.
+     *
+     * @default Duration.days(7)
+     */
+    readonly rebuildInterval?: Duration;
+    /**
+     * VPC where builder instances will be launched.
+     *
+     * @default default account VPC
+     */
+    readonly vpc?: ec2.IVpc;
+    /**
+     * Security Group to assign to launched builder instances.
+     *
+     * @default default account security group
+     */
+    readonly securityGroup?: ec2.ISecurityGroup;
+    /**
+     * Where to place the network interfaces within the VPC.
+     *
+     * @default default VPC subnet
+     */
+    readonly subnetSelection?: ec2.SubnetSelection;
+    /**
+     * The instance type used to build the image.
+     *
+     * @default m5.large
+     */
+    readonly instanceType?: ec2.InstanceType;
+    /**
+     * The number of days log events are kept in CloudWatch Logs. When updating
+     * this property, unsetting it doesn't remove the log retention policy. To
+     * remove the retention policy, set the value to `INFINITE`.
+     *
+     * @default logs.RetentionDays.ONE_MONTH
+     */
+    readonly logRetention?: logs.RetentionDays;
+    /**
+     * 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.
+     *
+     * We try to not leave anything behind when removed. But sometimes a log staying behind is useful.
+     *
+     * @default RemovalPolicy.DESTROY
+     */
+    readonly logRemovalPolicy?: RemovalPolicy;
+}
+/**
+ * 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: [
+ *     'set -ex',
+ *     'apt-get install p7zip',
+ *   ],
+ * }));
+ * new Ec2Runner(this, 'EC2 provider', {
+ *     label: 'custom-ec2',
+ *     amiBuilder: builder,
+ * });
+ * ```
+ */
+export declare class AmiBuilder extends ImageBuilderBase implements IAmiBuilder {
+    private boundAmi?;
+    constructor(scope: Construct, id: string, props?: AmiBuilderProps);
+    private addBaseWindowsComponents;
+    private addBaseLinuxComponents;
+    /**
+     * Add a component to be installed before any other components. Useful for required system settings like certificates or proxy settings.
+     * @param component
+     */
+    prependComponent(component: ImageBuilderComponent): void;
+    /**
+     * Add a component to be installed.
+     * @param component
+     */
+    addComponent(component: ImageBuilderComponent): void;
+    /**
+     * 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: string): void;
+    /**
+     * Called by IRunnerProvider to finalize settings and create the AMI builder.
+     */
+    bind(): RunnerAmi;
+    private imageCleaner;
+}

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

@@ -0,0 +1,274 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AmiBuilder = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const utils_1 = require("../../utils");
+const common_1 = require("../common");
+const common_2 = require("./common");
+const linux_components_1 = require("./linux-components");
+const windows_components_1 = require("./windows-components");
+/**
+ * Image builder recipe for Amazon Machine Image (AMI).
+ */
+class AmiRecipe extends common_2.ImageBuilderObjectBase {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const name = common_2.uniqueImageBuilderName(this);
+        let components = props.components.map(component => {
+            return {
+                componentArn: component.arn,
+            };
+        });
+        let parentAmi;
+        let workingDirectory;
+        if (props.platform == 'Linux') {
+            let archUrl;
+            if (props.architecture.is(common_1.Architecture.X86_64)) {
+                archUrl = 'amd64';
+            }
+            else if (props.architecture.is(common_1.Architecture.ARM64)) {
+                archUrl = 'arm64';
+            }
+            else {
+                throw new Error(`Unsupported architecture for parent AMI: ${props.architecture.name}`);
+            }
+            parentAmi = aws_cdk_lib_1.aws_ec2.MachineImage.fromSsmParameter(`/aws/service/canonical/ubuntu/server/focal/stable/current/${archUrl}/hvm/ebs-gp2/ami-id`, {
+                os: aws_cdk_lib_1.aws_ec2.OperatingSystemType.LINUX,
+            }).getImage(this).imageId;
+            workingDirectory = '/home/runner';
+        }
+        else if (props.platform == 'Windows') {
+            parentAmi = aws_cdk_lib_1.aws_ec2.MachineImage.latestWindows(aws_cdk_lib_1.aws_ec2.WindowsVersion.WINDOWS_SERVER_2022_ENGLISH_FULL_CONTAINERSLATEST).getImage(this).imageId;
+            workingDirectory = 'C:/'; // must exist or Image Builder fails and must not be empty or git will stall installing from the default windows\system32
+        }
+        else {
+            throw new Error(`Unsupported AMI recipe platform: ${props.platform}`);
+        }
+        const recipe = new aws_cdk_lib_1.aws_imagebuilder.CfnImageRecipe(this, 'Recipe', {
+            name: name,
+            version: this.version('ImageRecipe', name, {
+                platform: props.platform,
+                components,
+            }),
+            parentImage: parentAmi,
+            components,
+            workingDirectory,
+        });
+        this.arn = recipe.attrArn;
+        this.name = name;
+    }
+}
+/**
+ * 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: [
+ *     'set -ex',
+ *     'apt-get install p7zip',
+ *   ],
+ * }));
+ * new Ec2Runner(this, 'EC2 provider', {
+ *     label: 'custom-ec2',
+ *     amiBuilder: builder,
+ * });
+ * ```
+ */
+class AmiBuilder extends common_2.ImageBuilderBase {
+    constructor(scope, id, props) {
+        super(scope, id, {
+            os: props?.os,
+            supportedOs: [common_1.Os.LINUX, common_1.Os.WINDOWS],
+            architecture: props?.architecture,
+            supportedArchitectures: [common_1.Architecture.X86_64, common_1.Architecture.ARM64],
+            instanceType: props?.instanceType,
+            vpc: props?.vpc,
+            securityGroup: props?.securityGroup,
+            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_1.Os.WINDOWS)) {
+            this.addBaseWindowsComponents();
+        }
+        else if (this.os.is(common_1.Os.LINUX)) {
+            this.addBaseLinuxComponents();
+        }
+    }
+    addBaseWindowsComponents() {
+        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));
+        this.addComponent(windows_components_1.WindowsComponents.docker(this, 'Docker'));
+    }
+    addBaseLinuxComponents() {
+        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));
+        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) {
+        this.prependComponent(new common_2.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 AMI builder.
+     */
+    bind() {
+        if (this.boundAmi) {
+            return this.boundAmi;
+        }
+        const launchTemplate = new aws_cdk_lib_1.aws_ec2.LaunchTemplate(this, 'Launch template');
+        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: common_2.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 AmiRecipe(this, 'Ami Recipe', {
+            platform: this.platform,
+            components: this.components,
+            architecture: 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 = utils_1.BundledNodejsFunction.singleton(this, 'delete-ami', {
+            initialPolicy: [
+                new aws_cdk_lib_1.aws_iam.PolicyStatement({
+                    actions: ['ec2:DescribeLaunchTemplateVersions', 'ec2:DescribeImages', 'ec2:DeregisterImage'],
+                    resources: ['*'],
+                }),
+            ],
+            timeout: cdk.Duration.minutes(5),
+        });
+        // 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,
+            },
+        });
+    }
+}
+exports.AmiBuilder = AmiBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ami.js","sourceRoot":"","sources":["../../../src/providers/image-builders/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  aws_s3_assets as s3_assets, CustomResource,\n  Duration,\n  RemovalPolicy,\n  Stack,\n} from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { BundledNodejsFunction } from '../../utils';\nimport { Architecture, IAmiBuilder, Os, RunnerAmi, RunnerVersion } from '../common';\nimport { ImageBuilderBase, ImageBuilderComponent, ImageBuilderObjectBase, uniqueImageBuilderName } from './common';\nimport { LinuxUbuntuComponents } from './linux-components';\nimport { WindowsComponents } from './windows-components';\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 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 logs can still be viewed, and you can see why the build failed.\n   *\n   * We try to not leave anything behind when removed. But sometimes a log staying behind is useful.\n   *\n   * @default RemovalPolicy.DESTROY\n   */\n  readonly logRemovalPolicy?: RemovalPolicy;\n}\n\n/**\n * Properties for AmiRecipe construct.\n */\ninterface AmiRecipeProperties {\n  /**\n   * Target platform. Must match builder platform.\n   */\n  readonly platform: 'Linux' | 'Windows';\n\n  /**\n   * Target architecture. Must match builder platform.\n   */\n  readonly architecture: Architecture;\n\n  /**\n   * Components to add to target container image.\n   */\n  readonly components: ImageBuilderComponent[];\n}\n\n/**\n * Image builder recipe for Amazon Machine Image (AMI).\n */\nclass AmiRecipe extends ImageBuilderObjectBase {\n  public readonly arn: string;\n  public readonly name: string;\n\n  constructor(scope: Construct, id: string, props: AmiRecipeProperties) {\n    super(scope, id);\n\n    const name = uniqueImageBuilderName(this);\n\n    let components = props.components.map(component => {\n      return {\n        componentArn: component.arn,\n      };\n    });\n\n    let parentAmi;\n    let workingDirectory;\n    if (props.platform == 'Linux') {\n      let archUrl;\n      if (props.architecture.is(Architecture.X86_64)) {\n        archUrl = 'amd64';\n      } else if (props.architecture.is(Architecture.ARM64)) {\n        archUrl = 'arm64';\n      } else {\n        throw new Error(`Unsupported architecture for parent AMI: ${props.architecture.name}`);\n      }\n      parentAmi = ec2.MachineImage.fromSsmParameter(\n        `/aws/service/canonical/ubuntu/server/focal/stable/current/${archUrl}/hvm/ebs-gp2/ami-id`,\n        {\n          os: ec2.OperatingSystemType.LINUX,\n        },\n      ).getImage(this).imageId;\n      workingDirectory = '/home/runner';\n    } else if (props.platform == 'Windows') {\n      parentAmi = ec2.MachineImage.latestWindows(ec2.WindowsVersion.WINDOWS_SERVER_2022_ENGLISH_FULL_CONTAINERSLATEST).getImage(this).imageId;\n      workingDirectory = 'C:/'; // must exist or Image Builder fails and must not be empty or git will stall installing from the default windows\\system32\n    } else {\n      throw new Error(`Unsupported AMI recipe platform: ${props.platform}`);\n    }\n\n    const recipe = new imagebuilder.CfnImageRecipe(this, 'Recipe', {\n      name: name,\n      version: this.version('ImageRecipe', name, {\n        platform: props.platform,\n        components,\n      }),\n      parentImage: parentAmi,\n      components,\n      workingDirectory,\n    });\n\n    this.arn = recipe.attrArn;\n    this.name = name;\n  }\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 *     'set -ex',\n *     'apt-get install p7zip',\n *   ],\n * }));\n * new Ec2Runner(this, 'EC2 provider', {\n *     label: 'custom-ec2',\n *     amiBuilder: builder,\n * });\n * ```\n */\nexport class AmiBuilder extends ImageBuilderBase implements IAmiBuilder {\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.WINDOWS],\n      architecture: props?.architecture,\n      supportedArchitectures: [Architecture.X86_64, Architecture.ARM64],\n      instanceType: props?.instanceType,\n      vpc: props?.vpc,\n      securityGroup: props?.securityGroup,\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();\n    } else if (this.os.is(Os.LINUX)) {\n      this.addBaseLinuxComponents();\n    }\n  }\n\n  private addBaseWindowsComponents() {\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    this.addComponent(WindowsComponents.docker(this, 'Docker'));\n  }\n\n  private addBaseLinuxComponents() {\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    this.addComponent(LinuxUbuntuComponents.docker(this, 'Docker', this.architecture));\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    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 AMI builder.\n   */\n  bind(): RunnerAmi {\n    if (this.boundAmi) {\n      return this.boundAmi;\n    }\n\n    const launchTemplate = new ec2.LaunchTemplate(this, 'Launch template');\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    });\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 = BundledNodejsFunction.singleton(this, 'delete-ami', {\n      initialPolicy: [\n        new iam.PolicyStatement({\n          actions: ['ec2:DescribeLaunchTemplateVersions', 'ec2:DescribeImages', 'ec2:DeregisterImage'],\n          resources: ['*'],\n        }),\n      ],\n      timeout: cdk.Duration.minutes(5),\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"]}