@cloudsnorkel/cdk-github-runners 0.8.4 → 0.9.1

package/lib/providers/ecs.js

@@ -0,0 +1,258 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EcsRunnerProvider = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const autoscaling = require("aws-cdk-lib/aws-autoscaling");
+const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
+const common_1 = require("./common");
+const fargate_1 = require("./fargate");
+const image_builders_1 = require("./image-builders");
+class EcsEc2LaunchTarget {
+    constructor(props) {
+        this.props = props;
+    }
+    /**
+     * Called when the ECS launch type configured on RunTask
+     */
+    bind(_task, _launchTargetOptions) {
+        return {
+            parameters: {
+                PropagateTags: aws_cdk_lib_1.aws_ecs.PropagatedTagSource.TASK_DEFINITION,
+                CapacityProviderStrategy: [
+                    {
+                        CapacityProvider: this.props.capacityProvider,
+                    },
+                ],
+            },
+        };
+    }
+}
+/**
+ * GitHub Actions runner provider using ECS on EC2 to execute jobs.
+ *
+ * ECS can be useful when you want more control of the infrastructure running the GitHub Actions Docker containers. You can control the autoscaling
+ * group to scale down to zero during the night and scale up during work hours. This way you can still save money, but have to wait less for
+ * infrastructure to spin up.
+ *
+ * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.
+ */
+class EcsRunnerProvider extends common_1.BaseProvider {
+    /**
+     * Create new image builder that builds ECS specific runner images using Ubuntu.
+     *
+     * Included components:
+     *  * `RunnerImageComponent.requiredPackages()`
+     *  * `RunnerImageComponent.runnerUser()`
+     *  * `RunnerImageComponent.git()`
+     *  * `RunnerImageComponent.githubCli()`
+     *  * `RunnerImageComponent.awsCli()`
+     *  * `RunnerImageComponent.dockerInDocker()`
+     *  * `RunnerImageComponent.githubRunner()`
+     */
+    static imageBuilder(scope, id, props) {
+        return image_builders_1.RunnerImageBuilder.new(scope, id, {
+            os: common_1.Os.LINUX_UBUNTU,
+            architecture: common_1.Architecture.X86_64,
+            components: [
+                image_builders_1.RunnerImageComponent.requiredPackages(),
+                image_builders_1.RunnerImageComponent.runnerUser(),
+                image_builders_1.RunnerImageComponent.git(),
+                image_builders_1.RunnerImageComponent.githubCli(),
+                image_builders_1.RunnerImageComponent.awsCli(),
+                image_builders_1.RunnerImageComponent.dockerInDocker(),
+                image_builders_1.RunnerImageComponent.githubRunner(props?.runnerVersion ?? common_1.RunnerVersion.latest()),
+            ],
+            ...props,
+        });
+    }
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.labels = props?.labels ?? ['ecs'];
+        this.vpc = props?.vpc ?? aws_cdk_lib_1.aws_ec2.Vpc.fromLookup(this, 'default vpc', { isDefault: true });
+        this.subnetSelection = props?.subnetSelection;
+        this.securityGroups = props?.securityGroups ?? [new aws_cdk_lib_1.aws_ec2.SecurityGroup(this, 'security group', { vpc: this.vpc })];
+        this.connections = new aws_cdk_lib_1.aws_ec2.Connections({ securityGroups: this.securityGroups });
+        this.assignPublicIp = props?.assignPublicIp ?? true;
+        this.cluster = props?.cluster ? props.cluster : new aws_cdk_lib_1.aws_ecs.Cluster(this, 'cluster', {
+            vpc: this.vpc,
+            enableFargateCapacityProviders: false,
+        });
+        const imageBuilder = props?.imageBuilder ?? EcsRunnerProvider.imageBuilder(this, 'Image Builder');
+        const image = this.image = imageBuilder.bindDockerImage();
+        if (props?.capacityProvider && (props?.minInstances || props?.maxInstances || props?.instanceType || props?.storageSize)) {
+            cdk.Annotations.of(this).addWarning('When using a custom capacity provider, minInstances, maxInstances, instanceType and storageSize will be ignored.');
+        }
+        this.capacityProvider = props?.capacityProvider ?? new aws_cdk_lib_1.aws_ecs.AsgCapacityProvider(this, 'Capacity Provider', {
+            autoScalingGroup: new autoscaling.AutoScalingGroup(this, 'Auto Scaling Group', {
+                vpc: this.vpc,
+                vpcSubnets: this.subnetSelection,
+                minCapacity: props?.minInstances ?? 0,
+                maxCapacity: props?.maxInstances ?? 5,
+                machineImage: this.defaultClusterInstanceAmi(),
+                instanceType: props?.instanceType ?? this.defaultClusterInstanceType(),
+                blockDevices: props?.storageSize ? [
+                    {
+                        deviceName: '/dev/sda1',
+                        volume: {
+                            ebsDevice: {
+                                volumeSize: props?.storageSize?.toGibibytes(),
+                                deleteOnTermination: true,
+                            },
+                        },
+                    },
+                ] : undefined,
+                spotPrice: props?.spotMaxPrice,
+            }),
+            spotInstanceDraining: false, // waste of money to restart jobs as the restarted job won't have a token
+        });
+        this.securityGroups.map(sg => this.capacityProvider.autoScalingGroup.addSecurityGroup(sg));
+        this.capacityProvider.autoScalingGroup.role.addManagedPolicy(aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'));
+        this.capacityProvider.autoScalingGroup.addUserData(this.loginCommand(), this.pullCommand());
+        image.imageRepository.grantPull(this.capacityProvider.autoScalingGroup);
+        this.cluster.addAsgCapacityProvider(this.capacityProvider, {
+            spotInstanceDraining: false,
+            machineImageType: aws_ecs_1.MachineImageType.AMAZON_LINUX_2,
+        });
+        this.logGroup = new aws_cdk_lib_1.aws_logs.LogGroup(this, 'logs', {
+            retention: props?.logRetention ?? aws_logs_1.RetentionDays.ONE_MONTH,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.DESTROY,
+        });
+        this.dind = (props?.dockerInDocker ?? true) && !image.os.is(common_1.Os.WINDOWS);
+        this.task = new aws_cdk_lib_1.aws_ecs.Ec2TaskDefinition(this, 'task');
+        this.container = this.task.addContainer('runner', {
+            image: aws_cdk_lib_1.aws_ecs.AssetImage.fromEcrRepository(image.imageRepository, image.imageTag),
+            cpu: props?.cpu ?? 1024,
+            memoryLimitMiB: props?.memoryLimitMiB ?? 3500,
+            logging: aws_cdk_lib_1.aws_ecs.AwsLogDriver.awsLogs({
+                logGroup: this.logGroup,
+                streamPrefix: 'runner',
+            }),
+            command: (0, fargate_1.ecsRunCommand)(this.image.os, this.dind),
+            user: image.os.is(common_1.Os.WINDOWS) ? undefined : 'runner',
+            privileged: this.dind,
+        });
+        // docker-in-docker
+        if (this.dind) {
+            this.task.addVolume({
+                name: 'docker',
+                host: {
+                    sourcePath: '/var/run/docker.sock',
+                },
+            });
+            this.container.addMountPoints({
+                sourceVolume: 'docker',
+                containerPath: '/var/run/docker.sock.host',
+                readOnly: false,
+            });
+        }
+        this.grantPrincipal = this.task.taskRole;
+    }
+    defaultClusterInstanceType() {
+        if (this.image.architecture.is(common_1.Architecture.X86_64)) {
+            return aws_cdk_lib_1.aws_ec2.InstanceType.of(aws_cdk_lib_1.aws_ec2.InstanceClass.M5, aws_cdk_lib_1.aws_ec2.InstanceSize.LARGE);
+        }
+        if (this.image.architecture.is(common_1.Architecture.ARM64)) {
+            return aws_cdk_lib_1.aws_ec2.InstanceType.of(aws_cdk_lib_1.aws_ec2.InstanceClass.M6G, aws_cdk_lib_1.aws_ec2.InstanceSize.LARGE);
+        }
+        throw new Error(`Unable to find instance type for ECS instances for ${this.image.architecture.name}`);
+    }
+    defaultClusterInstanceAmi() {
+        if (this.image.os.is(common_1.Os.LINUX) || this.image.os.is(common_1.Os.LINUX_UBUNTU) || this.image.os.is(common_1.Os.LINUX_AMAZON_2)) {
+            if (this.image.architecture.is(common_1.Architecture.X86_64)) {
+                return aws_cdk_lib_1.aws_ecs.EcsOptimizedImage.amazonLinux2(aws_cdk_lib_1.aws_ecs.AmiHardwareType.STANDARD);
+            }
+            if (this.image.architecture.is(common_1.Architecture.ARM64)) {
+                return aws_cdk_lib_1.aws_ecs.EcsOptimizedImage.amazonLinux2(aws_cdk_lib_1.aws_ecs.AmiHardwareType.ARM);
+            }
+        }
+        if (this.image.os.is(common_1.Os.WINDOWS)) {
+            return aws_cdk_lib_1.aws_ecs.EcsOptimizedImage.windows(aws_cdk_lib_1.aws_ecs.WindowsOptimizedVersion.SERVER_2019);
+        }
+        throw new Error(`Unable to find AMI for ECS instances for ${this.image.os.name}/${this.image.architecture.name}`);
+    }
+    pullCommand() {
+        if (this.image.os.is(common_1.Os.WINDOWS)) {
+            return `Start-Job -ScriptBlock { docker pull ${this.image.imageRepository.repositoryUri}:${this.image.imageTag} }`;
+        }
+        return `docker pull ${this.image.imageRepository.repositoryUri}:${this.image.imageTag} &`;
+    }
+    loginCommand() {
+        const thisStack = aws_cdk_lib_1.Stack.of(this);
+        if (this.image.os.is(common_1.Os.WINDOWS)) {
+            return `(Get-ECRLoginCommand).Password | docker login --username AWS --password-stdin ${thisStack.account}.dkr.ecr.${thisStack.region}.amazonaws.com`;
+        }
+        return `aws ecr get-login-password --region ${thisStack.region} | docker login --username AWS --password-stdin ${thisStack.account}.dkr.ecr.${thisStack.region}.amazonaws.com`;
+    }
+    /**
+     * Generate step function task(s) to start a new runner.
+     *
+     * Called by GithubRunners and shouldn't be called manually.
+     *
+     * @param parameters workflow job details
+     */
+    getStepFunctionTask(parameters) {
+        const task = new aws_cdk_lib_1.aws_stepfunctions_tasks.EcsRunTask(this, this.labels.join(', '), {
+            integrationPattern: aws_stepfunctions_1.IntegrationPattern.RUN_JOB,
+            taskDefinition: this.task,
+            cluster: this.cluster,
+            launchTarget: new EcsEc2LaunchTarget({ capacityProvider: this.capacityProvider.capacityProviderName }),
+            assignPublicIp: this.assignPublicIp,
+            containerOverrides: [
+                {
+                    containerDefinition: this.container,
+                    environment: [
+                        {
+                            name: 'RUNNER_TOKEN',
+                            value: parameters.runnerTokenPath,
+                        },
+                        {
+                            name: 'RUNNER_NAME',
+                            value: parameters.runnerNamePath,
+                        },
+                        {
+                            name: 'RUNNER_LABEL',
+                            value: this.labels.join(','),
+                        },
+                        {
+                            name: 'GITHUB_DOMAIN',
+                            value: parameters.githubDomainPath,
+                        },
+                        {
+                            name: 'OWNER',
+                            value: parameters.ownerPath,
+                        },
+                        {
+                            name: 'REPO',
+                            value: parameters.repoPath,
+                        },
+                    ],
+                },
+            ],
+        });
+        this.addRetry(task, ['Ecs.EcsException', 'Ecs.LimitExceededException', 'Ecs.UpdateInProgressException']);
+        return task;
+    }
+    grantStateMachine(_) {
+    }
+    status(statusFunctionRole) {
+        this.image.imageRepository.grant(statusFunctionRole, 'ecr:DescribeImages');
+        return {
+            type: this.constructor.name,
+            labels: this.labels,
+            vpcArn: this.vpc?.vpcArn,
+            securityGroups: this.securityGroups.map(sg => sg.securityGroupId),
+            roleArn: this.task.taskRole.roleArn,
+            logGroup: this.logGroup.logGroupName,
+            image: {
+                imageRepository: this.image.imageRepository.repositoryUri,
+                imageTag: this.image.imageTag,
+                imageBuilderLogGroup: this.image.logGroup?.logGroupName,
+            },
+        };
+    }
+}
+exports.EcsRunnerProvider = EcsRunnerProvider;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ecs.js","sourceRoot":"","sources":["../../src/providers/ecs.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_ecs as ecs,\n  aws_iam as iam,\n  aws_logs as logs,\n  aws_stepfunctions as stepfunctions,\n  aws_stepfunctions_tasks as stepfunctions_tasks,\n  RemovalPolicy,\n  Stack,\n} from 'aws-cdk-lib';\nimport * as autoscaling from 'aws-cdk-lib/aws-autoscaling';\nimport { MachineImageType } from 'aws-cdk-lib/aws-ecs';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { IntegrationPattern } from 'aws-cdk-lib/aws-stepfunctions';\nimport { Construct } from 'constructs';\nimport {\n  Architecture,\n  BaseProvider,\n  IRunnerProvider,\n  IRunnerProviderStatus,\n  Os,\n  RunnerImage,\n  RunnerProviderProps,\n  RunnerRuntimeParameters,\n  RunnerVersion,\n} from './common';\nimport { ecsRunCommand } from './fargate';\nimport { IRunnerImageBuilder, RunnerImageBuilder, RunnerImageBuilderProps, RunnerImageComponent } from './image-builders';\n\n/**\n * Properties for EcsRunnerProvider.\n */\nexport interface EcsRunnerProviderProps extends RunnerProviderProps {\n  /**\n   * Runner image builder used to build Docker images containing GitHub Runner and all requirements.\n   *\n   * The image builder determines the OS and architecture of the runner.\n   *\n   * @default EcsRunnerProvider.imageBuilder()\n   */\n  readonly imageBuilder?: IRunnerImageBuilder;\n\n  /**\n   * GitHub Actions labels used for this provider.\n   *\n   * These labels are used to identify which provider should spawn a new on-demand runner. Every job sends a webhook with the labels it's looking for\n   * based on runs-on. We match the labels from the webhook with the labels specified here. If all the labels specified here are present in the\n   * job's labels, this provider will be chosen and spawn a new runner.\n   *\n   * @default ['ecs']\n   */\n  readonly labels?: string[];\n\n  /**\n   * VPC to launch the runners in.\n   *\n   * @default default account VPC\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Subnets to run the runners in.\n   *\n   * @default ECS default\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * Security groups to assign to the task.\n   *\n   * @default a new security group\n   */\n  readonly securityGroups?: ec2.ISecurityGroup[];\n\n  /**\n   * Existing ECS cluster to use.\n   *\n   * @default a new cluster\n   */\n  readonly cluster?: ecs.Cluster;\n\n  /**\n   * Existing capacity provider to use.\n   *\n   * @default new capacity provider\n   */\n  readonly capacityProvider?: ecs.AsgCapacityProvider;\n\n  /**\n   * Assign public IP to the runner task.\n   *\n   * Make sure the task will have access to GitHub. A public IP might be required unless you have NAT gateway.\n   *\n   * @default true\n   */\n  readonly assignPublicIp?: boolean;\n\n  /**\n   * The number of cpu units used by the task. 1024 units is 1 vCPU. Fractions of a vCPU are supported.\n   *\n   * @default 1024\n   */\n  readonly cpu?: number;\n\n  /**\n   * The amount (in MiB) of memory used by the task.\n   *\n   * @default 3500\n   */\n  readonly memoryLimitMiB?: number;\n\n  /**\n   * Instance type of ECS cluster instances. Only used when creating a new cluster.\n   *\n   * @default m5.large or m6g.large\n   */\n  readonly instanceType?: ec2.InstanceType;\n\n  /**\n   * The minimum number of instances to run in the cluster. Only used when creating a new cluster.\n   *\n   * @default 0\n   */\n  readonly minInstances?: number;\n\n  /**\n   * The maximum number of instances to run in the cluster. Only used when creating a new cluster.\n   *\n   * @default 5\n   */\n  readonly maxInstances?: number;\n\n  /**\n   * Size of volume available for launched cluster instances. This modifies the boot volume size and doesn't add any additional volumes.\n   *\n   * Each instance can be used by multiple runners, so make sure there is enough space for all of them.\n   *\n   * @default default size for AMI (usually 30GB for Linux and 50GB for Windows)\n   */\n  readonly storageSize?: cdk.Size;\n\n  /**\n   * Support building and running Docker images by enabling Docker-in-Docker (dind) and the required CodeBuild privileged mode. Disabling this can\n   * speed up provisioning of CodeBuild runners. If you don't intend on running or building Docker images, disable this for faster start-up times.\n   *\n   * @default true\n   */\n  readonly dockerInDocker?: boolean;\n\n  /**\n   * Use spot capacity and set a maximum price for spot instances.\n   *\n   * @default no spot capacity\n   */\n  readonly spotMaxPrice?: string;\n}\n\ninterface EcsEc2LaunchTargetProps {\n  readonly capacityProvider: string;\n}\n\nclass EcsEc2LaunchTarget implements stepfunctions_tasks.IEcsLaunchTarget {\n  constructor(readonly props: EcsEc2LaunchTargetProps) {\n  }\n\n  /**\n   * Called when the ECS launch type configured on RunTask\n   */\n  public bind(_task: stepfunctions_tasks.EcsRunTask,\n    _launchTargetOptions: stepfunctions_tasks.LaunchTargetBindOptions): stepfunctions_tasks.EcsLaunchTargetConfig {\n    return {\n      parameters: {\n        PropagateTags: ecs.PropagatedTagSource.TASK_DEFINITION,\n        CapacityProviderStrategy: [\n          {\n            CapacityProvider: this.props.capacityProvider,\n          },\n        ],\n      },\n    };\n  }\n}\n\n/**\n * GitHub Actions runner provider using ECS on EC2 to execute jobs.\n *\n * ECS can be useful when you want more control of the infrastructure running the GitHub Actions Docker containers. You can control the autoscaling\n * group to scale down to zero during the night and scale up during work hours. This way you can still save money, but have to wait less for\n * infrastructure to spin up.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class EcsRunnerProvider extends BaseProvider implements IRunnerProvider {\n  /**\n   * Create new image builder that builds ECS specific runner images using Ubuntu.\n   *\n   * Included components:\n   *  * `RunnerImageComponent.requiredPackages()`\n   *  * `RunnerImageComponent.runnerUser()`\n   *  * `RunnerImageComponent.git()`\n   *  * `RunnerImageComponent.githubCli()`\n   *  * `RunnerImageComponent.awsCli()`\n   *  * `RunnerImageComponent.dockerInDocker()`\n   *  * `RunnerImageComponent.githubRunner()`\n   */\n  public static imageBuilder(scope: Construct, id: string, props?: RunnerImageBuilderProps): RunnerImageBuilder {\n    return RunnerImageBuilder.new(scope, id, {\n      os: Os.LINUX_UBUNTU,\n      architecture: Architecture.X86_64,\n      components: [\n        RunnerImageComponent.requiredPackages(),\n        RunnerImageComponent.runnerUser(),\n        RunnerImageComponent.git(),\n        RunnerImageComponent.githubCli(),\n        RunnerImageComponent.awsCli(),\n        RunnerImageComponent.dockerInDocker(),\n        RunnerImageComponent.githubRunner(props?.runnerVersion ?? RunnerVersion.latest()),\n      ],\n      ...props,\n    });\n  }\n\n  /**\n   * Cluster hosting the task hosting the runner.\n   */\n  private readonly cluster: ecs.Cluster;\n\n  /**\n   * Capacity provider used to scale the cluster.\n   */\n  private readonly capacityProvider: ecs.AsgCapacityProvider;\n\n  /**\n   * ECS task hosting the runner.\n   */\n  private readonly task: ecs.Ec2TaskDefinition;\n\n  /**\n   * Container definition hosting the runner.\n   */\n  private readonly container: ecs.ContainerDefinition;\n\n  /**\n   * Labels associated with this provider.\n   */\n  readonly labels: string[];\n\n  /**\n   * VPC used for hosting the runner task.\n   */\n  private readonly vpc?: ec2.IVpc;\n\n  /**\n   * Subnets used for hosting the runner task.\n   */\n  private readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * Whether runner task will have a public IP.\n   */\n  private readonly assignPublicIp: boolean;\n\n  /**\n   * Grant principal used to add permissions to the runner role.\n   */\n  readonly grantPrincipal: iam.IPrincipal;\n\n  /**\n   * The network connections associated with this resource.\n   */\n  readonly connections: ec2.Connections;\n\n  /**\n   * Docker image loaded with GitHub Actions Runner and its prerequisites. The image is built by an image builder and is specific to ECS tasks.\n   */\n  private readonly image: RunnerImage;\n\n  /**\n   * Log group where provided runners will save their logs.\n   *\n   * Note that this is not the job log, but the runner itself. It will not contain output from the GitHub Action but only metadata on its execution.\n   */\n  readonly logGroup: logs.ILogGroup;\n\n  /**\n   * Security groups associated with this provider.\n   */\n  private readonly securityGroups: ec2.ISecurityGroup[];\n\n  /**\n   * Run docker in docker.\n   */\n  private readonly dind: boolean;\n\n  constructor(scope: Construct, id: string, props?: EcsRunnerProviderProps) {\n    super(scope, id, props);\n\n    this.labels = props?.labels ?? ['ecs'];\n    this.vpc = props?.vpc ?? ec2.Vpc.fromLookup(this, 'default vpc', { isDefault: true });\n    this.subnetSelection = props?.subnetSelection;\n    this.securityGroups = props?.securityGroups ?? [new ec2.SecurityGroup(this, 'security group', { vpc: this.vpc })];\n    this.connections = new ec2.Connections({ securityGroups: this.securityGroups });\n    this.assignPublicIp = props?.assignPublicIp ?? true;\n    this.cluster = props?.cluster ? props.cluster : new ecs.Cluster(\n      this,\n      'cluster',\n      {\n        vpc: this.vpc,\n        enableFargateCapacityProviders: false,\n      },\n    );\n\n    const imageBuilder = props?.imageBuilder ?? EcsRunnerProvider.imageBuilder(this, 'Image Builder');\n    const image = this.image = imageBuilder.bindDockerImage();\n\n    if (props?.capacityProvider && (props?.minInstances || props?.maxInstances || props?.instanceType || props?.storageSize)) {\n      cdk.Annotations.of(this).addWarning('When using a custom capacity provider, minInstances, maxInstances, instanceType and storageSize will be ignored.');\n    }\n\n    this.capacityProvider = props?.capacityProvider ?? new ecs.AsgCapacityProvider(this, 'Capacity Provider', {\n      autoScalingGroup: new autoscaling.AutoScalingGroup(this, 'Auto Scaling Group', {\n        vpc: this.vpc,\n        vpcSubnets: this.subnetSelection,\n        minCapacity: props?.minInstances ?? 0,\n        maxCapacity: props?.maxInstances ?? 5,\n        machineImage: this.defaultClusterInstanceAmi(),\n        instanceType: props?.instanceType ?? this.defaultClusterInstanceType(),\n        blockDevices: props?.storageSize ? [\n          {\n            deviceName: '/dev/sda1',\n            volume: {\n              ebsDevice: {\n                volumeSize: props?.storageSize?.toGibibytes(),\n                deleteOnTermination: true,\n              },\n            },\n          },\n        ] : undefined,\n        spotPrice: props?.spotMaxPrice,\n      }),\n      spotInstanceDraining: false, // waste of money to restart jobs as the restarted job won't have a token\n    });\n    this.securityGroups.map(sg => this.capacityProvider.autoScalingGroup.addSecurityGroup(sg));\n    this.capacityProvider.autoScalingGroup.role.addManagedPolicy(iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'));\n    this.capacityProvider.autoScalingGroup.addUserData(this.loginCommand(), this.pullCommand());\n    image.imageRepository.grantPull(this.capacityProvider.autoScalingGroup);\n\n    this.cluster.addAsgCapacityProvider(\n      this.capacityProvider,\n      {\n        spotInstanceDraining: false,\n        machineImageType: MachineImageType.AMAZON_LINUX_2,\n      },\n    );\n\n    this.logGroup = new logs.LogGroup(this, 'logs', {\n      retention: props?.logRetention ?? RetentionDays.ONE_MONTH,\n      removalPolicy: RemovalPolicy.DESTROY,\n    });\n\n    this.dind = (props?.dockerInDocker ?? true) && !image.os.is(Os.WINDOWS);\n\n    this.task = new ecs.Ec2TaskDefinition(this, 'task');\n    this.container = this.task.addContainer(\n      'runner',\n      {\n        image: ecs.AssetImage.fromEcrRepository(image.imageRepository, image.imageTag),\n        cpu: props?.cpu ?? 1024,\n        memoryLimitMiB: props?.memoryLimitMiB ?? 3500,\n        logging: ecs.AwsLogDriver.awsLogs({\n          logGroup: this.logGroup,\n          streamPrefix: 'runner',\n        }),\n        command: ecsRunCommand(this.image.os, this.dind),\n        user: image.os.is(Os.WINDOWS) ? undefined : 'runner',\n        privileged: this.dind,\n      },\n    );\n\n    // docker-in-docker\n    if (this.dind) {\n      this.task.addVolume({\n        name: 'docker',\n        host: {\n          sourcePath: '/var/run/docker.sock',\n        },\n      });\n      this.container.addMountPoints({\n        sourceVolume: 'docker',\n        containerPath: '/var/run/docker.sock.host',\n        readOnly: false,\n      });\n    }\n\n    this.grantPrincipal = this.task.taskRole;\n  }\n\n  private defaultClusterInstanceType() {\n    if (this.image.architecture.is(Architecture.X86_64)) {\n      return ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.LARGE);\n    }\n    if (this.image.architecture.is(Architecture.ARM64)) {\n      return ec2.InstanceType.of(ec2.InstanceClass.M6G, ec2.InstanceSize.LARGE);\n    }\n\n    throw new Error(`Unable to find instance type for ECS instances for ${this.image.architecture.name}`);\n  }\n\n  private defaultClusterInstanceAmi() {\n    if (this.image.os.is(Os.LINUX) || this.image.os.is(Os.LINUX_UBUNTU) || this.image.os.is(Os.LINUX_AMAZON_2)) {\n      if (this.image.architecture.is(Architecture.X86_64)) {\n        return ecs.EcsOptimizedImage.amazonLinux2(ecs.AmiHardwareType.STANDARD);\n      }\n      if (this.image.architecture.is(Architecture.ARM64)) {\n        return ecs.EcsOptimizedImage.amazonLinux2(ecs.AmiHardwareType.ARM);\n      }\n    }\n\n    if (this.image.os.is(Os.WINDOWS)) {\n      return ecs.EcsOptimizedImage.windows(ecs.WindowsOptimizedVersion.SERVER_2019);\n    }\n\n    throw new Error(`Unable to find AMI for ECS instances for ${this.image.os.name}/${this.image.architecture.name}`);\n  }\n\n  private pullCommand() {\n    if (this.image.os.is(Os.WINDOWS)) {\n      return `Start-Job -ScriptBlock { docker pull ${this.image.imageRepository.repositoryUri}:${this.image.imageTag} }`;\n    }\n    return `docker pull ${this.image.imageRepository.repositoryUri}:${this.image.imageTag} &`;\n  }\n\n  private loginCommand() {\n    const thisStack = Stack.of(this);\n    if (this.image.os.is(Os.WINDOWS)) {\n      return `(Get-ECRLoginCommand).Password | docker login --username AWS --password-stdin ${thisStack.account}.dkr.ecr.${thisStack.region}.amazonaws.com`;\n    }\n    return `aws ecr get-login-password --region ${thisStack.region} | docker login --username AWS --password-stdin ${thisStack.account}.dkr.ecr.${thisStack.region}.amazonaws.com`;\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    const task = new stepfunctions_tasks.EcsRunTask(\n      this,\n      this.labels.join(', '),\n      {\n        integrationPattern: IntegrationPattern.RUN_JOB, // sync\n        taskDefinition: this.task,\n        cluster: this.cluster,\n        launchTarget: new EcsEc2LaunchTarget({ capacityProvider: this.capacityProvider.capacityProviderName }),\n        assignPublicIp: this.assignPublicIp,\n        containerOverrides: [\n          {\n            containerDefinition: this.container,\n            environment: [\n              {\n                name: 'RUNNER_TOKEN',\n                value: parameters.runnerTokenPath,\n              },\n              {\n                name: 'RUNNER_NAME',\n                value: parameters.runnerNamePath,\n              },\n              {\n                name: 'RUNNER_LABEL',\n                value: this.labels.join(','),\n              },\n              {\n                name: 'GITHUB_DOMAIN',\n                value: parameters.githubDomainPath,\n              },\n              {\n                name: 'OWNER',\n                value: parameters.ownerPath,\n              },\n              {\n                name: 'REPO',\n                value: parameters.repoPath,\n              },\n            ],\n          },\n        ],\n      },\n    );\n\n    this.addRetry(task, ['Ecs.EcsException', 'Ecs.LimitExceededException', 'Ecs.UpdateInProgressException']);\n\n    return task;\n  }\n\n  grantStateMachine(_: iam.IGrantable) {\n  }\n\n  status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus {\n    this.image.imageRepository.grant(statusFunctionRole, 'ecr:DescribeImages');\n\n    return {\n      type: this.constructor.name,\n      labels: this.labels,\n      vpcArn: this.vpc?.vpcArn,\n      securityGroups: this.securityGroups.map(sg => sg.securityGroupId),\n      roleArn: this.task.taskRole.roleArn,\n      logGroup: this.logGroup.logGroupName,\n      image: {\n        imageRepository: this.image.imageRepository.repositoryUri,\n        imageTag: this.image.imageTag,\n        imageBuilderLogGroup: this.image.logGroup?.logGroupName,\n      },\n    };\n  }\n}\n"]}

package/lib/providers/fargate.d.ts

@@ -1,18 +1,19 @@
 import { aws_ec2 as ec2, aws_ecs as ecs, aws_iam as iam, aws_logs as logs, aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import { BaseProvider, IImageBuilder, IRunnerProvider, IRunnerProviderStatus, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';
+import { BaseProvider, IRunnerProvider, IRunnerProviderStatus, Os, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';
+import { IRunnerImageBuilder, RunnerImageBuilder, RunnerImageBuilderProps } from './image-builders';
 /**
- * Properties for FargateRunner.
+ * Properties for FargateRunnerProvider.
  */
 export interface FargateRunnerProviderProps extends RunnerProviderProps {
     /**
-     * Provider running an image to run inside CodeBuild with GitHub runner pre-configured. A user named `runner` is expected to exist.
+     * Runner image builder used to build Docker images containing GitHub Runner and all requirements.
      *
      * The image builder determines the OS and architecture of the runner.
      *
-     * @default image builder with `FargateRunner.LINUX_X64_DOCKERFILE_PATH` as Dockerfile
+     * @default FargateRunnerProvider.imageBuilder()
      */
-    readonly imageBuilder?: IImageBuilder;
+    readonly imageBuilder?: IRunnerImageBuilder;
     /**
      * GitHub Actions label used for this provider.
      *
@@ -123,6 +124,10 @@ export interface FargateRunnerProviderProps extends RunnerProviderProps {
      */
     readonly spot?: boolean;
 }
+/**
+ * @internal
+ */
+export declare function ecsRunCommand(os: Os, dind: boolean): string[];
 /**
  * GitHub Actions runner provider using Fargate to execute jobs.
  *
@@ -137,6 +142,8 @@ export declare class FargateRunnerProvider extends BaseProvider implements IRunn
      * Available build arguments that can be set in the image builder:
      * * `BASE_IMAGE` sets the `FROM` line. This should be an Ubuntu compatible image.
      * * `EXTRA_PACKAGES` can be used to install additional packages.
+     *
+     * @deprecated Use `imageBuilder()` instead.
      */
     static readonly LINUX_X64_DOCKERFILE_PATH: string;
     /**
@@ -145,8 +152,22 @@ export declare class FargateRunnerProvider extends BaseProvider implements IRunn
      * Available build arguments that can be set in the image builder:
      * * `BASE_IMAGE` sets the `FROM` line. This should be an Ubuntu compatible image.
      * * `EXTRA_PACKAGES` can be used to install additional packages.
+     *
+     * @deprecated Use `imageBuilder()` instead.
      */
     static readonly LINUX_ARM64_DOCKERFILE_PATH: string;
+    /**
+     * Create new image builder that builds Fargate specific runner images using Ubuntu.
+     *
+     * Included components:
+     *  * `RunnerImageComponent.requiredPackages()`
+     *  * `RunnerImageComponent.runnerUser()`
+     *  * `RunnerImageComponent.git()`
+     *  * `RunnerImageComponent.githubCli()`
+     *  * `RunnerImageComponent.awsCli()`
+     *  * `RunnerImageComponent.githubRunner()`
+     */
+    static imageBuilder(scope: Construct, id: string, props?: RunnerImageBuilderProps): RunnerImageBuilder;
     /**
      * Cluster hosting the task hosting the runner.
      */
@@ -209,7 +230,6 @@ export declare class FargateRunnerProvider extends BaseProvider implements IRunn
     getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable;
     grantStateMachine(_: iam.IGrantable): void;
     status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus;
-    private runCommand;
 }
 /**
  * @deprecated use {@link FargateRunnerProvider}