ਤੁਸੀਂ graceful shutdown ਨੂੰ ਕਿਵੇਂ ਲਾਗੂ ਕਰਦੇ ਹੋ?

Question

Accepted Answer

**Graceful shutdown** ਦਾ ਮਤਲਬ ਹੈ ਕਿ ਇੱਕ ਸਰਵਰ ਨੂੰ ਸਾਫ ਤਰੀਕੇ ਨਾਲ ਬੰਦ ਕਰਨਾ ਜਦੋਂ ਇਹ ਇੱਕ ਸਮਾਪਤੀ ਸਿਗਨਲ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ — ਵਿਚ ਦੌੜ ਰਹੇ ਬੇਨਤੀਆਂ ਨੂੰ ਪੂਰਾ ਕਰਨਾ, ਕੁਨੈਕਸ਼ਨਾਂ ਨੂੰ ਬੰਦ ਕਰਨਾ (DB, ਆਦਿ), ਅਤੇ ਸਰੋਤਾਂ ਨੂੰ ਮੁਕਤ ਕਰਨਾ — ਬਜਾਏ ਇਸਦੇ ਕਿ ਇਸ ਨੂੰ ਅਚਾਨਕ ਮਾਰਿਆ ਜਾਵੇ ਅਤੇ ਕਿਰਿਆਸ਼ੀਲ ਕੰਮ ਨੂੰ ਡਰਾਪ ਕੀਤਾ ਜਾਵੇ। ਇਹ zero-downtime ਡਿਪਲਾਏ ਅਤੇ ਭਰੋਸੇ ਯੋਗਤਾ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।

## ਅਚਾਨਕ shutdown ਇੱਕ ਸਮੱਸਿਆ ਕਿਉਂ ਹੈ

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

Deploy ਅਤੇ autoscaling ਦੌਰਾਨ, ਪ੍ਰਕਿਰਿਆਵਾਂ ਮੁਲਤਵੀ ਬੰਦ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ — ਇਸ ਨੂੰ ਸਾਫ ਤਰੀਕੇ ਨਾਲ ਕਰਨਾ ਉਹ ਹੈ ਜੋ deployment ਨੂੰ ਸੁਚਾਲੂ ਬਣਾਉਂਦਾ ਹੈ।

## ਇਸ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

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

ਕ੍ਰਮ: ਸਿਗਨਲ ਨੂੰ ਫੜੋ → `server.close()` (ਨਵੇ ਕੁਨੈਕਸ਼ਨਾਂ ਨੂੰ ਬੰਦ ਕਰੋ, ਮੌਜੂਦਾ ਨੂੰ ਖਾਲੀ ਕਰੋ) → DB/Redis/ਹੋਰ ਸਰੋਤਾਂ ਨੂੰ ਬੰਦ ਕਰੋ → exit। ਇੱਕ **timeout fallback** force-exit ਕਰਦਾ ਹੈ ਜੇ ਕੁਝ ਹੈਂਗ ਹੋ ਜਾਵੇ, ਇਸ ਲਈ ਇੱਕ ਸਟਕ ਕੁਨੈਕਸ਼ਨ shutdown ਨੂੰ ਹਮੇਸ਼ਾ ਲਈ ਬਲਾਕ ਨਹੀਂ ਕਰ ਸਕਦਾ।

## ਸਿਗਨਲ

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

## containerized ਵਾਤਾਵਰਨ ਵਿੱਚ

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

## ਇਹ ਕਿਉਂ ਮਾਇਨੇ ਰੱਖਦਾ ਹੈ

Graceful shutdown ਉਹ ਹੈ ਜੋ **zero-downtime deployments** ਅਤੇ ਆਧੁਨਿਕ (ਖਾਸ ਕਰ ਕੇ containerized/orchestrated) ਵਾਤਾਵਰਨ ਵਿੱਚ ਭਰੋਸੇ ਯੋਗ ਆਪਰੇਸ਼ਨ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ, ਜਿੱਥੇ ਪ੍ਰਕਿਰਿਆਵਾਂ ਨਿਯਮਿਤ ਤੌਰ 'ਤੇ ਬੰਦ ਅਤੇ ਮੁੜ ਸ਼ੁਰੂ ਕੀਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ।

ਇਸ ਤੋਂ ਬਿਨਾ, ਹਰ deploy ਜਾਂ scale-down ਕਿਰਿਆਸ਼ੀਲ ਬੇਨਤੀਆਂ ਨੂੰ ਡਰਾਪ ਕਰਦਾ ਹੈ ਅਤੇ ਡਾਟਾ ਅਸੰਗਤਤਾ ਦਾ ਖਤਰਾ ਹੁੰਦਾ ਹੈ।

Catch-signal → stop-accepting → drain → close-resources → exit ਕ੍ਰਮ ਨੂੰ ਲਾਗੂ ਕਰਨਾ (ਇੱਕ timeout ਸੁਰੱਖਿਆ ਜਾਲ ਦੇ ਨਾਲ) production-ready Node ਸੇਵਾਵਾਂ ਦੀ ਇੱਕ ਪਛਾਣ ਹੈ ਅਤੇ ਇੱਕ ਅਕਸਰ-ਨਜ਼ਰ ਅੰਦਾਜ਼ ਪਰ ਮਹੱਤਵਪੂਰਨ ਆਪਰੇਸ਼ਨ ਸਮੱਸਿਆ ਹੈ।