நீங்கள் எவ்வாறு கரையான வெளியேறலை செயல்படுத்துகிறீர்கள்?

Question

Accepted Answer

**கரையான வெளியேறல்** என்பது ஒரு சர்வர் ஒரு முடிவுரை சமிக்ஞை பெறும்போது சுத்தமாக நிறுத்துவது — விமான வேண்டுதல்களை முடிக்க, இணைப்புகளை (DB, முதலியன) மூட, மற்றும் வளங்களை வெளியிட — அதை இடிந்து விடுவதற்கும் அலாவ சுரியோட வேலை. இது பூஜ்யம் downtime விருந்து மற்றும் நம்பகத்வத்திற்கு உத்தாவதாகும்.

## ஏன் கொடூர வெளியேறல் ஒரு சிக்கல் ஆகும்

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

புறப்பட்டு மற்றும் autoscaling போது, செயல்முறைகள் தொடர்ந்து நிறுத்தப்படுகிறது — சுத்தமாக செய்யப்படுவது என்பது விருந்து வரிசை செயல்படுத்துவது.

## செயல்படுத்த

```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/பிற வளங்களை மூட → வெளியேறு. ஒரு **timeout fallback** இல்லாமல் வெளியேற, ஒன்று தொங்க வெளியேறல் நிறுத்த முடியாது.

## சமிக்ஞைகள்

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

## கொள்கலன் சூழல்களில்

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

## ஏன் இது முக்கியமானது

கரையான வெளியேறல் என்பது **பூஜ்யம் downtime விருந்து** மற்றும் நம்பகமான செயல்பாட்டை நவீன (குறிப்பாக கொள்கலன்/ஒழுங்கமாக) சூழல்களில் செயல்படுத்தும், செயல்முறைகள் வழக்கமாக நிறுத்தப்பட்டு மீண்டும் தொடங்கப்படுகின்றன.

தோல்வி இல்லாமல், ஒவ்வொரு வெளியேறல் அல்லது scale-down செயல்பாட்டு மற்றும் ஆபத்து தரவு ஒழுங்கமின்மை தூக்கியெறியும்.

கை சமிக்ஞை → நிறுத்து-ஆவர் → கொட்டைக்குறிப்பு → மூடு-வளங்கள் → வெளியேறு (timeout பாதுகாப்பு பிணையம்) என்பது உৎपादନ-தயாராய் Node சேவைகள் மற்றும் அடிக்கடி தவிர்க்கப்பட்ட ஆனால் முக்கியமான செயல்பாட்டு கவலை ஒரு பண்பு.