Un déploiement qui redémarre simplement le process applicatif produit presque toujours une coupure de quelques secondes, souvent invisible en local, mais parfaitement visible en production sous charge : requêtes qui échouent avec une erreur de connexion, WebSocket coupé, utilisateur en plein formulaire qui perd sa session. "Zero-downtime" n'est pas une case à cocher dans la configuration d'un hébergeur, c'est un ensemble de garanties à construire à plusieurs niveaux : routage, process, base de données.

Le problème concret

Supposons une API Node.js/NestJS derrière un reverse proxy, déployée via Docker. Le déploiement naïf consiste à arrêter le container, tirer la nouvelle image, démarrer le nouveau container. Entre l'arrêt de l'ancien et la disponibilité du nouveau, toute requête entrante échoue. Même avec un démarrage rapide (quelques secondes), sous un trafic suffisant, ça représente des centaines de requêtes en erreur.

Le mécanisme de base : rolling deployment avec health checks

L'idée centrale du zero-downtime est de ne jamais couper l'ancienne version avant que la nouvelle soit prouvée saine et prête à recevoir du trafic. Avec Docker Compose et un orchestrateur simple, ou avec Kubernetes, le principe est le même : démarrer la nouvelle instance en parallèle, attendre qu'elle réponde correctement à un health check, basculer le trafic, puis seulement ensuite arrêter l'ancienne.

# Exemple Kubernetes : rolling update avec readinessProbe
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-backend
spec:
  replicas: 3
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 0
      maxSurge: 1
  template:
    spec:
      containers:
        - name: api
          image: registry.example.com/api:v2.4.0
          readinessProbe:
            httpGet:
              path: /health/ready
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 3
          livenessProbe:
            httpGet:
              path: /health/live
              port: 3000
            initialDelaySeconds: 10
            periodSeconds: 10

maxUnavailable: 0 garantit qu'aucune instance saine n'est retirée avant qu'une nouvelle instance saine la remplace. readinessProbe distingue "le process tourne" (livenessProbe) de "le process est prêt à recevoir du trafic utilisateur" (readinessProbe) - une distinction cruciale, car un process Node.js peut démarrer en quelques millisecondes tout en n'ayant pas encore établi sa connexion à PostgreSQL ou chargé son cache.

// NestJS : endpoint de readiness qui vérifie les dépendances critiques
@Controller("health")
export class HealthController {
  constructor(
    private readonly dataSource: DataSource,
    private readonly redis: Redis,
  ) {}

  @Get("ready")
  async ready() {
    await this.dataSource.query("SELECT 1");
    await this.redis.ping();
    return { status: "ok" };
  }

  @Get("live")
  live() {
    return { status: "ok" };
  }
}

Le problème des connexions en vol

Même avec un routage parfait, arrêter brutalement un process qui a des requêtes HTTP en cours de traitement, ou des connexions WebSocket ouvertes, coupe ces connexions. La correction est le graceful shutdown : à la réception du signal SIGTERM, le process doit arrêter d'accepter de nouvelles connexions, laisser les requêtes en cours se terminer, puis quitter.

// main.ts (NestJS)
async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  app.enableShutdownHooks();

  process.on("SIGTERM", async () => {
    console.log("SIGTERM reçu, arrêt progressif...");
    await app.close(); // laisse les requêtes en cours se terminer
    process.exit(0);
  });

  await app.listen(3000);
}
bootstrap();

Il faut aussi laisser un délai de grâce suffisant entre le SIGTERM et le SIGKILL forcé (terminationGracePeriodSeconds en Kubernetes, souvent 30 secondes par défaut) pour que les requêtes longues (upload de fichier, génération de rapport) aient le temps de se terminer plutôt que d'être tuées brutalement.

Le vrai piège : les migrations de base de données

C'est là que la plupart des déploiements "zero-downtime" échouent en pratique. Pendant un rolling deployment, l'ancienne version et la nouvelle version du code tournent simultanément pendant plusieurs secondes à plusieurs minutes, et les deux interrogent la même base de données. Une migration qui renomme une colonne ou supprime une colonne encore utilisée par l'ancien code casse l'ancienne version en plein trafic.

-- MAUVAIS : casse l'ancienne version du code pendant le rollout
ALTER TABLE orders RENAME COLUMN client_id TO customer_id;

La bonne approche est la migration en plusieurs étapes rétrocompatibles, déployées sur plusieurs releases distinctes :

-- Étape 1 (release N) : ajouter la nouvelle colonne, sans toucher l'ancienne
ALTER TABLE orders ADD COLUMN customer_id INT;

-- Le code de la release N écrit dans les DEUX colonnes (client_id et customer_id)
-- et lit encore depuis client_id.

-- Étape 2 (release N+1, une fois N entièrement déployée) :
-- backfill des lignes existantes
UPDATE orders SET customer_id = client_id WHERE customer_id IS NULL;

-- Le code de la release N+1 lit désormais customer_id.

-- Étape 3 (release N+2, une fois N+1 stable) :
-- suppression de l'ancienne colonne, devenue inutile
ALTER TABLE orders DROP COLUMN client_id;

Ce pattern "expand / migrate / contract" s'applique à toute modification de schéma qui change un contrat déjà consommé par du code en production : renommage de colonne, changement de type, suppression de table. Il demande de la discipline (plusieurs releases pour un seul changement de schéma) mais c'est le prix du zero-downtime réel.

Rolling, blue-green, canary : trois stratégies, trois compromis

Le rolling deployment décrit plus haut n'est qu'une des stratégies possibles, et le choix dépend du niveau de risque acceptable et de la capacité d'infrastructure disponible.

Le blue-green deployment maintient deux environnements de production complets et identiques (bleu et vert). La nouvelle version est déployée entièrement sur l'environnement inactif, testée en conditions réelles sans trafic utilisateur, puis le routeur bascule instantanément tout le trafic d'un environnement à l'autre. L'avantage est un rollback immédiat : si un problème apparaît, on rebascule le routeur vers l'environnement précédent en quelques secondes, sans avoir à redéployer quoi que ce soit. Le coût est de maintenir deux fois la capacité d'infrastructure, au moins pendant la fenêtre de transition.

# Exemple simplifié avec un load balancer piloté par tag
# 1. Déployer la nouvelle version sur l'environnement "green"
kubectl apply -f deployment-green.yaml
kubectl rollout status deployment/api-green

# 2. Basculer le service vers green une fois les vérifications passées
kubectl patch service api-service -p '{"spec":{"selector":{"env":"green"}}}'

# 3. En cas de problème, rollback instantané vers blue
kubectl patch service api-service -p '{"spec":{"selector":{"env":"blue"}}}'

Le canary deployment route une petite fraction du trafic réel (5%, puis 25%, puis 100% progressivement) vers la nouvelle version, tout en surveillant les métriques d'erreur et de latence à chaque palier. C'est la stratégie la plus prudente pour détecter un bug qui ne se révèle que sous trafic réel (un cas limite dans les données de production que les tests n'ont pas couvert), au prix d'une mise en œuvre plus complexe : il faut un routage pondéré au niveau du load balancer ou du service mesh, et une définition claire des métriques qui déclenchent un rollback automatique.

Le rolling deployment reste le choix par défaut le plus répandu parce qu'il ne demande ni infrastructure doublée ni routage pondéré sophistiqué, mais il offre moins de garanties de rollback instantané qu'un blue-green : revenir en arrière signifie redéployer l'ancienne version, pas simplement basculer un pointeur.

Le drainage des connexions à la base de données

Un angle mort fréquent du graceful shutdown applicatif concerne le pool de connexions à la base de données. Fermer le serveur HTTP ne suffit pas si le pool de connexions PostgreSQL reste ouvert et que l'orchestrateur tue le process avant que les connexions actives n'aient été proprement libérées : ça peut laisser des transactions à moitié engagées ou des verrous non relâchés jusqu'au timeout de la connexion côté serveur de base de données.

process.on("SIGTERM", async () => {
  await app.close();        // arrête d'accepter de nouvelles requêtes HTTP
  await dataSource.destroy(); // ferme proprement le pool de connexions PostgreSQL
  process.exit(0);
});

L'ordre compte : fermer d'abord la couche HTTP pour que plus aucune nouvelle requête ne tente d'utiliser une connexion, laisser les requêtes en cours se terminer naturellement (ce que fait app.close() dans NestJS en attendant les handlers actifs), puis seulement ensuite fermer le pool de base de données. Inverser l'ordre risque de faire échouer des requêtes en cours avec une erreur de connexion perdue, un symptôme qui ressemble à un bug applicatif mais qui est en réalité un problème de séquencement du shutdown.

Diagnostiquer un déploiement qui coupe encore le service

Les symptômes typiques à chercher dans les logs et le monitoring au moment précis d'un déploiement :

  • Pic d'erreurs 502/503 côté reverse proxy : health check absent ou mal configuré, ou maxUnavailable non nul.
  • Erreurs applicatives column does not exist juste après un déploiement : migration non rétrocompatible, ancienne version encore en train de servir du trafic.
  • Connexions WebSocket qui se coupent en masse à heure fixe : absence de graceful shutdown, SIGKILL trop rapide après le SIGTERM.

Quand ça ne suffit pas

Pour des migrations lourdes sur de très grosses tables (des dizaines de millions de lignes), même un ALTER TABLE ADD COLUMN rétrocompatible peut verrouiller la table assez longtemps pour impacter la latence, selon le moteur de base de données et sa version. PostgreSQL gère bien ADD COLUMN avec valeur par défaut depuis la version 11 sans réécriture complète de table, mais un backfill par UPDATE massif doit être fait par petits lots (batch) avec des pauses, pas en une seule transaction, pour éviter de saturer les connexions ou de bloquer des écritures concurrentes.

À retenir

Le zero-downtime réel repose sur trois garanties indépendantes qui doivent toutes être vraies en même temps : le routage ne bascule jamais vers une instance qui n'a pas prouvé sa santé, le process sortant termine son travail en cours avant de mourir, et le schéma de base de données reste compatible avec deux versions du code qui tournent en parallèle pendant la transition. Oublier la troisième est la cause la plus fréquente d'incidents malgré une infrastructure de déploiement par ailleurs correcte.