Déployer le Hub Watchflare avec Docker

Déployez le Hub Watchflare avec Docker Compose. Inclut le fichier Compose complet, la génération des secrets, la configuration TimescaleDB, les volumes de données et les options de montage bind.

Le Hub est distribué sous la forme d’une seule image Docker qui embarque le tableau de bord web. Il s’exécute aux côtés d’un conteneur TimescaleDB pour le stockage persistant.

Astuce

Première fois ? Le démarrage rapide vous met en route en moins de 5 minutes.

Remarque

Vous préférez fonctionner sans Docker ? Voir Installation binaire (Linux) pour une installation en service systemd natif.

Prérequis

Docker Engine 20.10+
Docker Compose v2+
Deux ports ouverts : 8080 (HTTP) et 50051 (gRPC)

1. Créer le fichier Compose

Enregistrez ce qui suit sous docker-compose.yml dans un répertoire dédié :

services:
  watchflare:
    image: ghcr.io/watchflare-io/watchflare:latest
    container_name: watchflare
    ports:
      - "${HUB_PORT:-8080}:8080"
      - "${GRPC_PORT:-50051}:50051"
    environment:
      - POSTGRES_HOST=postgres
      - POSTGRES_PORT=5432
      - POSTGRES_USER=${POSTGRES_USER:-watchflare}
      - POSTGRES_PASSWORD=${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
      - POSTGRES_DB=${POSTGRES_DB:-watchflare}
      - POSTGRES_SSLMODE=disable
      - GRPC_PORT=${GRPC_PORT:-50051}
      - JWT_SECRET=${JWT_SECRET:?Set JWT_SECRET in .env}
      - NOTIFICATION_ENCRYPTION_KEY=${NOTIFICATION_ENCRYPTION_KEY:?Set NOTIFICATION_ENCRYPTION_KEY in .env}
      - TLS_MODE=${TLS_MODE:-auto}
      - TLS_PKI_DIR=/var/lib/watchflare/pki
      - GRPC_TIMESTAMP_WINDOW=${GRPC_TIMESTAMP_WINDOW:-300}
      - ENV=production
      - COOKIE_SECURE=${COOKIE_SECURE:-}
      - COOKIE_DOMAIN=${COOKIE_DOMAIN:-}
      - TRUSTED_PROXIES=${TRUSTED_PROXIES:-127.0.0.1,::1}
    volumes:
      - pki_data:/var/lib/watchflare/pki
    depends_on:
      postgres:
        condition: service_healthy
    networks:
      - watchflare_net
    restart: unless-stopped

  postgres:
    image: timescale/timescaledb:latest-pg16
    container_name: watchflare-postgres
    environment:
      POSTGRES_USER: ${POSTGRES_USER:-watchflare}
      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:?Set POSTGRES_PASSWORD in .env}
      POSTGRES_DB: ${POSTGRES_DB:-watchflare}
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-watchflare}"]
      interval: 10s
      timeout: 5s
      retries: 5
    networks:
      - watchflare_net
    restart: unless-stopped

volumes:
  pgdata:
    driver: local
  pki_data:
    driver: local

networks:
  watchflare_net:
    driver: bridge

2. Créer le fichier `.env`

Générez les trois secrets obligatoires. NOTIFICATION_ENCRYPTION_KEY chiffre les identifiants SMTP et les URL des canaux de notification au repos. Créez-la maintenant, même si vous ne prévoyez pas d’utiliser les notifications pour l’instant, car le fichier Compose exige qu’elle soit définie :

printf "POSTGRES_PASSWORD=%s\nJWT_SECRET=%s\nNOTIFICATION_ENCRYPTION_KEY=%s\n" \
  "$(openssl rand -base64 32)" \
  "$(openssl rand -base64 32)" \
  "$(openssl rand -base64 32)" > .env

$r = [System.Security.Cryptography.RandomNumberGenerator]
$h = { -join ($r::GetBytes(32) | % { '{0:x2}' -f $_ }) }
"POSTGRES_PASSWORD=$(& $h)", "JWT_SECRET=$(& $h)", "NOTIFICATION_ENCRYPTION_KEY=$(& $h)" | Set-Content .env

Remarque

Sous macOS, utilisez l’onglet Linux, car openssl est disponible par défaut.

3. Démarrer la stack

bash

$ docker compose up -d
[+] Running 3/3
✔ Network watchflare_watchflare_net  Created
✔ Container watchflare-postgres      Started
✔ Container watchflare               Started

Vérifiez que les deux conteneurs sont en cours d’exécution :

docker compose ps

Le Hub sera disponible sur http://your-host:8080.

Persistance des données

La stack utilise deux volumes Docker nommés :

Volume	Contenu
`pgdata`	Base PostgreSQL (métriques, hôtes, paquets, utilisateurs)
`pki_data`	CA TLS et certificat serveur (générés automatiquement au premier démarrage)

Les volumes nommés sont gérés par Docker, aucune configuration des permissions n’est donc nécessaire. Les données persistent après les redémarrages de conteneurs et les mises à jour d’image.

Montages bind

Par défaut, pgdata et pki_data sont des volumes nommés gérés par Docker. Pour stocker les données à un chemin précis sur l’hôte (par exemple pour les inclure dans un script de sauvegarde, inspecter les fichiers directement, ou migrer vers une autre machine), remplacez l’un, l’autre, ou les deux par un montage bind vers un répertoire de l’hôte.

Les deux volumes peuvent être remplacés indépendamment ou ensemble.

Données PKI (Hub, UID `65532`)

Le conteneur Hub s’exécute sous l’UID 65532. Le répertoire PKI doit appartenir à cet utilisateur avant le démarrage du conteneur :

mkdir -p /your/path/pki
sudo chown -R 65532:65532 /your/path/pki

Puis mettez à jour docker-compose.yml :

# Remplacer :
- pki_data:/var/lib/watchflare/pki
# Par :
- /your/path/pki:/var/lib/watchflare/pki

Retirez pki_data de la section volumes: en bas du fichier s’il ne sert plus.

Données de la base (TimescaleDB, UID `70`)

Le conteneur TimescaleDB exécute PostgreSQL sous l’UID 70. Le répertoire de données doit appartenir à cet utilisateur :

mkdir -p /your/path/pgdata
sudo chown -R 70:70 /your/path/pgdata

Puis mettez à jour docker-compose.yml :

# Remplacer :
- pgdata:/var/lib/postgresql/data
# Par :
- /your/path/pgdata:/var/lib/postgresql/data

Retirez pgdata de la section volumes: en bas du fichier s’il ne sert plus.

Attention

Ne copiez jamais un répertoire de données PostgreSQL tant que le conteneur est en cours d’exécution. Les fichiers seront dans un état incohérent. Utilisez pg_dump pour les sauvegardes à chaud, ou arrêtez d’abord la stack avec docker compose stop avant de copier.