@bluedynamics/cdk8s-monitoring 0.0.1

package/lib/constructs/thanos-compactor.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThanosCompactorConstruct = void 0;
+const constructs_1 = require("constructs");
+const k8s_1 = require("../imports/k8s");
+/**
+ * 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)
+ */
+class ThanosCompactorConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace, config } = props;
+        // Create StatefulSet
+        // Wave 3: Compaction - after S3 bucket and credentials are ready
+        new k8s_1.KubeStatefulSet(this, 'statefulset', {
+            metadata: {
+                name: 'thanos-compactor',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-compactor',
+                    'app.kubernetes.io/component': 'compactor',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                serviceName: 'thanos-compactor',
+                replicas: 1, // Singleton - only one compactor should run
+                selector: {
+                    matchLabels: {
+                        'app.kubernetes.io/name': 'thanos-compactor',
+                    },
+                },
+                template: {
+                    metadata: {
+                        labels: {
+                            'app.kubernetes.io/name': 'thanos-compactor',
+                            'app.kubernetes.io/component': 'compactor',
+                        },
+                    },
+                    spec: {
+                        // No arch nodeSelector: Thanos images are multi-arch; let the
+                        // scheduler place this on any worker (legacy ARM64 pin removed).
+                        // Fix volume permissions for Thanos user (UID 10001)
+                        securityContext: {
+                            fsGroup: 10001,
+                            runAsUser: 10001,
+                            runAsNonRoot: true,
+                        },
+                        containers: [
+                            {
+                                name: 'thanos-compactor',
+                                image: `quay.io/thanos/thanos:${config.versions.thanos}`,
+                                args: [
+                                    'compact',
+                                    '--log.level=info',
+                                    '--data-dir=/var/thanos/compactor',
+                                    '--objstore.config-file=/etc/thanos/objstore.yml',
+                                    '--wait', // Wait for other compactors to finish (prevents conflicts)
+                                    // Downsampling configuration
+                                    `--retention.resolution-raw=${config.retention.prometheusS3Raw}d`, // Keep raw data for 30 days
+                                    `--retention.resolution-5m=${config.retention.prometheusS35m}d`, // Keep 5m data for 180 days (6 months)
+                                    `--retention.resolution-1h=${config.retention.prometheusS31h}d`, // Keep 1h data for 730 days (2 years)
+                                    // Compaction configuration
+                                    '--compact.concurrency=1',
+                                    '--delete-delay=48h', // Wait 48h before deleting blocks (safety margin)
+                                ],
+                                ports: [
+                                    {
+                                        name: 'http',
+                                        containerPort: 10902,
+                                    },
+                                ],
+                                volumeMounts: [
+                                    {
+                                        name: 'objstore-config',
+                                        mountPath: '/etc/thanos',
+                                        readOnly: true,
+                                    },
+                                    {
+                                        name: 'data',
+                                        mountPath: '/var/thanos/compactor',
+                                    },
+                                ],
+                                livenessProbe: {
+                                    httpGet: {
+                                        path: '/-/healthy',
+                                        port: k8s_1.IntOrString.fromString('http'),
+                                    },
+                                    initialDelaySeconds: 30,
+                                    periodSeconds: 30,
+                                },
+                                readinessProbe: {
+                                    httpGet: {
+                                        path: '/-/ready',
+                                        port: k8s_1.IntOrString.fromString('http'),
+                                    },
+                                    initialDelaySeconds: 30,
+                                    periodSeconds: 5,
+                                },
+                                resources: {
+                                    requests: {
+                                        cpu: k8s_1.Quantity.fromString(config.resources.thanosCompactor.requests.cpu),
+                                        memory: k8s_1.Quantity.fromString(config.resources.thanosCompactor.requests.memory),
+                                    },
+                                    limits: {
+                                        cpu: k8s_1.Quantity.fromString(config.resources.thanosCompactor.limits.cpu),
+                                        memory: k8s_1.Quantity.fromString(config.resources.thanosCompactor.limits.memory),
+                                    },
+                                },
+                            },
+                        ],
+                        volumes: [
+                            {
+                                name: 'objstore-config',
+                                secret: {
+                                    secretName: 'thanos-objstore-config',
+                                },
+                            },
+                        ],
+                        priorityClassName: 'high-priority',
+                    },
+                },
+                volumeClaimTemplates: [
+                    {
+                        metadata: {
+                            name: 'data',
+                        },
+                        spec: {
+                            accessModes: ['ReadWriteOnce'],
+                            storageClassName: 'longhorn',
+                            resources: {
+                                requests: {
+                                    storage: k8s_1.Quantity.fromString(config.storage.thanosCompactor), // Working directory for compaction operations
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        // Create HTTP Service (for metrics/debugging)
+        new k8s_1.KubeService(this, 'service', {
+            metadata: {
+                name: 'thanos-compactor',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-compactor',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                ports: [
+                    {
+                        name: 'http',
+                        port: 10902,
+                        targetPort: 'http',
+                        protocol: 'TCP',
+                    },
+                ],
+                selector: {
+                    'app.kubernetes.io/name': 'thanos-compactor',
+                },
+            },
+        });
+    }
+}
+exports.ThanosCompactorConstruct = ThanosCompactorConstruct;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"thanos-compactor.js","sourceRoot":"","sources":["../../src/constructs/thanos-compactor.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { KubeStatefulSet, KubeService, Quantity, IntOrString } from '../imports/k8s';\nimport { MonitoringConfig } from '../types';\n\nexport interface ThanosCompactorProps {\n  namespace: string;\n  config: MonitoringConfig;\n}\n\n/**\n * Creates Thanos Compactor StatefulSet and Service.\n *\n * Thanos Compactor performs:\n * - Downsampling: Creates 5-minute and 1-hour resolution data from raw blocks\n * - Compaction: Merges small blocks into larger ones for better query performance\n * - Retention enforcement: Deletes blocks older than configured retention\n *\n * Retention Strategy:\n * - Raw (15s resolution): 30 days\n * - 5-minute resolution: 180 days (6 months)\n * - 1-hour resolution: 730 days (2 years)\n *\n * Components:\n * - StatefulSet (1 replica - singleton, 20Gi PVC for working directory)\n * - HTTP Service (for metrics and debugging)\n *\n * Prerequisites:\n * - Namespace exists\n * - PriorityClass 'high-priority' exists\n * - Longhorn storage class available\n * - Thanos S3 secret exists (thanos-objstore-config)\n * - S3 bucket contains Prometheus data blocks\n *\n * Sync Wave: 3 (compaction - can run alongside Store Gateway)\n */\nexport class ThanosCompactorConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: ThanosCompactorProps) {\n    super(scope, id);\n\n    const { namespace, config } = props;\n\n    // Create StatefulSet\n    // Wave 3: Compaction - after S3 bucket and credentials are ready\n    new KubeStatefulSet(this, 'statefulset', {\n      metadata: {\n        name: 'thanos-compactor',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-compactor',\n          'app.kubernetes.io/component': 'compactor',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '3',\n        },\n      },\n      spec: {\n        serviceName: 'thanos-compactor',\n        replicas: 1, // Singleton - only one compactor should run\n        selector: {\n          matchLabels: {\n            'app.kubernetes.io/name': 'thanos-compactor',\n          },\n        },\n        template: {\n          metadata: {\n            labels: {\n              'app.kubernetes.io/name': 'thanos-compactor',\n              'app.kubernetes.io/component': 'compactor',\n            },\n          },\n          spec: {\n            // No arch nodeSelector: Thanos images are multi-arch; let the\n            // scheduler place this on any worker (legacy ARM64 pin removed).\n\n            // Fix volume permissions for Thanos user (UID 10001)\n            securityContext: {\n              fsGroup: 10001,\n              runAsUser: 10001,\n              runAsNonRoot: true,\n            },\n\n            containers: [\n              {\n                name: 'thanos-compactor',\n                image: `quay.io/thanos/thanos:${config.versions.thanos}`,\n                args: [\n                  'compact',\n                  '--log.level=info',\n                  '--data-dir=/var/thanos/compactor',\n                  '--objstore.config-file=/etc/thanos/objstore.yml',\n                  '--wait', // Wait for other compactors to finish (prevents conflicts)\n                  // Downsampling configuration\n                  `--retention.resolution-raw=${config.retention.prometheusS3Raw}d`, // Keep raw data for 30 days\n                  `--retention.resolution-5m=${config.retention.prometheusS35m}d`, // Keep 5m data for 180 days (6 months)\n                  `--retention.resolution-1h=${config.retention.prometheusS31h}d`, // Keep 1h data for 730 days (2 years)\n                  // Compaction configuration\n                  '--compact.concurrency=1',\n                  '--delete-delay=48h', // Wait 48h before deleting blocks (safety margin)\n                ],\n                ports: [\n                  {\n                    name: 'http',\n                    containerPort: 10902,\n                  },\n                ],\n                volumeMounts: [\n                  {\n                    name: 'objstore-config',\n                    mountPath: '/etc/thanos',\n                    readOnly: true,\n                  },\n                  {\n                    name: 'data',\n                    mountPath: '/var/thanos/compactor',\n                  },\n                ],\n                livenessProbe: {\n                  httpGet: {\n                    path: '/-/healthy',\n                    port: IntOrString.fromString('http'),\n                  },\n                  initialDelaySeconds: 30,\n                  periodSeconds: 30,\n                },\n                readinessProbe: {\n                  httpGet: {\n                    path: '/-/ready',\n                    port: IntOrString.fromString('http'),\n                  },\n                  initialDelaySeconds: 30,\n                  periodSeconds: 5,\n                },\n                resources: {\n                  requests: {\n                    cpu: Quantity.fromString(config.resources.thanosCompactor.requests.cpu),\n                    memory: Quantity.fromString(config.resources.thanosCompactor.requests.memory),\n                  },\n                  limits: {\n                    cpu: Quantity.fromString(config.resources.thanosCompactor.limits.cpu),\n                    memory: Quantity.fromString(config.resources.thanosCompactor.limits.memory),\n                  },\n                },\n              },\n            ],\n\n            volumes: [\n              {\n                name: 'objstore-config',\n                secret: {\n                  secretName: 'thanos-objstore-config',\n                },\n              },\n            ],\n\n            priorityClassName: 'high-priority',\n          },\n        },\n        volumeClaimTemplates: [\n          {\n            metadata: {\n              name: 'data',\n            },\n            spec: {\n              accessModes: ['ReadWriteOnce'],\n              storageClassName: 'longhorn',\n              resources: {\n                requests: {\n                  storage: Quantity.fromString(config.storage.thanosCompactor), // Working directory for compaction operations\n                },\n              },\n            },\n          },\n        ],\n      },\n    });\n\n    // Create HTTP Service (for metrics/debugging)\n    new KubeService(this, 'service', {\n      metadata: {\n        name: 'thanos-compactor',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-compactor',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '3',\n        },\n      },\n      spec: {\n        ports: [\n          {\n            name: 'http',\n            port: 10902,\n            targetPort: 'http' as any,\n            protocol: 'TCP',\n          },\n        ],\n        selector: {\n          'app.kubernetes.io/name': 'thanos-compactor',\n        },\n      },\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,30 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface ThanosQueryProps {
+    namespace: string;
+    config: MonitoringConfig;
+}
+/**
+ * Creates Thanos Query Deployment and Services.
+ *
+ * Thanos Query provides a unified query interface for:
+ * - Local Prometheus data (3-day retention)
+ * - Historical S3 data (via Thanos Store Gateway)
+ * - Automatic deduplication across Prometheus replicas
+ *
+ * Components:
+ * - Deployment (2 replicas with anti-affinity)
+ * - HTTP Service (port 9090 for Grafana queries)
+ * - gRPC Service (headless, for future Query Frontend)
+ *
+ * Prerequisites:
+ * - Namespace exists
+ * - PriorityClass 'high-priority' exists
+ * - Prometheus with Thanos sidecar running
+ * - Thanos Store Gateway running
+ *
+ * Sync Wave: 3 (query layer - after Prometheus and Store)
+ */
+export declare class ThanosQueryConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: ThanosQueryProps);
+}

package/lib/constructs/thanos-query.js

@@ -0,0 +1,205 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThanosQueryConstruct = void 0;
+const constructs_1 = require("constructs");
+const k8s_1 = require("../imports/k8s");
+/**
+ * Creates Thanos Query Deployment and Services.
+ *
+ * Thanos Query provides a unified query interface for:
+ * - Local Prometheus data (3-day retention)
+ * - Historical S3 data (via Thanos Store Gateway)
+ * - Automatic deduplication across Prometheus replicas
+ *
+ * Components:
+ * - Deployment (2 replicas with anti-affinity)
+ * - HTTP Service (port 9090 for Grafana queries)
+ * - gRPC Service (headless, for future Query Frontend)
+ *
+ * Prerequisites:
+ * - Namespace exists
+ * - PriorityClass 'high-priority' exists
+ * - Prometheus with Thanos sidecar running
+ * - Thanos Store Gateway running
+ *
+ * Sync Wave: 3 (query layer - after Prometheus and Store)
+ */
+class ThanosQueryConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace, config } = props;
+        // Create Deployment
+        // Wave 3: Query Layer - after Prometheus and Store are ready
+        new k8s_1.KubeDeployment(this, 'deployment', {
+            metadata: {
+                name: 'thanos-query',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-query',
+                    'app.kubernetes.io/component': 'query',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                replicas: config.replicas.thanosQuery,
+                selector: {
+                    matchLabels: {
+                        'app.kubernetes.io/name': 'thanos-query',
+                    },
+                },
+                template: {
+                    metadata: {
+                        labels: {
+                            'app.kubernetes.io/name': 'thanos-query',
+                            'app.kubernetes.io/component': 'query',
+                        },
+                    },
+                    spec: {
+                        // No arch nodeSelector: Thanos images are multi-arch; let the
+                        // scheduler place these on any worker (legacy ARM64 pin removed).
+                        // Spread replicas across different nodes for HA
+                        affinity: {
+                            podAntiAffinity: {
+                                preferredDuringSchedulingIgnoredDuringExecution: [
+                                    {
+                                        weight: 100,
+                                        podAffinityTerm: {
+                                            labelSelector: {
+                                                matchLabels: {
+                                                    'app.kubernetes.io/name': 'thanos-query',
+                                                },
+                                            },
+                                            topologyKey: 'kubernetes.io/hostname',
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        containers: [
+                            {
+                                name: 'thanos-query',
+                                image: `quay.io/thanos/thanos:${config.versions.thanos}`,
+                                args: [
+                                    'query',
+                                    '--log.level=info',
+                                    '--query.replica-label=replica',
+                                    '--query.replica-label=prometheus_replica',
+                                    // Connect to Prometheus sidecars via gRPC.
+                                    // The sidecar gRPC port is exposed by the operator's thanos
+                                    // discovery service (thanosService.enabled=true), NOT by
+                                    // prometheus-operated (which only exposes http-web:9090).
+                                    `--endpoint=dnssrv+_grpc._tcp.kube-prometheus-stack-thanos-discovery.${namespace}.svc.cluster.local`,
+                                    // Connect to Thanos Store Gateway
+                                    `--endpoint=dnssrv+_grpc._tcp.thanos-store-grpc.${namespace}.svc.cluster.local`,
+                                ],
+                                ports: [
+                                    {
+                                        name: 'http',
+                                        containerPort: 10902,
+                                    },
+                                    {
+                                        name: 'grpc',
+                                        containerPort: 10901,
+                                    },
+                                ],
+                                livenessProbe: {
+                                    httpGet: {
+                                        path: '/-/healthy',
+                                        port: k8s_1.IntOrString.fromNumber(10902), // HTTP port (named 'http' in ports list)
+                                    },
+                                    initialDelaySeconds: 10,
+                                    periodSeconds: 30,
+                                },
+                                readinessProbe: {
+                                    httpGet: {
+                                        path: '/-/ready',
+                                        port: k8s_1.IntOrString.fromNumber(10902), // HTTP port (named 'http' in ports list)
+                                    },
+                                    initialDelaySeconds: 15,
+                                    periodSeconds: 5,
+                                },
+                                resources: {
+                                    requests: {
+                                        cpu: k8s_1.Quantity.fromString(config.resources.thanosQuery.requests.cpu),
+                                        memory: k8s_1.Quantity.fromString(config.resources.thanosQuery.requests.memory),
+                                    },
+                                    limits: {
+                                        cpu: k8s_1.Quantity.fromString(config.resources.thanosQuery.limits.cpu),
+                                        memory: k8s_1.Quantity.fromString(config.resources.thanosQuery.limits.memory),
+                                    },
+                                },
+                            },
+                        ],
+                        priorityClassName: 'high-priority',
+                    },
+                },
+            },
+        });
+        // Create HTTP Service (for Grafana)
+        new k8s_1.KubeService(this, 'service-http', {
+            metadata: {
+                name: 'thanos-query',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-query',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                ports: [
+                    {
+                        name: 'http',
+                        port: 9090,
+                        // Container http port is 10902. A bare string is dropped by cdk8s
+                        // (targetPort expects IntOrString), which silently defaulted
+                        // targetPort to 9090 and made the Service refuse connections.
+                        targetPort: k8s_1.IntOrString.fromString('http'),
+                        protocol: 'TCP',
+                    },
+                ],
+                selector: {
+                    'app.kubernetes.io/name': 'thanos-query',
+                },
+                sessionAffinity: 'ClientIP',
+            },
+        });
+        // Create gRPC Service (headless, for future Query Frontend)
+        new k8s_1.KubeService(this, 'service-grpc', {
+            metadata: {
+                name: 'thanos-query-grpc',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-query',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                type: 'ClusterIP',
+                clusterIp: 'None', // Headless service for DNS-based discovery
+                ports: [
+                    {
+                        name: 'grpc',
+                        port: 10901,
+                        targetPort: k8s_1.IntOrString.fromString('grpc'),
+                        protocol: 'TCP',
+                    },
+                ],
+                selector: {
+                    'app.kubernetes.io/name': 'thanos-query',
+                },
+            },
+        });
+    }
+}
+exports.ThanosQueryConstruct = ThanosQueryConstruct;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"thanos-query.js","sourceRoot":"","sources":["../../src/constructs/thanos-query.ts"],"names":[],"mappings":"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","sourcesContent":["import { Construct } from 'constructs';\nimport { KubeDeployment, KubeService, Quantity, IntOrString } from '../imports/k8s';\nimport { MonitoringConfig } from '../types';\n\nexport interface ThanosQueryProps {\n  namespace: string;\n  config: MonitoringConfig;\n}\n\n/**\n * Creates Thanos Query Deployment and Services.\n *\n * Thanos Query provides a unified query interface for:\n * - Local Prometheus data (3-day retention)\n * - Historical S3 data (via Thanos Store Gateway)\n * - Automatic deduplication across Prometheus replicas\n *\n * Components:\n * - Deployment (2 replicas with anti-affinity)\n * - HTTP Service (port 9090 for Grafana queries)\n * - gRPC Service (headless, for future Query Frontend)\n *\n * Prerequisites:\n * - Namespace exists\n * - PriorityClass 'high-priority' exists\n * - Prometheus with Thanos sidecar running\n * - Thanos Store Gateway running\n *\n * Sync Wave: 3 (query layer - after Prometheus and Store)\n */\nexport class ThanosQueryConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: ThanosQueryProps) {\n    super(scope, id);\n\n    const { namespace, config } = props;\n\n    // Create Deployment\n    // Wave 3: Query Layer - after Prometheus and Store are ready\n    new KubeDeployment(this, 'deployment', {\n      metadata: {\n        name: 'thanos-query',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-query',\n          'app.kubernetes.io/component': 'query',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '3',\n        },\n      },\n      spec: {\n        replicas: config.replicas.thanosQuery,\n        selector: {\n          matchLabels: {\n            'app.kubernetes.io/name': 'thanos-query',\n          },\n        },\n        template: {\n          metadata: {\n            labels: {\n              'app.kubernetes.io/name': 'thanos-query',\n              'app.kubernetes.io/component': 'query',\n            },\n          },\n          spec: {\n            // No arch nodeSelector: Thanos images are multi-arch; let the\n            // scheduler place these on any worker (legacy ARM64 pin removed).\n\n            // Spread replicas across different nodes for HA\n            affinity: {\n              podAntiAffinity: {\n                preferredDuringSchedulingIgnoredDuringExecution: [\n                  {\n                    weight: 100,\n                    podAffinityTerm: {\n                      labelSelector: {\n                        matchLabels: {\n                          'app.kubernetes.io/name': 'thanos-query',\n                        },\n                      },\n                      topologyKey: 'kubernetes.io/hostname',\n                    },\n                  },\n                ],\n              },\n            },\n\n            containers: [\n              {\n                name: 'thanos-query',\n                image: `quay.io/thanos/thanos:${config.versions.thanos}`,\n                args: [\n                  'query',\n                  '--log.level=info',\n                  '--query.replica-label=replica',\n                  '--query.replica-label=prometheus_replica',\n                  // Connect to Prometheus sidecars via gRPC.\n                  // The sidecar gRPC port is exposed by the operator's thanos\n                  // discovery service (thanosService.enabled=true), NOT by\n                  // prometheus-operated (which only exposes http-web:9090).\n                  `--endpoint=dnssrv+_grpc._tcp.kube-prometheus-stack-thanos-discovery.${namespace}.svc.cluster.local`,\n                  // Connect to Thanos Store Gateway\n                  `--endpoint=dnssrv+_grpc._tcp.thanos-store-grpc.${namespace}.svc.cluster.local`,\n                ],\n                ports: [\n                  {\n                    name: 'http',\n                    containerPort: 10902,\n                  },\n                  {\n                    name: 'grpc',\n                    containerPort: 10901,\n                  },\n                ],\n                livenessProbe: {\n                  httpGet: {\n                    path: '/-/healthy',\n                    port: IntOrString.fromNumber(10902), // HTTP port (named 'http' in ports list)\n                  },\n                  initialDelaySeconds: 10,\n                  periodSeconds: 30,\n                },\n                readinessProbe: {\n                  httpGet: {\n                    path: '/-/ready',\n                    port: IntOrString.fromNumber(10902), // HTTP port (named 'http' in ports list)\n                  },\n                  initialDelaySeconds: 15,\n                  periodSeconds: 5,\n                },\n                resources: {\n                  requests: {\n                    cpu: Quantity.fromString(config.resources.thanosQuery.requests.cpu),\n                    memory: Quantity.fromString(config.resources.thanosQuery.requests.memory),\n                  },\n                  limits: {\n                    cpu: Quantity.fromString(config.resources.thanosQuery.limits.cpu),\n                    memory: Quantity.fromString(config.resources.thanosQuery.limits.memory),\n                  },\n                },\n              },\n            ],\n\n            priorityClassName: 'high-priority',\n          },\n        },\n      },\n    });\n\n    // Create HTTP Service (for Grafana)\n    new KubeService(this, 'service-http', {\n      metadata: {\n        name: 'thanos-query',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-query',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '3',\n        },\n      },\n      spec: {\n        ports: [\n          {\n            name: 'http',\n            port: 9090,\n            // Container http port is 10902. A bare string is dropped by cdk8s\n            // (targetPort expects IntOrString), which silently defaulted\n            // targetPort to 9090 and made the Service refuse connections.\n            targetPort: IntOrString.fromString('http'),\n            protocol: 'TCP',\n          },\n        ],\n        selector: {\n          'app.kubernetes.io/name': 'thanos-query',\n        },\n        sessionAffinity: 'ClientIP',\n      },\n    });\n\n    // Create gRPC Service (headless, for future Query Frontend)\n    new KubeService(this, 'service-grpc', {\n      metadata: {\n        name: 'thanos-query-grpc',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-query',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '3',\n        },\n      },\n      spec: {\n        type: 'ClusterIP',\n        clusterIp: 'None', // Headless service for DNS-based discovery\n        ports: [\n          {\n            name: 'grpc',\n            port: 10901,\n            targetPort: IntOrString.fromString('grpc'),\n            protocol: 'TCP',\n          },\n        ],\n        selector: {\n          'app.kubernetes.io/name': 'thanos-query',\n        },\n      },\n    });\n  }\n}\n"]}

package/lib/constructs/thanos-s3-bucket.d.ts

@@ -0,0 +1,24 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface ThanosS3BucketProps {
+    config: MonitoringConfig;
+}
+/**
+ * Creates Crossplane Bucket resources for Thanos long-term metrics storage.
+ *
+ * This construct generates:
+ * - S3 Bucket (via Crossplane Upbound provider-aws-s3)
+ * - BucketVersioning (for recovery)
+ * - BucketLifecycleConfiguration (2-year retention)
+ *
+ * Prerequisites:
+ * - Crossplane operator installed
+ * - Upbound provider-aws-s3 installed
+ * - ProviderConfig 'hetzner-s3' configured (points to Hetzner S3)
+ * - Hetzner S3 credentials secret exists in crossplane-system
+ *
+ * Sync Wave: 1 (external dependencies - must exist before pods access S3)
+ */
+export declare class ThanosS3BucketConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: ThanosS3BucketProps);
+}