@bluedynamics/cdk8s-monitoring 0.0.1

package/lib/constructs/thanos-s3-bucket.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThanosS3BucketConstruct = void 0;
+const cdk8s_1 = require("cdk8s");
+const constructs_1 = require("constructs");
+const s3_aws_upbound_io_1 = require("../imports/s3.aws.upbound.io");
+/**
+ * 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)
+ */
+class ThanosS3BucketConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { config } = props;
+        const bucketName = config.s3.buckets.thanos;
+        const region = config.s3.region;
+        // Create Bucket
+        // Wave 1: External Dependencies - S3 bucket provisioned by Crossplane
+        // Note: Using ApiObject because cdk8s import limitations prevent importing Bucket type
+        new cdk8s_1.ApiObject(this, 'bucket', {
+            apiVersion: 's3.aws.upbound.io/v1beta2',
+            kind: 'Bucket',
+            metadata: {
+                name: bucketName,
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'thanos',
+                    'app.kubernetes.io/component': 'storage',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                    'crossplane.io/external-name': bucketName,
+                    'description': 'Thanos long-term metrics storage (2-year retention)',
+                },
+            },
+            spec: {
+                deletionPolicy: 'Delete',
+                managementPolicies: [
+                    'Observe',
+                    'Create',
+                    'Delete',
+                    // Skip Update to avoid tagging operations (not supported by Hetzner S3)
+                ],
+                forProvider: {
+                    region: region, // Production region (endpoint determines actual location)
+                },
+                providerConfigRef: {
+                    name: 'hetzner-s3',
+                },
+            },
+        });
+        // Create BucketVersioning
+        // Enable versioning for bucket recovery
+        // Note: Using ApiObject because cdk8s import limitations prevent importing BucketVersioning type
+        new cdk8s_1.ApiObject(this, 'versioning', {
+            apiVersion: 's3.aws.upbound.io/v1beta2',
+            kind: 'BucketVersioning',
+            metadata: {
+                name: 'thanos-metrics-versioning',
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'thanos',
+                    'app.kubernetes.io/component': 'storage',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                },
+            },
+            spec: {
+                forProvider: {
+                    region: region, // Production region (same as bucket)
+                    bucketRef: {
+                        name: bucketName,
+                    },
+                    versioningConfiguration: {
+                        status: 'Enabled',
+                    },
+                },
+                providerConfigRef: {
+                    name: 'hetzner-s3',
+                },
+            },
+        });
+        // Create BucketLifecycleConfiguration
+        // Lifecycle policy: Delete downsampled blocks after 2 years (cost control)
+        new s3_aws_upbound_io_1.BucketLifecycleConfiguration(this, 'lifecycle', {
+            metadata: {
+                name: 'thanos-metrics-lifecycle',
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'thanos',
+                    'app.kubernetes.io/component': 'storage',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                },
+            },
+            spec: {
+                managementPolicies: [
+                    s3_aws_upbound_io_1.BucketLifecycleConfigurationSpecManagementPolicies.OBSERVE,
+                    s3_aws_upbound_io_1.BucketLifecycleConfigurationSpecManagementPolicies.CREATE,
+                    s3_aws_upbound_io_1.BucketLifecycleConfigurationSpecManagementPolicies.DELETE,
+                ],
+                forProvider: {
+                    region: region, // Production region (same as bucket)
+                    bucketRef: {
+                        name: bucketName,
+                    },
+                    rule: [
+                        {
+                            id: 'expire-old-blocks',
+                            status: 'Enabled',
+                            expiration: [
+                                {
+                                    days: config.retention.prometheusS31h, // 730 days (2 years) retention
+                                },
+                            ],
+                        },
+                    ],
+                },
+                providerConfigRef: {
+                    name: 'hetzner-s3',
+                },
+            },
+        });
+    }
+}
+exports.ThanosS3BucketConstruct = ThanosS3BucketConstruct;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"thanos-s3-bucket.js","sourceRoot":"","sources":["../../src/constructs/thanos-s3-bucket.ts"],"names":[],"mappings":"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","sourcesContent":["import { ApiObject } from 'cdk8s';\nimport { Construct } from 'constructs';\nimport { BucketLifecycleConfiguration, BucketLifecycleConfigurationSpecManagementPolicies } from '../imports/s3.aws.upbound.io';\nimport { MonitoringConfig } from '../types';\n\nexport interface ThanosS3BucketProps {\n  config: MonitoringConfig;\n}\n\n/**\n * Creates Crossplane Bucket resources for Thanos long-term metrics storage.\n *\n * This construct generates:\n * - S3 Bucket (via Crossplane Upbound provider-aws-s3)\n * - BucketVersioning (for recovery)\n * - BucketLifecycleConfiguration (2-year retention)\n *\n * Prerequisites:\n * - Crossplane operator installed\n * - Upbound provider-aws-s3 installed\n * - ProviderConfig 'hetzner-s3' configured (points to Hetzner S3)\n * - Hetzner S3 credentials secret exists in crossplane-system\n *\n * Sync Wave: 1 (external dependencies - must exist before pods access S3)\n */\nexport class ThanosS3BucketConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: ThanosS3BucketProps) {\n    super(scope, id);\n\n    const { config } = props;\n    const bucketName = config.s3.buckets.thanos;\n    const region = config.s3.region;\n\n    // Create Bucket\n    // Wave 1: External Dependencies - S3 bucket provisioned by Crossplane\n    // Note: Using ApiObject because cdk8s import limitations prevent importing Bucket type\n    new ApiObject(this, 'bucket', {\n      apiVersion: 's3.aws.upbound.io/v1beta2',\n      kind: 'Bucket',\n      metadata: {\n        name: bucketName,\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'thanos',\n          'app.kubernetes.io/component': 'storage',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '1',\n          'crossplane.io/external-name': bucketName,\n          'description': 'Thanos long-term metrics storage (2-year retention)',\n        },\n      },\n      spec: {\n        deletionPolicy: 'Delete',\n        managementPolicies: [\n          'Observe',\n          'Create',\n          'Delete',\n          // Skip Update to avoid tagging operations (not supported by Hetzner S3)\n        ],\n        forProvider: {\n          region: region, // Production region (endpoint determines actual location)\n        },\n        providerConfigRef: {\n          name: 'hetzner-s3',\n        },\n      },\n    });\n\n    // Create BucketVersioning\n    // Enable versioning for bucket recovery\n    // Note: Using ApiObject because cdk8s import limitations prevent importing BucketVersioning type\n    new ApiObject(this, 'versioning', {\n      apiVersion: 's3.aws.upbound.io/v1beta2',\n      kind: 'BucketVersioning',\n      metadata: {\n        name: 'thanos-metrics-versioning',\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'thanos',\n          'app.kubernetes.io/component': 'storage',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '1',\n        },\n      },\n      spec: {\n        forProvider: {\n          region: region, // Production region (same as bucket)\n          bucketRef: {\n            name: bucketName,\n          },\n          versioningConfiguration: {\n            status: 'Enabled',\n          },\n        },\n        providerConfigRef: {\n          name: 'hetzner-s3',\n        },\n      },\n    });\n\n    // Create BucketLifecycleConfiguration\n    // Lifecycle policy: Delete downsampled blocks after 2 years (cost control)\n    new BucketLifecycleConfiguration(this, 'lifecycle', {\n      metadata: {\n        name: 'thanos-metrics-lifecycle',\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'thanos',\n          'app.kubernetes.io/component': 'storage',\n          'app.kubernetes.io/managed-by': 'cdk8s',\n          'app.kubernetes.io/part-of': 'monitoring',\n        },\n        annotations: {\n          'argocd.argoproj.io/sync-wave': '1',\n        },\n      },\n      spec: {\n        managementPolicies: [\n          BucketLifecycleConfigurationSpecManagementPolicies.OBSERVE,\n          BucketLifecycleConfigurationSpecManagementPolicies.CREATE,\n          BucketLifecycleConfigurationSpecManagementPolicies.DELETE,\n        ],\n        forProvider: {\n          region: region, // Production region (same as bucket)\n          bucketRef: {\n            name: bucketName,\n          },\n          rule: [\n            {\n              id: 'expire-old-blocks',\n              status: 'Enabled',\n              expiration: [\n                {\n                  days: config.retention.prometheusS31h, // 730 days (2 years) retention\n                },\n              ],\n            },\n          ],\n        },\n        providerConfigRef: {\n          name: 'hetzner-s3',\n        },\n      },\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,27 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface ThanosS3CredentialsProps {
+    namespace: string;
+    config: MonitoringConfig;
+}
+/**
+ * Creates ExternalSecret for Thanos S3 credentials.
+ *
+ * This construct replicates Hetzner S3 credentials from crossplane-system
+ * namespace to monitoring namespace and transforms them into Thanos objstore.yml format.
+ *
+ * Prerequisites:
+ * - External Secrets Operator installed
+ * - ClusterSecretStore 'hetzner-s3-cluster-store' exists (points to crossplane-system)
+ * - Secret 'hetzner-s3-creds-standard' exists in crossplane-system namespace
+ *
+ * Generated Secret:
+ * - Name: thanos-objstore-config
+ * - Key: objstore.yml
+ * - Format: Thanos object storage configuration YAML
+ *
+ * Sync Wave: 1 (external dependencies - must exist before Thanos components start)
+ */
+export declare class ThanosS3CredentialsConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: ThanosS3CredentialsProps);
+}

package/lib/constructs/thanos-s3-credentials.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThanosS3CredentialsConstruct = void 0;
+const constructs_1 = require("constructs");
+const external_secrets_io_1 = require("../imports/external-secrets.io");
+/**
+ * Creates ExternalSecret for Thanos S3 credentials.
+ *
+ * This construct replicates Hetzner S3 credentials from crossplane-system
+ * namespace to monitoring namespace and transforms them into Thanos objstore.yml format.
+ *
+ * Prerequisites:
+ * - External Secrets Operator installed
+ * - ClusterSecretStore 'hetzner-s3-cluster-store' exists (points to crossplane-system)
+ * - Secret 'hetzner-s3-creds-standard' exists in crossplane-system namespace
+ *
+ * Generated Secret:
+ * - Name: thanos-objstore-config
+ * - Key: objstore.yml
+ * - Format: Thanos object storage configuration YAML
+ *
+ * Sync Wave: 1 (external dependencies - must exist before Thanos components start)
+ */
+class ThanosS3CredentialsConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace, config } = props;
+        // Create ExternalSecret that replicates S3 credentials
+        // Wave 1: External Dependencies - credentials must exist before Thanos components
+        new external_secrets_io_1.ExternalSecret(this, 'thanos-s3-external-secret', {
+            metadata: {
+                name: 'thanos-s3-credentials-es',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos',
+                    'app.kubernetes.io/component': 'objstore-config',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                },
+            },
+            spec: {
+                // Refresh credentials every hour (automatic rotation support)
+                refreshInterval: '1h',
+                // Use existing ClusterSecretStore for Hetzner S3 (infrastructure-level secrets)
+                secretStoreRef: {
+                    name: 'hetzner-s3-cluster-store',
+                    kind: external_secrets_io_1.ExternalSecretSpecSecretStoreRefKind.CLUSTER_SECRET_STORE,
+                },
+                // Target secret that Thanos sidecar will consume
+                target: {
+                    name: 'thanos-objstore-config',
+                    creationPolicy: external_secrets_io_1.ExternalSecretSpecTargetCreationPolicy.OWNER,
+                    // Transform AWS credential format into Thanos objstore.yml
+                    template: {
+                        engineVersion: external_secrets_io_1.ExternalSecretSpecTargetTemplateEngineVersion.V2,
+                        data: {
+                            'objstore.yml': `type: S3
+config:
+  bucket: "${config.s3.buckets.thanos}"
+  endpoint: "${config.s3.endpointNoProtocol}"
+  region: ${config.s3.region}
+  access_key: {{ .AWS_ACCESS_KEY_ID }}
+  secret_key: {{ .AWS_SECRET_ACCESS_KEY }}
+  insecure: false
+  signature_version2: false
+  http_config:
+    idle_conn_timeout: 90s
+    response_header_timeout: 2m
+    insecure_skip_verify: false
+  trace:
+    enable: false
+  part_size: 67108864  # 64MB upload chunks
+`,
+                        },
+                    },
+                },
+                // Fetch S3 credentials from crossplane-system/hetzner-s3-creds-standard
+                dataFrom: [
+                    {
+                        extract: {
+                            key: 'hetzner-s3-creds-standard',
+                        },
+                    },
+                ],
+            },
+        });
+    }
+}
+exports.ThanosS3CredentialsConstruct = ThanosS3CredentialsConstruct;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,30 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface ThanosStoreProps {
+    namespace: string;
+    config: MonitoringConfig;
+}
+/**
+ * Creates Thanos Store Gateway StatefulSet and Services.
+ *
+ * Thanos Store Gateway queries historical data from S3 and makes it
+ * available via gRPC to Thanos Query. This enables transparent querying
+ * of metrics older than the Prometheus local retention (>3 days).
+ *
+ * Components:
+ * - StatefulSet (2 replicas with anti-affinity, 10Gi PVC each for index cache)
+ * - gRPC Service (headless, for Thanos Query discovery)
+ * - HTTP Service (for debugging and metrics)
+ *
+ * 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 (storage gateway - after S3 bucket and credentials)
+ */
+export declare class ThanosStoreConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: ThanosStoreProps);
+}

package/lib/constructs/thanos-store.js

@@ -0,0 +1,239 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThanosStoreConstruct = void 0;
+const constructs_1 = require("constructs");
+const k8s_1 = require("../imports/k8s");
+/**
+ * Creates Thanos Store Gateway StatefulSet and Services.
+ *
+ * Thanos Store Gateway queries historical data from S3 and makes it
+ * available via gRPC to Thanos Query. This enables transparent querying
+ * of metrics older than the Prometheus local retention (>3 days).
+ *
+ * Components:
+ * - StatefulSet (2 replicas with anti-affinity, 10Gi PVC each for index cache)
+ * - gRPC Service (headless, for Thanos Query discovery)
+ * - HTTP Service (for debugging and metrics)
+ *
+ * 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 (storage gateway - after S3 bucket and credentials)
+ */
+class ThanosStoreConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace, config } = props;
+        // Create StatefulSet
+        // Wave 3: Storage Gateway - after S3 bucket and credentials are ready
+        new k8s_1.KubeStatefulSet(this, 'statefulset', {
+            metadata: {
+                name: 'thanos-store',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-store',
+                    'app.kubernetes.io/component': 'store-gateway',
+                    'app.kubernetes.io/managed-by': 'cdk8s',
+                    'app.kubernetes.io/part-of': 'monitoring',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '3',
+                },
+            },
+            spec: {
+                serviceName: 'thanos-store',
+                replicas: config.replicas.thanosStore,
+                selector: {
+                    matchLabels: {
+                        'app.kubernetes.io/name': 'thanos-store',
+                    },
+                },
+                template: {
+                    metadata: {
+                        labels: {
+                            'app.kubernetes.io/name': 'thanos-store',
+                            'app.kubernetes.io/component': 'store-gateway',
+                        },
+                    },
+                    spec: {
+                        // No arch nodeSelector: Thanos images are multi-arch; let the
+                        // scheduler place these on any worker (the ARM64 pin was a legacy
+                        // placement onto the cax31 agent pool, now being retired → EX).
+                        // Spread replicas across different nodes for HA
+                        affinity: {
+                            podAntiAffinity: {
+                                preferredDuringSchedulingIgnoredDuringExecution: [
+                                    {
+                                        weight: 100,
+                                        podAffinityTerm: {
+                                            labelSelector: {
+                                                matchLabels: {
+                                                    'app.kubernetes.io/name': 'thanos-store',
+                                                },
+                                            },
+                                            topologyKey: 'kubernetes.io/hostname',
+                                        },
+                                    },
+                                ],
+                            },
+                        },
+                        // Fix volume permissions for Thanos user (UID 10001)
+                        securityContext: {
+                            fsGroup: 10001,
+                            runAsUser: 10001,
+                            runAsNonRoot: true,
+                        },
+                        containers: [
+                            {
+                                name: 'thanos-store',
+                                image: `quay.io/thanos/thanos:${config.versions.thanos}`,
+                                args: [
+                                    'store',
+                                    '--log.level=info',
+                                    '--data-dir=/var/thanos/store',
+                                    '--objstore.config-file=/etc/thanos/objstore.yml',
+                                    '--index-cache-size=500MB',
+                                    '--chunk-pool-size=500MB',
+                                ],
+                                ports: [
+                                    {
+                                        name: 'http',
+                                        containerPort: 10902,
+                                    },
+                                    {
+                                        name: 'grpc',
+                                        containerPort: 10901,
+                                    },
+                                ],
+                                volumeMounts: [
+                                    {
+                                        name: 'objstore-config',
+                                        mountPath: '/etc/thanos',
+                                        readOnly: true,
+                                    },
+                                    {
+                                        name: 'data',
+                                        mountPath: '/var/thanos/store',
+                                    },
+                                ],
+                                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.thanosStore.requests.cpu),
+                                        memory: k8s_1.Quantity.fromString(config.resources.thanosStore.requests.memory),
+                                    },
+                                    limits: {
+                                        cpu: k8s_1.Quantity.fromString(config.resources.thanosStore.limits.cpu),
+                                        memory: k8s_1.Quantity.fromString(config.resources.thanosStore.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.thanosStore), // Cache for S3 index data
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        });
+        // Create gRPC Service (headless, for Thanos Query to discover)
+        new k8s_1.KubeService(this, 'service-grpc', {
+            metadata: {
+                name: 'thanos-store-grpc',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-store',
+                    '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: 'grpc',
+                        protocol: 'TCP',
+                    },
+                ],
+                selector: {
+                    'app.kubernetes.io/name': 'thanos-store',
+                },
+            },
+        });
+        // Create HTTP Service (for debugging/metrics)
+        new k8s_1.KubeService(this, 'service-http', {
+            metadata: {
+                name: 'thanos-store-http',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'thanos-store',
+                    '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-store',
+                },
+            },
+        });
+    }
+}
+exports.ThanosStoreConstruct = ThanosStoreConstruct;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"thanos-store.js","sourceRoot":"","sources":["../../src/constructs/thanos-store.ts"],"names":[],"mappings":";;;AAAA,2CAAuC;AACvC,wCAAqF;AAQrF;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAa,oBAAqB,SAAQ,sBAAS;IACjD,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAuB;QAC/D,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,GAAG,KAAK,CAAC;QAEpC,qBAAqB;QACrB,sEAAsE;QACtE,IAAI,qBAAe,CAAC,IAAI,EAAE,aAAa,EAAE;YACvC,QAAQ,EAAE;gBACR,IAAI,EAAE,cAAc;gBACpB,SAAS,EAAE,SAAS;gBACpB,MAAM,EAAE;oBACN,wBAAwB,EAAE,cAAc;oBACxC,6BAA6B,EAAE,eAAe;oBAC9C,8BAA8B,EAAE,OAAO;oBACvC,2BAA2B,EAAE,YAAY;iBAC1C;gBACD,WAAW,EAAE;oBACX,8BAA8B,EAAE,GAAG;iBACpC;aACF;YACD,IAAI,EAAE;gBACJ,WAAW,EAAE,cAAc;gBAC3B,QAAQ,EAAE,MAAM,CAAC,QAAQ,CAAC,WAAW;gBACrC,QAAQ,EAAE;oBACR,WAAW,EAAE;wBACX,wBAAwB,EAAE,cAAc;qBACzC;iBACF;gBACD,QAAQ,EAAE;oBACR,QAAQ,EAAE;wBACR,MAAM,EAAE;4BACN,wBAAwB,EAAE,cAAc;4BACxC,6BAA6B,EAAE,eAAe;yBAC/C;qBACF;oBACD,IAAI,EAAE;wBACJ,8DAA8D;wBAC9D,kEAAkE;wBAClE,gEAAgE;wBAEhE,gDAAgD;wBAChD,QAAQ,EAAE;4BACR,eAAe,EAAE;gCACf,+CAA+C,EAAE;oCAC/C;wCACE,MAAM,EAAE,GAAG;wCACX,eAAe,EAAE;4CACf,aAAa,EAAE;gDACb,WAAW,EAAE;oDACX,wBAAwB,EAAE,cAAc;iDACzC;6CACF;4CACD,WAAW,EAAE,wBAAwB;yCACtC;qCACF;iCACF;6BACF;yBACF;wBAED,qDAAqD;wBACrD,eAAe,EAAE;4BACf,OAAO,EAAE,KAAK;4BACd,SAAS,EAAE,KAAK;4BAChB,YAAY,EAAE,IAAI;yBACnB;wBAED,UAAU,EAAE;4BACV;gCACE,IAAI,EAAE,cAAc;gCACpB,KAAK,EAAE,yBAAyB,MAAM,CAAC,QAAQ,CAAC,MAAM,EAAE;gCACxD,IAAI,EAAE;oCACJ,OAAO;oCACP,kBAAkB;oCAClB,8BAA8B;oCAC9B,iDAAiD;oCACjD,0BAA0B;oCAC1B,yBAAyB;iCAC1B;gCACD,KAAK,EAAE;oCACL;wCACE,IAAI,EAAE,MAAM;wCACZ,aAAa,EAAE,KAAK;qCACrB;oCACD;wCACE,IAAI,EAAE,MAAM;wCACZ,aAAa,EAAE,KAAK;qCACrB;iCACF;gCACD,YAAY,EAAE;oCACZ;wCACE,IAAI,EAAE,iBAAiB;wCACvB,SAAS,EAAE,aAAa;wCACxB,QAAQ,EAAE,IAAI;qCACf;oCACD;wCACE,IAAI,EAAE,MAAM;wCACZ,SAAS,EAAE,mBAAmB;qCAC/B;iCACF;gCACD,aAAa,EAAE;oCACb,OAAO,EAAE;wCACP,IAAI,EAAE,YAAY;wCAClB,IAAI,EAAE,iBAAW,CAAC,UAAU,CAAC,MAAM,CAAC;qCACrC;oCACD,mBAAmB,EAAE,EAAE;oCACvB,aAAa,EAAE,EAAE;iCAClB;gCACD,cAAc,EAAE;oCACd,OAAO,EAAE;wCACP,IAAI,EAAE,UAAU;wCAChB,IAAI,EAAE,iBAAW,CAAC,UAAU,CAAC,MAAM,CAAC;qCACrC;oCACD,mBAAmB,EAAE,EAAE;oCACvB,aAAa,EAAE,CAAC;iCACjB;gCACD,SAAS,EAAE;oCACT,QAAQ,EAAE;wCACR,GAAG,EAAE,cAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,GAAG,CAAC;wCACnE,MAAM,EAAE,cAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,QAAQ,CAAC,MAAM,CAAC;qCAC1E;oCACD,MAAM,EAAE;wCACN,GAAG,EAAE,cAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,GAAG,CAAC;wCACjE,MAAM,EAAE,cAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,WAAW,CAAC,MAAM,CAAC,MAAM,CAAC;qCACxE;iCACF;6BACF;yBACF;wBAED,OAAO,EAAE;4BACP;gCACE,IAAI,EAAE,iBAAiB;gCACvB,MAAM,EAAE;oCACN,UAAU,EAAE,wBAAwB;iCACrC;6BACF;yBACF;wBAED,iBAAiB,EAAE,eAAe;qBACnC;iBACF;gBACD,oBAAoB,EAAE;oBACpB;wBACE,QAAQ,EAAE;4BACR,IAAI,EAAE,MAAM;yBACb;wBACD,IAAI,EAAE;4BACJ,WAAW,EAAE,CAAC,eAAe,CAAC;4BAC9B,gBAAgB,EAAE,UAAU;4BAC5B,SAAS,EAAE;gCACT,QAAQ,EAAE;oCACR,OAAO,EAAE,cAAQ,CAAC,UAAU,CAAC,MAAM,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,0BAA0B;iCACrF;6BACF;yBACF;qBACF;iBACF;aACF;SACF,CAAC,CAAC;QAEH,+DAA+D;QAC/D,IAAI,iBAAW,CAAC,IAAI,EAAE,cAAc,EAAE;YACpC,QAAQ,EAAE;gBACR,IAAI,EAAE,mBAAmB;gBACzB,SAAS,EAAE,SAAS;gBACpB,MAAM,EAAE;oBACN,wBAAwB,EAAE,cAAc;oBACxC,8BAA8B,EAAE,OAAO;iBACxC;gBACD,WAAW,EAAE;oBACX,8BAA8B,EAAE,GAAG;iBACpC;aACF;YACD,IAAI,EAAE;gBACJ,IAAI,EAAE,WAAW;gBACjB,SAAS,EAAE,MAAM,EAAE,2CAA2C;gBAC9D,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,MAAM;wBACZ,IAAI,EAAE,KAAK;wBACX,UAAU,EAAE,MAAa;wBACzB,QAAQ,EAAE,KAAK;qBAChB;iBACF;gBACD,QAAQ,EAAE;oBACR,wBAAwB,EAAE,cAAc;iBACzC;aACF;SACF,CAAC,CAAC;QAEH,8CAA8C;QAC9C,IAAI,iBAAW,CAAC,IAAI,EAAE,cAAc,EAAE;YACpC,QAAQ,EAAE;gBACR,IAAI,EAAE,mBAAmB;gBACzB,SAAS,EAAE,SAAS;gBACpB,MAAM,EAAE;oBACN,wBAAwB,EAAE,cAAc;oBACxC,8BAA8B,EAAE,OAAO;iBACxC;gBACD,WAAW,EAAE;oBACX,8BAA8B,EAAE,GAAG;iBACpC;aACF;YACD,IAAI,EAAE;gBACJ,KAAK,EAAE;oBACL;wBACE,IAAI,EAAE,MAAM;wBACZ,IAAI,EAAE,KAAK;wBACX,UAAU,EAAE,MAAa;wBACzB,QAAQ,EAAE,KAAK;qBAChB;iBACF;gBACD,QAAQ,EAAE;oBACR,wBAAwB,EAAE,cAAc;iBACzC;aACF;SACF,CAAC,CAAC;IACL,CAAC;CACF;AA3ND,oDA2NC","sourcesContent":["import { Construct } from 'constructs';\nimport { KubeStatefulSet, KubeService, Quantity, IntOrString } from '../imports/k8s';\nimport { MonitoringConfig } from '../types';\n\nexport interface ThanosStoreProps {\n  namespace: string;\n  config: MonitoringConfig;\n}\n\n/**\n * Creates Thanos Store Gateway StatefulSet and Services.\n *\n * Thanos Store Gateway queries historical data from S3 and makes it\n * available via gRPC to Thanos Query. This enables transparent querying\n * of metrics older than the Prometheus local retention (>3 days).\n *\n * Components:\n * - StatefulSet (2 replicas with anti-affinity, 10Gi PVC each for index cache)\n * - gRPC Service (headless, for Thanos Query discovery)\n * - HTTP Service (for debugging and metrics)\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 (storage gateway - after S3 bucket and credentials)\n */\nexport class ThanosStoreConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: ThanosStoreProps) {\n    super(scope, id);\n\n    const { namespace, config } = props;\n\n    // Create StatefulSet\n    // Wave 3: Storage Gateway - after S3 bucket and credentials are ready\n    new KubeStatefulSet(this, 'statefulset', {\n      metadata: {\n        name: 'thanos-store',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-store',\n          'app.kubernetes.io/component': 'store-gateway',\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-store',\n        replicas: config.replicas.thanosStore,\n        selector: {\n          matchLabels: {\n            'app.kubernetes.io/name': 'thanos-store',\n          },\n        },\n        template: {\n          metadata: {\n            labels: {\n              'app.kubernetes.io/name': 'thanos-store',\n              'app.kubernetes.io/component': 'store-gateway',\n            },\n          },\n          spec: {\n            // No arch nodeSelector: Thanos images are multi-arch; let the\n            // scheduler place these on any worker (the ARM64 pin was a legacy\n            // placement onto the cax31 agent pool, now being retired → EX).\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-store',\n                        },\n                      },\n                      topologyKey: 'kubernetes.io/hostname',\n                    },\n                  },\n                ],\n              },\n            },\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-store',\n                image: `quay.io/thanos/thanos:${config.versions.thanos}`,\n                args: [\n                  'store',\n                  '--log.level=info',\n                  '--data-dir=/var/thanos/store',\n                  '--objstore.config-file=/etc/thanos/objstore.yml',\n                  '--index-cache-size=500MB',\n                  '--chunk-pool-size=500MB',\n                ],\n                ports: [\n                  {\n                    name: 'http',\n                    containerPort: 10902,\n                  },\n                  {\n                    name: 'grpc',\n                    containerPort: 10901,\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/store',\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.thanosStore.requests.cpu),\n                    memory: Quantity.fromString(config.resources.thanosStore.requests.memory),\n                  },\n                  limits: {\n                    cpu: Quantity.fromString(config.resources.thanosStore.limits.cpu),\n                    memory: Quantity.fromString(config.resources.thanosStore.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.thanosStore), // Cache for S3 index data\n                },\n              },\n            },\n          },\n        ],\n      },\n    });\n\n    // Create gRPC Service (headless, for Thanos Query to discover)\n    new KubeService(this, 'service-grpc', {\n      metadata: {\n        name: 'thanos-store-grpc',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-store',\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: 'grpc' as any,\n            protocol: 'TCP',\n          },\n        ],\n        selector: {\n          'app.kubernetes.io/name': 'thanos-store',\n        },\n      },\n    });\n\n    // Create HTTP Service (for debugging/metrics)\n    new KubeService(this, 'service-http', {\n      metadata: {\n        name: 'thanos-store-http',\n        namespace: namespace,\n        labels: {\n          'app.kubernetes.io/name': 'thanos-store',\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-store',\n        },\n      },\n    });\n  }\n}\n"]}

package/lib/default-config.d.ts

@@ -0,0 +1,12 @@
+import { DefaultableConfig, MonitoringConfig, MonitoringConfigInput } from './types';
+/**
+ * Package-shipped defaults for everything that has a sensible universal value.
+ * Values mirror the kup6s production config at the time of extraction; integration
+ * charts override only what they need via {@link mergeConfig}.
+ */
+export declare const DEFAULT_CONFIG: DefaultableConfig;
+/**
+ * Resolve a full MonitoringConfig by deep-merging the caller's overrides over
+ * DEFAULT_CONFIG. Required cluster values are passed through verbatim.
+ */
+export declare function mergeConfig(input: MonitoringConfigInput): MonitoringConfig;