@ydkn/pulumi-components 0.4.4 → 0.4.6

package/lib/gitlab/runners/runner.ts

@@ -1,122 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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();
-  }
-}

package/lib/grafana/agent.ts

@@ -1,449 +0,0 @@
-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 MetricsArgs {
-  url: pulumi.Input<string>;
-  username?: pulumi.Input<string>;
-  password?: pulumi.Input<string>;
-}
-
-export interface LogsArgs {
-  url: pulumi.Input<string>;
-  username?: pulumi.Input<string>;
-  password?: pulumi.Input<string>;
-}
-
-export interface AgentArgs {
-  namespace?: pulumi.Input<string>;
-  clusterName: pulumi.Input<string>;
-  metrics?: pulumi.Input<MetricsArgs>;
-  logs?: pulumi.Input<LogsArgs>;
-}
-
-export class Agent extends ComponentResource {
-  private readonly helmRelease: kubernetes.helm.v3.Release;
-  private readonly serviceAccount: k8s.core.v1.ServiceAccount;
-  private readonly clusterRole: k8s.rbac.v1.ClusterRole;
-  private readonly clusterRoleBinding: k8s.rbac.v1.ClusterRoleBinding;
-  private readonly agent: k8s.apiextensions.CustomResource;
-  private readonly metricsSecret?: k8s.core.v1.Secret;
-  private readonly metrics?: k8s.apiextensions.CustomResource;
-  private readonly kubeletServiceMonitor?: prometheus.ServiceMonitor;
-  private readonly cadvisorServiceMonitor?: prometheus.ServiceMonitor;
-  private readonly logsSecret?: k8s.core.v1.Secret;
-  private readonly logs?: k8s.apiextensions.CustomResource;
-  private readonly podLogs?: k8s.apiextensions.CustomResource;
-  public readonly namespace: pulumi.Output<string>;
-
-  /**
-   * Create a new grafana agent resource.
-   * @param name The name of the grafana agent resource.
-   * @param args A bag of arguments to control the grafana agent creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: AgentArgs, opts?: pulumi.ComponentResourceOptions) {
-    super("grafana:agent", 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.helmRelease = new kubernetes.helm.v3.Release(
-      name,
-      {
-        name: `${name}-operator`,
-        namespace: this.namespace,
-        repositoryOpts: { repo: "https://grafana.github.io/helm-charts" },
-        chart: "grafana-agent-operator",
-        values: {
-          fullnameOverride: `${name}-operator`,
-          kubeletService: {
-            namespace: this.namespace,
-            serviceName: "kubelet",
-          },
-          resources: {
-            requests: { memory: "256Mi" },
-            limits: { memory: "320Mi" },
-          },
-        },
-      },
-      k8sOpts
-    );
-
-    const metadata = {
-      name,
-      namespace: this.namespace,
-      labels: {
-        "app.kubernetes.io/name": "grafana-agent",
-        "app.kubernetes.io/instance": name,
-      },
-    };
-
-    this.serviceAccount = new k8s.core.v1.ServiceAccount(name, { metadata }, k8sOpts);
-
-    this.clusterRole = new k8s.rbac.v1.ClusterRole(
-      name,
-      {
-        metadata,
-        rules: [
-          {
-            apiGroups: [""],
-            resources: ["nodes", "nodes/proxy", "nodes/metrics", "services", "endpoints", "pods", "events"],
-            verbs: ["get", "list", "watch"],
-          },
-          { apiGroups: ["networking.k8s.io"], resources: ["ingresses"], verbs: ["get", "list", "watch"] },
-          { nonResourceURLs: ["/metrics", "/metrics/cadvisor"], verbs: ["get"] },
-        ],
-      },
-      k8sOpts
-    );
-
-    this.clusterRoleBinding = new k8s.rbac.v1.ClusterRoleBinding(
-      name,
-      {
-        metadata,
-        subjects: [
-          {
-            kind: this.serviceAccount.kind,
-            namespace: this.serviceAccount.metadata.namespace,
-            name: this.serviceAccount.metadata.name,
-          },
-        ],
-        roleRef: {
-          apiGroup: "rbac.authorization.k8s.io",
-          kind: this.clusterRole.kind,
-          name: this.clusterRole.metadata.name,
-        },
-      },
-      k8sOpts
-    );
-
-    this.agent = new k8s.apiextensions.CustomResource(
-      name,
-      {
-        apiVersion: "monitoring.grafana.com/v1alpha1",
-        kind: "GrafanaAgent",
-        metadata,
-        spec: {
-          logLevel: "info",
-          serviceAccountName: this.serviceAccount.metadata.name,
-          metrics: {
-            instanceSelector: {
-              matchLabels: { agent: "grafana-agent-metrics" },
-            },
-            externalLabels: { cluster: args.clusterName },
-          },
-          logs: {
-            instanceSelector: {
-              matchLabels: { agent: "grafana-agent-logs" },
-            },
-          },
-        },
-      },
-      { ...k8sOpts, dependsOn: [this.helmRelease] }
-    );
-
-    if (args.metrics !== undefined) {
-      this.metricsSecret = new k8s.core.v1.Secret(
-        `${name}-metrics`,
-        {
-          metadata: { ...metadata, name: `${name}-metrics` },
-          stringData: pulumi.all([args.metrics]).apply(([m]) => {
-            return {
-              username: m.username ?? "",
-              password: m.password ?? "",
-            };
-          }),
-        },
-        k8sOpts
-      );
-
-      this.metrics = new k8s.apiextensions.CustomResource(
-        `${name}-metrics`,
-        {
-          apiVersion: "monitoring.grafana.com/v1alpha1",
-          kind: "MetricsInstance",
-          metadata: { ...metadata, labels: { ...metadata.labels, agent: "grafana-agent-metrics" } },
-          spec: {
-            remoteWrite: [
-              {
-                url: pulumi.all([args.metrics]).apply(([m]) => m.url),
-                basicAuth: {
-                  username: { name: this.metricsSecret.metadata.name, key: "username" },
-                  password: { name: this.metricsSecret.metadata.name, key: "password" },
-                },
-              },
-            ],
-            serviceMonitorNamespaceSelector: {},
-            serviceMonitorSelector: { matchLabels: {} },
-            podMonitorNamespaceSelector: {},
-            podMonitorSelector: { matchLabels: {} },
-            probeNamespaceSelector: {},
-            probeSelector: { matchLabels: {} },
-          },
-        },
-        { ...k8sOpts, dependsOn: [this.agent] }
-      );
-
-      this.kubeletServiceMonitor = new prometheus.ServiceMonitor(
-        `${name}-kubelet`,
-        {
-          metadata: { name: `${name}-kubelet`, namespace: "kube-system" },
-          spec: {
-            endpoints: [
-              {
-                bearerTokenFile: "/var/run/secrets/kubernetes.io/serviceaccount/token",
-                honorLabels: true,
-                interval: "60s",
-                port: "https-metrics",
-                scheme: "https",
-                tlsConfig: { insecureSkipVerify: true },
-                metricRelabelings: [
-                  {
-                    action: "drop",
-                    sourceLabels: ["__name__"],
-                    regex: [
-                      "go_.*",
-                      "storage_operation_duration_seconds_bucket",
-                      "storage_operation_duration_seconds_count",
-                      "kubelet_runtime_operations_duration_seconds_bucket",
-                      "rest_client_request_duration_seconds_bucket",
-                    ].join("|"),
-                  },
-                  {
-                    action: "drop",
-                    sourceLabels: ["service"],
-                    regex: "prometheus-operator-.*",
-                  },
-                  {
-                    action: "keep",
-                    regex: [
-                      "kubelet_cgroup_manager_duration_seconds_count",
-                      "kubelet_pod_start_duration_seconds_count",
-                      "kubelet_runtime_operations_total",
-                      "kubelet_pleg_relist_duration_seconds_bucket",
-                      "volume_manager_total_volumes",
-                      "kubelet_volume_stats_capacity_bytes",
-                      "container_cpu_usage_seconds_total",
-                      "container_network_transmit_bytes_total",
-                      "kubelet_runtime_operations_errors_total",
-                      "container_network_receive_bytes_total",
-                      "container_memory_swap",
-                      "container_network_receive_packets_total",
-                      "container_cpu_cfs_periods_total",
-                      "container_cpu_cfs_throttled_periods_total",
-                      "kubelet_running_pod_count",
-                      "node_namespace_pod_container:container_cpu_usage_seconds_total:sum_rate",
-                      "container_memory_working_set_bytes",
-                      "storage_operation_errors_total",
-                      "kubelet_pleg_relist_duration_seconds_count",
-                      "kubelet_running_pods",
-                      "process_resident_memory_bytes",
-                      "kubelet_running_containers",
-                      "kubelet_node_config_error",
-                      "kubelet_cgroup_manager_duration_seconds_bucket",
-                      "kubelet_running_container_count",
-                      "kubelet_volume_stats_available_bytes",
-                      "kubelet_volume_stats_inodes",
-                      "container_memory_rss",
-                      "kubelet_pod_worker_duration_seconds_count",
-                      "kubelet_node_name",
-                      "kubelet_pleg_relist_interval_seconds_bucket",
-                      "container_network_receive_packets_dropped_total",
-                      "kubelet_pod_worker_duration_seconds_bucket",
-                      "container_start_time_seconds",
-                      "container_network_transmit_packets_dropped_total",
-                      "process_cpu_seconds_total",
-                      "container_memory_cache",
-                      "container_network_transmit_packets_total",
-                      "kubelet_volume_stats_inodes_used",
-                      "up",
-                      "rest_client_requests_total",
-                    ].join("|"),
-                    sourceLabels: ["__name__"],
-                  },
-                  {
-                    action: "replace",
-                    targetLabel: "job",
-                    replacement: "integrations/kubernetes/kubelet",
-                  },
-                ],
-                relabelings: [{ sourceLabels: ["__metrics_path__"], targetLabel: "metrics_path" }],
-              },
-            ],
-            namespaceSelector: { matchNames: ["kube-system"] },
-            selector: { matchLabels: { "app.kubernetes.io/name": "kubelet" } },
-          },
-        },
-        { ...k8sOpts, dependsOn: [this.metrics] }
-      );
-
-      this.cadvisorServiceMonitor = new prometheus.ServiceMonitor(
-        `${name}-cadvisor`,
-        {
-          metadata: { name: `${name}-cadvisor`, namespace: "kube-system" },
-          spec: {
-            endpoints: [
-              {
-                bearerTokenFile: "/var/run/secrets/kubernetes.io/serviceaccount/token",
-                honorLabels: true,
-                honorTimestamps: false,
-                interval: "60s",
-                path: "/metrics/cadvisor",
-                port: "https-metrics",
-                scheme: "https",
-                tlsConfig: { insecureSkipVerify: true },
-                metricRelabelings: [
-                  {
-                    action: "drop",
-                    sourceLabels: ["__name__"],
-                    regex: [
-                      "go_.*",
-                      "storage_operation_duration_seconds_bucket",
-                      "storage_operation_duration_seconds_count",
-                      "kubelet_runtime_operations_duration_seconds_bucket",
-                      "rest_client_request_duration_seconds_bucket",
-                    ].join("|"),
-                  },
-                  {
-                    action: "drop",
-                    sourceLabels: ["service"],
-                    regex: "prometheus-operator-.*",
-                  },
-                  {
-                    action: "drop",
-                    sourceLabels: ["namespace"],
-                    regex: "^$",
-                  },
-                  {
-                    action: "drop",
-                    sourceLabels: ["pod"],
-                    regex: "^$",
-                  },
-                  {
-                    action: "keep",
-                    regex: [
-                      "kubelet_cgroup_manager_duration_seconds_count",
-                      "kubelet_pod_start_duration_seconds_count",
-                      "kubelet_runtime_operations_total",
-                      "kubelet_pleg_relist_duration_seconds_bucket",
-                      "volume_manager_total_volumes",
-                      "kubelet_volume_stats_capacity_bytes",
-                      "container_cpu_usage_seconds_total",
-                      "container_network_transmit_bytes_total",
-                      "kubelet_runtime_operations_errors_total",
-                      "container_network_receive_bytes_total",
-                      "container_memory_swap",
-                      "container_network_receive_packets_total",
-                      "container_cpu_cfs_periods_total",
-                      "container_cpu_cfs_throttled_periods_total",
-                      "kubelet_running_pod_count",
-                      "node_namespace_pod_container:container_cpu_usage_seconds_total:sum_rate",
-                      "container_memory_working_set_bytes",
-                      "storage_operation_errors_total",
-                      "kubelet_pleg_relist_duration_seconds_count",
-                      "kubelet_running_pods",
-                      "process_resident_memory_bytes",
-                      "kubelet_running_containers",
-                      "kubelet_node_config_error",
-                      "kubelet_cgroup_manager_duration_seconds_bucket",
-                      "kubelet_running_container_count",
-                      "kubelet_volume_stats_available_bytes",
-                      "kubelet_volume_stats_inodes",
-                      "container_memory_rss",
-                      "kubelet_pod_worker_duration_seconds_count",
-                      "kubelet_node_name",
-                      "kubelet_pleg_relist_interval_seconds_bucket",
-                      "container_network_receive_packets_dropped_total",
-                      "kubelet_pod_worker_duration_seconds_bucket",
-                      "container_start_time_seconds",
-                      "container_network_transmit_packets_dropped_total",
-                      "process_cpu_seconds_total",
-                      "container_memory_cache",
-                      "container_network_transmit_packets_total",
-                      "kubelet_volume_stats_inodes_used",
-                      "up",
-                      "rest_client_requests_total",
-                    ].join("|"),
-                    sourceLabels: ["__name__"],
-                  },
-                  {
-                    action: "replace",
-                    targetLabel: "job",
-                    replacement: "integrations/kubernetes/cadvisor",
-                  },
-                ],
-                relabelings: [{ sourceLabels: ["__metrics_path__"], targetLabel: "metrics_path" }],
-              },
-            ],
-            namespaceSelector: { matchNames: ["kube-system"] },
-            selector: { matchLabels: { "app.kubernetes.io/name": "kubelet" } },
-          },
-        },
-        { ...k8sOpts, dependsOn: [this.metrics] }
-      );
-    }
-
-    if (args.logs !== undefined) {
-      this.logsSecret = new k8s.core.v1.Secret(
-        `${name}-logs-credentials`,
-        {
-          metadata: { ...metadata, name: `${name}-logs-credentials` },
-          stringData: pulumi.all([args.logs]).apply(([l]) => {
-            return {
-              username: l.username ?? "",
-              password: l.password ?? "",
-            };
-          }),
-        },
-        k8sOpts
-      );
-
-      this.logs = new k8s.apiextensions.CustomResource(
-        `${name}-logs`,
-        {
-          apiVersion: "monitoring.grafana.com/v1alpha1",
-          kind: "LogsInstance",
-          metadata: { ...metadata, labels: { ...metadata.labels, agent: "grafana-agent-logs" } },
-          spec: {
-            clients: [
-              {
-                url: pulumi.all([args.logs]).apply(([l]) => l.url),
-                basicAuth: {
-                  username: { name: this.logsSecret.metadata.name, key: "username" },
-                  password: { name: this.logsSecret.metadata.name, key: "password" },
-                },
-                externalLabels: { cluster: args.clusterName },
-              },
-            ],
-            podLogsNamespaceSelector: {},
-            podLogsSelector: { matchLabels: {} },
-          },
-        },
-        { ...k8sOpts, dependsOn: [this.agent] }
-      );
-
-      this.podLogs = new k8s.apiextensions.CustomResource(
-        `${name}-podlogs`,
-        {
-          apiVersion: "monitoring.grafana.com/v1alpha1",
-          kind: "PodLogs",
-          metadata,
-          spec: {
-            pipelineStages: [],
-            namespaceSelector: {},
-            selector: { matchLabels: {} },
-          },
-        },
-        { ...k8sOpts, dependsOn: [this.logs] }
-      );
-    }
-
-    this.registerOutputs();
-  }
-}

package/lib/grafana/dashboard.ts

@@ -1,38 +0,0 @@
-import * as pulumi from "@pulumi/pulumi";
-import * as k8s from "@pulumi/kubernetes";
-
-export interface DashboardArgs {
-  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
-  name: pulumi.Input<string>;
-  data: pulumi.Input<string>;
-}
-
-export class Dashboard extends k8s.core.v1.ConfigMap {
-  /**
-   * Create a new Grafana dashboard resource.
-   * @param name The name of the Grafana dashboard resource.
-   * @param args A bag of arguments to control the Grafana dashboard creation.
-   * @param opts A bag of options that control this resource's behavior.
-   */
-  constructor(name: string, args: DashboardArgs, opts?: pulumi.CustomResourceOptions) {
-    super(
-      name,
-      {
-        metadata: pulumi.all([args.metadata]).apply(([metadata]) => {
-          return {
-            ...metadata,
-            labels: { ...metadata.labels, grafana_dashboard: "1" },
-          };
-        }),
-        data: pulumi.all([args.name, args.data]).apply(([dashboardName, data]) => {
-          const d: { [key: string]: string } = {};
-
-          d[`${dashboardName}.json`] = data;
-
-          return d;
-        }),
-      },
-      opts
-    );
-  }
-}