@ydkn/pulumi-components 0.4.2 → 0.4.4

package/lib/gitlab/runners/cleanup.ts

@@ -0,0 +1,104 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../../common";
+
+export interface RunnerCleanupArgs {
+  namespace?: pulumi.Input<string>;
+  accessToken: pulumi.Input<string>;
+  schedule?: pulumi.Input<string>;
+}
+
+export class RunnerCleanup extends ComponentResource {
+  private readonly secret: k8s.core.v1.Secret;
+  private readonly cronjob: k8s.batch.v1.CronJob;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new GitLab runner cleanup resource.
+   * @param name The name of the GitLab runner cleanup resource.
+   * @param args A bag of arguments to control the GitLab runner cleanup creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: RunnerCleanupArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("gitlab:runners:cleanup", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    if (args.schedule === undefined) {
+      args.schedule = "0 1 * * *";
+    }
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    const metadata = {
+      name,
+      namespace: this.namespace,
+      labels: {
+        "app.kubernetes.io/name": "gitlab-runners",
+        "app.kubernetes.io/component": "cleanup",
+        "app.kubernetes.io/instance": name,
+      },
+    };
+
+    this.secret = new k8s.core.v1.Secret(
+      name,
+      {
+        metadata,
+        stringData: {
+          token: args.accessToken,
+        },
+      },
+      opts
+    );
+
+    this.cronjob = new k8s.batch.v1.CronJob(
+      name,
+      {
+        metadata,
+        spec: {
+          schedule: args.schedule,
+          concurrencyPolicy: "Forbid",
+          successfulJobsHistoryLimit: 0,
+          failedJobsHistoryLimit: 1,
+          jobTemplate: {
+            metadata: { labels: metadata.labels },
+            spec: {
+              template: {
+                spec: {
+                  restartPolicy: "OnFailure",
+                  containers: [
+                    {
+                      name: "gitlab-runner-cleanup",
+                      image: "registry.gitlab.com/ydkn/gitlab-runner-cleanup:latest",
+                      imagePullPolicy: "Always",
+                      env: [
+                        {
+                          name: "TOKEN",
+                          valueFrom: { secretKeyRef: { name: this.secret.metadata.name, key: "token" } },
+                        },
+                      ],
+                      securityContext: {
+                        runAsUser: 65532,
+                        runAsGroup: 65532,
+                        readOnlyRootFilesystem: true,
+                      },
+                      resources: {
+                        requests: { memory: "32Mi" },
+                        limits: { memory: "48Mi" },
+                      },
+                    },
+                  ],
+                },
+              },
+            },
+          },
+        },
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/gitlab/runners/{index.d.ts → index.ts}

@@ -1,5 +1,5 @@
 import { RunnerArgs, Runner } from "./runner";
 import { RunnersArgs, Runners } from "./runners";
 import { RunnerCleanupArgs, RunnerCleanup } from "./cleanup";
+
 export { RunnerArgs, Runner, RunnersArgs, Runners, RunnerCleanupArgs, RunnerCleanup };
-//# sourceMappingURL=index.d.ts.map

package/lib/gitlab/runners/runner.ts

@@ -0,0 +1,122 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../../common";
+import * as kubernetes from "../../kubernetes";
+import * as prometheus from "../../prometheus";
+
+export interface RunnerArgs {
+  request?: pulumi.Input<string>;
+  limit?: pulumi.Input<string>;
+}
+
+export interface RunnerArgs {
+  namespace?: pulumi.Input<string>;
+  token: pulumi.Input<string>;
+  concurrency?: pulumi.Input<number>;
+  tags?: pulumi.Input<pulumi.Input<string>[]>;
+  runUntagged?: pulumi.Input<boolean>;
+  image?: pulumi.Input<string>;
+  memory?: pulumi.Input<RunnerArgs>;
+  helperMemory?: pulumi.Input<RunnerArgs>;
+  serviceMemory?: pulumi.Input<RunnerArgs>;
+}
+
+export class Runner extends ComponentResource {
+  private readonly helmRelease: k8s.helm.v3.Release;
+  private readonly podMonitor: prometheus.PodMonitor;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new GitLab runner resource.
+   * @param name The name of the GitLab runner resource.
+   * @param args A bag of arguments to control the GitLab runner creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: RunnerArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("gitlab:runners:runner", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    if (args.concurrency === undefined) {
+      args.concurrency = 2;
+    }
+
+    if (args.image === undefined) {
+      args.image = "ubuntu:latest";
+    }
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    const metadata = {
+      name,
+      namespace: this.namespace,
+      labels: {
+        "app.kubernetes.io/name": "gitlab-runners",
+        "app.kubernetes.io/component": "runner",
+        "app.kubernetes.io/instance": name,
+      },
+    };
+
+    const config = pulumi
+      .all([args.image, args.memory, args.helperMemory, args.serviceMemory])
+      .apply(([image, memory, helperMemory, serviceMemory]) =>
+        [
+          "[[runners]]",
+          "[runners.kubernetes]",
+          `image = "${image}"`,
+          memory && memory.request ? `memory_request = "${memory.request}"` : undefined,
+          memory && memory.limit ? `memory_limit = "${memory.limit}"` : undefined,
+          helperMemory && helperMemory.request ? `helper_memory_request = "${helperMemory.request}"` : undefined,
+          helperMemory && helperMemory.limit ? `helper_memory_limit = "${helperMemory.limit}"` : undefined,
+          serviceMemory && serviceMemory.request ? `service_memory_request = "${serviceMemory.request}"` : undefined,
+          serviceMemory && serviceMemory.limit ? `service_memory_limit = "${serviceMemory.limit}"` : undefined,
+          "[runners.feature_flags]",
+          "FF_GITLAB_REGISTRY_HELPER_IMAGE = true",
+        ]
+          .filter((l) => l)
+          .join("\n")
+      );
+
+    this.helmRelease = new kubernetes.helm.v3.Release(
+      name,
+      {
+        namespace: metadata.namespace,
+        repositoryOpts: { repo: "https://charts.gitlab.io/" },
+        chart: "gitlab-runner",
+        values: {
+          fullnameOverride: name,
+          gitlabUrl: "https://gitlab.com/",
+          runnerRegistrationToken: args.token,
+          concurrent: args.concurrency,
+          rbac: { create: true },
+          runners: {
+            config,
+            tags: pulumi.all([args.tags]).apply((tags) => (tags ?? []).join(",")),
+            runUntagged: args.runUntagged ?? false,
+          },
+          resources: {
+            requests: { memory: "48Mi" },
+            limits: { memory: "64Mi" },
+          },
+        },
+      },
+      opts
+    );
+
+    this.podMonitor = new prometheus.PodMonitor(
+      name,
+      {
+        metadata,
+        spec: {
+          selector: { matchLabels: { app: name } },
+          podMetricsEndpoints: [{ targetPort: 9252, honorLabels: true }],
+        },
+      },
+      { ...opts, dependsOn: [this.helmRelease] }
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/gitlab/runners/runners.ts

@@ -0,0 +1,49 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../../common";
+import { RunnerArgs, Runner } from "./runner";
+
+export interface RunnersArgs {
+  namespace?: pulumi.Input<string>;
+  runners: pulumi.Input<{ [key: string]: pulumi.Input<RunnerArgs> }>;
+}
+
+export class Runners extends ComponentResource {
+  private readonly runners: pulumi.Output<Runner[]>;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new GitLab runners resource.
+   * @param name The name of the GitLab runners resource.
+   * @param args A bag of arguments to control the GitLab runners creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: RunnersArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("gitlab:runners", name, args, opts);
+
+    const k8sOpts = this.opts(k8s.Provider);
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, k8sOpts).metadata.name;
+
+    this.runners = pulumi.all([args.runners]).apply(([runnerConfigs]) => {
+      const runners: Runner[] = [];
+
+      for (const runnerName in runnerConfigs) {
+        // eslint-disable-next-line security/detect-object-injection
+        const runner = new Runner(
+          runnerName,
+          { ...runnerConfigs[runnerName], namespace: this.namespace },
+          { ...opts, parent: this }
+        );
+
+        runners.push(runner);
+      }
+
+      return runners;
+    });
+
+    this.registerOutputs();
+  }
+}