@cloudsnorkel/cdk-github-runners 0.5.7 → 0.6.0

package/lib/providers/ec2.d.ts

@@ -0,0 +1,106 @@
+import * as cdk from 'aws-cdk-lib';
+import { aws_ec2 as ec2, aws_iam as iam, aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';
+import { Construct } from 'constructs';
+import { BaseProvider, IAmiBuilder, IRunnerProvider, IRunnerProviderStatus, RunnerProviderProps, RunnerRuntimeParameters } from './common';
+/**
+ * Properties for {@link Ec2Runner} construct.
+ */
+export interface Ec2RunnerProps extends RunnerProviderProps {
+    /**
+     * AMI builder that creates AMIs with GitHub runner pre-configured. On Linux, a user named `runner` is expected to exist with access to Docker.
+     *
+     * @default AMI builder for Ubuntu Linux
+     */
+    readonly amiBuilder?: IAmiBuilder;
+    /**
+     * GitHub Actions labels used for this provider.
+     *
+     * 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
+     * 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
+     * job's labels, this provider will be chosen and spawn a new runner.
+     *
+     * @default ['ec2']
+     */
+    readonly labels?: string[];
+    /**
+     * Instance type for launched runner instances.
+     *
+     * @default m5.large
+     */
+    readonly instanceType?: ec2.InstanceType;
+    /**
+     * Size of volume available for launched runner instances. This modifies the boot volume size and doesn't add any additional volumes.
+     *
+     * @default 30GB
+     */
+    readonly storageSize?: cdk.Size;
+    /**
+     * Security Group to assign to launched runner instances.
+     *
+     * @default account's default security group
+     */
+    readonly securityGroup?: ec2.ISecurityGroup;
+    /**
+     * Subnet where the runner instances will be launched.
+     *
+     * @default default subnet of account's default VPC
+     */
+    readonly subnet?: ec2.ISubnet;
+    /**
+     * Use spot instances to save money. Spot instances are cheaper but not always available and can be stopped prematurely.
+     *
+     * @default false
+     */
+    readonly spot?: boolean;
+    /**
+     * Set a maximum price for spot instances.
+     *
+     * @default no max price (you will pay current spot price)
+     */
+    readonly spotMaxPrice?: string;
+}
+/**
+ * GitHub Actions runner provider using EC2 to execute jobs.
+ *
+ * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.
+ */
+export declare class Ec2Runner extends BaseProvider implements IRunnerProvider {
+    /**
+     * Labels associated with this provider.
+     */
+    readonly labels: string[];
+    /**
+     * VPC subnet used for hosting launched instances.
+     */
+    readonly subnet?: ec2.ISubnet;
+    /**
+     * Security group attached to launched instances.
+     */
+    readonly securityGroup?: ec2.ISecurityGroup;
+    /**
+     * Grant principal used to add permissions to the runner role.
+     */
+    readonly grantPrincipal: iam.IPrincipal;
+    private readonly ami;
+    private readonly logGroup;
+    private readonly role;
+    private readonly instanceType;
+    private readonly storageSize;
+    private readonly spot;
+    private readonly spotMaxPrice;
+    constructor(scope: Construct, id: string, props: Ec2RunnerProps);
+    /**
+     * 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: RunnerRuntimeParameters): stepfunctions.IChainable;
+    grantStateMachine(stateMachineRole: iam.IGrantable): void;
+    status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus;
+    /**
+     * The network connections associated with this resource.
+     */
+    get connections(): ec2.Connections;
+}

package/lib/providers/ec2.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Ec2Runner = void 0;
+const cdk = require("aws-cdk-lib");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const aws_stepfunctions_1 = require("aws-cdk-lib/aws-stepfunctions");
+const common_1 = require("./common");
+const ami_1 = require("./image-builders/ami");
+// this script is specifically made so `poweroff` is absolutely always called
+// each `{}` is a variable coming from `params` below
+const linuxUserDataTemplate = `#!/bin/bash -x
+TASK_TOKEN="{}"
+heartbeat () {
+  while true; do
+    aws stepfunctions send-task-heartbeat --task-token "$TASK_TOKEN"
+    sleep 60
+  done
+}
+setup_logs () {
+  cat <<EOF > /tmp/log.conf || exit 1
+  {
+    "logs": {
+      "log_stream_name": "unknown",
+      "logs_collected": {
+        "files": {
+          "collect_list": [
+            {
+              "file_path": "/var/log/runner.log",
+              "log_group_name": "{}",
+              "log_stream_name": "{}",
+              "timezone": "UTC"
+            }
+          ]
+        }
+      }
+    }
+  }
+EOF
+  /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -s -c file:/tmp/log.conf || exit 2
+}
+action () {
+  sudo -Hu runner /home/runner/config.sh --unattended --url "https://{}/{}/{}" --token "{}" --ephemeral --work _work --labels "{}" {} --name "{}" || exit 1
+  sudo --preserve-env=AWS_REGION -Hu runner /home/runner/run.sh || exit 2
+}
+heartbeat &
+if setup_logs && action | tee /var/log/runner.log 2>&1; then
+  aws stepfunctions send-task-success --task-token "$TASK_TOKEN" --task-output '{"ok": true}'
+else
+  aws stepfunctions send-task-failure --task-token "$TASK_TOKEN"
+fi
+poweroff
+`.replace(/{/g, '\\{').replace(/}/g, '\\}').replace(/\\{\\}/g, '{}');
+// this script is specifically made so `poweroff` is absolutely always called
+// each `{}` is a variable coming from `params` below and their order should match the linux script
+const windowsUserDataTemplate = `<powershell>
+$TASK_TOKEN = "{}"
+Start-Job -ScriptBlock {
+  while (1) {
+    aws stepfunctions send-task-heartbeat --task-token "$using:TASK_TOKEN"
+    sleep 60
+  }
+}
+function setup_logs () {
+  echo '{
+    "logs": {
+      "log_stream_name": "unknown",
+      "logs_collected": {
+        "files": {
+         "collect_list": [
+            {
+              "file_path": "/actions/runner.log",
+              "log_group_name": "{}",
+              "log_stream_name": "{}",
+              "timezone": "UTC"
+            }
+          ]
+        }
+      }
+    }
+  }' | Out-File -Encoding ASCII $Env:TEMP/log.conf
+  & "C:/Program Files/Amazon/AmazonCloudWatchAgent/amazon-cloudwatch-agent-ctl.ps1" -a fetch-config -m ec2 -s -c file:$Env:TEMP/log.conf
+}
+function action () {
+  cd /actions
+  ./config.cmd --unattended --url "https://{}/{}/{}" --token "{}" --ephemeral --work _work --labels "{}" {} --name "{}" 2>&1 | Out-File -Encoding ASCII -Append /actions/runner.log
+  if ($LASTEXITCODE -ne 0) { return 1 }
+  ./run.cmd 2>&1 | Out-File -Encoding ASCII -Append /actions/runner.log
+  if ($LASTEXITCODE -ne 0) { return 2 }
+  return 0
+}
+setup_logs
+$r = action
+if ($r -eq 0) {
+  aws stepfunctions send-task-success --task-token "$TASK_TOKEN" --task-output '{ }'
+} else {
+  aws stepfunctions send-task-failure --task-token "$TASK_TOKEN"
+}
+Stop-Computer -ComputerName localhost -Force
+</powershell>
+`.replace(/{/g, '\\{').replace(/}/g, '\\}').replace(/\\{\\}/g, '{}');
+/**
+ * GitHub Actions runner provider using EC2 to execute jobs.
+ *
+ * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.
+ */
+class Ec2Runner extends common_1.BaseProvider {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.labels = props.labels ?? ['ec2'];
+        this.securityGroup = props.securityGroup;
+        this.subnet = props.subnet;
+        this.instanceType = props.instanceType ?? aws_cdk_lib_1.aws_ec2.InstanceType.of(aws_cdk_lib_1.aws_ec2.InstanceClass.M5, aws_cdk_lib_1.aws_ec2.InstanceSize.LARGE);
+        this.storageSize = props.storageSize ?? cdk.Size.gibibytes(30); // 30 is the minimum for Windows
+        this.spot = props.spot ?? false;
+        this.spotMaxPrice = props.spotMaxPrice;
+        const amiBuilder = props.amiBuilder ?? new ami_1.AmiBuilder(this, 'Image Builder');
+        this.ami = amiBuilder.bind();
+        if (!this.ami.architecture.instanceTypeMatch(this.instanceType)) {
+            throw new Error(`AMI architecture (${this.ami.architecture.name}) doesn't match runner instance type (${this.instanceType} / ${this.instanceType.architecture})`);
+        }
+        this.grantPrincipal = this.role = new aws_cdk_lib_1.aws_iam.Role(this, 'Role', {
+            assumedBy: new aws_cdk_lib_1.aws_iam.ServicePrincipal('ec2.amazonaws.com'),
+            managedPolicies: [
+                aws_cdk_lib_1.aws_iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),
+            ],
+        });
+        this.grantPrincipal.addToPrincipalPolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            actions: ['states:SendTaskFailure', 'states:SendTaskSuccess', 'states:SendTaskHeartbeat'],
+            resources: ['*'],
+        }));
+        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.logGroup.grantWrite(this);
+    }
+    /**
+     * 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) {
+        // we need to build user data in two steps because passing the template as the first parameter to stepfunctions.JsonPath.format fails on syntax
+        const params = [
+            aws_cdk_lib_1.aws_stepfunctions.JsonPath.taskToken,
+            this.logGroup.logGroupName,
+            parameters.runnerNamePath,
+            parameters.githubDomainPath,
+            parameters.ownerPath,
+            parameters.repoPath,
+            parameters.runnerTokenPath,
+            this.labels.join(','),
+            this.ami.runnerVersion.is(common_1.RunnerVersion.latest()) ? '' : '--disableupdate',
+            parameters.runnerNamePath,
+        ];
+        const passUserData = new aws_cdk_lib_1.aws_stepfunctions.Pass(this, `${this.labels.join(', ')} data`, {
+            parameters: {
+                userdataTemplate: this.ami.os.is(common_1.Os.WINDOWS) ? windowsUserDataTemplate : linuxUserDataTemplate,
+            },
+            resultPath: aws_cdk_lib_1.aws_stepfunctions.JsonPath.stringAt('$.ec2'),
+        });
+        // we can't use fleets because they don't let us override user data, security groups or even disk size
+        // we can't use requestSpotInstances because it doesn't support launch templates, and it's deprecated
+        const run = new aws_cdk_lib_1.aws_stepfunctions_tasks.CallAwsService(this, this.labels.join(', '), {
+            integrationPattern: aws_stepfunctions_1.IntegrationPattern.WAIT_FOR_TASK_TOKEN,
+            service: 'ec2',
+            action: 'runInstances',
+            heartbeat: aws_cdk_lib_1.Duration.minutes(5),
+            parameters: {
+                LaunchTemplate: {
+                    LaunchTemplateId: this.ami.launchTemplate.launchTemplateId,
+                },
+                MinCount: 1,
+                MaxCount: 1,
+                InstanceType: this.instanceType.toString(),
+                UserData: aws_cdk_lib_1.aws_stepfunctions.JsonPath.base64Encode(aws_cdk_lib_1.aws_stepfunctions.JsonPath.format(aws_cdk_lib_1.aws_stepfunctions.JsonPath.stringAt('$.ec2.userdataTemplate'), ...params)),
+                InstanceInitiatedShutdownBehavior: aws_cdk_lib_1.aws_ec2.InstanceInitiatedShutdownBehavior.TERMINATE,
+                IamInstanceProfile: {
+                    Arn: new aws_cdk_lib_1.aws_iam.CfnInstanceProfile(this, 'Instance Profile', {
+                        roles: [this.role.roleName],
+                    }).attrArn,
+                },
+                MetadataOptions: {
+                    HttpTokens: 'required',
+                },
+                SecurityGroupIds: this.securityGroup ? [this.securityGroup.securityGroupId] : undefined,
+                SubnetId: this.subnet?.subnetId,
+                BlockDeviceMappings: [{
+                        DeviceName: '/dev/sda1',
+                        Ebs: {
+                            DeleteOnTermination: true,
+                            VolumeSize: this.storageSize.toGibibytes(),
+                        },
+                    }],
+                InstanceMarketOptions: this.spot ? {
+                    MarketType: 'spot',
+                    SpotOptions: {
+                        MaxPrice: this.spotMaxPrice,
+                        SpotInstanceType: 'one-time',
+                    },
+                } : undefined,
+            },
+            iamResources: ['*'],
+        });
+        return passUserData.next(run);
+    }
+    grantStateMachine(stateMachineRole) {
+        stateMachineRole.grantPrincipal.addToPrincipalPolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            actions: ['iam:PassRole'],
+            resources: [this.role.roleArn],
+            conditions: {
+                StringEquals: {
+                    'iam:PassedToService': 'ec2.amazonaws.com',
+                },
+            },
+        }));
+        stateMachineRole.grantPrincipal.addToPrincipalPolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            actions: ['ec2:createTags'],
+            resources: [aws_cdk_lib_1.Stack.of(this).formatArn({
+                    service: 'ec2',
+                    resource: '*',
+                })],
+        }));
+    }
+    status(statusFunctionRole) {
+        statusFunctionRole.grantPrincipal.addToPrincipalPolicy(new aws_cdk_lib_1.aws_iam.PolicyStatement({
+            actions: ['ec2:DescribeLaunchTemplateVersions'],
+            resources: ['*'],
+        }));
+        return {
+            type: this.constructor.name,
+            labels: this.labels,
+            securityGroup: this.securityGroup?.securityGroupId,
+            roleArn: this.role.roleArn,
+            ami: {
+                launchTemplate: this.ami.launchTemplate.launchTemplateId || 'unknown',
+                amiBuilderLogGroup: this.ami.logGroup?.logGroupName,
+            },
+        };
+    }
+    /**
+     * The network connections associated with this resource.
+     */
+    get connections() {
+        return this.securityGroup?.connections ?? new aws_cdk_lib_1.aws_ec2.Connections();
+    }
+}
+exports.Ec2Runner = Ec2Runner;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ec2.js","sourceRoot":"","sources":["../../src/providers/ec2.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_iam as iam,\n  aws_logs as logs,\n  aws_stepfunctions as stepfunctions,\n  aws_stepfunctions_tasks as stepfunctions_tasks,\n  Duration,\n  RemovalPolicy,\n  Stack,\n} from 'aws-cdk-lib';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { IntegrationPattern } from 'aws-cdk-lib/aws-stepfunctions';\nimport { Construct } from 'constructs';\nimport {\n  BaseProvider,\n  IAmiBuilder,\n  IRunnerProvider,\n  IRunnerProviderStatus,\n  Os,\n  RunnerAmi,\n  RunnerProviderProps,\n  RunnerRuntimeParameters,\n  RunnerVersion,\n} from './common';\nimport { AmiBuilder } from './image-builders/ami';\n\n// this script is specifically made so `poweroff` is absolutely always called\n// each `{}` is a variable coming from `params` below\nconst linuxUserDataTemplate = `#!/bin/bash -x\nTASK_TOKEN=\"{}\"\nheartbeat () {\n  while true; do\n    aws stepfunctions send-task-heartbeat --task-token \"$TASK_TOKEN\"\n    sleep 60\n  done\n}\nsetup_logs () {\n  cat <<EOF > /tmp/log.conf || exit 1\n  {\n    \"logs\": {\n      \"log_stream_name\": \"unknown\",\n      \"logs_collected\": {\n        \"files\": {\n          \"collect_list\": [\n            {\n              \"file_path\": \"/var/log/runner.log\",\n              \"log_group_name\": \"{}\",\n              \"log_stream_name\": \"{}\",\n              \"timezone\": \"UTC\"\n            }\n          ]\n        }\n      }\n    }\n  }\nEOF\n  /opt/aws/amazon-cloudwatch-agent/bin/amazon-cloudwatch-agent-ctl -a fetch-config -m ec2 -s -c file:/tmp/log.conf || exit 2\n}\naction () {\n  sudo -Hu runner /home/runner/config.sh --unattended --url \"https://{}/{}/{}\" --token \"{}\" --ephemeral --work _work --labels \"{}\" {} --name \"{}\" || exit 1\n  sudo --preserve-env=AWS_REGION -Hu runner /home/runner/run.sh || exit 2\n}\nheartbeat &\nif setup_logs && action | tee /var/log/runner.log 2>&1; then\n  aws stepfunctions send-task-success --task-token \"$TASK_TOKEN\" --task-output '{\"ok\": true}'\nelse\n  aws stepfunctions send-task-failure --task-token \"$TASK_TOKEN\"\nfi\npoweroff\n`.replace(/{/g, '\\\\{').replace(/}/g, '\\\\}').replace(/\\\\{\\\\}/g, '{}');\n\n// this script is specifically made so `poweroff` is absolutely always called\n// each `{}` is a variable coming from `params` below and their order should match the linux script\nconst windowsUserDataTemplate = `<powershell>\n$TASK_TOKEN = \"{}\"\nStart-Job -ScriptBlock {\n  while (1) {\n    aws stepfunctions send-task-heartbeat --task-token \"$using:TASK_TOKEN\"\n    sleep 60\n  }\n}\nfunction setup_logs () {\n  echo '{\n    \"logs\": {\n      \"log_stream_name\": \"unknown\",\n      \"logs_collected\": {\n        \"files\": {\n         \"collect_list\": [\n            {\n              \"file_path\": \"/actions/runner.log\",\n              \"log_group_name\": \"{}\",\n              \"log_stream_name\": \"{}\",\n              \"timezone\": \"UTC\"\n            }\n          ]\n        }\n      }\n    }\n  }' | Out-File -Encoding ASCII $Env:TEMP/log.conf\n  & \"C:/Program Files/Amazon/AmazonCloudWatchAgent/amazon-cloudwatch-agent-ctl.ps1\" -a fetch-config -m ec2 -s -c file:$Env:TEMP/log.conf\n}\nfunction action () {\n  cd /actions\n  ./config.cmd --unattended --url \"https://{}/{}/{}\" --token \"{}\" --ephemeral --work _work --labels \"{}\" {} --name \"{}\" 2>&1 | Out-File -Encoding ASCII -Append /actions/runner.log\n  if ($LASTEXITCODE -ne 0) { return 1 }\n  ./run.cmd 2>&1 | Out-File -Encoding ASCII -Append /actions/runner.log\n  if ($LASTEXITCODE -ne 0) { return 2 }\n  return 0\n}\nsetup_logs\n$r = action\nif ($r -eq 0) {\n  aws stepfunctions send-task-success --task-token \"$TASK_TOKEN\" --task-output '{ }'\n} else {\n  aws stepfunctions send-task-failure --task-token \"$TASK_TOKEN\"\n}\nStop-Computer -ComputerName localhost -Force\n</powershell>\n`.replace(/{/g, '\\\\{').replace(/}/g, '\\\\}').replace(/\\\\{\\\\}/g, '{}');\n\n\n/**\n * Properties for {@link Ec2Runner} construct.\n */\nexport interface Ec2RunnerProps extends RunnerProviderProps {\n  /**\n   * AMI builder that creates AMIs with GitHub runner pre-configured. On Linux, a user named `runner` is expected to exist with access to Docker.\n   *\n   * @default AMI builder for Ubuntu Linux\n   */\n  readonly amiBuilder?: IAmiBuilder;\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 ['ec2']\n   */\n  readonly labels?: string[];\n\n  /**\n   * Instance type for launched runner instances.\n   *\n   * @default m5.large\n   */\n  readonly instanceType?: ec2.InstanceType;\n\n  /**\n   * Size of volume available for launched runner instances. This modifies the boot volume size and doesn't add any additional volumes.\n   *\n   * @default 30GB\n   */\n  readonly storageSize?: cdk.Size;\n\n  /**\n   * Security Group to assign to launched runner instances.\n   *\n   * @default account's default security group\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Subnet where the runner instances will be launched.\n   *\n   * @default default subnet of account's default VPC\n   */\n  readonly subnet?: ec2.ISubnet;\n\n  /**\n   * Use spot instances to save money. Spot instances are cheaper but not always available and can be stopped prematurely.\n   *\n   * @default false\n   */\n  readonly spot?: boolean;\n\n  /**\n   * Set a maximum price for spot instances.\n   *\n   * @default no max price (you will pay current spot price)\n   */\n  readonly spotMaxPrice?: string;\n}\n\n/**\n * GitHub Actions runner provider using EC2 to execute jobs.\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 Ec2Runner extends BaseProvider implements IRunnerProvider {\n  /**\n   * Labels associated with this provider.\n   */\n  readonly labels: string[];\n\n  /**\n   * VPC subnet used for hosting launched instances.\n   */\n  readonly subnet?: ec2.ISubnet;\n\n  /**\n   * Security group attached to launched instances.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Grant principal used to add permissions to the runner role.\n   */\n  readonly grantPrincipal: iam.IPrincipal;\n\n  private readonly ami: RunnerAmi;\n  private readonly logGroup: logs.LogGroup;\n  private readonly role: iam.Role;\n  private readonly instanceType: ec2.InstanceType;\n  private readonly storageSize: cdk.Size;\n  private readonly spot: boolean;\n  private readonly spotMaxPrice: string | undefined;\n\n  constructor(scope: Construct, id: string, props: Ec2RunnerProps) {\n    super(scope, id);\n\n    this.labels = props.labels ?? ['ec2'];\n    this.securityGroup = props.securityGroup;\n    this.subnet = props.subnet;\n    this.instanceType = props.instanceType ?? ec2.InstanceType.of(ec2.InstanceClass.M5, ec2.InstanceSize.LARGE);\n    this.storageSize = props.storageSize ?? cdk.Size.gibibytes(30); // 30 is the minimum for Windows\n    this.spot = props.spot ?? false;\n    this.spotMaxPrice = props.spotMaxPrice;\n\n    const amiBuilder = props.amiBuilder ?? new AmiBuilder(this, 'Image Builder');\n    this.ami = amiBuilder.bind();\n\n    if (!this.ami.architecture.instanceTypeMatch(this.instanceType)) {\n      throw new Error(`AMI architecture (${this.ami.architecture.name}) doesn't match runner instance type (${this.instanceType} / ${this.instanceType.architecture})`);\n    }\n\n    this.grantPrincipal = this.role = new iam.Role(this, 'Role', {\n      assumedBy: new iam.ServicePrincipal('ec2.amazonaws.com'),\n      managedPolicies: [\n        iam.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),\n      ],\n    });\n    this.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({\n      actions: ['states:SendTaskFailure', 'states:SendTaskSuccess', 'states:SendTaskHeartbeat'],\n      resources: ['*'], // no support for stateMachine.stateMachineArn :(\n    }));\n\n    this.logGroup = new logs.LogGroup(\n      this,\n      'Logs',\n      {\n        retention: props.logRetention ?? RetentionDays.ONE_MONTH,\n        removalPolicy: RemovalPolicy.DESTROY,\n      },\n    );\n    this.logGroup.grantWrite(this);\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    // we need to build user data in two steps because passing the template as the first parameter to stepfunctions.JsonPath.format fails on syntax\n\n    const params = [\n      stepfunctions.JsonPath.taskToken,\n      this.logGroup.logGroupName,\n      parameters.runnerNamePath,\n      parameters.githubDomainPath,\n      parameters.ownerPath,\n      parameters.repoPath,\n      parameters.runnerTokenPath,\n      this.labels.join(','),\n      this.ami.runnerVersion.is(RunnerVersion.latest()) ? '' : '--disableupdate',\n      parameters.runnerNamePath,\n    ];\n\n    const passUserData = new stepfunctions.Pass(this, `${this.labels.join(', ')} data`, {\n      parameters: {\n        userdataTemplate: this.ami.os.is(Os.WINDOWS) ? windowsUserDataTemplate : linuxUserDataTemplate,\n      },\n      resultPath: stepfunctions.JsonPath.stringAt('$.ec2'),\n    });\n\n    // we can't use fleets because they don't let us override user data, security groups or even disk size\n    // we can't use requestSpotInstances because it doesn't support launch templates, and it's deprecated\n\n    const run = new stepfunctions_tasks.CallAwsService(this, this.labels.join(', '), {\n      integrationPattern: IntegrationPattern.WAIT_FOR_TASK_TOKEN,\n      service: 'ec2',\n      action: 'runInstances',\n      heartbeat: Duration.minutes(5),\n      parameters: {\n        LaunchTemplate: {\n          LaunchTemplateId: this.ami.launchTemplate.launchTemplateId,\n        },\n        MinCount: 1,\n        MaxCount: 1,\n        InstanceType: this.instanceType.toString(),\n        UserData: stepfunctions.JsonPath.base64Encode(\n          stepfunctions.JsonPath.format(\n            stepfunctions.JsonPath.stringAt('$.ec2.userdataTemplate'),\n            ...params,\n          ),\n        ),\n        InstanceInitiatedShutdownBehavior: ec2.InstanceInitiatedShutdownBehavior.TERMINATE,\n        IamInstanceProfile: {\n          Arn: new iam.CfnInstanceProfile(this, 'Instance Profile', {\n            roles: [this.role.roleName],\n          }).attrArn,\n        },\n        MetadataOptions: {\n          HttpTokens: 'required',\n        },\n        SecurityGroupIds: this.securityGroup ? [this.securityGroup.securityGroupId] : undefined,\n        SubnetId: this.subnet?.subnetId,\n        BlockDeviceMappings: [{\n          DeviceName: '/dev/sda1',\n          Ebs: {\n            DeleteOnTermination: true,\n            VolumeSize: this.storageSize.toGibibytes(),\n          },\n        }],\n        InstanceMarketOptions: this.spot ? {\n          MarketType: 'spot',\n          SpotOptions: {\n            MaxPrice: this.spotMaxPrice,\n            SpotInstanceType: 'one-time',\n          },\n        } : undefined,\n      },\n      iamResources: ['*'],\n    });\n\n    return passUserData.next(run);\n  }\n\n  grantStateMachine(stateMachineRole: iam.IGrantable) {\n    stateMachineRole.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({\n      actions: ['iam:PassRole'],\n      resources: [this.role.roleArn],\n      conditions: {\n        StringEquals: {\n          'iam:PassedToService': 'ec2.amazonaws.com',\n        },\n      },\n    }));\n\n    stateMachineRole.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({\n      actions: ['ec2:createTags'],\n      resources: [Stack.of(this).formatArn({\n        service: 'ec2',\n        resource: '*',\n      })],\n    }));\n  }\n\n  status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus {\n    statusFunctionRole.grantPrincipal.addToPrincipalPolicy(new iam.PolicyStatement({\n      actions: ['ec2:DescribeLaunchTemplateVersions'],\n      resources: ['*'],\n    }));\n\n    return {\n      type: this.constructor.name,\n      labels: this.labels,\n      securityGroup: this.securityGroup?.securityGroupId,\n      roleArn: this.role.roleArn,\n      ami: {\n        launchTemplate: this.ami.launchTemplate.launchTemplateId || 'unknown',\n        amiBuilderLogGroup: this.ami.logGroup?.logGroupName,\n      },\n    };\n  }\n\n  /**\n   * The network connections associated with this resource.\n   */\n  public get connections(): ec2.Connections {\n    return this.securityGroup?.connections ?? new ec2.Connections();\n  }\n}\n"]}

package/lib/providers/fargate.d.ts

@@ -1,6 +1,6 @@
 import { aws_ec2 as ec2, aws_ecs as ecs, aws_iam as iam, aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
-import { BaseProvider, IImageBuilder, IRunnerProvider, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';
+import { BaseProvider, IImageBuilder, IRunnerProvider, IRunnerProviderStatus, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';
 /**
  * Properties for FargateRunner.
  */
@@ -114,7 +114,7 @@ export interface FargateRunnerProps extends RunnerProviderProps {
     readonly spot?: boolean;
 }
 /**
- * GitHub Actions runner provider using Fargate to execute the actions.
+ * GitHub Actions runner provider using Fargate to execute jobs.
  *
  * Creates a task definition with a single container that gets started for each job.
  *
@@ -182,7 +182,7 @@ export declare class FargateRunner extends BaseProvider implements IRunnerProvid
      */
     readonly spot: boolean;
     /**
-     * Docker image used to start a new Fargate task.
+     * Docker image loaded with GitHub Actions Runner and its prerequisites. The image is built by an image builder and is specific to Fargate tasks.
      */
     readonly image: RunnerImage;
     constructor(scope: Construct, id: string, props: FargateRunnerProps);
@@ -194,5 +194,7 @@ export declare class FargateRunner extends BaseProvider implements IRunnerProvid
      * @param parameters workflow job details
      */
     getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable;
+    grantStateMachine(_: iam.IGrantable): void;
+    status(statusFunctionRole: iam.IGrantable): IRunnerProviderStatus;
     private runCommand;
 }

package/lib/providers/fargate.js

@@ -36,7 +36,7 @@ class EcsFargateLaunchTarget {
     }
 }
 /**
- * GitHub Actions runner provider using Fargate to execute the actions.
+ * GitHub Actions runner provider using Fargate to execute jobs.
  *
  * Creates a task definition with a single container that gets started for each job.
  *
@@ -157,17 +157,38 @@ class FargateRunner extends common_1.BaseProvider {
             ],
         });
     }
+    grantStateMachine(_) {
+    }
+    status(statusFunctionRole) {
+        this.image.imageRepository.grant(statusFunctionRole, 'ecr:DescribeImages');
+        return {
+            type: this.constructor.name,
+            labels: this.labels,
+            vpcArn: this.vpc?.vpcArn,
+            securityGroup: this.securityGroup?.securityGroupId,
+            roleArn: this.task.taskRole.roleArn,
+            image: {
+                imageRepository: this.image.imageRepository.repositoryUri,
+                imageTag: this.image.imageTag,
+                imageBuilderLogGroup: this.image.logGroup?.logGroupName,
+            },
+        };
+    }
     runCommand() {
+        let runnerFlags = '';
+        if (this.image.runnerVersion.is(common_1.RunnerVersion.latest())) {
+            runnerFlags = '--disableupdate';
+        }
         if (this.image.os.is(common_1.Os.LINUX)) {
             return [
                 'sh', '-c',
-                'if [ "${RUNNER_VERSION}" = "latest" ]; then RUNNER_FLAGS=""; else RUNNER_FLAGS="--disableupdate"; fi && ./config.sh --unattended --url "https://${GITHUB_DOMAIN}/${OWNER}/${REPO}" --token "${RUNNER_TOKEN}" --ephemeral --work _work --labels "${RUNNER_LABEL}" ${RUNNER_FLAGS} --name "${RUNNER_NAME}" && ./run.sh',
+                `./config.sh --unattended --url "https://$GITHUB_DOMAIN/$OWNER/$REPO" --token "$RUNNER_TOKEN" --ephemeral --work _work --labels "$RUNNER_LABEL" ${runnerFlags} --name "$RUNNER_NAME" && ./run.sh`,
             ];
         }
         else if (this.image.os.is(common_1.Os.WINDOWS)) {
             return [
                 'powershell', '-Command',
-                'if (${Env:RUNNER_VERSION} -eq "latest") { $RunnerFlags = "" } else { $RunnerFlags = "--disableupdate" } ; cd \\actions ; ./config.cmd --unattended --url "https://${Env:GITHUB_DOMAIN}/${Env:OWNER}/${Env:REPO}" --token "${Env:RUNNER_TOKEN}" --ephemeral --work _work --labels "${Env:RUNNER_LABEL}" ${RunnerFlags} --name "${Env:RUNNER_NAME}" ; ./run.cmd',
+                `cd \\actions ; ./config.cmd --unattended --url "https://\${Env:GITHUB_DOMAIN}/\${Env:OWNER}/\${Env:REPO}" --token "\${Env:RUNNER_TOKEN}" --ephemeral --work _work --labels "\${Env:RUNNER_LABEL}" ${runnerFlags} --name "\${Env:RUNNER_NAME}" ; ./run.cmd`,
             ];
         }
         else {
@@ -177,7 +198,7 @@ class FargateRunner extends common_1.BaseProvider {
 }
 exports.FargateRunner = FargateRunner;
 _a = JSII_RTTI_SYMBOL_1;
-FargateRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.FargateRunner", version: "0.5.7" };
+FargateRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.FargateRunner", version: "0.6.0" };
 /**
  * Path to Dockerfile for Linux x64 with all the requirement for Fargate runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.
  *
@@ -194,4 +215,4 @@ FargateRunner.LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images',
  * * `EXTRA_PACKAGES` can be used to install additional packages.
  */
 FargateRunner.LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'fargate', 'linux-arm64');
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate.js","sourceRoot":"","sources":["../../src/providers/fargate.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\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} from 'aws-cdk-lib';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { IntegrationPattern } from 'aws-cdk-lib/aws-stepfunctions';\nimport { Construct } from 'constructs';\nimport { Architecture, BaseProvider, IImageBuilder, IRunnerProvider, Os, RunnerImage, RunnerProviderProps, RunnerRuntimeParameters } from './common';\nimport { CodeBuildImageBuilder } from './image-builders/codebuild';\n\n/**\n * Properties for FargateRunner.\n */\nexport interface FargateRunnerProps extends RunnerProviderProps {\n  /**\n   * Provider running an image to run inside CodeBuild with GitHub runner pre-configured. A user named `runner` is expected to exist.\n   *\n   * @default image builder with `FargateRunner.LINUX_X64_DOCKERFILE_PATH` as Dockerfile\n   */\n  readonly imageBuilder?: IImageBuilder;\n\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default undefined\n   * @deprecated use {@link labels} instead\n   */\n  readonly label?: string;\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 ['fargate']\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 Fargate default\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * Security Group to assign to the task.\n   *\n   * @default a new security group\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Existing Fargate cluster to use.\n   *\n   * @default a new cluster\n   */\n  readonly cluster?: ecs.Cluster;\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. For tasks using the Fargate launch type,\n   * this field is required and you must use one of the following values,\n   * which determines your range of valid values for the memory parameter:\n   *\n   * 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)\n   *\n   * 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)\n   *\n   * 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)\n   *\n   * 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)\n   *\n   * 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)\n   *\n   * @default 1024\n   */\n  readonly cpu?: number;\n\n  /**\n   * The amount (in MiB) of memory used by the task. For tasks using the Fargate launch type,\n   * this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter:\n   *\n   * 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU)\n   *\n   * 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU)\n   *\n   * 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU)\n   *\n   * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU)\n   *\n   * Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU)\n   *\n   * @default 2048\n   */\n  readonly memoryLimitMiB?: number;\n\n  /**\n   * The amount (in GiB) of ephemeral storage to be allocated to the task. The maximum supported value is 200 GiB.\n   *\n   * NOTE: This parameter is only supported for tasks hosted on AWS Fargate using platform version 1.4.0 or later.\n   *\n   * @default 20\n   */\n  readonly ephemeralStorageGiB?: number;\n\n  /**\n   * Use Fargate spot capacity provider to save money.\n   *\n   * * Runners may fail to start due to missing capacity.\n   * * Runners might be stopped prematurely with spot pricing.\n   *\n   * @default false\n   */\n  readonly spot?: boolean;\n}\n\n/**\n * Properties for EcsFargateLaunchTarget.\n */\ninterface EcsFargateLaunchTargetProps {\n  readonly spot: boolean;\n  readonly enableExecute: boolean;\n}\n\n/**\n * Our special launch target that can use spot instances and set EnableExecuteCommand.\n */\nclass EcsFargateLaunchTarget implements stepfunctions_tasks.IEcsLaunchTarget {\n  constructor(readonly props: EcsFargateLaunchTargetProps) {}\n\n  /**\n   * Called when the Fargate launch type configured on RunTask\n   */\n  public bind(_task: stepfunctions_tasks.EcsRunTask,\n    launchTargetOptions: stepfunctions_tasks.LaunchTargetBindOptions): stepfunctions_tasks.EcsLaunchTargetConfig {\n    if (!launchTargetOptions.taskDefinition.isFargateCompatible) {\n      throw new Error('Supplied TaskDefinition is not compatible with Fargate');\n    }\n\n    return {\n      parameters: {\n        EnableExecuteCommand: this.props.enableExecute,\n        CapacityProviderStrategy: [\n          {\n            CapacityProvider: this.props.spot ? 'FARGATE_SPOT' : 'FARGATE',\n          },\n        ],\n      },\n    };\n  }\n}\n\n/**\n * GitHub Actions runner provider using Fargate to execute the actions.\n *\n * Creates a task definition with a single container that gets started for each job.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class FargateRunner extends BaseProvider implements IRunnerProvider {\n  /**\n   * Path to Dockerfile for Linux x64 with all the requirement for Fargate runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be an Ubuntu compatible image.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'fargate', 'linux-x64');\n\n  /**\n   * Path to Dockerfile for Linux ARM64 with all the requirement for Fargate runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be an Ubuntu compatible image.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'fargate', 'linux-arm64');\n\n  /**\n   * Cluster hosting the task hosting the runner.\n   */\n  readonly cluster: ecs.Cluster;\n\n  /**\n   * Fargate task hosting the runner.\n   */\n  readonly task: ecs.FargateTaskDefinition;\n\n  /**\n   * Container definition hosting the runner.\n   */\n  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  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Subnets used for hosting the runner task.\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * Security group attached to the task.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Whether runner task will have a public IP.\n   */\n  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   * Use spot pricing for Fargate tasks.\n   */\n  readonly spot: boolean;\n\n  /**\n   * Docker image used to start a new Fargate task.\n   */\n  readonly image: RunnerImage;\n\n  constructor(scope: Construct, id: string, props: FargateRunnerProps) {\n    super(scope, id);\n\n    this.labels = this.labelsFromProperties('fargate', props.label, props.labels);\n    this.vpc = props.vpc ?? ec2.Vpc.fromLookup(this, 'default vpc', { isDefault: true });\n    this.subnetSelection = props.subnetSelection;\n    this.securityGroup = props.securityGroup ?? new ec2.SecurityGroup(this, 'security group', { vpc: this.vpc });\n    this.connections = this.securityGroup.connections;\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: true,\n      },\n    );\n    this.spot = props.spot ?? false;\n\n    const imageBuilder = props.imageBuilder ?? new CodeBuildImageBuilder(this, 'Image Builder', {\n      dockerfilePath: FargateRunner.LINUX_X64_DOCKERFILE_PATH,\n    });\n    const image = this.image = imageBuilder.bind();\n\n    let arch: ecs.CpuArchitecture;\n    if (image.architecture.is(Architecture.ARM64)) {\n      arch = ecs.CpuArchitecture.ARM64;\n    } else if (image.architecture.is(Architecture.X86_64)) {\n      arch = ecs.CpuArchitecture.X86_64;\n    } else {\n      throw new Error(`${image.architecture.name} is not supported on Fargate`);\n    }\n\n    let os: ecs.OperatingSystemFamily;\n    if (image.os.is(Os.LINUX)) {\n      os = ecs.OperatingSystemFamily.LINUX;\n    } else if (image.os.is(Os.WINDOWS)) {\n      os = ecs.OperatingSystemFamily.WINDOWS_SERVER_2019_CORE;\n      if (props.ephemeralStorageGiB) {\n        throw new Error('Ephemeral storage is not supported on Fargate Windows');\n      }\n    } else {\n      throw new Error(`${image.os.name} is not supported on Fargate`);\n    }\n\n    this.task = new ecs.FargateTaskDefinition(\n      this,\n      'task',\n      {\n        cpu: props.cpu ?? 1024,\n        memoryLimitMiB: props.memoryLimitMiB ?? 2048,\n        ephemeralStorageGiB: props.ephemeralStorageGiB ?? !image.os.is(Os.WINDOWS) ? 25 : undefined,\n        runtimePlatform: {\n          operatingSystemFamily: os,\n          cpuArchitecture: arch,\n        },\n      },\n    );\n    this.container = this.task.addContainer(\n      'runner',\n      {\n        image: ecs.AssetImage.fromEcrRepository(image.imageRepository, image.imageTag),\n        logging: ecs.AwsLogDriver.awsLogs({\n          logGroup: new logs.LogGroup(this, 'logs', {\n            retention: props.logRetention ?? RetentionDays.ONE_MONTH,\n            removalPolicy: RemovalPolicy.DESTROY,\n          }),\n          streamPrefix: 'runner',\n        }),\n        command: this.runCommand(),\n      },\n    );\n\n    this.grantPrincipal = new iam.UnknownPrincipal({ resource: this.task.taskRole });\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    return new stepfunctions_tasks.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 EcsFargateLaunchTarget({\n          spot: this.spot,\n          enableExecute: this.image.os.is(Os.LINUX),\n        }),\n        subnets: this.subnetSelection,\n        assignPublicIp: this.assignPublicIp,\n        securityGroups: this.securityGroup ? [this.securityGroup] : undefined,\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\n  private runCommand(): string[] {\n    if (this.image.os.is(Os.LINUX)) {\n      return [\n        'sh', '-c',\n        'if [ \"${RUNNER_VERSION}\" = \"latest\" ]; then RUNNER_FLAGS=\"\"; else RUNNER_FLAGS=\"--disableupdate\"; fi && ./config.sh --unattended --url \"https://${GITHUB_DOMAIN}/${OWNER}/${REPO}\" --token \"${RUNNER_TOKEN}\" --ephemeral --work _work --labels \"${RUNNER_LABEL}\" ${RUNNER_FLAGS} --name \"${RUNNER_NAME}\" && ./run.sh',\n      ];\n    } else if (this.image.os.is(Os.WINDOWS)) {\n      return [\n        'powershell', '-Command',\n        'if (${Env:RUNNER_VERSION} -eq \"latest\") { $RunnerFlags = \"\" } else { $RunnerFlags = \"--disableupdate\" } ; cd \\\\actions ; ./config.cmd --unattended --url \"https://${Env:GITHUB_DOMAIN}/${Env:OWNER}/${Env:REPO}\" --token \"${Env:RUNNER_TOKEN}\" --ephemeral --work _work --labels \"${Env:RUNNER_LABEL}\" ${RunnerFlags} --name \"${Env:RUNNER_NAME}\" ; ./run.cmd',\n      ];\n    } else {\n      throw new Error(`Fargate runner doesn't support ${this.image.os.name}`);\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"fargate.js","sourceRoot":"","sources":["../../src/providers/fargate.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\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} from 'aws-cdk-lib';\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  IImageBuilder,\n  IRunnerProvider,\n  IRunnerProviderStatus,\n  Os,\n  RunnerImage,\n  RunnerProviderProps,\n  RunnerRuntimeParameters, RunnerVersion,\n} from './common';\nimport { CodeBuildImageBuilder } from './image-builders/codebuild';\n\n/**\n * Properties for FargateRunner.\n */\nexport interface FargateRunnerProps extends RunnerProviderProps {\n  /**\n   * Provider running an image to run inside CodeBuild with GitHub runner pre-configured. A user named `runner` is expected to exist.\n   *\n   * @default image builder with `FargateRunner.LINUX_X64_DOCKERFILE_PATH` as Dockerfile\n   */\n  readonly imageBuilder?: IImageBuilder;\n\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default undefined\n   * @deprecated use {@link labels} instead\n   */\n  readonly label?: string;\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 ['fargate']\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 Fargate default\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * Security Group to assign to the task.\n   *\n   * @default a new security group\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Existing Fargate cluster to use.\n   *\n   * @default a new cluster\n   */\n  readonly cluster?: ecs.Cluster;\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. For tasks using the Fargate launch type,\n   * this field is required and you must use one of the following values,\n   * which determines your range of valid values for the memory parameter:\n   *\n   * 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB)\n   *\n   * 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB)\n   *\n   * 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB)\n   *\n   * 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB)\n   *\n   * 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB)\n   *\n   * @default 1024\n   */\n  readonly cpu?: number;\n\n  /**\n   * The amount (in MiB) of memory used by the task. For tasks using the Fargate launch type,\n   * this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter:\n   *\n   * 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU)\n   *\n   * 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU)\n   *\n   * 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU)\n   *\n   * Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU)\n   *\n   * Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU)\n   *\n   * @default 2048\n   */\n  readonly memoryLimitMiB?: number;\n\n  /**\n   * The amount (in GiB) of ephemeral storage to be allocated to the task. The maximum supported value is 200 GiB.\n   *\n   * NOTE: This parameter is only supported for tasks hosted on AWS Fargate using platform version 1.4.0 or later.\n   *\n   * @default 20\n   */\n  readonly ephemeralStorageGiB?: number;\n\n  /**\n   * Use Fargate spot capacity provider to save money.\n   *\n   * * Runners may fail to start due to missing capacity.\n   * * Runners might be stopped prematurely with spot pricing.\n   *\n   * @default false\n   */\n  readonly spot?: boolean;\n}\n\n/**\n * Properties for EcsFargateLaunchTarget.\n */\ninterface EcsFargateLaunchTargetProps {\n  readonly spot: boolean;\n  readonly enableExecute: boolean;\n}\n\n/**\n * Our special launch target that can use spot instances and set EnableExecuteCommand.\n */\nclass EcsFargateLaunchTarget implements stepfunctions_tasks.IEcsLaunchTarget {\n  constructor(readonly props: EcsFargateLaunchTargetProps) {}\n\n  /**\n   * Called when the Fargate launch type configured on RunTask\n   */\n  public bind(_task: stepfunctions_tasks.EcsRunTask,\n    launchTargetOptions: stepfunctions_tasks.LaunchTargetBindOptions): stepfunctions_tasks.EcsLaunchTargetConfig {\n    if (!launchTargetOptions.taskDefinition.isFargateCompatible) {\n      throw new Error('Supplied TaskDefinition is not compatible with Fargate');\n    }\n\n    return {\n      parameters: {\n        EnableExecuteCommand: this.props.enableExecute,\n        CapacityProviderStrategy: [\n          {\n            CapacityProvider: this.props.spot ? 'FARGATE_SPOT' : 'FARGATE',\n          },\n        ],\n      },\n    };\n  }\n}\n\n/**\n * GitHub Actions runner provider using Fargate to execute jobs.\n *\n * Creates a task definition with a single container that gets started for each job.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class FargateRunner extends BaseProvider implements IRunnerProvider {\n  /**\n   * Path to Dockerfile for Linux x64 with all the requirement for Fargate runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be an Ubuntu compatible image.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'fargate', 'linux-x64');\n\n  /**\n   * Path to Dockerfile for Linux ARM64 with all the requirement for Fargate runner. Use this Dockerfile unless you need to customize it further than allowed by hooks.\n   *\n   * Available build arguments that can be set in the image builder:\n   * * `BASE_IMAGE` sets the `FROM` line. This should be an Ubuntu compatible image.\n   * * `EXTRA_PACKAGES` can be used to install additional packages.\n   */\n  public static readonly LINUX_ARM64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'fargate', 'linux-arm64');\n\n  /**\n   * Cluster hosting the task hosting the runner.\n   */\n  readonly cluster: ecs.Cluster;\n\n  /**\n   * Fargate task hosting the runner.\n   */\n  readonly task: ecs.FargateTaskDefinition;\n\n  /**\n   * Container definition hosting the runner.\n   */\n  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  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Subnets used for hosting the runner task.\n   */\n  readonly subnetSelection?: ec2.SubnetSelection;\n\n  /**\n   * Security group attached to the task.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Whether runner task will have a public IP.\n   */\n  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   * Use spot pricing for Fargate tasks.\n   */\n  readonly spot: boolean;\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 Fargate tasks.\n   */\n  readonly image: RunnerImage;\n\n  constructor(scope: Construct, id: string, props: FargateRunnerProps) {\n    super(scope, id);\n\n    this.labels = this.labelsFromProperties('fargate', props.label, props.labels);\n    this.vpc = props.vpc ?? ec2.Vpc.fromLookup(this, 'default vpc', { isDefault: true });\n    this.subnetSelection = props.subnetSelection;\n    this.securityGroup = props.securityGroup ?? new ec2.SecurityGroup(this, 'security group', { vpc: this.vpc });\n    this.connections = this.securityGroup.connections;\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: true,\n      },\n    );\n    this.spot = props.spot ?? false;\n\n    const imageBuilder = props.imageBuilder ?? new CodeBuildImageBuilder(this, 'Image Builder', {\n      dockerfilePath: FargateRunner.LINUX_X64_DOCKERFILE_PATH,\n    });\n    const image = this.image = imageBuilder.bind();\n\n    let arch: ecs.CpuArchitecture;\n    if (image.architecture.is(Architecture.ARM64)) {\n      arch = ecs.CpuArchitecture.ARM64;\n    } else if (image.architecture.is(Architecture.X86_64)) {\n      arch = ecs.CpuArchitecture.X86_64;\n    } else {\n      throw new Error(`${image.architecture.name} is not supported on Fargate`);\n    }\n\n    let os: ecs.OperatingSystemFamily;\n    if (image.os.is(Os.LINUX)) {\n      os = ecs.OperatingSystemFamily.LINUX;\n    } else if (image.os.is(Os.WINDOWS)) {\n      os = ecs.OperatingSystemFamily.WINDOWS_SERVER_2019_CORE;\n      if (props.ephemeralStorageGiB) {\n        throw new Error('Ephemeral storage is not supported on Fargate Windows');\n      }\n    } else {\n      throw new Error(`${image.os.name} is not supported on Fargate`);\n    }\n\n    this.task = new ecs.FargateTaskDefinition(\n      this,\n      'task',\n      {\n        cpu: props.cpu ?? 1024,\n        memoryLimitMiB: props.memoryLimitMiB ?? 2048,\n        ephemeralStorageGiB: props.ephemeralStorageGiB ?? !image.os.is(Os.WINDOWS) ? 25 : undefined,\n        runtimePlatform: {\n          operatingSystemFamily: os,\n          cpuArchitecture: arch,\n        },\n      },\n    );\n    this.container = this.task.addContainer(\n      'runner',\n      {\n        image: ecs.AssetImage.fromEcrRepository(image.imageRepository, image.imageTag),\n        logging: ecs.AwsLogDriver.awsLogs({\n          logGroup: new logs.LogGroup(this, 'logs', {\n            retention: props.logRetention ?? RetentionDays.ONE_MONTH,\n            removalPolicy: RemovalPolicy.DESTROY,\n          }),\n          streamPrefix: 'runner',\n        }),\n        command: this.runCommand(),\n      },\n    );\n\n    this.grantPrincipal = new iam.UnknownPrincipal({ resource: this.task.taskRole });\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    return new stepfunctions_tasks.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 EcsFargateLaunchTarget({\n          spot: this.spot,\n          enableExecute: this.image.os.is(Os.LINUX),\n        }),\n        subnets: this.subnetSelection,\n        assignPublicIp: this.assignPublicIp,\n        securityGroups: this.securityGroup ? [this.securityGroup] : undefined,\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\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      securityGroup: this.securityGroup?.securityGroupId,\n      roleArn: this.task.taskRole.roleArn,\n      image: {\n        imageRepository: this.image.imageRepository.repositoryUri,\n        imageTag: this.image.imageTag,\n        imageBuilderLogGroup: this.image.logGroup?.logGroupName,\n      },\n    };\n  }\n\n  private runCommand(): string[] {\n    let runnerFlags = '';\n    if (this.image.runnerVersion.is(RunnerVersion.latest())) {\n      runnerFlags = '--disableupdate';\n    }\n\n    if (this.image.os.is(Os.LINUX)) {\n      return [\n        'sh', '-c',\n        `./config.sh --unattended --url \"https://$GITHUB_DOMAIN/$OWNER/$REPO\" --token \"$RUNNER_TOKEN\" --ephemeral --work _work --labels \"$RUNNER_LABEL\" ${runnerFlags} --name \"$RUNNER_NAME\" && ./run.sh`,\n      ];\n    } else if (this.image.os.is(Os.WINDOWS)) {\n      return [\n        'powershell', '-Command',\n        `cd \\\\actions ; ./config.cmd --unattended --url \"https://\\${Env:GITHUB_DOMAIN}/\\${Env:OWNER}/\\${Env:REPO}\" --token \"\\${Env:RUNNER_TOKEN}\" --ephemeral --work _work --labels \"\\${Env:RUNNER_LABEL}\" ${runnerFlags} --name \"\\${Env:RUNNER_NAME}\" ; ./run.cmd`,\n      ];\n    } else {\n      throw new Error(`Fargate runner doesn't support ${this.image.os.name}`);\n    }\n  }\n}\n"]}