@ydkn/pulumi-components 0.4.2 → 0.4.4

package/lib/grafana/agent.ts

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

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

package/lib/grafana/datasource.ts

@@ -0,0 +1,59 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import * as yaml from "js-yaml";
+
+export interface DataSourceArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  type: pulumi.Input<string>;
+  name: pulumi.Input<string>;
+  url: pulumi.Input<string>;
+  orgId?: pulumi.Input<string>;
+  isDefault?: pulumi.Input<boolean>;
+}
+
+export class DataSource extends k8s.core.v1.Secret {
+  /**
+   * Create a new Grafana data source resource.
+   * @param name The name of the Grafana data source resource.
+   * @param args A bag of arguments to control the Grafana data source creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: DataSourceArgs, opts?: pulumi.CustomResourceOptions) {
+    super(
+      name,
+      {
+        metadata: pulumi.all([args.metadata]).apply(([metadata]) => {
+          return {
+            ...metadata,
+            labels: { ...metadata.labels, grafana_datasource: "1" },
+          };
+        }),
+        stringData: pulumi
+          .all([args.type, args.name, args.url, args.orgId, args.isDefault])
+          .apply(([dsType, dsName, url, orgId, isDefault]) => {
+            const data: { [key: string]: string } = {};
+
+            data[`${dsName}.yml`] = yaml.dump({
+              apiVersion: 1,
+              deleteDatasources: [{ name: dsName, orgId: orgId ?? 1 }],
+              datasources: [
+                {
+                  uid: name,
+                  name: dsName,
+                  type: dsType,
+                  access: "proxy",
+                  orgId: orgId ?? 1,
+                  url,
+                  editable: false,
+                  isDefault: isDefault ?? false,
+                },
+              ],
+            });
+
+            return data;
+          }),
+      },
+      opts
+    );
+  }
+}

package/lib/grafana/deployment.ts

@@ -0,0 +1,78 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as random from "@pulumi/random";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+
+export interface GrafanaArgs {
+  namespace?: pulumi.Input<string>;
+  hostname?: pulumi.Input<string>;
+  ingressClassName?: pulumi.Input<string>;
+  replicas?: pulumi.Input<number>;
+}
+
+export class Grafana extends ComponentResource {
+  private readonly helmRelease: kubernetes.helm.v3.Release;
+  public readonly adminPassword: pulumi.Output<string>;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new grafana resource.
+   * @param name The name of grafana resource.
+   * @param args A bag of arguments to control the grafana creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: GrafanaArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("grafana", name, args, opts);
+
+    const emptyOpts = this.opts();
+    const k8sOpts = this.opts(k8s.Provider);
+
+    if (args.replicas === undefined) {
+      args.replicas = 1;
+    }
+
+    this.adminPassword = pulumi.secret(
+      new random.RandomPassword(`${name}-admin-password`, { length: 24, special: true }, emptyOpts).result
+    );
+
+    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,
+        namespace: this.namespace,
+        repositoryOpts: { repo: "https://grafana.github.io/helm-charts" },
+        chart: "grafana",
+        values: {
+          fullnameOverride: name,
+          replicas: args.replicas,
+          adminPassword: this.adminPassword,
+          testFramework: { enabled: false },
+          plugins: ["grafana-piechart-panel", "vonage-status-panel"],
+          ingress: kubernetes.helm.v3.ingressValues(name, [args.hostname], args.ingressClassName),
+          rbac: { pspEnabled: false },
+          serviceMonitor: { enabled: false }, // TODO
+          sidecar: {
+            datasources: { enabled: true, searchNamespace: "ALL" },
+            dashboards: { enabled: true, searchNamespace: "ALL" },
+            resources: {
+              requests: { memory: "64Mi" },
+              limits: { memory: "96Mi" },
+            },
+          },
+          resources: {
+            requests: { memory: "192Mi" },
+            limits: { memory: "256Mi" },
+          },
+        },
+      },
+      k8sOpts
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/grafana/index.ts

@@ -0,0 +1,17 @@
+import { GrafanaArgs, Grafana } from "./deployment";
+import { DataSourceArgs, DataSource } from "./datasource";
+import { DashboardArgs, Dashboard } from "./dashboard";
+import { MetricsArgs, LogsArgs, AgentArgs, Agent } from "./agent";
+
+export {
+  GrafanaArgs,
+  Grafana,
+  DataSourceArgs,
+  DataSource,
+  DashboardArgs,
+  Dashboard,
+  MetricsArgs,
+  LogsArgs,
+  AgentArgs,
+  Agent,
+};