@cloudsnorkel/cdk-github-runners 0.1.1 → 0.3.1

package/lib/providers/docker-images/fargate/linux-arm64/Dockerfile

@@ -0,0 +1,45 @@
+ARG BASE_IMAGE="public.ecr.aws/lts/ubuntu:20.04"
+FROM $BASE_IMAGE
+
+# setup user
+RUN addgroup runner && adduser --system --disabled-password --home /home/runner --ingroup runner runner
+
+# add dependencies and sudo
+ARG EXTRA_PACKAGES=""
+RUN apt-get update && apt-get upgrade -y && apt-get install -y curl sudo jq bash zip unzip software-properties-common ca-certificates $EXTRA_PACKAGES && \
+    usermod -aG sudo runner && \
+    echo "%sudo   ALL=(ALL:ALL) NOPASSWD: ALL" > /etc/sudoers.d/runner
+
+# install extra certificates
+COPY extra_certs/. /tmp/certs/
+RUN if [ -f /tmp/certs/certs.pem ]; then cp /tmp/certs/certs.pem /usr/local/share/ca-certificates/github-enterprise-server.crt; update-ca-certificates; else echo no self-signed certificates; fi
+
+# add latest git
+RUN add-apt-repository ppa:git-core/ppa && apt update && apt-get install -y git
+
+# add awscli
+RUN curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o awscliv2.zip && \
+    unzip -q awscliv2.zip && ./aws/install && rm -rf awscliv2.zip aws
+
+# add ghcli
+RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg && \
+    echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] https://cli.github.com/packages stable main" | sudo tee /etc/apt/sources.list.d/github-cli.list > /dev/null  && \
+    apt update && \
+    apt install -y gh
+
+# setup working directory
+WORKDIR /home/runner
+
+# add runner without github's api which is rate limited
+ARG RUNNER_VERSION=latest
+RUN if [ "${RUNNER_VERSION}" = "latest" ]; then RUNNER_VERSION=`curl  -w "%{redirect_url}" -fsS https://github.com/actions/runner/releases/latest | grep -oE "[^/v]+$"`; fi && \
+    curl -fsSLO  "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz" && \
+    tar xzf "actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz" && \
+    rm actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz && \
+    ./bin/installdependencies.sh
+
+# configure runner
+USER runner
+
+ADD runner.sh .
+CMD ["bash", "/home/runner/runner.sh"]

package/lib/providers/docker-images/fargate/{Dockerfile → linux-x64/Dockerfile}

@@ -1,13 +1,22 @@
-FROM public.ecr.aws/lts/ubuntu:18.04
+ARG BASE_IMAGE="public.ecr.aws/lts/ubuntu:20.04"
+FROM $BASE_IMAGE
 
 # setup user
 RUN addgroup runner && adduser --system --disabled-password --home /home/runner --ingroup runner runner
 
 # add dependencies and sudo
-RUN apt-get update && apt-get upgrade -y && apt-get install -y curl sudo jq bash git zip unzip && \
+ARG EXTRA_PACKAGES=""
+RUN apt-get update && apt-get upgrade -y && apt-get install -y curl sudo jq bash zip unzip software-properties-common ca-certificates $EXTRA_PACKAGES && \
     usermod -aG sudo runner && \
     echo "%sudo   ALL=(ALL:ALL) NOPASSWD: ALL" > /etc/sudoers.d/runner
 
+# install extra certificates
+COPY extra_certs/. /tmp/certs/
+RUN if [ -f /tmp/certs/certs.pem ]; then cp /tmp/certs/certs.pem /usr/local/share/ca-certificates/github-enterprise-server.crt; update-ca-certificates; else echo no self-signed certificates; fi
+
+# add latest git
+RUN add-apt-repository ppa:git-core/ppa && apt update && apt-get install -y git
+
 # add awscli
 RUN curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o awscliv2.zip && \
     unzip -q awscliv2.zip && ./aws/install && rm -rf awscliv2.zip aws
@@ -21,9 +30,9 @@ RUN curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | s
 # setup working directory
 WORKDIR /home/runner
 
-# add runner
-ARG RUNNER_VERSION
-RUN if [ "${RUNNER_VERSION}" = "latest" ]; then RUNNER_VERSION=`curl -fsSL https://api.github.com/repos/actions/runner/releases/latest | jq -r .tag_name | cut -c2-`; fi && \
+# add runner without github's api which is rate limited
+ARG RUNNER_VERSION=latest
+RUN if [ "${RUNNER_VERSION}" = "latest" ]; then RUNNER_VERSION=`curl  -w "%{redirect_url}" -fsS https://github.com/actions/runner/releases/latest | grep -oE "[^/v]+$"`; fi && \
     curl -fsSLO  "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz" && \
     tar xzf "actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz" && \
     rm actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz && \

package/lib/providers/docker-images/fargate/linux-x64/runner.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+set -e -u -o pipefail
+
+/home/runner/config.sh --unattended --url "https://${GITHUB_DOMAIN}/${OWNER}/${REPO}" --token "${RUNNER_TOKEN}" --ephemeral --work _work --labels "${RUNNER_LABEL}" --disableupdate --name "${RUNNER_NAME}"
+/home/runner/run.sh

package/lib/providers/docker-images/lambda/linux-arm64/Dockerfile

@@ -0,0 +1,36 @@
+# https://docs.aws.amazon.com/lambda/latest/dg/images-create.html
+
+ARG BASE_IMAGE="public.ecr.aws/lambda/nodejs:14-arm64"
+FROM $BASE_IMAGE
+
+WORKDIR /runner
+
+# install extra certificates
+COPY extra_certs/. /tmp/certs/
+RUN if [ -f /tmp/certs/certs.pem ]; then cp /tmp/certs/certs.pem /etc/pki/ca-trust/source/anchors/ghe.crt; update-ca-trust; else echo no self-signed certificates; fi
+
+# add dependencies
+ARG EXTRA_PACKAGES=""
+RUN yum update -y && yum install -y jq tar gzip bzip2 which binutils git zip unzip $EXTRA_PACKAGES
+
+# add awscli
+RUN curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o awscliv2.zip && \
+    unzip -q awscliv2.zip && ./aws/install && rm -rf awscliv2.zip aws
+
+# add ghcli
+RUN curl -fsSSL https://cli.github.com/packages/rpm/gh-cli.repo -o /etc/yum.repos.d/gh-cli.repo && \
+    yum install -y gh
+
+# add runner without github's api which is rate limited
+ARG RUNNER_VERSION=latest
+RUN if [ "${RUNNER_VERSION}" = "latest" ]; then RUNNER_VERSION=`curl  -w "%{redirect_url}" -fsS https://github.com/actions/runner/releases/latest | grep -oE "[^/v]+$"`; fi && \
+    curl -fsSLO  "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz" && \
+    tar xzf "actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz" && \
+    rm actions-runner-linux-arm64-${RUNNER_VERSION}.tar.gz && \
+    yum install -y openssl-libs krb5-libs zlib libicu60
+# doesn't work on CentOS - RUN ./bin/installdependencies.sh
+
+# prepare for execution
+WORKDIR ${LAMBDA_TASK_ROOT}
+COPY runner.js runner.sh ${LAMBDA_TASK_ROOT}/
+CMD ["runner.handler"]

package/lib/providers/docker-images/lambda/linux-x64/Dockerfile

@@ -0,0 +1,35 @@
+# https://docs.aws.amazon.com/lambda/latest/dg/images-create.html
+
+ARG BASE_IMAGE="public.ecr.aws/lambda/nodejs:14-x86_64"
+FROM $BASE_IMAGE
+
+WORKDIR /runner
+
+# install extra certificates
+COPY extra_certs/. /tmp/certs/
+RUN if [ -f /tmp/certs/certs.pem ]; then cp /tmp/certs/certs.pem /etc/pki/ca-trust/source/anchors/ghe.crt; update-ca-trust; else echo no self-signed certificates; fi
+
+# add dependencies
+ARG EXTRA_PACKAGES=""
+RUN yum update -y && yum install -y jq tar gzip bzip2 which binutils git zip unzip $EXTRA_PACKAGES
+
+# add awscli
+RUN curl -fsSL "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o awscliv2.zip && \
+    unzip -q awscliv2.zip && ./aws/install && rm -rf awscliv2.zip aws
+
+# add ghcli
+RUN curl -fsSSL https://cli.github.com/packages/rpm/gh-cli.repo -o /etc/yum.repos.d/gh-cli.repo && \
+    yum install -y gh
+
+# add runner without github's api which is rate limited
+ARG RUNNER_VERSION=latest
+RUN if [ "${RUNNER_VERSION}" = "latest" ]; then RUNNER_VERSION=`curl  -w "%{redirect_url}" -fsS https://github.com/actions/runner/releases/latest | grep -oE "[^/v]+$"`; fi && \
+    curl -fsSLO "https://github.com/actions/runner/releases/download/v${RUNNER_VERSION}/actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz" && \
+    tar xzf "actions-runner-linux-x64-${RUNNER_VERSION}.tar.gz" && \
+    rm -f actions-runner-linux-x64-*.tar.gz && \
+    yum install -y openssl-libs krb5-libs zlib libicu60
+
+# prepare for execution
+WORKDIR ${LAMBDA_TASK_ROOT}
+COPY runner.js runner.sh ${LAMBDA_TASK_ROOT}/
+CMD ["runner.handler"]

package/lib/providers/docker-images/lambda/linux-x64/runner.js

@@ -0,0 +1,29 @@
+const exec = require('child_process').exec;
+
+exports.handler = async (event, context) => {
+  await new Promise((resolve, reject) => {
+    const shellScript = exec('sh runner.sh', {
+      env: {
+        OWNER: event.owner,
+        REPO: event.repo,
+        GITHUB_DOMAIN: event.githubDomain,
+        RUNNER_TOKEN: event.token,
+        RUNNER_NAME: event.runnerName,
+        RUNNER_LABEL: event.label,
+      },
+    });
+    shellScript.stdout.on('data', (data) => {
+      console.log(data);
+    });
+    shellScript.stderr.on('data', (data) => {
+      console.error(data);
+    });
+    shellScript.on('exit', (code) => {
+      if (code) {
+        reject(new Error(`Runner failed with exit code ${code}`));
+      } else {
+        resolve();
+      }
+    });
+  });
+}

package/lib/providers/docker-images/lambda/linux-x64/runner.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+set -e -u -o pipefail
+
+cp -r /runner /tmp/
+cd /tmp/runner
+
+export PATH=/var/lang/bin:/usr/local/bin:/usr/bin/:/bin:/opt/bin
+./config.sh --unattended --url "https://${GITHUB_DOMAIN}/${OWNER}/${REPO}" --token "${RUNNER_TOKEN}" --ephemeral --work _work --labels "${RUNNER_LABEL}" --name "${RUNNER_NAME}" --disableupdate
+echo Config done
+./run.sh
+echo Run done

package/lib/providers/fargate.d.ts

@@ -1,10 +1,26 @@
 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 { IRunnerProvider, RunnerProviderProps, RunnerRuntimeParameters } from './common';
+import { IImageBuilder, IRunnerProvider, RunnerProviderProps, RunnerRuntimeParameters } from './common';
 /**
  * Properties for FargateRunner.
  */
 export interface FargateRunnerProps extends RunnerProviderProps {
+    /**
+     * Provider running an image to run inside CodeBuild with GitHub runner pre-configured. A user named `runner` is expected to exist.
+     *
+     * The entry point should start GitHub runner. For example:
+     *
+     * ```
+     * #!/bin/bash
+     * set -e -u -o pipefail
+     *
+     * /home/runner/config.sh --unattended --url "https://${GITHUB_DOMAIN}/${OWNER}/${REPO}" --token "${RUNNER_TOKEN}" --ephemeral --work _work --labels "${RUNNER_LABEL}" --disableupdate --name "${RUNNER_NAME}"
+     * /home/runner/run.sh
+     * ```
+     *
+     * @default image builder with `FargateRunner.LINUX_X64_DOCKERFILE_PATH` as Dockerfile
+     */
+    readonly imageBuilder?: IImageBuilder;
     /**
      * GitHub Actions label used for this provider.
      *
@@ -80,6 +96,15 @@ export interface FargateRunnerProps extends RunnerProviderProps {
      * @default 20
      */
     readonly ephemeralStorageGiB?: number;
+    /**
+     * Use Fargate spot capacity provider to save money.
+     *
+     * * Runners may fail to start due to missing capacity.
+     * * Runners might be stopped prematurely with spot pricing.
+     *
+     * @default false
+     */
+    readonly spot?: boolean;
 }
 /**
  * GitHub Actions runner provider using Fargate to execute the actions.
@@ -89,6 +114,22 @@ export interface FargateRunnerProps extends RunnerProviderProps {
  * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.
  */
 export declare class FargateRunner extends Construct implements IRunnerProvider {
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    static readonly LINUX_X64_DOCKERFILE_PATH: string;
+    /**
+     * 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.
+     *
+     * 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.
+     */
+    static readonly LINUX_ARM64_DOCKERFILE_PATH: string;
     /**
      * Cluster hosting the task hosting the runner.
      */
@@ -125,6 +166,10 @@ export declare class FargateRunner extends Construct implements IRunnerProvider
      * The network connections associated with this resource.
      */
     readonly connections: ec2.Connections;
+    /**
+     * Use spot pricing for Fargate tasks.
+     */
+    readonly spot: boolean;
     constructor(scope: Construct, id: string, props: FargateRunnerProps);
     /**
      * Generate step function task(s) to start a new runner.
@@ -135,4 +180,3 @@ export declare class FargateRunner extends Construct implements IRunnerProvider
      */
     getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable;
 }
-//# sourceMappingURL=fargate.d.ts.map

package/lib/providers/fargate.js

@@ -5,9 +5,30 @@ exports.FargateRunner = void 0;
 const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 const path = require("path");
 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 constructs_1 = require("constructs");
 const common_1 = require("./common");
+const codebuild_1 = require("./image-builders/codebuild");
+class EcsFargateSpotLaunchTarget {
+    /**
+     * Called when the Fargate launch type configured on RunTask
+     */
+    bind(_task, launchTargetOptions) {
+        if (!launchTargetOptions.taskDefinition.isFargateCompatible) {
+            throw new Error('Supplied TaskDefinition is not compatible with Fargate');
+        }
+        return {
+            parameters: {
+                CapacityProviderStrategy: [
+                    {
+                        CapacityProvider: 'FARGATE_SPOT',
+                    },
+                ],
+            },
+        };
+    }
+}
 /**
  * GitHub Actions runner provider using Fargate to execute the actions.
  *
@@ -27,19 +48,37 @@ class FargateRunner extends constructs_1.Construct {
             vpc: this.vpc,
             enableFargateCapacityProviders: true,
         });
+        this.spot = props.spot ?? false;
+        const imageBuilder = props.imageBuilder ?? new codebuild_1.CodeBuildImageBuilder(this, 'Image Builder', {
+            dockerfilePath: FargateRunner.LINUX_X64_DOCKERFILE_PATH,
+        });
+        const image = imageBuilder.bind();
+        let arch;
+        if (image.architecture.is(common_1.Architecture.ARM64)) {
+            arch = aws_cdk_lib_1.aws_ecs.CpuArchitecture.ARM64;
+        }
+        else if (image.architecture.is(common_1.Architecture.X86_64)) {
+            arch = aws_cdk_lib_1.aws_ecs.CpuArchitecture.X86_64;
+        }
+        else {
+            throw new Error(`${image.architecture.name} is not supported on Fargate`);
+        }
         this.task = new aws_cdk_lib_1.aws_ecs.FargateTaskDefinition(this, 'task', {
             cpu: props.cpu || 1024,
             memoryLimitMiB: props.memoryLimitMiB || 2048,
             ephemeralStorageGiB: props.ephemeralStorageGiB || 25,
+            runtimePlatform: {
+                operatingSystemFamily: aws_cdk_lib_1.aws_ecs.OperatingSystemFamily.LINUX,
+                cpuArchitecture: arch,
+            },
         });
         this.container = this.task.addContainer('runner', {
-            image: aws_cdk_lib_1.aws_ecs.AssetImage.fromAsset(path.join(__dirname, 'docker-images', 'fargate'), {
-                buildArgs: {
-                    RUNNER_VERSION: props.runnerVersion ? props.runnerVersion.version : common_1.RunnerVersion.latest().version,
-                },
-            }),
+            image: aws_cdk_lib_1.aws_ecs.AssetImage.fromEcrRepository(image.imageRepository, image.imageTag),
             logging: aws_cdk_lib_1.aws_ecs.AwsLogDriver.awsLogs({
-                logGroup: new aws_cdk_lib_1.aws_logs.LogGroup(this, 'logs'),
+                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,
+                }),
                 streamPrefix: 'runner',
             }),
         });
@@ -53,11 +92,11 @@ class FargateRunner extends constructs_1.Construct {
      * @param parameters workflow job details
      */
     getStepFunctionTask(parameters) {
-        return new aws_cdk_lib_1.aws_stepfunctions_tasks.EcsRunTask(this, 'Fargate Runner', {
+        return new aws_cdk_lib_1.aws_stepfunctions_tasks.EcsRunTask(this, this.label, {
             integrationPattern: aws_stepfunctions_1.IntegrationPattern.RUN_JOB,
             taskDefinition: this.task,
             cluster: this.cluster,
-            launchTarget: new aws_cdk_lib_1.aws_stepfunctions_tasks.EcsFargateLaunchTarget(),
+            launchTarget: this.spot ? new EcsFargateSpotLaunchTarget() : new aws_cdk_lib_1.aws_stepfunctions_tasks.EcsFargateLaunchTarget(),
             assignPublicIp: this.assignPublicIp,
             securityGroups: this.securityGroup ? [this.securityGroup] : undefined,
             containerOverrides: [
@@ -96,5 +135,21 @@ class FargateRunner extends constructs_1.Construct {
 }
 exports.FargateRunner = FargateRunner;
 _a = JSII_RTTI_SYMBOL_1;
-FargateRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.FargateRunner", version: "0.1.1" };
-//# 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} from 'aws-cdk-lib';\nimport { IntegrationPattern } from 'aws-cdk-lib/aws-stepfunctions';\nimport { Construct } from 'constructs';\nimport { IRunnerProvider, RunnerProviderProps, RunnerRuntimeParameters, RunnerVersion } from './common';\n\n/**\n * Properties for FargateRunner.\n */\nexport interface FargateRunnerProps extends RunnerProviderProps {\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default 'fargate'\n   */\n  readonly label?: 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   * 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/**\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 Construct implements IRunnerProvider {\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   * Label associated with this provider.\n   */\n  readonly label: string;\n\n  /**\n   * VPC used for hosting the task.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group attached to the task.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Whether 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  constructor(scope: Construct, id: string, props: FargateRunnerProps) {\n    super(scope, id);\n\n    this.label = props.label || 'fargate';\n    this.vpc = props.vpc || ec2.Vpc.fromLookup(this, 'default vpc', { isDefault: true });\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\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 || 25,\n      },\n    );\n    this.container = this.task.addContainer(\n      'runner',\n      {\n        image: ecs.AssetImage.fromAsset(\n          path.join(__dirname, 'docker-images', 'fargate'),\n          {\n            buildArgs: {\n              RUNNER_VERSION: props.runnerVersion ? props.runnerVersion.version : RunnerVersion.latest().version,\n            },\n          },\n        ),\n        logging: ecs.AwsLogDriver.awsLogs({\n          logGroup: new logs.LogGroup(this, 'logs'),\n          streamPrefix: 'runner',\n        }),\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      'Fargate Runner',\n      {\n        integrationPattern: IntegrationPattern.RUN_JOB, // sync\n        taskDefinition: this.task,\n        cluster: this.cluster,\n        launchTarget: new stepfunctions_tasks.EcsFargateLaunchTarget(),\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.label,\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}"]}
+FargateRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.FargateRunner", version: "0.3.1" };
+/**
+ * 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.
+ *
+ * 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.
+ */
+FargateRunner.LINUX_X64_DOCKERFILE_PATH = path.join(__dirname, 'docker-images', 'fargate', 'linux-x64');
+/**
+ * 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.
+ *
+ * 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.
+ */
+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, 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, IImageBuilder, IRunnerProvider, 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   * The entry point should start GitHub runner. For example:\n   *\n   * ```\n   * #!/bin/bash\n   * set -e -u -o pipefail\n   *\n   * /home/runner/config.sh --unattended --url \"https://${GITHUB_DOMAIN}/${OWNER}/${REPO}\" --token \"${RUNNER_TOKEN}\" --ephemeral --work _work --labels \"${RUNNER_LABEL}\" --disableupdate --name \"${RUNNER_NAME}\"\n   * /home/runner/run.sh\n   * ```\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 'fargate'\n   */\n  readonly label?: 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   * 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\nclass EcsFargateSpotLaunchTarget implements stepfunctions_tasks.IEcsLaunchTarget {\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        CapacityProviderStrategy: [\n          {\n            CapacityProvider: 'FARGATE_SPOT',\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 Construct 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   * Label associated with this provider.\n   */\n  readonly label: string;\n\n  /**\n   * VPC used for hosting the task.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group attached to the task.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Whether 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  constructor(scope: Construct, id: string, props: FargateRunnerProps) {\n    super(scope, id);\n\n    this.label = props.label || 'fargate';\n    this.vpc = props.vpc || ec2.Vpc.fromLookup(this, 'default vpc', { isDefault: true });\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 = 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    this.task = new ecs.FargateTaskDefinition(\n      this,\n      'task',\n      {\n        cpu: props.cpu || 1024,\n        memoryLimitMiB: props.memoryLimitMiB || 2048,\n        ephemeralStorageGiB: props.ephemeralStorageGiB || 25,\n        runtimePlatform: {\n          operatingSystemFamily: ecs.OperatingSystemFamily.LINUX,\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      },\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.label,\n      {\n        integrationPattern: IntegrationPattern.RUN_JOB, // sync\n        taskDefinition: this.task,\n        cluster: this.cluster,\n        launchTarget: this.spot ? new EcsFargateSpotLaunchTarget() : new stepfunctions_tasks.EcsFargateLaunchTarget(),\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.label,\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"]}