@ydkn/pulumi-components 0.4.2 → 0.4.4

package/lib/postgresql/operator.ts

@@ -0,0 +1,70 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as kubernetes from "../kubernetes";
+
+export interface OperatorArgs {
+  namespace?: pulumi.Input<string>;
+  clusterDomain?: pulumi.Input<string>;
+}
+
+export class Operator extends ComponentResource {
+  private readonly helmRelease: kubernetes.helm.v3.Release;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new PostgreSQL operator resource.
+   * @param name The name of PostgreSQL operator resource.
+   * @param args A bag of arguments to control the PostgreSQL operator creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: OperatorArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("postgresql:operator", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    this.helmRelease = new kubernetes.helm.v3.Release(
+      name,
+      {
+        namespace: this.namespace,
+        repositoryOpts: { repo: "https://opensource.zalando.com/postgres-operator/charts/postgres-operator" },
+        chart: "postgres-operator",
+        values: {
+          fullnameOverride: name,
+          enableJsonLogging: true,
+          configMajorVersionUpgrade: {
+            major_version_upgrade_mode: "full",
+          },
+          configKubernetes: {
+            cluster_domain: args.clusterDomain ?? "cluster.local",
+            enable_pod_antiaffinity: true,
+            enable_pod_disruption_budget: true,
+          },
+          configPostgresPodResources: {
+            default_cpu_limit: "200m",
+            default_memory_limit: "256Mi",
+            min_cpu_limit: "100m",
+            min_memory_limit: "64Mi",
+          },
+          configDebug: {
+            debug_logging: false,
+          },
+          configTeamsApi: {
+            enable_admin_role_for_users: false,
+          },
+          resources: {
+            requests: { cpu: "50m", memory: "64Mi" },
+            limits: { cpu: "200m", memory: "96Mi" },
+          },
+        },
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+}

package/lib/prometheus/index.ts

@@ -0,0 +1,23 @@
+import { PodMetricsEndpoint, PodMonitorSpec, PodMonitorArgs, PodMonitor } from "./podMonitor";
+import {
+  NamespaceSelector,
+  EndpointArgs,
+  ServiceMonitorSpec,
+  ServiceMonitorArgs,
+  ServiceMonitor,
+} from "./serviceMonitor";
+import { OperatorArgs, Operator } from "./operator";
+
+export {
+  PodMetricsEndpoint,
+  PodMonitorSpec,
+  PodMonitorArgs,
+  PodMonitor,
+  NamespaceSelector,
+  EndpointArgs,
+  ServiceMonitorSpec,
+  ServiceMonitorArgs,
+  ServiceMonitor,
+  OperatorArgs,
+  Operator,
+};

package/lib/prometheus/monitor.ts

@@ -0,0 +1,13 @@
+import * as pulumi from "@pulumi/pulumi";
+
+export interface TLSConfigArgs {
+  insecureSkipVerify?: pulumi.Input<boolean>;
+}
+
+export interface RelabelingArgs {
+  action?: pulumi.Input<string>;
+  regex?: pulumi.Input<string>;
+  sourceLabels?: pulumi.Input<pulumi.Input<string>[]>;
+  targetLabel?: pulumi.Input<string>;
+  replacement?: pulumi.Input<string>;
+}

package/lib/prometheus/operator.ts

@@ -0,0 +1,264 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { ComponentResource } from "../common";
+import * as helm from "../kubernetes/helm";
+
+export interface SlackArgs {
+  url: pulumi.Input<string>;
+  channel: pulumi.Input<string>;
+  sendResolved?: pulumi.Input<boolean>;
+  iconURL?: pulumi.Input<string>;
+  title?: pulumi.Input<string>;
+  text?: pulumi.Input<string>;
+}
+
+export interface AlertmanagerArgs {
+  serviceHostname?: pulumi.Input<string>;
+  hostname?: pulumi.Input<string>;
+  ingressClassName?: pulumi.Input<string>;
+  slack?: pulumi.Input<SlackArgs>;
+}
+
+export interface OperatorArgs {
+  namespace?: pulumi.Input<string>;
+  serviceHostname?: pulumi.Input<string>;
+  ingressClassName?: pulumi.Input<string>;
+  hostname?: pulumi.Input<string>;
+  alertmanager?: pulumi.Input<AlertmanagerArgs>;
+  storage?: pulumi.Input<string>;
+  retention?: pulumi.Input<string>;
+}
+
+export class Operator extends ComponentResource {
+  private readonly helmRelease: helm.v3.Release;
+  public readonly namespace: pulumi.Output<string>;
+
+  /**
+   * Create a new Prometheus operator resource.
+   * @param name The name of the Prometheus operator resource.
+   * @param args A bag of arguments to control the Prometheus operator creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: OperatorArgs, opts?: pulumi.ComponentResourceOptions) {
+    super("prometheus:operator", name, args, opts);
+
+    opts = this.opts(k8s.Provider);
+
+    if (args.storage === undefined) {
+      args.storage = "10Gi";
+    }
+
+    if (args.retention === undefined) {
+      args.retention = "24h"; // "1440h";
+    }
+
+    this.namespace = args.namespace
+      ? pulumi.output(args.namespace)
+      : new k8s.core.v1.Namespace(name, { metadata: { name } }, opts).metadata.name;
+
+    this.helmRelease = new helm.v3.Release(
+      name,
+      {
+        namespace: this.namespace,
+        repositoryOpts: { repo: "https://prometheus-community.github.io/helm-charts" },
+        chart: "kube-prometheus-stack",
+        values: pulumi.all([args.alertmanager]).apply(([alertmanager]) => {
+          return {
+            fullnameOverride: name,
+            prometheusOperator: {
+              resources: {
+                requests: { memory: "192Mi" },
+                limits: { memory: "512Mi", cpu: "200m" },
+              },
+              prometheusConfigReloader: {
+                resources: {
+                  requests: { memory: "32Mi" },
+                  limits: { memory: "48Mi", cpu: "200m" },
+                },
+              },
+            },
+            prometheus: {
+              prometheusSpec: {
+                retention: args.retention,
+                logFormat: "json",
+                externalUrl: args.hostname,
+                enableRemoteWriteReceiver: true,
+                remoteWriteDashboards: true,
+                storageSpec: {
+                  volumeClaimTemplate: {
+                    spec: {
+                      accessModes: ["ReadWriteOnce"],
+                      resources: { requests: { storage: args.storage } },
+                    },
+                  },
+                },
+                additionalAlertManagerConfigs:
+                  alertmanager !== undefined && alertmanager.hostname !== undefined
+                    ? [{ scheme: "https", static_configs: [{ targets: [alertmanager.hostname] }] }]
+                    : [],
+                serviceMonitorSelector: { matchLabels: { prometheusNoScrape: "none" } },
+                podMonitorSelector: { matchLabels: { prometheusNoScrape: "none" } },
+                probeSelector: { matchLabels: { prometheusNoScrape: "none" } },
+                ruleSelector: { matchLabels: { prometheusNoScrape: "none" } },
+                podAntiAffinity: "soft",
+                resources: {
+                  requests: { memory: "1536Mi" },
+                  limits: { memory: "2048Mi" },
+                },
+              },
+              service: {
+                annotations:
+                  args.serviceHostname !== undefined
+                    ? { "external-dns.alpha.kubernetes.io/hostname": args.serviceHostname }
+                    : {},
+              },
+              ingress: helm.v3.ingressValues(
+                pulumi.interpolate`${name}-prometheus`,
+                [args.hostname],
+                args.ingressClassName
+              ),
+            },
+            alertmanager: {
+              alertmanagerSpec: {
+                externalUrl: pulumi.interpolate`https://${alertmanager?.hostname}`,
+                retention: "120h",
+                podAntiAffinity: "soft",
+                resources: {
+                  requests: { memory: "64Mi" },
+                  limits: { memory: "128Mi" },
+                },
+              },
+              config: {
+                global: {
+                  slack_api_url: alertmanager?.slack ? alertmanager.slack.url : undefined,
+                },
+                route: { receiver: alertmanager?.slack !== undefined ? "slack" : undefined },
+                receivers: [{ name: "null" }, { name: "slack", slack_configs: this.slackConfigs(alertmanager?.slack) }],
+              },
+              service: {
+                annotations:
+                  alertmanager?.serviceHostname !== undefined
+                    ? { "external-dns.alpha.kubernetes.io/hostname": alertmanager.serviceHostname }
+                    : {},
+              },
+              ingress: helm.v3.ingressValues(
+                pulumi.interpolate`${name}-alertmanager`,
+                [alertmanager?.hostname],
+                alertmanager?.ingressClassName ?? args.ingressClassName
+              ),
+            },
+            grafana: {
+              enabled: false,
+              forceDeployDatasources: true,
+              forceDeployDashboards: true,
+              deleteDatasources: [{ name: "Prometheus", orgId: 1 }],
+              sidecar: {
+                datasources: { url: pulumi.interpolate`http://${name}-prometheus.${this.namespace}.svc:9090` },
+                dashboards: { multicluster: { global: { enabled: true }, etcd: { enabled: true } } },
+              },
+            },
+            kubeStateMetrics: { enabled: false },
+            nodeExporter: { enabled: false },
+            kubeApiServer: { enabled: false, serviceMonitor: { metricRelabelings: [] } },
+            kubeControllerManager: { enabled: false, serviceMonitor: { metricRelabelings: [] } },
+            kubeScheduler: { enabled: false, serviceMonitor: { metricRelabelings: [] } },
+            kubeEtcd: { enabled: false, serviceMonitor: { metricRelabelings: [] } },
+            kubeProxy: { enabled: false, serviceMonitor: { metricRelabelings: [] } },
+            kubelet: { enabled: false, serviceMonitor: { metricRelabelings: [] } },
+            coreDns: { enabled: false, serviceMonitor: { metricRelabelings: [] } },
+          };
+        }),
+      },
+      opts
+    );
+
+    this.registerOutputs();
+  }
+
+  private slackConfigs(slack?: pulumi.Input<SlackArgs>): pulumi.Output<any>[] {
+    if (slack === undefined) {
+      return [];
+    }
+
+    return [
+      pulumi.all([slack]).apply(([slack]) => {
+        return {
+          send_resolved: slack.sendResolved !== undefined ? slack.sendResolved : true,
+          icon_url: slack.iconURL ?? "https://avatars3.githubusercontent.com/u/3380462",
+          channel: slack.channel,
+          color: [
+            `{{ if eq .Status "firing" -}}`,
+            `{{ if eq .CommonLabels.severity "warning" -}}`,
+            "warning",
+            `{{- else if eq .CommonLabels.severity "critical" -}}`,
+            "danger",
+            "{{- else -}}",
+            "#439FE0",
+            "{{- end -}}",
+            "{{ else -}}",
+            "good",
+            "{{- end }}",
+          ].join(""),
+          title:
+            slack.title ??
+            [
+              "[",
+              "{{ .Status | toUpper -}}",
+              `{{ if eq .Status "firing" }}:{{ .Alerts.Firing | len }}{{- end -}}`,
+              "] ",
+              "{{ .CommonLabels.alertname }}",
+            ].join(""),
+          text:
+            slack.text ??
+            [
+              `{{- if eq .CommonLabels.severity "critical" -}}`,
+              "*Severity:* `Critical`",
+              `{{- else if eq .CommonLabels.severity "warning" -}}`,
+              "*Severity:* `Warning`",
+              `{{- else if eq .CommonLabels.severity "info" -}}`,
+              "*Severity:* `Info`",
+              "{{- end }}",
+              "{{- if (index .Alerts 0).Annotations.summary }}",
+              `{{- "\\n" -}}`,
+              "*Summary:* ",
+              "{{ (index .Alerts 0).Annotations.summary }}",
+              "{{- end }}",
+              "{{ range .Alerts }}",
+              "{{- if .Annotations.description }}",
+              `{{- "\\n" -}}`,
+              "{{ .Annotations.description }}",
+              `{{- "\\n" -}}`,
+              "{{- end }}",
+              "{{- if .Annotations.message }}",
+              `{{- "\\n" -}}`,
+              "{{ .Annotations.message }}",
+              `{{- "\\n" -}}`,
+              "{{- end }}",
+              "{{- end }}",
+            ].join(""),
+          actions: [
+            { type: "button", text: "Query :mag:", url: "{{ (index .Alerts 0).GeneratorURL }}" },
+            {
+              type: "button",
+              text: "Dashboard :chart_with_upwards_trend:",
+              url: "{{ (index .Alerts 0).Annotations.dashboard_url }}",
+            },
+            {
+              type: "button",
+              text: "Silence :no_bell:",
+              url: [
+                "{{ .ExternalURL }}/#/silences/new?filter=%7B",
+                "{{- range .CommonLabels.SortedPairs -}}",
+                `{{- if ne .Name "alertname" -}}`,
+                `{{- .Name }}%3D"{{- .Value -}}"%2C%20`,
+                "{{- end -}}",
+                "{{- end -}}",
+                `alertname%3D"{{- .CommonLabels.alertname -}}"%7D`,
+              ].join(""),
+            },
+          ],
+        };
+      }),
+    ];
+  }
+}

package/lib/prometheus/podMonitor.ts

@@ -0,0 +1,32 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { RelabelingArgs, TLSConfigArgs } from "./monitor";
+
+export interface PodMetricsEndpoint {
+  targetPort?: pulumi.Input<number | string>;
+  honorLabels?: pulumi.Input<boolean>;
+  tlsConfig?: pulumi.Input<TLSConfigArgs>;
+  metricRelabelings?: pulumi.Input<pulumi.Input<RelabelingArgs>[]>;
+}
+
+export interface PodMonitorSpec {
+  selector?: pulumi.Input<k8s.types.input.meta.v1.LabelSelector>;
+  podMetricsEndpoints?: pulumi.Input<pulumi.Input<PodMetricsEndpoint>[]>;
+}
+
+export interface PodMonitorArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  spec: pulumi.Input<PodMonitorSpec>;
+}
+
+export class PodMonitor extends k8s.apiextensions.CustomResource {
+  /**
+   * Create a new pod monitor resource.
+   * @param name The name of the pod monitor resource.
+   * @param args A bag of arguments to control the pod monitor creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: PodMonitorArgs, opts?: pulumi.CustomResourceOptions) {
+    super(name, { ...args, apiVersion: "monitoring.coreos.com/v1", kind: "PodMonitor" }, opts);
+  }
+}

package/lib/prometheus/serviceMonitor.ts

@@ -0,0 +1,43 @@
+import * as pulumi from "@pulumi/pulumi";
+import * as k8s from "@pulumi/kubernetes";
+import { RelabelingArgs, TLSConfigArgs } from "./monitor";
+
+export interface NamespaceSelector {
+  matchNames?: pulumi.Input<pulumi.Input<string | undefined>[]>;
+}
+
+export interface EndpointArgs {
+  path?: pulumi.Input<string>;
+  port?: pulumi.Input<string | number>;
+  honorLabels?: pulumi.Input<boolean>;
+  honorTimestamps?: pulumi.Input<boolean>;
+  interval?: pulumi.Input<string>;
+  bearerTokenFile?: pulumi.Input<string>;
+  scheme?: pulumi.Input<string>;
+  tlsConfig?: pulumi.Input<TLSConfigArgs>;
+  metricRelabelings?: pulumi.Input<pulumi.Input<RelabelingArgs>[]>;
+  relabelings?: pulumi.Input<pulumi.Input<RelabelingArgs>[]>;
+}
+
+export interface ServiceMonitorSpec {
+  namespaceSelector?: pulumi.Input<NamespaceSelector>;
+  selector?: pulumi.Input<k8s.types.input.meta.v1.LabelSelector>;
+  endpoints?: pulumi.Input<pulumi.Input<EndpointArgs>[]>;
+}
+
+export interface ServiceMonitorArgs {
+  metadata: pulumi.Input<k8s.types.input.meta.v1.ObjectMeta>;
+  spec: pulumi.Input<ServiceMonitorSpec>;
+}
+
+export class ServiceMonitor extends k8s.apiextensions.CustomResource {
+  /**
+   * Create a new service monitor resource.
+   * @param name The name of the service monitor resource.
+   * @param args A bag of arguments to control the service monitor creation.
+   * @param opts A bag of options that control this resource's behavior.
+   */
+  constructor(name: string, args: ServiceMonitorArgs, opts?: pulumi.CustomResourceOptions) {
+    super(name, { ...args, apiVersion: "monitoring.coreos.com/v1", kind: "ServiceMonitor" }, opts);
+  }
+}