20. Production PM2 Cluster Deployment, Memory Leak Profiling (heapdump) & Healthchecks • Node.js Backend Architecture: Libuv to High-Scale Microservices • Rishabh Ki Kaksha

Node.js Backend Architecture: Libuv to High-Scale Microservices › 20. Production PM2 Cluster Deployment, Memory Leak Profiling (heapdump) & Healthchecks

50 mins

← Prev

Course Syllabus

Module 1: Node.js Internals, Libuv & Event Loop Architecture

01. Node.js Architecture: V8, Libuv, C++ Bindings & Non-Blocking I/O 02. Libuv Event Loop 6 Phases: Timers, Pending, Poll, Check (setImmediate) & Close 03. process.nextTick vs setImmediate vs queueMicrotask (Starvation Traps)

Module 2: Buffers, Binary Protocols & Stream Pipelines

04. Buffer Allocation: Buffer.alloc vs Buffer.allocUnsafe & Memory Security 05. Node.js Streams: Readable, Writable, Duplex & Transform Streams 06. Backpressure Management & stream.pipeline vs .pipe() Gotchas

Module 3: Enterprise Express & High-Scale REST API Architecture

07. Production Express Architecture: Controller-Service-Repository Pattern 08. Custom Global Error Handling, Async Handlers & Zod Request Validation 09. High-Performance Caching with Redis & Invalidation Strategies

Module 4: Authentication, Cryptography & Web Security

10. Authentication Architecture: JWT Access/Refresh Tokens & Sliding Sessions 11. Node.js Crypto Module: Password Hashing (Argon2 vs bcrypt) & AES-256-GCM 12. API Security Hardening: Helmet, CORS, Rate Limiting & OWASP Defenses

Module 5: Concurrency, Clustering & Worker Threads

13. Child Processes: spawn vs exec vs execFile vs fork 14. Multi-Core Clustering: Node.js Cluster Module & Zero-Downtime Reloads 15. Worker Threads (worker_threads) & SharedArrayBuffer for CPU-Bound Tasks

Module 6: Microservices, Message Queues (BullMQ/RabbitMQ) & Production Ops

16. Real-Time WebSockets Architecture: Socket.io with Redis Adapter Scaling 17. Asynchronous Task Queues with Redis & BullMQ (Retries, Backoff, Dead Letters) 18. Microservices Architecture: gRPC Protocols with Protocol Buffers in Node.js 19. Observability: Winston Structured Logging, OpenTelemetry & Prometheus Metrics 20. Production PM2 Cluster Deployment, Memory Leak Profiling (heapdump) & Healthchecks

Interactive Lesson Studio

# 20. Production PM2 Cluster Deployment, Memory Leak Profiling (heapdump) & Healthchecks

> Node.js Notes by Rishabh - Topic 20

---

### 1. Master Production PM2 Configuration (`ecosystem.config.js`) 👑

```javascript
module.exports = {
    apps: [
        {
            name: "rishabh-kaksha-api",
            script: "./dist/server.js",
            instances: "max",             // Auto-detects all available CPU Cores!
            exec_mode: "cluster",         // Multi-core cluster mode
            watch: false,
            max_memory_restart: "500M",   // Auto-restarts if memory leak crosses 500MB
            env_production: {
                NODE_ENV: "production",
                PORT: 3000
            },
            kill_timeout: 5000,           // 5s Graceful Shutdown window
            listen_timeout: 8000
        }
    ]
};
```

---

### 2. Graceful Shutdown Architecture (Zero Dropped Packets 🛡️)

Jab server restart ya redeploy hota hai:

```typescript
function setupGracefulShutdown(server: http.Server) {
    const shutdown = async (signal: string) => {
        console.log(`🛑 Received ${signal}. Starting Graceful Shutdown...`);

// 1. Stop accepting new connections:
        server.close(async () => {
            console.log("✅ HTTP server closed. Draining active connections...");

// 2. Close Database & Redis connections:
            await db.$disconnect();
            await redis.quit();

console.log("✅ All connections drained. Clean process exit.");
            process.exit(0);
        });

// 3. Force exit if cleanup takes > 10 seconds:
        setTimeout(() => {
            console.error("⚠️ Force exiting after timeout!");
            process.exit(1);
        }, 10000);
    };

process.on("SIGTERM", () => shutdown("SIGTERM"));
    process.on("SIGINT", () => shutdown("SIGINT"));
}
```

---

### 3. Memory Leak Hunting with V8 Heap Snapshots 🔬

Agar memory lagatar badhti ja rahi ho:

```typescript
import v8 from "v8";
import fs from "fs";

// Trigger heap snapshot on demand:
app.post("/admin/heapdump", (req, res) => {
    const snapshotStream = v8.getHeapSnapshot();
    const fileName = `heap-${Date.now()}.heapsnapshot`;
    const fileStream = fs.createWriteStream(fileName);
    snapshotStream.pipe(fileStream);
    res.json({ message: "Heap snapshot saved!", file: fileName });
});
```
*Chrome DevTools ➔ Memory Tab ➔ Load `.heapsnapshot` ➔ Compare Objects to find unreleased closures / global arrays!*

---

### 4. Kubernetes Liveness (`/healthz`) vs Readiness (`/ready`)

*   **Liveness Probe (`/healthz`):** Check karta hai ki process zinda hai ya deadlock ho chuki hai (Restart if failed).
*   **Readiness Probe (`/ready`):** Check karta hai ki DB aur Redis connected hain ya nahi (Don't route traffic if failed).

---

### 5. Master Comparison Matrix

---

### 6. Interview Ke 3 Sawal Is Topic Se

1. **`pm2 restart` aur `pm2 reload` me kya critical difference hai?** -> `pm2 restart` saare processes ko ek sath kill karke restart karta hai (downtime); `pm2 reload` 1-by-1 worker ko restart karta hai (0s zero-downtime).
2. **Node.js me memory leaks ke sabse common causes kya hote hain?** -> Global variables me objects append karna, `setInterval` aur event listeners ko unregister/cleanup na karna, aur closures me heavy data structures ko capture rakhna.
3. **Graceful shutdown me `server.close()` kya karta hai?** -> Naye incoming HTTP requests ko reject karta hai aur currently processing active requests ko complete hone ka waqt deta hai.

---
**Course Completed:** Node.js Backend Architecture (All 20 Lessons Completed!) 🎉🚀🔥⚡🏢

Loading lesson content...

JavaScript

Full IDE

Live Execution Terminal

Click "Execute Live" to run code.
                

Lesson Mastery AI Quiz

AI Doubt Solver

CERTIFICATE OF COMPLETION

Rishabh Gehlot

PHP 8+ & Laravel 11 Master Track