Aller au contenu
CassiopeDocumentation

Données & reporting

Ingestion et tableaux de bord

Section intitulée « Ingestion et tableaux de bord »

Metabase interroge vos bases (PostgreSQL, MySQL, MongoDB, fichiers…) et publie des tableaux de bord, des questions sauvegardées et des alertes sans écrire de code. L’add-on PostgreSQL de ce blueprint sert de base interne à Metabase : utilisateurs, questions, tableaux de bord. Vos sources de données se déclarent ensuite dans l’interface, sous Administration → Bases de données.

apiVersion: cassiope.eu/v1alpha1
kind: Blueprint
project:
  slug: pilotage
  name: Pilotage d'activité
  environments:
    - slug: production
      name: Production
      addons:
        - slug: interne
          name: Base interne Metabase
          templateKey: postgresql
          version: "17"
          backupEnabled: true
      services:
        - slug: metabase
          name: Metabase
          type: web
          source:
            imageRef: metabase/metabase:v0.58.37
          portsExposes: "3000"
          publiclyExposed: true
          resources: { cpuMillicores: 1000, ramMb: 2048 }
          env:
            - key: MB_ENCRYPTION_SECRET_KEY
              fromSecret: true
            - key: MB_SITE_URL
              value: ${CASSIOPE_PUBLIC_URL}
            - key: MB_DB_TYPE
              value: postgres
            - key: MB_DB_HOST
              value: ${MB_PG_HOST}
            - key: MB_DB_PORT
              value: ${MB_PG_PORT}
            - key: MB_DB_DBNAME
              value: ${MB_PG_DATABASE}
            - key: MB_DB_USER
              value: ${MB_PG_USER}
            - key: MB_DB_PASS
              value: ${MB_PG_PASSWORD}
          bindings:
            - addon: interne
              envVarKey: MB_PG
              derive: split-postgres

Metabase lit sa base interne dans cinq variables MB_DB_* : la liaison derive: split-postgres fournit MB_PG_HOST, MB_PG_PORT, MB_PG_DATABASE, MB_PG_USER et MB_PG_PASSWORD, que les variables citent avec ${…}. MB_ENCRYPTION_SECRET_KEY (16 caractères au moins) chiffre les identifiants des sources que vous ajoutez : gardez-la, la changer les rend illisibles. Au premier accès, Metabase déroule son assistant de configuration et crée le compte administrateur.

Pour interroger une base hébergée sur la plateforme, créez-lui un add-on, puis recopiez son hôte interne et ses identifiants (page de l’add-on) dans le formulaire de la source.

Valeur à fournir à l’import :

{
  "production/metabase": { "MB_ENCRYPTION_SECRET_KEY": "une chaîne aléatoire d'au moins 16 caractères" }
}

Collecte d’événements métier

Section intitulée « Collecte d’événements métier »

Redpanda Connect (l’ex-Benthos) assemble des flux de données par configuration, sans code. Trois instances de la même image, chacune avec son fichier /connect.yaml monté par la plateforme :

  • ingestion reçoit des événements JSON en POST /events (authentification basique) et les publie sur le sujet NATS events.received ;
  • ecriture les lit sur ce sujet et les insère dans la collection MongoDB events ;
  • archivage lit le même sujet et conserve le message brut dans la collection archives ;
  • inspecteur (mongo-express) est une interface web pour lire ces collections : l’add-on MongoDB n’a ni console ni accès direct depuis l’extérieur.

Chaque lecteur a son propre groupe de consommation (queue) : les deux reçoivent tous les événements.

apiVersion: cassiope.eu/v1alpha2
kind: Blueprint
project:
  slug: collecte-evenements
  name: Collecte d'événements
  environments:
    - slug: production
      name: Production
      addons:
        - slug: bus
          name: Bus d'événements
          templateKey: nats
          version: "2.11"
        - slug: evenements
          name: Événements
          templateKey: mongodb
          version: "8"
          backupEnabled: true
      services:
        - slug: ingestion
          name: Point d'entrée
          type: web
          source:
            imageRef: redpandadata/connect:4.115.1
          portsExposes: "4195"
          publiclyExposed: true
          resources: { cpuMillicores: 250, ramMb: 256 }
          env:
            - key: INGEST_PASSWORD_HASH
              fromSecret: true
          bindings:
            - addon: bus
              envVarKey: NATS_URL
          files:
            - mountPath: /connect.yaml
              content: |
                http:
                  basic_auth:
                    enabled: true
                    username: collecte
                    password_hash: ${INGEST_PASSWORD_HASH}
                    algorithm: sha256
                input:
                  http_server:
                    path: /events
                    allowed_verbs: [POST]
                output:
                  nats:
                    urls: ["${NATS_URL}"]
                    subject: events.received
        - slug: ecriture
          name: Écriture des événements
          type: worker
          source:
            imageRef: redpandadata/connect:4.115.1
          resources: { cpuMillicores: 250, ramMb: 256 }
          bindings:
            - addon: bus
              envVarKey: NATS_URL
            - addon: evenements
              envVarKey: MONGODB_URL
          files:
            - mountPath: /connect.yaml
              content: |
                input:
                  nats:
                    urls: ["${NATS_URL}"]
                    subject: events.received
                    queue: ecriture
                pipeline:
                  processors:
                    - mapping: |
                        root = this
                        root.received_at = now()
                output:
                  mongodb:
                    url: ${MONGODB_URL}
                    database: collecte
                    collection: events
                    operation: insert-one
                    document_map: root = this
        - slug: archivage
          name: Archivage des messages bruts
          type: worker
          source:
            imageRef: redpandadata/connect:4.115.1
          resources: { cpuMillicores: 250, ramMb: 256 }
          bindings:
            - addon: bus
              envVarKey: NATS_URL
            - addon: evenements
              envVarKey: MONGODB_URL
          files:
            - mountPath: /connect.yaml
              content: |
                input:
                  nats:
                    urls: ["${NATS_URL}"]
                    subject: events.received
                    queue: archivage
                pipeline:
                  processors:
                    - mapping: |
                        root.subject = @nats_subject
                        root.payload = content().string()
                        root.archived_at = now()
                output:
                  mongodb:
                    url: ${MONGODB_URL}
                    database: collecte
                    collection: archives
                    operation: insert-one
                    document_map: root = this
        - slug: inspecteur
          name: Inspecteur MongoDB
          type: web
          source:
            imageRef: mongo-express:1.0.2-20-alpine3.19
          portsExposes: "8081"
          publiclyExposed: true
          resources: { cpuMillicores: 250, ramMb: 256 }
          env:
            - key: ME_CONFIG_BASICAUTH_USERNAME
              value: inspecteur
            - key: ME_CONFIG_BASICAUTH_PASSWORD
              fromSecret: true
          bindings:
            - addon: evenements
              envVarKey: ME_CONFIG_MONGODB_URL

Les liaisons posent NATS_URL et MONGODB_URL (identifiants compris) ; la plateforme les substitue dans les fichiers au déploiement. L’authentification de l’entrée est celle du serveur HTTP de Redpanda Connect, qui attend le mot de passe haché en SHA-256 puis encodé en base64 :

Fenêtre de terminal
printf '%s' 'votre-mot-de-passe' | openssl dgst -sha256 -binary | base64

Envoi d’un événement (utilisateur collecte) :

Fenêtre de terminal
curl -u collecte:votre-mot-de-passe -X POST https://<adresse-du-service>/events \
  -H 'Content-Type: application/json' -d '{"type":"commande","montant":42}'

Valeur à fournir à l’import :

{
  "production/ingestion": { "INGEST_PASSWORD_HASH": "<résultat de la commande ci-dessus>" },
  "production/inspecteur": { "ME_CONFIG_BASICAUTH_PASSWORD": "<mot de passe de l'inspecteur>" }
}

Ce montage utilise NATS en publication simple : chaque message va aux abonnés connectés, sans être conservé, et un lecteur arrêté manque les événements publiés pendant ce temps. L’add-on NATS embarque JetStream ; pour une livraison garantie, créez un flux sur le sujet events.received et remplacez l’entrée nats par nats_jetstream (consommateur durable).

Lire les données

Section intitulée « Lire les données »

Ouvrez l’adresse du service inspecteur et connectez-vous avec l’utilisateur inspecteur et le mot de passe fourni à l’import. La base collecte contient les collections events (avec received_at) et archives (avec subject et archived_at) : leur contenu prouve que toute la chaîne HTTP → NATS → MongoDB fonctionne. Sans ce mot de passe, l’image retombe sur un identifiant par défaut connu : ne la déployez jamais sans.