Comment implémentez-vous un arrêt gracieux ?

Question

Accepted Answer

**L'arrêt gracieux** signifie arrêter proprement un serveur lorsqu'il reçoit un signal de terminaison — terminer les requêtes en cours, fermer les connexions (DB, etc.) et libérer les ressources — au lieu de le tuer brutalement et de perdre les travaux actifs. Il est essentiel pour les déploiements sans interruption et la fiabilité.

## Pourquoi l'arrêt brutal est un problème

```text
Without graceful shutdown, when the process is killed (deploy, scale-down, crash):
  ✗ In-flight requests are dropped → users get errors
  ✗ DB transactions left incomplete
  ✗ Connections not closed cleanly → leaks/locks
```

Pendant les déploiements et la mise à l'échelle automatique, les processus sont arrêtés constamment — le faire proprement est ce qui rend les déploiements transparents.

## L'implémenter

```js
import http from "http";
const server = http.createServer(app);
server.listen(3000);

async function shutdown(signal) {
  console.log(`${signal} received — shutting down gracefully`);

// 1. Stop accepting NEW connections; finish existing ones
  server.close(async () => {
    // 2. This callback runs once all active requests have completed
    await db.end();            // close database pool
    await redis.quit();        // close other connections
    console.log("clean shutdown complete");
    process.exit(0);           // exit successfully
  });

// 3. Safety net: force-exit if cleanup hangs too long
  setTimeout(() => {
    console.error("forced shutdown — cleanup timed out");
    process.exit(1);
  }, 10_000).unref();
}

// Listen for termination signals
process.on("SIGTERM", () => shutdown("SIGTERM")); // sent by orchestrators (k8s, Docker)
process.on("SIGINT", () => shutdown("SIGINT"));   // Ctrl+C in dev
```

La séquence : capturer le signal → `server.close()` (arrêter les nouvelles connexions, drainer les existantes) → fermer DB/Redis/autres ressources → quitter. Un **délai d'expiration de secours** force la sortie si quelque chose se bloque, donc une connexion coincée ne peut pas bloquer l'arrêt indéfiniment.

## Les signaux

```text
SIGTERM → the standard "please terminate" signal from orchestrators on deploy/scale-down
SIGINT  → Ctrl+C (development)
SIGKILL → cannot be caught (force kill) — graceful shutdown can't help here
```

## Dans les environnements conteneurisés

```text
Kubernetes/Docker send SIGTERM, wait a grace period (e.g. 30s), THEN SIGKILL.
Your app must finish within that window → keep the shutdown timeout shorter.
Readiness probes should mark the pod unready so the load balancer stops sending traffic.
```

## Pourquoi c'est important

L'arrêt gracieux est ce qui permet les **déploiements sans interruption** et le fonctionnement fiable dans les environnements modernes (notamment conteneurisés/orchestrés), où les processus sont régulièrement arrêtés et redémarrés.

Sans cela, chaque déploiement ou réduction d'échelle abandonne les requêtes actives et risque une incohérence des données.

L'implémentation de la séquence capturer-signal → arrêter-acceptation → drainer → fermer-ressources → quitter (avec un filet de sécurité de délai d'expiration) est une caractéristique des services Node prêts pour la production et une préoccupation opérationnelle souvent négligée mais importante.