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

package/docs/index.md

@@ -0,0 +1,105 @@
+# RIO CDK Constructs
+
+This package contains CDK2 constructs for RIO teams.
+
+> NPM: `@rio-cloud/cdk-v2-constructs`
+
+## Bootstrapping of CDK project
+
+```
+$ npx cdk init --language typescript
+```
+
+## Installation
+
+```
+$ npm install --save @rio-cloud/cdk-v2-constructs
+```
+
+## See also
+
+ * [How to contribute](./CONTRIBUTION.md)
+ * [Changelog](./CHANGELOG.md)
+ * [brief API description](./API.md)
+
+## Internal documentation for library devs
+[Documentation](./developers-readme.md)
+
+## Constructs overview (Under construction...)
+
+### Watchful
+
+Watchful constructs help generate some default monitors based on the resouces defined in your stack. Eg - If your stack contains a lambda function and you configure watchful construct, then it will create out of box metric monitors for Throttling, Lambda error and Log error monitors. The ever growing list of resources that watchful creates monitors for as of today are:
+
+- Application load balancer
+- Cloudfront
+- Documentdb
+- Dynamodb
+- Fargate
+- Lambda
+- RDS
+
+Simply add the following to your CDK stack to get started.
+```
+  import * as rio from '@rio-cloud/cdk-v2-constructs';
+    ...
+    const dw = new rio.watchfulv2.Watchful(this, 'Watchful', {
+      serviceName,
+    });
+    dw.watchScope(this); // Generates alarms for all supported resources
+    ...
+```
+
+There are options to override some defaults too. Please be aware that the library is very opinionated and is written with the most general use cases in mind. It is necessary to keep the use of the library simple enough, which means that there is only limited flexibility regarding the configuration options. Having said that, feel free to reach out to team CLAID over slack #rio-platform-support in case of feature requests.
+
+The broad classification of the monitors created by watchful are
+- Log error monitors
+- Metrics Query monitors: Basically everything other than log error monitors
+
+For Metrics query monitors, you can configure the priority (defaults as 3). For log error monitors, you can configure priority, renotification interval and can configure if the auto close of the monitor is disabled.
+```
+    ...
+    const dw = new Watchful(stack, 'Watchful2', { 
+      logErrorMonitorConfig: {
+        disableAutoClose: true, 
+        renotifyInterval: 150,
+        priority: 4,
+      },
+      queryErrorMonitorConfig: {
+        priority: 4
+      }
+    });
+    dw.watchScope(stack);
+```
+
+There is an `overrideAlarmThreshold` method which can be used to override the default watchful thresholds. Please make sure to use the method before the `watchscope` function.
+Eg -
+```
+...
+const dw = new Watchful(stack, 'Watchful', {});
+dw.overrideAlarmThreshold({
+  monitoredResourceScope: lambdaA,
+  monitorType: MonitorType.ERRORS,
+  threshold: 5,
+});
+dw.watchScope(stack);
+```
+
+### ClassifyPipelineType
+
+The pipelines can be tagged with key 'pipeline_type' to the following values:
+
+* deploy: To tag the production pipeline releasing the application
+* branch: The branch pipeline. Mostly used to test contributions / renovate updates
+* vulnerability: The vulnerability pipeline
+
+The construct `ClassifyPipelineType` can be used to tag the pipeline accordingly. This tag is also picked up by the Datadog pipeline metric used to monitor the pipelines. It is added as a tag to the metric. This gives you more flexibility with managing the monitors also. E.g. some teams don't want to get alerted for branch pipelines. You can then leverage this metric tag to filter the pipelines.
+
+Example:
+
+```typescript
+const pipeline = new pipelines.CodePipeline(this, 'Pipeline', {
+      ...
+    });
+rio.ClassifyPipelineType.apply(pipeline, rio.RioPipelineType.DEPLOY);
+```

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

@@ -0,0 +1,87 @@
+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 { Construct } from 'constructs';
+/**
+ * The GitLabRunnerProps require the VPC ID, a defined environment of account and region, optional
+ * runner configuration and optionally the GitLab Runner Manager instance type. By default, a T3 Micro instance will be used.
+ * For larger workloads and very active teams it is recommended to use T3 Small for the manager instead.
+ */
+export interface GitLabRunnerProps {
+    readonly env: Environment;
+    readonly runnersWorkerProps?: GitlabRunnerWorkerProps[];
+    readonly managerInstanceType?: InstanceType;
+}
+/**
+ * The GitlabRunnerWorkerProps interface provides a simplified GitLab Runner worker configuration
+ * requiring a token as an SSM parameter, one of the valid gitlab URLs, instance of you choice, the desired max spot price,
+ * whether to use spot instance or not and a default role.
+ * It is recommended to use the RunnerRoles construct, and it's exposed default runner role.
+ */
+export interface GitlabRunnerWorkerProps {
+    /** The SSM StringParameter with the registered runner token  */
+    token: StringParameter;
+    /** The GitLab instance URL, either https://gitlab.cicd.man or https://gitlab.collaborationlayer-traton.com */
+    gitInstanceUrl: GitlabInstanceUrl;
+    /** The instance type for the runner worker */
+    instanceType: InstanceType;
+    /** The desired max spot price */
+    spotPrice: number;
+    /** Whether to use spot instance or not, Requires ServiceLinked Role for EC2 Spot to be deployed in the account */
+    requestSpotPrice: boolean;
+    /** The default role for the runner worker when spawned */
+    defaultWorkerRole: IRole;
+    /** The maximum number of builds for an instance before it has to be decommissioned. Default 10 */
+    maxBuilds?: number;
+    /** The maximum number of instances to keep idle for new incoming jobs. Default 5 */
+    maxIdleInstance?: number;
+    /** The maximum idle time seconds for an instance. Default 900 seconds */
+    maxIdleTime?: number;
+}
+export type GitlabInstanceUrl = 'https://gitlab.cicd.man' | 'https://gitlab.collaborationlayer-traton.com';
+/**
+ * The construct create the GitLabRunner Manager instance which will autoscale Runner instances based on the configuration.
+ * By default, the construct will create a Runner with a manager T3 Micro instance which will be enabled to spawn T3 Large Runner
+ * worker spot instance. The default runner Role has only the permissions to upload and download from the S3 runner cache.
+ *
+ * minimal configuration with runner spot instance:
+ * ```ts
+ * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
+ * new GitlabRunner(stack, 'GitLabRunner', {
+ *  env: {account: '123456789012', region: 'eu-west-1'}
+ * });
+ *```
+ * recommended:
+ * ```ts
+ * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
+ * const runnerRoles = new RunnerRoles(stack, 'RunnerRoles', {env: {account: '123456789012', region: 'eu-west-1'}});
+ * 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
+ *    },
+ *  ],
+ * });
+ * ```
+ */
+export declare class GitlabRunner extends Construct {
+    private autoscalingConfig;
+    constructor(scope: Stack, id: string, props: GitLabRunnerProps);
+    private createWorkerConfigurations;
+    private getDefaultRunnerWorkerConfig;
+}

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

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitlabRunner = void 0;
+// 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");
+const aws_ssm_1 = require("aws-cdk-lib/aws-ssm");
+const constructs_1 = require("constructs");
+const rio_landing_zone_1 = require("../../../rio-landing-zone");
+/**
+ * The construct create the GitLabRunner Manager instance which will autoscale Runner instances based on the configuration.
+ * By default, the construct will create a Runner with a manager T3 Micro instance which will be enabled to spawn T3 Large Runner
+ * worker spot instance. The default runner Role has only the permissions to upload and download from the S3 runner cache.
+ *
+ * minimal configuration with runner spot instance:
+ * ```ts
+ * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
+ * new GitlabRunner(stack, 'GitLabRunner', {
+ *  env: {account: '123456789012', region: 'eu-west-1'}
+ * });
+ *```
+ * recommended:
+ * ```ts
+ * new SpotServiceLinkedRole(stack, 'SpotLinkedRole');
+ * const runnerRoles = new RunnerRoles(stack, 'RunnerRoles', {env: {account: '123456789012', region: 'eu-west-1'}});
+ * 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
+ *    },
+ *  ],
+ * });
+ * ```
+ */
+class GitlabRunner extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.autoscalingConfig = [{
+                periods: ['* * 7-24 * * 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,
+            network: {
+                vpc: vpc,
+            },
+            manager: {
+                instanceType: managerInstance,
+            },
+            checkInterval: 30, // check every 30s for pending jobs
+            concurrent: 300, // Global limit of concurrent jobs,
+        });
+    }
+    createWorkerConfigurations(workerProps, env) {
+        return workerProps.map(val => ({
+            token: val.token,
+            role: val.defaultWorkerRole,
+            configuration: {
+                url: val.gitInstanceUrl,
+                machine: {
+                    autoscaling: this.autoscalingConfig,
+                    maxBuilds: val.maxBuilds ?? 10,
+                    idleCount: val.maxIdleInstance ?? 5,
+                    idleTime: val.maxIdleTime ?? 900,
+                    machineOptions: {
+                        requestSpotInstance: val.requestSpotPrice,
+                        spotPrice: val.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" } }`,
+                ],
+            },
+            instanceType: val.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,
+                        },
+                    },
+                    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),
+            }];
+    }
+}
+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}"]}

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

@@ -0,0 +1,3 @@
+export * from './autoscaling-runner';
+export * from './runner-roles';
+export * from './spot-role';

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

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./autoscaling-runner"), exports);
+__exportStar(require("./runner-roles"), exports);
+__exportStar(require("./spot-role"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29udHJpYnV0aW9ucy9zbWFydC1yb3V0ZS9naXRsYWItcnVubmVyL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSx1REFBcUM7QUFDckMsaURBQStCO0FBQy9CLDhDQUE0QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXV0b3NjYWxpbmctcnVubmVyJztcbmV4cG9ydCAqIGZyb20gJy4vcnVubmVyLXJvbGVzJztcbmV4cG9ydCAqIGZyb20gJy4vc3BvdC1yb2xlJzsiXX0=

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

@@ -0,0 +1,20 @@
+import { Environment, Stack } from 'aws-cdk-lib';
+import { Role } from 'aws-cdk-lib/aws-iam';
+import { Construct } from 'constructs';
+export interface RunnerRoleProps {
+    env: Environment;
+}
+/**
+ * This construct provides a set of base roles for gitlab runners in order to build, test, validate and deploy applications
+ * on RIO. The roles need to be assumed during job runtime to perform more permissive actions, such as creating certificates to
+ * authenticate towards the RIO MSK, pushing docker images to ECR, performing a secrets backup, deploying stacks,
+ * or to publish an SPA to a S3 bucket. Do not assume the deployment role unless needed.
+ * The base role can be the default role attached to GitLab runners.
+ * The role allows to read various basic parameters such as the NIST data mirror, the OSS license bucket, DataDog keys
+ * and to pull ECR images form public Gallery or the specified account in the environment.
+ * The Role ARNs are export using CFNOutputs. Use the outputs to configure environment variables in your GitLab group.
+ */
+export declare class RunnerRoles extends Construct {
+    readonly runnerBaseRole: Role;
+    constructor(scope: Stack, id: string, props: RunnerRoleProps);
+}