01 Une seule machine

Le jeu tient sur une instance OVHcloud Public Cloud, dans la région de Paris : un modèle B3-16, avec 4 processeurs virtuels, 16 Go de mémoire et un disque de 100 Go, sous Debian 13. Pas de répartiteur de charge, pas de base de données managée, pas d'orchestrateur : Docker Compose, un fichier compose.yaml, et quelques scripts shell.

Ce choix tient à la forme du trafic. Les joueurs arrivent surtout le matin, pour la grille du jour, et chaque requête coûte peu : sur huit heures de production, PostgreSQL a passé 4,6 secondes au total à exécuter du SQL, 0,03 ms par requête en moyenne. Le goulot est le processeur Python, et je le règle avec le nombre de workers, pas avec plus de machines.

Au moment où tu lis ces lignes, la machine utilise moins de 2 Go de mémoire sur 16. Le reste sert de cache disque au noyau, ce qui profite surtout à PostgreSQL.

Les quatorze conteneurs, par rôle :

Rôle Conteneurs
Entrée caddy : HTTPS, certificats, routage
Application app-blue et app-green, deux copies du même service
Données db (PostgreSQL 18) et redis (la présence du temps réel)
Temps réel live, le serveur WebSocket en Rust
Journaux vector et victorialogs
Métriques victoriametrics, node-exporter, postgres-exporter et grafana
Préproduction app-preprod et db-preprod

02 Du commit au serveur

Rien ne se déploie à la main. Chaque push sur la branche principale lance la CI (lint, typage, tests sur un vrai PostgreSQL) ; si elle passe, le workflow de déploiement prend le relais.

push main branch CI lint, types, tests image GHCR, tag = SHA SSH The instance deploy.sh 1 pulls the image into the free color 2 migrations and stations 3 starts app-green, waits for /health 4 hot-reloads Caddy 5 stops app-blue, kept in reserve Caddy before after app-blue app-green only one color serves at a time
Du push à la production : la CI, l'image, puis la bascule sur l'instance.

L'image Docker est construite en deux étapes. Une étape Node compile et minifie le TypeScript et le CSS, puis disparaît : Node n'est pas dans l'image finale. L'étape finale part d'une Debian minimale, installe Python et les dépendances verrouillées avec uv, copie le code et les fichiers du front, et hache les noms des fichiers statiques pour qu'ils se mettent en cache un an. L'image est étiquetée par le SHA du commit et publiée sur le registre de GitHub.

Le workflow copie ensuite compose.yaml et les scripts sur l'instance par SSH, et lance deploy.sh. Les secrets suivent le même chemin : chaque secret de l'environnement GitHub nommé ENV_<NOM> est écrit dans le .env de l'instance, sans jamais passer sur une ligne de commande.

03 Bleu et vert

Pour déployer sans coupure, l'application existe en deux exemplaires, app-blue et app-green. Un seul sert à la fois. deploy.sh démarre l'autre avec la nouvelle image, attend qu'il réponde sur /health, puis dit à Caddy de changer de cible :

SH
echo "to app-$next:8000" > caddy/upstream.caddy.tmp
mv caddy/upstream.caddy.tmp caddy/upstream.caddy
docker compose exec -T caddy caddy reload --config /etc/caddy/Caddyfile

Le rechargement de Caddy est à chaud : les requêtes en cours finissent sur l'ancienne version, les nouvelles partent vers la nouvelle. L'ancienne reçoit ensuite un SIGTERM et dispose de 30 secondes pour finir son travail.

L'ancienne couleur n'est pas supprimée, seulement arrêtée. Si la nouvelle version a un problème, rollback.sh la redémarre et rebascule Caddy en quelques secondes.

Le serveur temps réel, lui, n'a pas besoin de ce ballet : il ne tient que des connexions WebSocket, que les navigateurs rouvrent d'eux-mêmes quand il redémarre.

04 Caddy devant tout

Caddy est le seul conteneur joignable depuis Internet, sur les ports 80 et 443. Il obtient et renouvelle seul les certificats Let's Encrypt de tous les domaines, compresse les réponses, et route : /live/* vers le serveur temps réel, le reste vers la couleur active.

Il fait aussi deux choses pour l'application. Il écrit l'adresse du client dans X-Real-IP, en écrasant ce que le client aurait envoyé, si bien que l'application peut lui faire confiance. Et il donne à chaque requête un identifiant, que l'application renvoie dans X-Request-Id et écrit dans ses journaux : avec lui, je retrouve tout ce qu'une requête lente a fait.

Caddy ne tient pas de journal d'accès. Il y écrirait l'adresse IP de chaque joueur, et c'est une donnée personnelle dont le jeu n'a pas besoin.

05 Ce qui tourne tout seul

Trois tâches cron lancent des commandes dans le conteneur actif :

  • La grille du jour, toutes les heures. Le serveur est à l'heure UTC alors que le jour de jeu est celui de Paris : la première exécution après minuit, heure de Paris, crée la grille, les suivantes ne font rien.
  • Les rappels, toutes les heures aussi, qui n'envoient des notifications qu'à 8 h et 20 h, heure de Paris.
  • Les sauvegardes, à chaque heure pile : un pg_dump de la base, gardé 48 heures, et celui de 4 h gardé 14 jours. Quand un bucket Object Storage est configuré, chaque dump y est aussi copié, chiffré avec age, hors de l'instance : une sauvegarde qui disparaît avec la machine n'en est pas une.

Côté système, unattended-upgrades applique les mises à jour de sécurité de Debian, et le pare-feu ne laisse entrer que SSH, HTTP et HTTPS.

Un piège à connaître : Docker contourne le pare-feu pour les ports qu'il publie. La base, VictoriaLogs, VictoriaMetrics et Grafana publient donc leur port sur 127.0.0.1 seulement. Je les atteins depuis l'instance, ou par un tunnel SSH, jamais directement depuis l'extérieur :

YAML
ports:
  - "127.0.0.1:5432:5432"

06 Voir ce qui se passe

Les erreurs non gérées partent vers Sentry. Pour le reste, deux piles tournent sur la machine elle-même.

Les journaux. L'application et le serveur temps réel écrivent un objet JSON par ligne. Vector lit les fichiers de journaux de Docker directement sur le disque, en lecture seule, plutôt que par le socket Docker : ce socket donne les droits root sur la machine, et un collecteur de journaux n'a pas à les avoir. Il ajoute à chaque ligne son service et son environnement, puis l'envoie à VictoriaLogs, qui garde 30 jours et 5 Gio au plus. Les deux couleurs y portent le même nom, service:app, pour qu'une recherche ne dépende pas de la couleur active :

TEXT
service:app environment:production status:>=500

Les métriques. VictoriaMetrics relève toutes les 30 secondes les chiffres de la machine (processeur, mémoire, disque) et ceux de PostgreSQL (connexions, transactions, taille), et les garde 30 jours. Grafana affiche les deux sources sur des tableaux de bord. Chacun de ces conteneurs a une limite de mémoire, et le déploiement ne les attend pas : si Grafana ne démarre pas, le site, lui, est déployé quand même.

Les journaux et Grafana sont aussi branchés à Claude Code par deux serveurs MCP. Je peux donc demander, en langage courant, quelles requêtes ont échoué cette nuit ou comment la mémoire a évolué pendant le pic du matin.

07 Ce qui a déjà mordu

En regardant s'il restait assez de place pour Grafana, j'ai trouvé 41 Go occupés sur le disque. La base pesait moins de 200 Mo, et les sauvegardes 47 Mo. Le reste, c'étaient 273 images Docker, dont 11 servaient encore.

La cause tenait en une option. Le script de déploiement nettoyait les images avec docker image prune -f, qui ne supprime que les images sans étiquette. Or chaque déploiement tire une image étiquetée par son commit : elle gardait son étiquette, et restait là pour toujours. Le nettoyage utilise maintenant -a, qui supprime toute image qu'aucun conteneur n'utilise. La couleur arrêtée garde la sienne, puisque son conteneur existe encore, et le retour arrière marche toujours.