@bluedynamics/cdk8s-monitoring 0.0.1

package/lib/constructs/grafana-password-secret.d.ts

@@ -0,0 +1,57 @@
+import { Construct } from 'constructs';
+import { ExternalSecret } from '../imports/external-secrets.io';
+export interface GrafanaPasswordSecretProps {
+    readonly namespace: string;
+}
+/**
+ * Creates ExternalSecret for stable Grafana admin credentials.
+ *
+ * This construct creates an ExternalSecret that replicates the Grafana admin password
+ * from the application-secrets namespace to the monitoring namespace, following the
+ * centralized secret management pattern.
+ *
+ * Prerequisites:
+ * - External Secrets Operator installed
+ * - ClusterSecretStore 'monitoring-app-secrets-store' exists (points to application-secrets)
+ * - Secret 'grafana-admin' exists in application-secrets namespace with keys:
+ *   - admin-user
+ *   - admin-password
+ *
+ * Security Model:
+ * - Source secret stored in centralized application-secrets namespace
+ * - ExternalSecret CR (this) committed to git (GitOps-safe, no password in git)
+ * - ESO automatically replicates secret to monitoring namespace
+ * - Password persists across Helm upgrades (no auto-regeneration)
+ *
+ * Benefits:
+ * - Centralized secret management (all app secrets in application-secrets namespace)
+ * - GitOps-safe (ExternalSecret in git, actual password not in git)
+ * - Password rotation (update source → auto-sync to monitoring)
+ * - Follows GitLab BDA security model (see documentation/sources/deployments/gitlabbda/explanation/security-model.md)
+ *
+ * Usage in prometheus-stack.ts:
+ * ```yaml
+ * grafana:
+ *   admin:
+ *     existingSecret: "grafana-admin-credentials"
+ *     userKey: "admin-user"
+ *     passwordKey: "admin-password"
+ * ```
+ *
+ * Manual Setup Required:
+ * 1. Create source secret in application-secrets namespace:
+ *    ```bash
+ *    kubectl create secret generic grafana-admin -n application-secrets \
+ *      --from-literal=admin-user=admin \
+ *      --from-literal=admin-password='YourSecurePassword123!'
+ *    ```
+ *
+ * 2. Create ClusterSecretStore (if not exists):
+ *    See: documentation/sources/deployments/monitoring/how-to/setup-grafana-password.md
+ *
+ * 3. Deploy monitoring stack (this ExternalSecret will sync the secret)
+ */
+export declare class GrafanaPasswordSecret extends Construct {
+    readonly externalSecret: ExternalSecret;
+    constructor(scope: Construct, id: string, props: GrafanaPasswordSecretProps);
+}

package/lib/constructs/grafana-password-secret.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GrafanaPasswordSecret = void 0;
+const constructs_1 = require("constructs");
+const external_secrets_io_1 = require("../imports/external-secrets.io");
+/**
+ * Creates ExternalSecret for stable Grafana admin credentials.
+ *
+ * This construct creates an ExternalSecret that replicates the Grafana admin password
+ * from the application-secrets namespace to the monitoring namespace, following the
+ * centralized secret management pattern.
+ *
+ * Prerequisites:
+ * - External Secrets Operator installed
+ * - ClusterSecretStore 'monitoring-app-secrets-store' exists (points to application-secrets)
+ * - Secret 'grafana-admin' exists in application-secrets namespace with keys:
+ *   - admin-user
+ *   - admin-password
+ *
+ * Security Model:
+ * - Source secret stored in centralized application-secrets namespace
+ * - ExternalSecret CR (this) committed to git (GitOps-safe, no password in git)
+ * - ESO automatically replicates secret to monitoring namespace
+ * - Password persists across Helm upgrades (no auto-regeneration)
+ *
+ * Benefits:
+ * - Centralized secret management (all app secrets in application-secrets namespace)
+ * - GitOps-safe (ExternalSecret in git, actual password not in git)
+ * - Password rotation (update source → auto-sync to monitoring)
+ * - Follows GitLab BDA security model (see documentation/sources/deployments/gitlabbda/explanation/security-model.md)
+ *
+ * Usage in prometheus-stack.ts:
+ * ```yaml
+ * grafana:
+ *   admin:
+ *     existingSecret: "grafana-admin-credentials"
+ *     userKey: "admin-user"
+ *     passwordKey: "admin-password"
+ * ```
+ *
+ * Manual Setup Required:
+ * 1. Create source secret in application-secrets namespace:
+ *    ```bash
+ *    kubectl create secret generic grafana-admin -n application-secrets \
+ *      --from-literal=admin-user=admin \
+ *      --from-literal=admin-password='YourSecurePassword123!'
+ *    ```
+ *
+ * 2. Create ClusterSecretStore (if not exists):
+ *    See: documentation/sources/deployments/monitoring/how-to/setup-grafana-password.md
+ *
+ * 3. Deploy monitoring stack (this ExternalSecret will sync the secret)
+ */
+class GrafanaPasswordSecret extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { namespace } = props;
+        // Create ExternalSecret to replicate Grafana credentials from application-secrets
+        // Wave 1: Credentials must exist before Grafana starts (Wave 2)
+        this.externalSecret = new external_secrets_io_1.ExternalSecret(this, 'external-secret', {
+            metadata: {
+                name: 'grafana-admin-credentials-es',
+                namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'grafana',
+                    'app.kubernetes.io/component': 'credentials',
+                    'app.kubernetes.io/managed-by': 'external-secrets',
+                },
+                annotations: {
+                    'argocd.argoproj.io/sync-wave': '1',
+                },
+            },
+            spec: {
+                // Sync every hour to detect password rotation
+                refreshInterval: '1h',
+                // Reference to ClusterSecretStore (application-secrets → monitoring)
+                secretStoreRef: {
+                    name: 'monitoring-app-secrets-store',
+                    kind: external_secrets_io_1.ExternalSecretSpecSecretStoreRefKind.CLUSTER_SECRET_STORE,
+                },
+                // Target secret name that Grafana will use
+                target: {
+                    name: 'grafana-admin-credentials',
+                    creationPolicy: external_secrets_io_1.ExternalSecretSpecTargetCreationPolicy.OWNER,
+                },
+                // Copy all data from source secret (admin-user, admin-password)
+                dataFrom: [
+                    {
+                        extract: {
+                            key: 'grafana-admin',
+                        },
+                    },
+                ],
+            },
+        });
+    }
+}
+exports.GrafanaPasswordSecret = GrafanaPasswordSecret;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,24 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface LokiS3BucketProps {
+    config: MonitoringConfig;
+}
+/**
+ * Creates Crossplane Bucket resources for Loki log storage.
+ *
+ * This construct generates:
+ * - S3 Bucket (via Crossplane Upbound provider-aws-s3)
+ * - BucketVersioning (for recovery of accidentally deleted logs)
+ * - BucketLifecycleConfiguration (90-day 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 LokiS3BucketConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: LokiS3BucketProps);
+}

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

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiS3BucketConstruct = 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 Loki log storage.
+ *
+ * This construct generates:
+ * - S3 Bucket (via Crossplane Upbound provider-aws-s3)
+ * - BucketVersioning (for recovery of accidentally deleted logs)
+ * - BucketLifecycleConfiguration (90-day 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 LokiS3BucketConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { config } = props;
+        const bucketName = config.s3.buckets.loki;
+        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': 'loki',
+                    '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': 'Loki log storage (90-day 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 recovery of accidentally deleted logs
+        // 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: 'loki-logs-versioning',
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'loki',
+                    '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: automatically delete logs older than 90 days
+        new s3_aws_upbound_io_1.BucketLifecycleConfiguration(this, 'lifecycle', {
+            metadata: {
+                name: 'loki-logs-lifecycle',
+                namespace: 'crossplane-system',
+                labels: {
+                    'app.kubernetes.io/name': 'loki',
+                    '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: 'delete-old-logs',
+                            status: 'Enabled',
+                            expiration: [
+                                {
+                                    days: 90, // 90-day retention (matches 31d Loki retention + buffer)
+                                },
+                            ],
+                        },
+                    ],
+                },
+                providerConfigRef: {
+                    name: 'hetzner-s3',
+                },
+            },
+        });
+    }
+}
+exports.LokiS3BucketConstruct = LokiS3BucketConstruct;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"loki-s3-bucket.js","sourceRoot":"","sources":["../../src/constructs/loki-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 LokiS3BucketProps {\n  config: MonitoringConfig;\n}\n\n/**\n * Creates Crossplane Bucket resources for Loki log storage.\n *\n * This construct generates:\n * - S3 Bucket (via Crossplane Upbound provider-aws-s3)\n * - BucketVersioning (for recovery of accidentally deleted logs)\n * - BucketLifecycleConfiguration (90-day 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 LokiS3BucketConstruct extends Construct {\n  constructor(scope: Construct, id: string, props: LokiS3BucketProps) {\n    super(scope, id);\n\n    const { config } = props;\n    const bucketName = config.s3.buckets.loki;\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': 'loki',\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': 'Loki log storage (90-day 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 recovery of accidentally deleted logs\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: 'loki-logs-versioning',\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'loki',\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: automatically delete logs older than 90 days\n    new BucketLifecycleConfiguration(this, 'lifecycle', {\n      metadata: {\n        name: 'loki-logs-lifecycle',\n        namespace: 'crossplane-system',\n        labels: {\n          'app.kubernetes.io/name': 'loki',\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: 'delete-old-logs',\n              status: 'Enabled',\n              expiration: [\n                {\n                  days: 90, // 90-day retention (matches 31d Loki retention + buffer)\n                },\n              ],\n            },\n          ],\n        },\n        providerConfigRef: {\n          name: 'hetzner-s3',\n        },\n      },\n    });\n  }\n}\n"]}

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

@@ -0,0 +1,27 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface LokiS3CredentialsProps {
+    namespace: string;
+    config: MonitoringConfig;
+}
+/**
+ * Creates ExternalSecret for Loki S3 credentials.
+ *
+ * This construct replicates Hetzner S3 credentials from crossplane-system
+ * namespace to monitoring namespace for Loki's object storage.
+ *
+ * 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: loki-s3-credentials
+ * - Keys: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
+ *
+ * Sync Wave: 1 (external dependencies - must exist before Loki starts)
+ */
+export declare class LokiS3CredentialsConstruct extends Construct {
+    readonly secretName = "loki-s3-credentials";
+    constructor(scope: Construct, id: string, props: LokiS3CredentialsProps);
+}

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

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LokiS3CredentialsConstruct = void 0;
+const constructs_1 = require("constructs");
+const external_secrets_io_1 = require("../imports/external-secrets.io");
+/**
+ * Creates ExternalSecret for Loki S3 credentials.
+ *
+ * This construct replicates Hetzner S3 credentials from crossplane-system
+ * namespace to monitoring namespace for Loki's object storage.
+ *
+ * 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: loki-s3-credentials
+ * - Keys: AWS_ACCESS_KEY_ID, AWS_SECRET_ACCESS_KEY
+ *
+ * Sync Wave: 1 (external dependencies - must exist before Loki starts)
+ */
+class LokiS3CredentialsConstruct extends constructs_1.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        this.secretName = 'loki-s3-credentials';
+        const { namespace } = props;
+        // Create ExternalSecret that replicates S3 credentials
+        // Wave 1: External Dependencies - credentials must exist before Loki components
+        new external_secrets_io_1.ExternalSecret(this, 'loki-s3-external-secret', {
+            metadata: {
+                name: 'loki-s3-credentials-es',
+                namespace: namespace,
+                labels: {
+                    'app.kubernetes.io/name': 'loki',
+                    'app.kubernetes.io/component': 's3-credentials',
+                    '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)
+                // Use full format to match Kubernetes normalization and avoid ArgoCD drift
+                refreshInterval: '1h0m0s',
+                // 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 Loki will consume via extraEnvFrom
+                target: {
+                    name: this.secretName,
+                    creationPolicy: external_secrets_io_1.ExternalSecretSpecTargetCreationPolicy.OWNER,
+                },
+                // Fetch S3 credentials from crossplane-system/hetzner-s3-creds-standard
+                dataFrom: [
+                    {
+                        extract: {
+                            key: 'hetzner-s3-creds-standard',
+                        },
+                    },
+                ],
+            },
+        });
+    }
+}
+exports.LokiS3CredentialsConstruct = LokiS3CredentialsConstruct;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/constructs/loki.d.ts

@@ -0,0 +1,30 @@
+import { Construct } from 'constructs';
+import { MonitoringConfig } from '../types';
+export interface LokiProps {
+    namespace: string;
+    config: MonitoringConfig;
+    s3CredentialsSecretName: string;
+}
+/**
+ * Creates Loki HelmChart for log aggregation.
+ *
+ * This construct deploys Loki in SimpleScalable mode with:
+ * - Backend (2 replicas) - Index and compaction
+ * - Read (2 replicas) - Query processing
+ * - Write (2 replicas) - Log ingestion
+ * - Gateway (1 replica) - HTTP API endpoint
+ * - S3 storage backend (Hetzner Object Storage)
+ *
+ * Prerequisites:
+ * - Namespace exists
+ * - PriorityClass 'high-priority' exists
+ * - Longhorn storage class available
+ * - S3 bucket exists (via Crossplane)
+ * - S3 credentials secret exists (via LokiS3CredentialsConstruct)
+ *
+ * Sync Wave: 2 (core services - after S3 credentials secret)
+ */
+export declare class LokiConstruct extends Construct {
+    constructor(scope: Construct, id: string, props: LokiProps);
+    private generateHelmValues;
+}