@bluedynamics/cdk8s-monitoring 0.0.1

package/lib/constructs/prometheus-stack.js

@@ -0,0 +1,477 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrometheusStackConstruct = void 0;
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+/**
+ * Creates kube-prometheus-stack HelmChart with Prometheus, Grafana, and Alertmanager.
+ *
+ * This is the core monitoring stack that includes:
+ * - Prometheus (metrics collection, 2 replicas, 3d retention)
+ * - Grafana (visualization, ingress with Let's Encrypt)
+ * - Alertmanager (alert routing, SMTP notifications)
+ * - Prometheus Operator (manages Prometheus CRDs)
+ * - Node Exporter (system metrics DaemonSet)
+ * - kube-state-metrics (Kubernetes resource metrics)
+ *
+ * Prerequisites:
+ * - Namespace exists
+ * - PriorityClass 'high-priority' exists
+ * - Longhorn storage class available
+ * - cert-manager ClusterIssuer configured
+ * - Thanos S3 secret exists (thanos-objstore-config)
+ *
+ * Sync Wave: 2 (core services - after S3 buckets and secrets)
+ */
+class PrometheusStackConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace, config } = props;
+        // Generate Helm values YAML
+        const helmValues = this.generateHelmValues(config);
+        // Create HelmChart resource (K3S Helm controller)
+        // Wave 2: Core Services - monitoring stack
+        new cdk8s_1.ApiObject(this, 'kube-prometheus-stack', {
+            apiVersion: 'helm.cattle.io/v1',
+            kind: 'HelmChart',
+            metadata: {
+                name: 'kube-prometheus-stack',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'kube-prometheus-stack',
+                    'app.kubernetes.io/component': 'monitoring',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '2',
+                },
+            },
+            spec: {
+                repo: 'https://prometheus-community.github.io/helm-charts',
+                chart: 'kube-prometheus-stack',
+                version: config.versions.prometheusStack === 'latest' ? undefined : config.versions.prometheusStack,
+                targetNamespace: namespace,
+                valuesContent: helmValues,
+            },
+        });
+    }
+    generateHelmValues(config) {
+        return `kubeEtcd:
+  enabled: false
+
+# Disable kube-controller-manager and kube-scheduler monitoring. See https://github.com/cablespaghetti/k3s-monitoring/issues/2
+kubeControllerManager:
+  enabled: false
+kubeScheduler:
+  enabled: false
+
+# Detect PodDisruptionBudgets that would block a node drain during k3s upgrades.
+# Operator-managed PDBs sit at disruptionsAllowed=0 by design (Longhorn instance-managers,
+# CNPG *-primary) and are excluded so the alert only fires on anomalous app PDBs.
+additionalPrometheusRulesMap:
+  pdb-drain-safety:
+    groups:
+      - name: pdb.rules
+        interval: 1m
+        rules:
+          - alert: PodDisruptionBudgetUndrainable
+            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!="longhorn-system", poddisruptionbudget!~".*-primary"} == 0
+            for: 15m
+            labels:
+              severity: warning
+              component: cluster-upgrade
+            annotations:
+              summary: "PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} allows 0 voluntary disruptions"
+              description: |
+                The PodDisruptionBudget {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }}
+                has allowed 0 voluntary disruptions for over 15 minutes. This will block a node
+                drain during k3s upgrades. Operator-managed PDBs (Longhorn, CNPG primaries) are
+                excluded from this alert. Likely a degraded deployment (0 healthy pods) or a
+                single-replica deployment with minAvailable=1.
+                Check: kubectl get pdb -n {{ $labels.namespace }} {{ $labels.poddisruptionbudget }}
+          - alert: PodDisruptionBudgetUndrainableCritical
+            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!="longhorn-system", poddisruptionbudget!~".*-primary"} == 0
+            for: 1h
+            labels:
+              severity: critical
+              component: cluster-upgrade
+            annotations:
+              summary: "PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} undrainable >1h"
+              description: |
+                PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} has blocked
+                voluntary disruptions for over an hour. A k3s agent upgrade would stall on this node.
+  # Detect an EX dedicated worker stuck NotReady — likely a MicroOS reboot hang
+  # (pings but sshd/kubelet dead). A hung node also holds the cluster-wide kured
+  # lock, blocking all further graceful reboots, so this must be caught fast.
+  ex-worker-reboot:
+    groups:
+      - name: ex-worker.rules
+        interval: 1m
+        rules:
+          - alert: ExWorkerNotReady
+            expr: kube_node_status_condition{condition="Ready",status="true",node=~"kup6s-ex-.*"} == 0
+            for: 15m
+            labels:
+              severity: critical
+              component: node
+            annotations:
+              summary: "EX worker {{ $labels.node }} NotReady for >15m"
+              description: |
+                EX dedicated worker {{ $labels.node }} has been NotReady for over 15 minutes.
+                Possible MicroOS reboot hang (pings but sshd/kubelet/longhorn-manager dead) — the
+                node may still hold the cluster-wide kured lock, blocking all further reboots.
+                Recovery: Hetzner Robot hardware reset. Do NOT force-detach Longhorn volumes.
+              runbook_url: "https://docs.kup6s.com/how-to/troubleshooting/ex-worker-ping-but-dead.html"
+
+# Drop high-cardinality API server and etcd histogram buckets to reduce memory usage
+# These metrics alone account for ~200k series (47% of total cardinality)
+# We keep _sum and _count suffixes which are sufficient for rate calculations
+kubeApiServer:
+  serviceMonitor:
+    metricRelabelings:
+      - sourceLabels: [__name__]
+        regex: 'apiserver_request_duration_seconds_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'apiserver_request_sli_duration_seconds_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'apiserver_request_body_size_bytes_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'apiserver_response_sizes_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'etcd_request_duration_seconds_bucket'
+        action: drop
+
+# Kubelet also exposes apiserver metrics - apply same filters
+kubelet:
+  serviceMonitor:
+    metricRelabelings:
+      - sourceLabels: [__name__]
+        regex: 'apiserver_request_duration_seconds_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'apiserver_request_sli_duration_seconds_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'apiserver_request_body_size_bytes_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'apiserver_response_sizes_bucket'
+        action: drop
+      - sourceLabels: [__name__]
+        regex: 'etcd_request_duration_seconds_bucket'
+        action: drop
+
+alertmanager:
+  config:
+    global:
+      smtp_from: ${config.smtp.from}
+      smtp_smarthost: ${config.smtp.host}:${config.smtp.port}
+      smtp_require_tls: ${config.smtp.requireTls}
+      smtp_auth_username: ${config.smtp.username || config.smtp.from}
+      smtp_auth_password: ${config.smtp.password || ''}
+    route:
+      group_by: ['job']
+      group_wait: 30s
+      group_interval: 5m
+      repeat_interval: 1h
+      receiver: email
+      routes:
+      - match:
+          alertname: Watchdog
+        receiver: 'null'
+      - match:
+          alertname: CPUThrottlingHigh
+        receiver: 'null'
+      - match:
+          alertname: KubeMemoryOvercommit
+        receiver: 'null'
+      - match:
+          alertname: KubeCPUOvercommit
+        receiver: 'null'
+      - match:
+          alertname: KubeletTooManyPods
+        receiver: 'null'
+
+    receivers:
+    - name: 'null'
+    - name: email
+      email_configs:
+      - send_resolved: true
+        to: ${config.smtp.from}
+
+    # Inhibition rules allow to mute a set of alerts given that another alert is firing.
+    # We use this to mute any warning-level notifications if the same alert is already critical.
+    inhibit_rules:
+    - source_match:
+        severity: 'critical'
+      target_match:
+        severity: 'warning'
+      # Apply inhibition if the alertname is the same.
+      equal: ['alertname', 'namespace']
+
+  alertmanagerSpec:
+    replicas: ${config.replicas.alertmanager}
+    podAntiAffinity: "soft"
+    storage:
+      volumeClaimTemplate:
+        spec:
+          accessModes: ["ReadWriteOnce"]
+          resources:
+            requests:
+              storage: ${config.storage.alertmanager}
+    resources:
+      limits:
+        cpu: ${config.resources.alertmanager.limits.cpu}
+        memory: ${config.resources.alertmanager.limits.memory}
+      requests:
+        cpu: ${config.resources.alertmanager.requests.cpu}
+        memory: ${config.resources.alertmanager.requests.memory}
+    priorityClassName: high-priority
+
+    # Sidecar containers resource requests (added 2025-11-18)
+    containers:
+    - name: config-reloader
+      resources:
+        requests:
+          cpu: ${config.resources.configReloader.requests.cpu}
+          memory: ${config.resources.configReloader.requests.memory}
+        limits:
+          cpu: ${config.resources.configReloader.limits.cpu}
+          memory: ${config.resources.configReloader.limits.memory}
+
+
+prometheus:
+  # Enable Thanos service for gRPC communication
+  # Required for Helm chart to properly render Thanos sidecar configuration
+  thanosService:
+    enabled: true
+
+  prometheusSpec:
+    retention: ${config.retention.prometheus}  # Reduced from 7d - Thanos provides long-term storage in S3
+
+    # Discover ALL ServiceMonitors and PodMonitors in ALL namespaces
+    # Setting NilUsesHelmValues: false means nil selectors = "select all"
+    # Empty namespace selectors {} mean "search all namespaces"
+    # Note: This does NOT affect Thanos sidecar - controlled by thanos.objectStorageConfig
+    serviceMonitorSelectorNilUsesHelmValues: false
+    podMonitorSelectorNilUsesHelmValues: false
+    serviceMonitorNamespaceSelector: {}
+    podMonitorNamespaceSelector: {}
+
+    replicas: ${config.replicas.prometheus}
+    podAntiAffinity: "hard"
+    storageSpec:
+      volumeClaimTemplate:
+        spec:
+          storageClassName: longhorn
+          accessModes: ["ReadWriteOnce"]
+          resources:
+            requests:
+              storage: ${config.storage.prometheus}  # Reduced from 6Gi (3d retention needs less space)
+
+    resources:
+      limits:
+        cpu: ${config.resources.prometheus.limits.cpu}
+        memory: ${config.resources.prometheus.limits.memory}
+      requests:
+        cpu: ${config.resources.prometheus.requests.cpu}
+        memory: ${config.resources.prometheus.requests.memory}
+    priorityClassName: high-priority
+
+    # External labels for multi-cluster identification and Thanos
+    externalLabels:
+      cluster: kup6s
+      replica: "$(POD_NAME)"
+
+    # Thanos sidecar for long-term metrics storage in S3
+    # NOTE: chart >=85.x requires the existingSecret shape. The legacy flat
+    # {name, key} form is silently dropped by the chart, which removes the
+    # sidecar and stops all S3 block uploads (regression seen 2026-03-31).
+    thanos:
+      objectStorageConfig:
+        existingSecret:
+          name: thanos-objstore-config  # ESO-managed secret
+          key: objstore.yml
+
+    # Sidecar containers resource requests (added 2025-11-18)
+    # NOTE: thanos-sidecar is NOT listed here - it's automatically injected by Prometheus Operator
+    # when thanos.objectStorageConfig is set. Specifying it in containers[] would override
+    # the operator's definition and require us to manually specify the image, which breaks
+    # when the operator updates the thanos version.
+    containers:
+    - name: config-reloader
+      resources:
+        requests:
+          cpu: ${config.resources.configReloader.requests.cpu}
+          memory: ${config.resources.configReloader.requests.memory}
+        limits:
+          cpu: ${config.resources.configReloader.limits.cpu}
+          memory: ${config.resources.configReloader.limits.memory}
+
+    service:
+      sessionAffinity: "ClientIP"
+
+
+grafana:
+  # Recreate strategy is required because the storage PVC is RWO:
+  # a RollingUpdate would surge a second pod that cannot mount the
+  # volume (FailedAttachVolume), blocking the rollout indefinitely.
+  deploymentStrategy:
+    type: Recreate
+
+  # Use existing secret for admin credentials (managed by ESO)
+  # This prevents password regeneration on Helm upgrades
+  admin:
+    existingSecret: "grafana-admin-credentials"
+    userKey: "admin-user"
+    passwordKey: "admin-password"
+
+  # Disable default Prometheus datasource (we provide our own pointing to Thanos Query)
+  defaultDatasourceEnabled: false
+
+  # Sidecar containers for dashboard/datasource provisioning
+  sidecar:
+    resources:
+      requests:
+        cpu: 10m
+        memory: 256Mi
+      limits:
+        cpu: 100m
+        memory: 512Mi
+    dashboards:
+      enabled: true
+    datasources:
+      enabled: false  # We manually provision datasources (Prometheus→Thanos, Loki)
+
+  ingress:
+    enabled: true
+    hosts:
+      - ${config.domains.grafana}
+    annotations:
+      cert-manager.io/cluster-issuer: "letsencrypt-cluster-issuer"
+      traefik.ingress.kubernetes.io/router.entrypoints: websecure
+    tls:
+      - secretName: grafana-general-tls
+        hosts:
+        - ${config.domains.grafana}
+
+  resources:
+    limits:
+      cpu: ${config.resources.grafana.limits.cpu}
+      memory: ${config.resources.grafana.limits.memory}
+    requests:
+      cpu: ${config.resources.grafana.requests.cpu}
+      memory: ${config.resources.grafana.requests.memory}
+
+  readinessProbe:
+    httpGet:
+      path: /api/health
+      port: 3000
+    initialDelaySeconds: 30
+    periodSeconds: 10
+    timeoutSeconds: 5
+    failureThreshold: 3
+
+  livenessProbe:
+    httpGet:
+      path: /api/health
+      port: 3000
+    initialDelaySeconds: 60
+    periodSeconds: 10
+    timeoutSeconds: 30
+    failureThreshold: 10
+
+  persistence:
+    enabled: true
+    storageClassName: longhorn
+    accessModes:
+      - ReadWriteOnce
+    size: ${config.storage.grafana}
+
+  # Manual datasource provisioning (sidecar disabled)
+  # Thanos Query → long-term/historical metrics (S3 via Store + live sidecar), default
+  # Prometheus → local, recent/high-res only (kept for low-latency recent queries)
+  # Loki for log aggregation
+  datasources:
+    datasources.yaml:
+      apiVersion: 1
+      # Delete any pre-existing Loki datasource (e.g. one created with a
+      # randomly generated UID before we pinned uid: loki). Without this,
+      # Grafana fails provisioning with "data source not found" because
+      # the upsert collides with the existing entry.
+      deleteDatasources:
+      - name: Loki
+        orgId: 1
+      datasources:
+      - name: Thanos
+        type: prometheus
+        uid: thanos
+        access: proxy
+        # thanos-query Service: http port 9090 -> container http 10902
+        url: http://thanos-query.${config.namespace}.svc.cluster.local:9090
+        isDefault: true
+        jsonData:
+          timeInterval: 30s
+      - name: Prometheus
+        type: prometheus
+        uid: prometheus
+        access: proxy
+        url: http://kube-prometheus-stack-prometheus.${config.namespace}.svc.cluster.local:9090
+        isDefault: false
+        jsonData:
+          timeInterval: 30s
+      - name: Loki
+        type: loki
+        uid: loki
+        access: proxy
+        url: http://loki-gateway.${config.namespace}.svc.cluster.local
+        jsonData:
+          maxLines: 1000
+
+prometheusOperator:
+  resources:
+    limits:
+      cpu: 1
+      memory: 512Mi
+    requests:
+      cpu: 50m
+      memory: 128Mi
+  priorityClassName: high-priority
+
+prometheus-node-exporter:
+  # Bind :9100 to the node InternalIP only, not 0.0.0.0. With kubeRBACProxy
+  # disabled the sub-chart sets HOST_IP from fieldRef status.hostIP, which is
+  # the node's InternalIP (EX: vSwitch 10.6.0.x via --node-ip; cloud: hcloud
+  # private IP). node-exporter is hostNetwork, so Prometheus already scrapes
+  # that InternalIP endpoint -> scraping is unaffected, only the public-NIC
+  # exposure of the unauthenticated metrics on the EX public IPs goes away.
+  service:
+    listenOnAllInterfaces: false
+  resources:
+    limits:
+      cpu: 50m
+      memory: 50Mi
+    requests:
+      cpu: 5m
+      memory: 16Mi
+  priorityClassName: high-priority
+
+kube-state-metrics:
+  resources:
+    limits:
+      cpu: 1
+      memory: 512Mi
+    requests:
+      cpu: 5m
+      memory: 128Mi
+  priorityClassName: high-priority
+`;
+    }
+}
+exports.PrometheusStackConstruct = PrometheusStackConstruct;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prometheus-stack.js","sourceRoot":"","sources":["../../src/constructs/prometheus-stack.ts"],"names":[],"mappings":";;;AAAA,iCAAkC;AAClC,2CAAuC;AAQvC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAa,wBAAyB,SAAQ,sBAAS;IACrD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAA2B;QACnE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QAEpC,4BAA4B;QAC5B,MAAM,UAAU,GAAG,IAAI,CAAC,kBAAkB,CAAC,MAAM,CAAC,CAAC;QAEnD,kDAAkD;QAClD,2CAA2C;QAC3C,IAAI,iBAAS,CAAC,IAAI,EAAE,uBAAuB,EAAE;YAC3C,UAAU,EAAE,mBAAmB;YAC/B,IAAI,EAAE,WAAW;YACjB,QAAQ,EAAE;gBACR,IAAI,EAAE,uBAAuB;gBAC7B,SAAS,EAAE,SAAS;gBACpB,MAAM,EAAE;oBACN,wBAAwB,EAAE,uBAAuB;oBACjD,6BAA6B,EAAE,YAAY;oBAC3C,8BAA8B,EAAE,OAAO;oBACvC,2BAA2B,EAAE,YAAY;iBAC1C;gBACD,WAAW,EAAE;oBACX,8BAA8B,EAAE,GAAG;iBACpC;aACF;YACD,IAAI,EAAE;gBACJ,IAAI,EAAE,oDAAoD;gBAC1D,KAAK,EAAE,uBAAuB;gBAC9B,OAAO,EAAE,MAAM,CAAC,QAAQ,CAAC,eAAe,KAAK,QAAQ,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,eAAe;gBACnG,eAAe,EAAE,SAAS;gBAC1B,aAAa,EAAE,UAAU;aAC1B;SACF,CAAC,CAAC;IACL,CAAC;IAEO,kBAAkB,CAAC,MAAwB;QACjD,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mBAgHQ,MAAM,CAAC,IAAI,CAAC,IAAI;wBACX,MAAM,CAAC,IAAI,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI;0BAClC,MAAM,CAAC,IAAI,CAAC,UAAU;4BACpB,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI;4BACxC,MAAM,CAAC,IAAI,CAAC,QAAQ,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA6BxC,MAAM,CAAC,IAAI,CAAC,IAAI;;;;;;;;;;;;;gBAad,MAAM,CAAC,QAAQ,CAAC,YAAY;;;;;;;;yBAQnB,MAAM,CAAC,OAAO,CAAC,YAAY;;;eAGrC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,GAAG;kBACrC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,MAAM,CAAC,MAAM;;eAE9C,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,GAAG;kBACvC,MAAM,CAAC,SAAS,CAAC,YAAY,CAAC,QAAQ,CAAC,MAAM;;;;;;;;iBAQ9C,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG;oBACzC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM;;iBAElD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG;oBACvC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM;;;;;;;;;;iBAUhD,MAAM,CAAC,SAAS,CAAC,UAAU;;;;;;;;;;;gBAW5B,MAAM,CAAC,QAAQ,CAAC,UAAU;;;;;;;;;yBASjB,MAAM,CAAC,OAAO,CAAC,UAAU;;;;eAInC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,GAAG;kBACnC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,MAAM,CAAC,MAAM;;eAE5C,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG;kBACrC,MAAM,CAAC,SAAS,CAAC,UAAU,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2B5C,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,GAAG;oBACzC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,QAAQ,CAAC,MAAM;;iBAElD,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,GAAG;oBACvC,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,MAAM,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UAwCvD,MAAM,CAAC,OAAO,CAAC,OAAO;;;;;;;YAOpB,MAAM,CAAC,OAAO,CAAC,OAAO;;;;aAIrB,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,GAAG;gBAChC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,MAAM;;aAEzC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAG;gBAClC,MAAM,CAAC,SAAS,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;YAyB5C,MAAM,CAAC,OAAO,CAAC,OAAO;;;;;;;;;;;;;;;;;;;;;;mCAsBC,MAAM,CAAC,SAAS;;;;;;;;uDAQI,MAAM,CAAC,SAAS;;;;;;;;mCAQpC,MAAM,CAAC,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyClD,CAAC;IACA,CAAC;CACF;AArcD,4DAqcC","sourcesContent":["import { ApiObject } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { MonitoringConfig } from '../types';\n\nexport interface PrometheusStackProps {\n  namespace: string;\n  config: MonitoringConfig;\n}\n\n/**\n * Creates kube-prometheus-stack HelmChart with Prometheus, Grafana, and Alertmanager.\n *\n * This is the core monitoring stack that includes:\n * - Prometheus (metrics collection, 2 replicas, 3d retention)\n * - Grafana (visualization, ingress with Let's Encrypt)\n * - Alertmanager (alert routing, SMTP notifications)\n * - Prometheus Operator (manages Prometheus CRDs)\n * - Node Exporter (system metrics DaemonSet)\n * - kube-state-metrics (Kubernetes resource metrics)\n *\n * Prerequisites:\n * - Namespace exists\n * - PriorityClass 'high-priority' exists\n * - Longhorn storage class available\n * - cert-manager ClusterIssuer configured\n * - Thanos S3 secret exists (thanos-objstore-config)\n *\n * Sync Wave: 2 (core services - after S3 buckets and secrets)\n */\nexport class PrometheusStackConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: PrometheusStackProps) {\n    super(scope, id);\n\n    const { namespace, config } = props;\n\n    // Generate Helm values YAML\n    const helmValues = this.generateHelmValues(config);\n\n    // Create HelmChart resource (K3S Helm controller)\n    // Wave 2: Core Services - monitoring stack\n    new ApiObject(this, 'kube-prometheus-stack', {\n      apiVersion: 'helm.cattle.io/v1',\n      kind: 'HelmChart',\n      metadata: {\n        name: 'kube-prometheus-stack',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'kube-prometheus-stack',\n          'app.kubernetes.io/component': 'monitoring',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '2',\n        },\n      },\n      spec: {\n        repo: 'https://prometheus-community.github.io/helm-charts',\n        chart: 'kube-prometheus-stack',\n        version: config.versions.prometheusStack === 'latest' ? undefined : config.versions.prometheusStack,\n        targetNamespace: namespace,\n        valuesContent: helmValues,\n      },\n    });\n  }\n\n  private generateHelmValues(config: MonitoringConfig): string {\n    return `kubeEtcd:\n  enabled: false\n\n# Disable kube-controller-manager and kube-scheduler monitoring. See https://github.com/cablespaghetti/k3s-monitoring/issues/2\nkubeControllerManager:\n  enabled: false\nkubeScheduler:\n  enabled: false\n\n# Detect PodDisruptionBudgets that would block a node drain during k3s upgrades.\n# Operator-managed PDBs sit at disruptionsAllowed=0 by design (Longhorn instance-managers,\n# CNPG *-primary) and are excluded so the alert only fires on anomalous app PDBs.\nadditionalPrometheusRulesMap:\n  pdb-drain-safety:\n    groups:\n      - name: pdb.rules\n        interval: 1m\n        rules:\n          - alert: PodDisruptionBudgetUndrainable\n            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!=\"longhorn-system\", poddisruptionbudget!~\".*-primary\"} == 0\n            for: 15m\n            labels:\n              severity: warning\n              component: cluster-upgrade\n            annotations:\n              summary: \"PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} allows 0 voluntary disruptions\"\n              description: |\n                The PodDisruptionBudget {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }}\n                has allowed 0 voluntary disruptions for over 15 minutes. This will block a node\n                drain during k3s upgrades. Operator-managed PDBs (Longhorn, CNPG primaries) are\n                excluded from this alert. Likely a degraded deployment (0 healthy pods) or a\n                single-replica deployment with minAvailable=1.\n                Check: kubectl get pdb -n {{ $labels.namespace }} {{ $labels.poddisruptionbudget }}\n          - alert: PodDisruptionBudgetUndrainableCritical\n            expr: kube_poddisruptionbudget_status_pod_disruptions_allowed{namespace!=\"longhorn-system\", poddisruptionbudget!~\".*-primary\"} == 0\n            for: 1h\n            labels:\n              severity: critical\n              component: cluster-upgrade\n            annotations:\n              summary: \"PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} undrainable >1h\"\n              description: |\n                PDB {{ $labels.namespace }}/{{ $labels.poddisruptionbudget }} has blocked\n                voluntary disruptions for over an hour. A k3s agent upgrade would stall on this node.\n  # Detect an EX dedicated worker stuck NotReady — likely a MicroOS reboot hang\n  # (pings but sshd/kubelet dead). A hung node also holds the cluster-wide kured\n  # lock, blocking all further graceful reboots, so this must be caught fast.\n  ex-worker-reboot:\n    groups:\n      - name: ex-worker.rules\n        interval: 1m\n        rules:\n          - alert: ExWorkerNotReady\n            expr: kube_node_status_condition{condition=\"Ready\",status=\"true\",node=~\"kup6s-ex-.*\"} == 0\n            for: 15m\n            labels:\n              severity: critical\n              component: node\n            annotations:\n              summary: \"EX worker {{ $labels.node }} NotReady for >15m\"\n              description: |\n                EX dedicated worker {{ $labels.node }} has been NotReady for over 15 minutes.\n                Possible MicroOS reboot hang (pings but sshd/kubelet/longhorn-manager dead) — the\n                node may still hold the cluster-wide kured lock, blocking all further reboots.\n                Recovery: Hetzner Robot hardware reset. Do NOT force-detach Longhorn volumes.\n              runbook_url: \"https://docs.kup6s.com/how-to/troubleshooting/ex-worker-ping-but-dead.html\"\n\n# Drop high-cardinality API server and etcd histogram buckets to reduce memory usage\n# These metrics alone account for ~200k series (47% of total cardinality)\n# We keep _sum and _count suffixes which are sufficient for rate calculations\nkubeApiServer:\n  serviceMonitor:\n    metricRelabelings:\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_sli_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_body_size_bytes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_response_sizes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'etcd_request_duration_seconds_bucket'\n        action: drop\n\n# Kubelet also exposes apiserver metrics - apply same filters\nkubelet:\n  serviceMonitor:\n    metricRelabelings:\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_sli_duration_seconds_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_request_body_size_bytes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'apiserver_response_sizes_bucket'\n        action: drop\n      - sourceLabels: [__name__]\n        regex: 'etcd_request_duration_seconds_bucket'\n        action: drop\n\nalertmanager:\n  config:\n    global:\n      smtp_from: ${config.smtp.from}\n      smtp_smarthost: ${config.smtp.host}:${config.smtp.port}\n      smtp_require_tls: ${config.smtp.requireTls}\n      smtp_auth_username: ${config.smtp.username || config.smtp.from}\n      smtp_auth_password: ${config.smtp.password || ''}\n    route:\n      group_by: ['job']\n      group_wait: 30s\n      group_interval: 5m\n      repeat_interval: 1h\n      receiver: email\n      routes:\n      - match:\n          alertname: Watchdog\n        receiver: 'null'\n      - match:\n          alertname: CPUThrottlingHigh\n        receiver: 'null'\n      - match:\n          alertname: KubeMemoryOvercommit\n        receiver: 'null'\n      - match:\n          alertname: KubeCPUOvercommit\n        receiver: 'null'\n      - match:\n          alertname: KubeletTooManyPods\n        receiver: 'null'\n\n    receivers:\n    - name: 'null'\n    - name: email\n      email_configs:\n      - send_resolved: true\n        to: ${config.smtp.from}\n\n    # Inhibition rules allow to mute a set of alerts given that another alert is firing.\n    # We use this to mute any warning-level notifications if the same alert is already critical.\n    inhibit_rules:\n    - source_match:\n        severity: 'critical'\n      target_match:\n        severity: 'warning'\n      # Apply inhibition if the alertname is the same.\n      equal: ['alertname', 'namespace']\n\n  alertmanagerSpec:\n    replicas: ${config.replicas.alertmanager}\n    podAntiAffinity: \"soft\"\n    storage:\n      volumeClaimTemplate:\n        spec:\n          accessModes: [\"ReadWriteOnce\"]\n          resources:\n            requests:\n              storage: ${config.storage.alertmanager}\n    resources:\n      limits:\n        cpu: ${config.resources.alertmanager.limits.cpu}\n        memory: ${config.resources.alertmanager.limits.memory}\n      requests:\n        cpu: ${config.resources.alertmanager.requests.cpu}\n        memory: ${config.resources.alertmanager.requests.memory}\n    priorityClassName: high-priority\n\n    # Sidecar containers resource requests (added 2025-11-18)\n    containers:\n    - name: config-reloader\n      resources:\n        requests:\n          cpu: ${config.resources.configReloader.requests.cpu}\n          memory: ${config.resources.configReloader.requests.memory}\n        limits:\n          cpu: ${config.resources.configReloader.limits.cpu}\n          memory: ${config.resources.configReloader.limits.memory}\n\n\nprometheus:\n  # Enable Thanos service for gRPC communication\n  # Required for Helm chart to properly render Thanos sidecar configuration\n  thanosService:\n    enabled: true\n\n  prometheusSpec:\n    retention: ${config.retention.prometheus}  # Reduced from 7d - Thanos provides long-term storage in S3\n\n    # Discover ALL ServiceMonitors and PodMonitors in ALL namespaces\n    # Setting NilUsesHelmValues: false means nil selectors = \"select all\"\n    # Empty namespace selectors {} mean \"search all namespaces\"\n    # Note: This does NOT affect Thanos sidecar - controlled by thanos.objectStorageConfig\n    serviceMonitorSelectorNilUsesHelmValues: false\n    podMonitorSelectorNilUsesHelmValues: false\n    serviceMonitorNamespaceSelector: {}\n    podMonitorNamespaceSelector: {}\n\n    replicas: ${config.replicas.prometheus}\n    podAntiAffinity: \"hard\"\n    storageSpec:\n      volumeClaimTemplate:\n        spec:\n          storageClassName: longhorn\n          accessModes: [\"ReadWriteOnce\"]\n          resources:\n            requests:\n              storage: ${config.storage.prometheus}  # Reduced from 6Gi (3d retention needs less space)\n\n    resources:\n      limits:\n        cpu: ${config.resources.prometheus.limits.cpu}\n        memory: ${config.resources.prometheus.limits.memory}\n      requests:\n        cpu: ${config.resources.prometheus.requests.cpu}\n        memory: ${config.resources.prometheus.requests.memory}\n    priorityClassName: high-priority\n\n    # External labels for multi-cluster identification and Thanos\n    externalLabels:\n      cluster: kup6s\n      replica: \"$(POD_NAME)\"\n\n    # Thanos sidecar for long-term metrics storage in S3\n    # NOTE: chart >=85.x requires the existingSecret shape. The legacy flat\n    # {name, key} form is silently dropped by the chart, which removes the\n    # sidecar and stops all S3 block uploads (regression seen 2026-03-31).\n    thanos:\n      objectStorageConfig:\n        existingSecret:\n          name: thanos-objstore-config  # ESO-managed secret\n          key: objstore.yml\n\n    # Sidecar containers resource requests (added 2025-11-18)\n    # NOTE: thanos-sidecar is NOT listed here - it's automatically injected by Prometheus Operator\n    # when thanos.objectStorageConfig is set. Specifying it in containers[] would override\n    # the operator's definition and require us to manually specify the image, which breaks\n    # when the operator updates the thanos version.\n    containers:\n    - name: config-reloader\n      resources:\n        requests:\n          cpu: ${config.resources.configReloader.requests.cpu}\n          memory: ${config.resources.configReloader.requests.memory}\n        limits:\n          cpu: ${config.resources.configReloader.limits.cpu}\n          memory: ${config.resources.configReloader.limits.memory}\n\n    service:\n      sessionAffinity: \"ClientIP\"\n\n\ngrafana:\n  # Recreate strategy is required because the storage PVC is RWO:\n  # a RollingUpdate would surge a second pod that cannot mount the\n  # volume (FailedAttachVolume), blocking the rollout indefinitely.\n  deploymentStrategy:\n    type: Recreate\n\n  # Use existing secret for admin credentials (managed by ESO)\n  # This prevents password regeneration on Helm upgrades\n  admin:\n    existingSecret: \"grafana-admin-credentials\"\n    userKey: \"admin-user\"\n    passwordKey: \"admin-password\"\n\n  # Disable default Prometheus datasource (we provide our own pointing to Thanos Query)\n  defaultDatasourceEnabled: false\n\n  # Sidecar containers for dashboard/datasource provisioning\n  sidecar:\n    resources:\n      requests:\n        cpu: 10m\n        memory: 256Mi\n      limits:\n        cpu: 100m\n        memory: 512Mi\n    dashboards:\n      enabled: true\n    datasources:\n      enabled: false  # We manually provision datasources (Prometheus→Thanos, Loki)\n\n  ingress:\n    enabled: true\n    hosts:\n      - ${config.domains.grafana}\n    annotations:\n      cert-manager.io/cluster-issuer: \"letsencrypt-cluster-issuer\"\n      traefik.ingress.kubernetes.io/router.entrypoints: websecure\n    tls:\n      - secretName: grafana-general-tls\n        hosts:\n        - ${config.domains.grafana}\n\n  resources:\n    limits:\n      cpu: ${config.resources.grafana.limits.cpu}\n      memory: ${config.resources.grafana.limits.memory}\n    requests:\n      cpu: ${config.resources.grafana.requests.cpu}\n      memory: ${config.resources.grafana.requests.memory}\n\n  readinessProbe:\n    httpGet:\n      path: /api/health\n      port: 3000\n    initialDelaySeconds: 30\n    periodSeconds: 10\n    timeoutSeconds: 5\n    failureThreshold: 3\n\n  livenessProbe:\n    httpGet:\n      path: /api/health\n      port: 3000\n    initialDelaySeconds: 60\n    periodSeconds: 10\n    timeoutSeconds: 30\n    failureThreshold: 10\n\n  persistence:\n    enabled: true\n    storageClassName: longhorn\n    accessModes:\n      - ReadWriteOnce\n    size: ${config.storage.grafana}\n\n  # Manual datasource provisioning (sidecar disabled)\n  # Thanos Query → long-term/historical metrics (S3 via Store + live sidecar), default\n  # Prometheus → local, recent/high-res only (kept for low-latency recent queries)\n  # Loki for log aggregation\n  datasources:\n    datasources.yaml:\n      apiVersion: 1\n      # Delete any pre-existing Loki datasource (e.g. one created with a\n      # randomly generated UID before we pinned uid: loki). Without this,\n      # Grafana fails provisioning with \"data source not found\" because\n      # the upsert collides with the existing entry.\n      deleteDatasources:\n      - name: Loki\n        orgId: 1\n      datasources:\n      - name: Thanos\n        type: prometheus\n        uid: thanos\n        access: proxy\n        # thanos-query Service: http port 9090 -> container http 10902\n        url: http://thanos-query.${config.namespace}.svc.cluster.local:9090\n        isDefault: true\n        jsonData:\n          timeInterval: 30s\n      - name: Prometheus\n        type: prometheus\n        uid: prometheus\n        access: proxy\n        url: http://kube-prometheus-stack-prometheus.${config.namespace}.svc.cluster.local:9090\n        isDefault: false\n        jsonData:\n          timeInterval: 30s\n      - name: Loki\n        type: loki\n        uid: loki\n        access: proxy\n        url: http://loki-gateway.${config.namespace}.svc.cluster.local\n        jsonData:\n          maxLines: 1000\n\nprometheusOperator:\n  resources:\n    limits:\n      cpu: 1\n      memory: 512Mi\n    requests:\n      cpu: 50m\n      memory: 128Mi\n  priorityClassName: high-priority\n\nprometheus-node-exporter:\n  # Bind :9100 to the node InternalIP only, not 0.0.0.0. With kubeRBACProxy\n  # disabled the sub-chart sets HOST_IP from fieldRef status.hostIP, which is\n  # the node's InternalIP (EX: vSwitch 10.6.0.x via --node-ip; cloud: hcloud\n  # private IP). node-exporter is hostNetwork, so Prometheus already scrapes\n  # that InternalIP endpoint -> scraping is unaffected, only the public-NIC\n  # exposure of the unauthenticated metrics on the EX public IPs goes away.\n  service:\n    listenOnAllInterfaces: false\n  resources:\n    limits:\n      cpu: 50m\n      memory: 50Mi\n    requests:\n      cpu: 5m\n      memory: 16Mi\n  priorityClassName: high-priority\n\nkube-state-metrics:\n  resources:\n    limits:\n      cpu: 1\n      memory: 512Mi\n    requests:\n      cpu: 5m\n      memory: 128Mi\n  priorityClassName: high-priority\n`;\n  }\n}\n"]}

package/lib/constructs/thanos-compactor.d.ts

@@ -0,0 +1,35 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface ThanosCompactorProps {
+    namespace: string;
+    config: MonitoringConfig;
+}
+/**
+ * Creates Thanos Compactor StatefulSet and Service.
+ *
+ * Thanos Compactor performs:
+ * - Downsampling: Creates 5-minute and 1-hour resolution data from raw blocks
+ * - Compaction: Merges small blocks into larger ones for better query performance
+ * - Retention enforcement: Deletes blocks older than configured retention
+ *
+ * Retention Strategy:
+ * - Raw (15s resolution): 30 days
+ * - 5-minute resolution: 180 days (6 months)
+ * - 1-hour resolution: 730 days (2 years)
+ *
+ * Components:
+ * - StatefulSet (1 replica - singleton, 20Gi PVC for working directory)
+ * - HTTP Service (for metrics and debugging)
+ *
+ * Prerequisites:
+ * - Namespace exists
+ * - PriorityClass 'high-priority' exists
+ * - Longhorn storage class available
+ * - Thanos S3 secret exists (thanos-objstore-config)
+ * - S3 bucket contains Prometheus data blocks
+ *
+ * Sync Wave: 3 (compaction - can run alongside Store Gateway)
+ */
+export declare class ThanosCompactorConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: ThanosCompactorProps);
+}