@rio-cloud/cdk-v2-constructs 6.2.1 → 6.3.0

package/lib/contributions/smart-route/gitlab-runner/autoscaling-runner.d.ts

@@ -1,7 +1,8 @@
 import { Environment, Stack } from 'aws-cdk-lib';
 import { InstanceType } from 'aws-cdk-lib/aws-ec2';
 import { IRole } from 'aws-cdk-lib/aws-iam';
-import { StringParameter } from 'aws-cdk-lib/aws-ssm';
+import { IBucket } from 'aws-cdk-lib/aws-s3';
+import { IStringParameter } from 'aws-cdk-lib/aws-ssm';
 import { Construct } from 'constructs';
 /**
  * The GitLabRunnerProps require the VPC ID, a defined environment of account and region, optional
@@ -10,8 +11,9 @@ import { Construct } from 'constructs';
  */
 export interface GitLabRunnerProps {
     readonly env: Environment;
-    readonly runnersWorkerProps?: GitlabRunnerWorkerProps[];
+    readonly runnersWorkerProps?: GitlabRunnerWorkerProps;
     readonly managerInstanceType?: InstanceType;
+    readonly cache: IBucket;
 }
 /**
  * The GitlabRunnerWorkerProps interface provides a simplified GitLab Runner worker configuration
@@ -21,23 +23,23 @@ export interface GitLabRunnerProps {
  */
 export interface GitlabRunnerWorkerProps {
     /** The SSM StringParameter with the registered runner token  */
-    token: StringParameter;
+    readonly token: IStringParameter;
     /** The GitLab instance URL, either https://gitlab.cicd.man or https://gitlab.collaborationlayer-traton.com */
-    gitInstanceUrl: GitlabInstanceUrl;
+    readonly gitInstanceUrl: GitlabInstanceUrl;
     /** The instance type for the runner worker */
-    instanceType: InstanceType;
+    readonly instanceType: InstanceType;
     /** The desired max spot price */
-    spotPrice: number;
+    readonly spotPrice: number;
     /** Whether to use spot instance or not, Requires ServiceLinked Role for EC2 Spot to be deployed in the account */
-    requestSpotPrice: boolean;
+    readonly requestSpotPrice: boolean;
     /** The default role for the runner worker when spawned */
-    defaultWorkerRole: IRole;
+    readonly defaultWorkerRole: IRole;
     /** The maximum number of builds for an instance before it has to be decommissioned. Default 10 */
-    maxBuilds?: number;
+    readonly maxBuilds?: number;
     /** The maximum number of instances to keep idle for new incoming jobs. Default 5 */
-    maxIdleInstance?: number;
+    readonly maxIdleInstance?: number;
     /** The maximum idle time seconds for an instance. Default 900 seconds */
-    maxIdleTime?: number;
+    readonly maxIdleTime?: number;
 }
 export type GitlabInstanceUrl = 'https://gitlab.cicd.man' | 'https://gitlab.collaborationlayer-traton.com';
 /**
@@ -48,34 +50,48 @@ export type GitlabInstanceUrl = 'https://gitlab.cicd.man' | 'https://gitlab.coll
  * minimal configuration with runner spot instance:
  * ```ts
  * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
+ * const myBucket = new Bucket(stack, 'MyShareRunnerCache', {
+ *     enforceSSL: true,
+ *     publicReadAccess: false,
+ *     encryption: BucketEncryption.S3_MANAGED,
+ *     lifecycleRules: [
+ *       {
+ *         enabled: true,
+ *         expiration: Duration.days(30),
+ *       },
+ *     ],
+ *   });
  * new GitlabRunner(stack, 'GitLabRunner', {
- *  env: {account: '123456789012', region: 'eu-west-1'}
+ *  env: {account: '123456789012', region: 'eu-west-1'},
+ *  cache: myBucket // use a S3 bucket without public access and a retention defined, use one cache bucket for all you runners
  * });
  *```
  * recommended:
  * ```ts
  * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
  * const runnerRoles = new RunnerRoles(stack, 'RunnerRoles', {env: {account: '123456789012', region: 'eu-west-1'}});
+ * const myBucket = new Bucket(stack, 'MyShareRunnerCache', {
+ *     enforceSSL: true,
+ *     publicReadAccess: false,
+ *     encryption: BucketEncryption.S3_MANAGED,
+ *     lifecycleRules: [
+ *       {
+ *         enabled: true,
+ *         expiration: Duration.days(30),
+ *       },
+ *     ],
+ *   });
  * new GitlabRunner(stack, 'GitLabRunner', {
  *  env: {account: '123456789012', region: 'eu-west-1'},
- *  runnersWorkerProps: [
- *    {
- *      token: myTokenForTaggedRunner1, // with this runner we only want to run jobs that require more power
- *      gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab
- *      instanceType: InstanceType.of(InstanceClass.M7I_FLEX, InstanceSize.XLARGE), // exemplary larger runner
- *      spotPrice: 0.2, // exemplary spot price
- *      requestSpotPrice: true,
- *      defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role
- *    },
- *    {
- *      token: myTokenForTaggedRunner2, // with this runner we want to run all generic jobs that do not require much processing power
- *      gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab
- *      instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.MEDIUM), // exemplary smaller runner
- *      spotPrice: 0.044, // exemplary spot price
- *      requestSpotPrice: true,
- *      defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role
- *    },
- *  ],
+ *  cache: myBucket // // use a S3 bucket without public access and a retention defined, use one cache bucket for all you runners
+ *  runnersWorkerProps: {
+ *    token: myTokenForTaggedRunner1, // with this runner we only want to run jobs that require more power
+ *    gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab
+ *    instanceType: InstanceType.of(InstanceClass.M7I_FLEX, InstanceSize.XLARGE), // exemplary larger runner
+ *    spotPrice: 0.2, // exemplary spot price
+ *    requestSpotPrice: true,
+ *    defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role
+ *  },
  * });
  * ```
  */

package/lib/contributions/smart-route/gitlab-runner/autoscaling-runner.js

@@ -1,6 +1,8 @@
 "use strict";
+var _a;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitlabRunner = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
 // eslint-disable-next-line import/no-extraneous-dependencies
 const cdk_autoscaling_gitlab_runner_1 = require("@pepperize/cdk-autoscaling-gitlab-runner");
 const aws_ec2_1 = require("aws-cdk-lib/aws-ec2");
@@ -15,34 +17,48 @@ const rio_landing_zone_1 = require("../../../rio-landing-zone");
  * minimal configuration with runner spot instance:
  * ```ts
  * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
+ * const myBucket = new Bucket(stack, 'MyShareRunnerCache', {
+ *     enforceSSL: true,
+ *     publicReadAccess: false,
+ *     encryption: BucketEncryption.S3_MANAGED,
+ *     lifecycleRules: [
+ *       {
+ *         enabled: true,
+ *         expiration: Duration.days(30),
+ *       },
+ *     ],
+ *   });
  * new GitlabRunner(stack, 'GitLabRunner', {
- *  env: {account: '123456789012', region: 'eu-west-1'}
+ *  env: {account: '123456789012', region: 'eu-west-1'},
+ *  cache: myBucket // use a S3 bucket without public access and a retention defined, use one cache bucket for all you runners
  * });
  *```
  * recommended:
  * ```ts
  * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
  * const runnerRoles = new RunnerRoles(stack, 'RunnerRoles', {env: {account: '123456789012', region: 'eu-west-1'}});
+ * const myBucket = new Bucket(stack, 'MyShareRunnerCache', {
+ *     enforceSSL: true,
+ *     publicReadAccess: false,
+ *     encryption: BucketEncryption.S3_MANAGED,
+ *     lifecycleRules: [
+ *       {
+ *         enabled: true,
+ *         expiration: Duration.days(30),
+ *       },
+ *     ],
+ *   });
  * new GitlabRunner(stack, 'GitLabRunner', {
  *  env: {account: '123456789012', region: 'eu-west-1'},
- *  runnersWorkerProps: [
- *    {
- *      token: myTokenForTaggedRunner1, // with this runner we only want to run jobs that require more power
- *      gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab
- *      instanceType: InstanceType.of(InstanceClass.M7I_FLEX, InstanceSize.XLARGE), // exemplary larger runner
- *      spotPrice: 0.2, // exemplary spot price
- *      requestSpotPrice: true,
- *      defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role
- *    },
- *    {
- *      token: myTokenForTaggedRunner2, // with this runner we want to run all generic jobs that do not require much processing power
- *      gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab
- *      instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.MEDIUM), // exemplary smaller runner
- *      spotPrice: 0.044, // exemplary spot price
- *      requestSpotPrice: true,
- *      defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role
- *    },
- *  ],
+ *  cache: myBucket // // use a S3 bucket without public access and a retention defined, use one cache bucket for all you runners
+ *  runnersWorkerProps: {
+ *    token: myTokenForTaggedRunner1, // with this runner we only want to run jobs that require more power
+ *    gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab
+ *    instanceType: InstanceType.of(InstanceClass.M7I_FLEX, InstanceSize.XLARGE), // exemplary larger runner
+ *    spotPrice: 0.2, // exemplary spot price
+ *    requestSpotPrice: true,
+ *    defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role
+ *  },
  * });
  * ```
  */
@@ -50,79 +66,86 @@ class GitlabRunner extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
         this.autoscalingConfig = [{
-                periods: ['* * 7-24 * * mon-fri *'],
+                periods: ['* * 7-22 * * mon-fri *'],
                 timezone: 'Europe/Berlin',
             }];
         const vpc = rio_landing_zone_1.RioLandingZone.getDefaultVpc(scope);
-        const runnerConfig = props.runnersWorkerProps ?
-            this.createWorkerConfigurations(props.runnersWorkerProps, props.env) :
-            this.getDefaultRunnerWorkerConfig(props.env);
-        const managerInstance = props.managerInstanceType ?? aws_ec2_1.InstanceType.of(aws_ec2_1.InstanceClass.T3, aws_ec2_1.InstanceSize.MICRO);
-        new cdk_autoscaling_gitlab_runner_1.GitlabRunnerAutoscaling(scope, `GLR${scope.stackName}`, {
-            runners: runnerConfig,
+        const runnerConfig = props.runnersWorkerProps
+            ? this.createWorkerConfigurations(props.runnersWorkerProps, props.env)
+            : this.getDefaultRunnerWorkerConfig(props.env);
+        const managerInstance = props.managerInstanceType ??
+            aws_ec2_1.InstanceType.of(aws_ec2_1.InstanceClass.T3, aws_ec2_1.InstanceSize.MICRO);
+        const runner = new cdk_autoscaling_gitlab_runner_1.GitlabRunnerAutoscaling(scope, `GLR${scope.stackName}`, {
+            runners: [runnerConfig],
             network: {
                 vpc: vpc,
             },
             manager: {
                 instanceType: managerInstance,
             },
+            cache: { bucket: props.cache },
             checkInterval: 30, // check every 30s for pending jobs
             concurrent: 300, // Global limit of concurrent jobs,
         });
+        // due to the new registration process we have to register the runner by running explicit commands on start of the manager
+        runner.manager.userData.addCommands('cp  /etc/gitlab-runner/config.toml  /etc/gitlab-runner/config_back.toml', // avoid toml merge conflicts
+        `gitlab-runner register --non-interactive --template-config /etc/gitlab-runner/config_back.toml --token ${props.runnersWorkerProps?.token.stringValue}`, 'gitlab-runner restart');
     }
     createWorkerConfigurations(workerProps, env) {
-        return workerProps.map(val => ({
-            token: val.token,
-            role: val.defaultWorkerRole,
+        return {
+            token: workerProps.token,
+            role: workerProps.defaultWorkerRole,
             configuration: {
-                url: val.gitInstanceUrl,
+                url: workerProps.gitInstanceUrl,
                 machine: {
                     autoscaling: this.autoscalingConfig,
-                    maxBuilds: val.maxBuilds ?? 10,
-                    idleCount: val.maxIdleInstance ?? 5,
-                    idleTime: val.maxIdleTime ?? 900,
+                    maxBuilds: workerProps.maxBuilds ?? 10,
+                    idleCount: workerProps.maxIdleInstance ?? 5,
+                    idleTime: workerProps.maxIdleTime ?? 900,
                     machineOptions: {
-                        requestSpotInstance: val.requestSpotPrice,
-                        spotPrice: val.spotPrice,
+                        requestSpotInstance: workerProps.requestSpotPrice,
+                        spotPrice: workerProps.spotPrice,
                     },
                 },
                 environment: [
                     'DOCKER_DRIVER=overlay2',
                     'DOCKER_TLS_DIRCE=/certs',
-                    `DOCKER_AUTH_CONFIG={"credHelpers": { "public.ecr.aws": "ecr-login", "${env.account}.dkr.ecr.<region>.amazonaws.com": "ecr-login" } }`,
+                    `DOCKER_AUTH_CONFIG={"credHelpers": { "public.ecr.aws": "ecr-login", "${env.account}.dkr.ecr.${env.region}.amazonaws.com": "ecr-login" } }`,
                 ],
             },
-            instanceType: val.instanceType,
-        }));
+            instanceType: workerProps.instanceType,
+        };
     }
     getDefaultRunnerWorkerConfig(env) {
         const gitLabRunnerTokenParameter = aws_ssm_1.StringParameter.fromStringParameterAttributes(this, 'RunnerToken', {
             parameterName: '/config/gitlab-runner-cdk/token',
         });
-        return [{
-                token: gitLabRunnerTokenParameter,
-                configuration: {
-                    url: 'https://gitlab.cicd.man',
-                    limit: 0,
-                    machine: {
-                        maxBuilds: 10,
-                        autoscaling: this.autoscalingConfig,
-                        idleCount: 5,
-                        idleTime: 900,
-                        machineOptions: {
-                            requestSpotInstance: true,
-                            spotPrice: 0.09,
-                        },
+        return {
+            token: gitLabRunnerTokenParameter,
+            configuration: {
+                url: 'https://gitlab.cicd.man',
+                limit: 0,
+                machine: {
+                    maxBuilds: 10,
+                    autoscaling: this.autoscalingConfig,
+                    idleCount: 5,
+                    idleTime: 900,
+                    machineOptions: {
+                        requestSpotInstance: true,
+                        spotPrice: 0.09,
                     },
-                    environment: [
-                        'DOCKER_DRIVER=overlay2',
-                        'DOCKER_TLS_DIRCE=/certs',
-                        `DOCKER_AUTH_CONFIG={"credHelpers": { "public.ecr.aws": "ecr-login", "${env.account}.dkr.ecr.<region>.amazonaws.com": "ecr-login" } }`,
-                    ],
                 },
-                instanceType: aws_ec2_1.InstanceType.of(aws_ec2_1.InstanceClass.T3, aws_ec2_1.InstanceSize.LARGE),
-            }];
+                environment: [
+                    'DOCKER_DRIVER=overlay2',
+                    'DOCKER_TLS_DIRCE=/certs',
+                    `DOCKER_AUTH_CONFIG={"credHelpers": { "public.ecr.aws": "ecr-login", "${env.account}.dkr.ecr.${env.region}.amazonaws.com": "ecr-login" } }`,
+                ],
+            },
+            instanceType: aws_ec2_1.InstanceType.of(aws_ec2_1.InstanceClass.T3, aws_ec2_1.InstanceSize.LARGE),
+        };
     }
 }
 exports.GitlabRunner = GitlabRunner;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autoscaling-runner.js","sourceRoot":"","sources":["../../../../src/contributions/smart-route/gitlab-runner/autoscaling-runner.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  AutoscalingConfiguration,\n  GitlabRunnerAutoscaling,\n  GitlabRunnerAutoscalingJobRunnerProps,\n} from '@pepperize/cdk-autoscaling-gitlab-runner';\nimport { Environment, Stack } from 'aws-cdk-lib';\nimport { InstanceClass, InstanceSize, InstanceType } from 'aws-cdk-lib/aws-ec2';\nimport { IRole } from 'aws-cdk-lib/aws-iam';\nimport { StringParameter } from 'aws-cdk-lib/aws-ssm';\nimport { Construct } from 'constructs';\nimport { RioLandingZone } from '../../../rio-landing-zone';\n\n\n/**\n * The GitLabRunnerProps require the VPC ID, a defined environment of account and region, optional\n * runner configuration and optionally the GitLab Runner Manager instance type. By default, a T3 Micro instance will be used.\n * For larger workloads and very active teams it is recommended to use T3 Small for the manager instead.\n */\nexport interface GitLabRunnerProps {\n  readonly env: Environment;\n  readonly runnersWorkerProps?: GitlabRunnerWorkerProps[];\n  readonly managerInstanceType?: InstanceType;\n}\n\n/**\n * The GitlabRunnerWorkerProps interface provides a simplified GitLab Runner worker configuration\n * requiring a token as an SSM parameter, one of the valid gitlab URLs, instance of you choice, the desired max spot price,\n * whether to use spot instance or not and a default role.\n * It is recommended to use the RunnerRoles construct, and it's exposed default runner role.\n */\nexport interface GitlabRunnerWorkerProps {\n  /** The SSM StringParameter with the registered runner token  */\n  token: StringParameter;\n  /** The GitLab instance URL, either https://gitlab.cicd.man or https://gitlab.collaborationlayer-traton.com */\n  gitInstanceUrl: GitlabInstanceUrl;\n  /** The instance type for the runner worker */\n  instanceType: InstanceType;\n  /** The desired max spot price */\n  spotPrice: number;\n  /** Whether to use spot instance or not, Requires ServiceLinked Role for EC2 Spot to be deployed in the account */\n  requestSpotPrice: boolean;\n  /** The default role for the runner worker when spawned */\n  defaultWorkerRole: IRole;\n  /** The maximum number of builds for an instance before it has to be decommissioned. Default 10 */\n  maxBuilds?: number;\n  /** The maximum number of instances to keep idle for new incoming jobs. Default 5 */\n  maxIdleInstance?: number;\n  /** The maximum idle time seconds for an instance. Default 900 seconds */\n  maxIdleTime?: number;\n}\n\nexport type GitlabInstanceUrl = 'https://gitlab.cicd.man' | 'https://gitlab.collaborationlayer-traton.com'\n\n\n/**\n * The construct create the GitLabRunner Manager instance which will autoscale Runner instances based on the configuration.\n * By default, the construct will create a Runner with a manager T3 Micro instance which will be enabled to spawn T3 Large Runner\n * worker spot instance. The default runner Role has only the permissions to upload and download from the S3 runner cache.\n *\n * minimal configuration with runner spot instance:\n * ```ts\n * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');\n * new GitlabRunner(stack, 'GitLabRunner', {\n *  env: {account: '123456789012', region: 'eu-west-1'}\n * });\n *```\n * recommended:\n * ```ts\n * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');\n * const runnerRoles = new RunnerRoles(stack, 'RunnerRoles', {env: {account: '123456789012', region: 'eu-west-1'}});\n * new GitlabRunner(stack, 'GitLabRunner', {\n *  env: {account: '123456789012', region: 'eu-west-1'},\n *  runnersWorkerProps: [\n *    {\n *      token: myTokenForTaggedRunner1, // with this runner we only want to run jobs that require more power\n *      gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab\n *      instanceType: InstanceType.of(InstanceClass.M7I_FLEX, InstanceSize.XLARGE), // exemplary larger runner\n *      spotPrice: 0.2, // exemplary spot price\n *      requestSpotPrice: true,\n *      defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role\n *    },\n *    {\n *      token: myTokenForTaggedRunner2, // with this runner we want to run all generic jobs that do not require much processing power\n *      gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab\n *      instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.MEDIUM), // exemplary smaller runner\n *      spotPrice: 0.044, // exemplary spot price\n *      requestSpotPrice: true,\n *      defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role\n *    },\n *  ],\n * });\n * ```\n */\nexport class GitlabRunner extends Construct {\n  private autoscalingConfig: AutoscalingConfiguration[] = [{\n    periods: ['* * 7-24 * * mon-fri *'],\n    timezone: 'Europe/Berlin',\n  }];\n  constructor(scope: Stack, id : string, props: GitLabRunnerProps) {\n    super(scope, id);\n\n    const vpc = RioLandingZone.getDefaultVpc(scope);\n\n    const runnerConfig = props.runnersWorkerProps ?\n      this.createWorkerConfigurations(props.runnersWorkerProps, props.env) :\n      this.getDefaultRunnerWorkerConfig(props.env);\n\n    const managerInstance = props.managerInstanceType ?? InstanceType.of(InstanceClass.T3, InstanceSize.MICRO);\n\n    new GitlabRunnerAutoscaling(scope, `GLR${scope.stackName}`, {\n      runners: runnerConfig,\n      network: {\n        vpc: vpc,\n      },\n      manager: {\n        instanceType: managerInstance,\n      },\n      checkInterval: 30, // check every 30s for pending jobs\n      concurrent: 300, // Global limit of concurrent jobs,\n    });\n  }\n\n  private createWorkerConfigurations(workerProps: GitlabRunnerWorkerProps[], env: Environment): GitlabRunnerAutoscalingJobRunnerProps[] {\n    return workerProps.map(val => (\n      {\n        token: val.token,\n        role: val.defaultWorkerRole,\n        configuration: {\n          url: val.gitInstanceUrl,\n          machine: {\n            autoscaling: this.autoscalingConfig,\n            maxBuilds: val.maxBuilds ?? 10,\n            idleCount: val.maxIdleInstance ?? 5,\n            idleTime: val.maxIdleTime ?? 900,\n            machineOptions: {\n              requestSpotInstance: val.requestSpotPrice,\n              spotPrice: val.spotPrice,\n            },\n          },\n          environment: [\n            'DOCKER_DRIVER=overlay2',\n            'DOCKER_TLS_DIRCE=/certs',\n            `DOCKER_AUTH_CONFIG={\"credHelpers\": { \"public.ecr.aws\": \"ecr-login\", \"${\n              env.account\n            }.dkr.ecr.<region>.amazonaws.com\": \"ecr-login\" } }`,\n          ],\n        },\n        instanceType: val.instanceType,\n      }\n    ));\n  }\n\n  private getDefaultRunnerWorkerConfig(env: Environment): GitlabRunnerAutoscalingJobRunnerProps[] {\n    const gitLabRunnerTokenParameter = StringParameter.fromStringParameterAttributes(this, 'RunnerToken', {\n      parameterName: '/config/gitlab-runner-cdk/token',\n    });\n    return [{\n      token: gitLabRunnerTokenParameter,\n      configuration: {\n        url: 'https://gitlab.cicd.man',\n        limit: 0,\n        machine: {\n          maxBuilds: 10,\n          autoscaling: this.autoscalingConfig,\n          idleCount: 5,\n          idleTime: 900,\n          machineOptions: {\n            requestSpotInstance: true,\n            spotPrice: 0.09,\n          },\n        },\n        environment: [\n          'DOCKER_DRIVER=overlay2',\n          'DOCKER_TLS_DIRCE=/certs',\n          `DOCKER_AUTH_CONFIG={\"credHelpers\": { \"public.ecr.aws\": \"ecr-login\", \"${\n            env.account\n          }.dkr.ecr.<region>.amazonaws.com\": \"ecr-login\" } }`,\n        ],\n      },\n      instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.LARGE),\n    }];\n  }\n}"]}
+_a = JSII_RTTI_SYMBOL_1;
+GitlabRunner[_a] = { fqn: "@rio-cloud/cdk-v2-constructs.GitlabRunner", version: "0.0.0" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"autoscaling-runner.js","sourceRoot":"","sources":["../../../../src/contributions/smart-route/gitlab-runner/autoscaling-runner.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport {\n  AutoscalingConfiguration,\n  GitlabRunnerAutoscaling,\n  GitlabRunnerAutoscalingJobRunnerProps,\n} from '@pepperize/cdk-autoscaling-gitlab-runner';\nimport { Environment, Stack } from 'aws-cdk-lib';\nimport { InstanceClass, InstanceSize, InstanceType } from 'aws-cdk-lib/aws-ec2';\nimport { IRole } from 'aws-cdk-lib/aws-iam';\nimport { IBucket } from 'aws-cdk-lib/aws-s3';\nimport { IStringParameter, StringParameter } from 'aws-cdk-lib/aws-ssm';\nimport { Construct } from 'constructs';\nimport { RioLandingZone } from '../../../rio-landing-zone';\n\n/**\n * The GitLabRunnerProps require the VPC ID, a defined environment of account and region, optional\n * runner configuration and optionally the GitLab Runner Manager instance type. By default, a T3 Micro instance will be used.\n * For larger workloads and very active teams it is recommended to use T3 Small for the manager instead.\n */\nexport interface GitLabRunnerProps {\n  readonly env: Environment;\n  readonly runnersWorkerProps?: GitlabRunnerWorkerProps;\n  readonly managerInstanceType?: InstanceType;\n  readonly cache: IBucket;\n}\n\n/**\n * The GitlabRunnerWorkerProps interface provides a simplified GitLab Runner worker configuration\n * requiring a token as an SSM parameter, one of the valid gitlab URLs, instance of you choice, the desired max spot price,\n * whether to use spot instance or not and a default role.\n * It is recommended to use the RunnerRoles construct, and it's exposed default runner role.\n */\nexport interface GitlabRunnerWorkerProps {\n  /** The SSM StringParameter with the registered runner token  */\n  readonly token: IStringParameter;\n  /** The GitLab instance URL, either https://gitlab.cicd.man or https://gitlab.collaborationlayer-traton.com */\n  readonly gitInstanceUrl: GitlabInstanceUrl;\n  /** The instance type for the runner worker */\n  readonly instanceType: InstanceType;\n  /** The desired max spot price */\n  readonly spotPrice: number;\n  /** Whether to use spot instance or not, Requires ServiceLinked Role for EC2 Spot to be deployed in the account */\n  readonly requestSpotPrice: boolean;\n  /** The default role for the runner worker when spawned */\n  readonly defaultWorkerRole: IRole;\n  /** The maximum number of builds for an instance before it has to be decommissioned. Default 10 */\n  readonly maxBuilds?: number;\n  /** The maximum number of instances to keep idle for new incoming jobs. Default 5 */\n  readonly maxIdleInstance?: number;\n  /** The maximum idle time seconds for an instance. Default 900 seconds */\n  readonly maxIdleTime?: number;\n}\n\nexport type GitlabInstanceUrl =\n  | 'https://gitlab.cicd.man'\n  | 'https://gitlab.collaborationlayer-traton.com';\n\n/**\n * The construct create the GitLabRunner Manager instance which will autoscale Runner instances based on the configuration.\n * By default, the construct will create a Runner with a manager T3 Micro instance which will be enabled to spawn T3 Large Runner\n * worker spot instance. The default runner Role has only the permissions to upload and download from the S3 runner cache.\n *\n * minimal configuration with runner spot instance:\n * ```ts\n * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');\n * const myBucket = new Bucket(stack, 'MyShareRunnerCache', {\n *     enforceSSL: true,\n *     publicReadAccess: false,\n *     encryption: BucketEncryption.S3_MANAGED,\n *     lifecycleRules: [\n *       {\n *         enabled: true,\n *         expiration: Duration.days(30),\n *       },\n *     ],\n *   });\n * new GitlabRunner(stack, 'GitLabRunner', {\n *  env: {account: '123456789012', region: 'eu-west-1'},\n *  cache: myBucket // use a S3 bucket without public access and a retention defined, use one cache bucket for all you runners\n * });\n *```\n * recommended:\n * ```ts\n * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');\n * const runnerRoles = new RunnerRoles(stack, 'RunnerRoles', {env: {account: '123456789012', region: 'eu-west-1'}});\n * const myBucket = new Bucket(stack, 'MyShareRunnerCache', {\n *     enforceSSL: true,\n *     publicReadAccess: false,\n *     encryption: BucketEncryption.S3_MANAGED,\n *     lifecycleRules: [\n *       {\n *         enabled: true,\n *         expiration: Duration.days(30),\n *       },\n *     ],\n *   });\n * new GitlabRunner(stack, 'GitLabRunner', {\n *  env: {account: '123456789012', region: 'eu-west-1'},\n *  cache: myBucket // // use a S3 bucket without public access and a retention defined, use one cache bucket for all you runners\n *  runnersWorkerProps: {\n *    token: myTokenForTaggedRunner1, // with this runner we only want to run jobs that require more power\n *    gitInstanceUrl: 'https://gitlab.cicd.man', // or the Traton GitLab\n *    instanceType: InstanceType.of(InstanceClass.M7I_FLEX, InstanceSize.XLARGE), // exemplary larger runner\n *    spotPrice: 0.2, // exemplary spot price\n *    requestSpotPrice: true,\n *    defaultWorkerRole: runnerRoles.runnerBaseRole, // use the base role\n *  },\n * });\n * ```\n */\nexport class GitlabRunner extends Construct {\n  private autoscalingConfig: AutoscalingConfiguration[] = [{\n    periods: ['* * 7-22 * * mon-fri *'],\n    timezone: 'Europe/Berlin',\n  }];\n  constructor(scope: Stack, id : string, props: GitLabRunnerProps) {\n    super(scope, id);\n\n    const vpc = RioLandingZone.getDefaultVpc(scope);\n\n    const runnerConfig = props.runnersWorkerProps\n      ? this.createWorkerConfigurations(props.runnersWorkerProps, props.env)\n      : this.getDefaultRunnerWorkerConfig(props.env);\n\n    const managerInstance =\n      props.managerInstanceType ??\n      InstanceType.of(InstanceClass.T3, InstanceSize.MICRO);\n\n    const runner = new GitlabRunnerAutoscaling(scope, `GLR${scope.stackName}`, {\n      runners: [runnerConfig],\n      network: {\n        vpc: vpc,\n      },\n      manager: {\n        instanceType: managerInstance,\n      },\n      cache: { bucket: props.cache },\n      checkInterval: 30, // check every 30s for pending jobs\n      concurrent: 300, // Global limit of concurrent jobs,\n    });\n    // due to the new registration process we have to register the runner by running explicit commands on start of the manager\n    runner.manager.userData.addCommands(\n      'cp  /etc/gitlab-runner/config.toml  /etc/gitlab-runner/config_back.toml', // avoid toml merge conflicts\n      `gitlab-runner register --non-interactive --template-config /etc/gitlab-runner/config_back.toml --token ${props.runnersWorkerProps?.token.stringValue}`,\n      'gitlab-runner restart', // restart the runner to ensure the config is picked up correctly\n    );\n  }\n\n  private createWorkerConfigurations(workerProps: GitlabRunnerWorkerProps, env: Environment): GitlabRunnerAutoscalingJobRunnerProps {\n    return {\n      token: workerProps.token,\n      role: workerProps.defaultWorkerRole,\n      configuration: {\n        url: workerProps.gitInstanceUrl,\n        machine: {\n          autoscaling: this.autoscalingConfig,\n          maxBuilds: workerProps.maxBuilds ?? 10,\n          idleCount: workerProps.maxIdleInstance ?? 5,\n          idleTime: workerProps.maxIdleTime ?? 900,\n          machineOptions: {\n            requestSpotInstance: workerProps.requestSpotPrice,\n            spotPrice: workerProps.spotPrice,\n          },\n        },\n        environment: [\n          'DOCKER_DRIVER=overlay2',\n          'DOCKER_TLS_DIRCE=/certs',\n          `DOCKER_AUTH_CONFIG={\"credHelpers\": { \"public.ecr.aws\": \"ecr-login\", \"${\n            env.account\n          }.dkr.ecr.${env.region}.amazonaws.com\": \"ecr-login\" } }`,\n        ],\n      },\n      instanceType: workerProps.instanceType,\n    };\n  }\n\n  private getDefaultRunnerWorkerConfig(\n    env: Environment,\n  ): GitlabRunnerAutoscalingJobRunnerProps {\n    const gitLabRunnerTokenParameter =\n      StringParameter.fromStringParameterAttributes(this, 'RunnerToken', {\n        parameterName: '/config/gitlab-runner-cdk/token',\n      });\n    return {\n      token: gitLabRunnerTokenParameter,\n      configuration: {\n        url: 'https://gitlab.cicd.man',\n        limit: 0,\n        machine: {\n          maxBuilds: 10,\n          autoscaling: this.autoscalingConfig,\n          idleCount: 5,\n          idleTime: 900,\n          machineOptions: {\n            requestSpotInstance: true,\n            spotPrice: 0.09,\n          },\n        },\n        environment: [\n          'DOCKER_DRIVER=overlay2',\n          'DOCKER_TLS_DIRCE=/certs',\n          `DOCKER_AUTH_CONFIG={\"credHelpers\": { \"public.ecr.aws\": \"ecr-login\", \"${\n            env.account\n          }.dkr.ecr.${env.region}.amazonaws.com\": \"ecr-login\" } }`,\n        ],\n      },\n      instanceType: InstanceType.of(InstanceClass.T3, InstanceSize.LARGE),\n    };\n  }\n}\n"]}

package/lib/contributions/smart-route/gitlab-runner/runner-roles.d.ts

@@ -2,7 +2,7 @@ import { Environment, Stack } from 'aws-cdk-lib';
 import { Role } from 'aws-cdk-lib/aws-iam';
 import { Construct } from 'constructs';
 export interface RunnerRoleProps {
-    env: Environment;
+    readonly env: Environment;
 }
 /**
  * This construct provides a set of base roles for gitlab runners in order to build, test, validate and deploy applications