Come implementi un arresto elegante?

Question

Accepted Answer

**L'arresto elegante** significa fermare un server in modo pulito quando riceve un segnale di terminazione — completare le richieste in volo, chiudere le connessioni (DB, ecc.), e rilasciare le risorse — invece di ucciderlo bruscamente e di scartare il lavoro attivo. È essenziale per i deploy a zero-downtime e l'affidabilità.

## Perché l'arresto brusco è un problema

```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
```

Durante i deploy e l'autoscaling, i processi vengono costantemente fermati — farlo in modo pulito è ciò che rende i deploy fluidi.

## Implementarlo

```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 sequenza: cattura il segnale → `server.close()` (ferma le nuove connessioni, svuota quelle esistenti) → chiudi DB/Redis/altre risorse → esci. Un **fallback con timeout** forza l'uscita se qualcosa si blocca, quindi una connessione bloccata non può bloccare l'arresto per sempre.

## I segnali

```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
```

## Negli ambienti containerizzati

```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.
```

## Perché è importante

L'arresto elegante è ciò che consente i **deploy a zero-downtime** e l'operazione affidabile in ambienti moderni (soprattutto containerizzati/orchestrati), dove i processi vengono routinariamente fermati e riavviati.

Senza di esso, ogni deploy o scale-down scarta le richieste attive e rischia l'incoerenza dei dati.

Implementare la sequenza cattura-segnale → stop-accettazione → svuota → chiudi-risorse → esci (con una rete di sicurezza per timeout) è un tratto distintivo dei servizi Node pronti per la produzione e una preoccupazione operativa importante ma spesso trascurata.