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

Question

IT Interview Practice · 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.

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

L'implémenter

Les signaux

Dans les environnements conteneurisés

Pourquoi c'est important

Questions connexes