Wie implementieren Sie elegantes Herunterfahren?

Question

IT Interview Practice · Accepted Answer

**Elegantes Herunterfahren** bedeutet, einen Server sauber zu stoppen, wenn er ein Beendigungssignal erhält — laufende Anfragen zu beenden, Verbindungen (Datenbank usw.) zu schließen und Ressourcen freizugeben — anstatt ihn abrupt zu beenden und aktive Arbeiten zu verlieren. Es ist für ausfallfreie Bereitstellungen und Zuverlässigkeit unerlässlich.

## Warum abruptes Herunterfahren ein Problem ist

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

Während Bereitstellungen und automatischer Skalierung werden Prozesse ständig gestoppt — dies sauber zu tun ist das, was Bereitstellungen nahtlos macht.

## Implementierung

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

Die Abfolge: Signal abfangen → `server.close()` (neue Verbindungen stoppen, bestehende leeren) → Datenbank/Redis/andere Ressourcen schließen → beenden. Ein **Timeout-Fallback** erzwingt den Ausstieg, wenn etwas hängt bleibt, damit eine hängend gebliebene Verbindung das Herunterfahren nicht auf Dauer blockiert.

## Die Signale

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

## In containerisierten Umgebungen

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

## Warum es wichtig ist

Elegantes Herunterfahren ist das, was **ausfallfreie Bereitstellungen** und zuverlässigen Betrieb in modernen (besonders containerisierten/orchestrierten) Umgebungen ermöglicht, in denen Prozesse routinemäßig gestoppt und neu gestartet werden.

Ohne es fallen bei jeder Bereitstellung oder beim Herunterskalieren aktive Anfragen weg und es besteht das Risiko von Dateiinkonsistenzen.

Die Implementierung der Abfolge Signal-abfangen → Akzeptieren-stoppen → Leeren → Ressourcen-schließen → Beenden (mit einem Timeout-Sicherheitsnetz) ist ein Merkmal von produktionsreifen Node-Services und ein häufig übersehener, aber wichtiger operativer Aspekt.

Warum abruptes Herunterfahren ein Problem ist

Implementierung

Die Signale

In containerisierten Umgebungen

Warum es wichtig ist

Ähnliche Fragen