로드 밸런싱과 수평적 확장

최대 앱 연결 = maxReplicas × processesPerPod × poolSizePerProcess

import cluster from 'node:cluster';
import { availableParallelism } from 'node:os';
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

const workerTarget = Math.max(1, availableParallelism());
const restartWindowMs = 60_000;
const maxRestartsPerWindow = 5;
const restartTimes: number[] = [];
const pendingRestarts = new Set<NodeJS.Timeout>();
let shuttingDown = false;

async function bootstrap() {
  const app = await NestFactory.create(AppModule);
  await app.listen(3000);
}

if (cluster.isPrimary) {
  const forkWorker = () => cluster.fork();
  const stopCluster = () => {
    if (shuttingDown) return;
    shuttingDown = true;
    for (const timer of pendingRestarts) clearTimeout(timer);
    pendingRestarts.clear();
    cluster.disconnect(() => process.exit(1));
    setTimeout(() => process.exit(1), 10_000).unref();
  };

  for (let index = 0; index < workerTarget; index += 1) {
    forkWorker();
  }

  cluster.on('exit', (worker, code, signal) => {
    if (shuttingDown) return;
    const now = Date.now();
    while (restartTimes[0] && now - restartTimes[0] > restartWindowMs) {
      restartTimes.shift();
    }
    restartTimes.push(now);

    console.error('worker exited', {
      pid: worker.process.pid,
      code,
      signal,
    });

    if (restartTimes.length > maxRestartsPerWindow) {
      console.error('restart budget exhausted; let the process supervisor intervene');
      stopCluster();
      return;
    }

    const delayMs = Math.min(1_000 * 2 ** (restartTimes.length - 1), 30_000);
    const timer = setTimeout(() => {
      pendingRestarts.delete(timer);
      if (!shuttingDown) forkWorker();
    }, delayMs);
    pendingRestarts.add(timer);
  });
} else {
  void bootstrap();
}

FROM node:24.19-alpine AS build
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

FROM node:24.19-alpine AS production-deps
WORKDIR /app
COPY package*.json ./
RUN npm ci --omit=dev && npm cache clean --force

FROM node:24.19-alpine AS runtime
ENV NODE_ENV=production
WORKDIR /app
COPY --chown=node:node package*.json ./
COPY --from=production-deps --chown=node:node /app/node_modules ./node_modules
COPY --from=build --chown=node:node /app/dist ./dist
USER node
EXPOSE 3000
CMD ["node", "dist/main.js"]

docker build -t ghcr.io/example/nestjs-app:2026.08.25-1 .
docker push ghcr.io/example/nestjs-app:2026.08.25-1

import { Controller, Get } from '@nestjs/common';
import { DataSource } from 'typeorm';

@Controller('health')
export class HealthController {
  constructor(private readonly dataSource: DataSource) {}

  @Get('startup')
  startup() {
    return { status: 'ok' };
  }

  @Get('live')
  live() {
    return { status: 'ok' };
  }

  @Get('ready')
  async ready() {
    await this.dataSource.query('SELECT 1');
    return { status: 'ok' };
  }
}

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nestjs-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nestjs-app
  template:
    metadata:
      labels:
        app: nestjs-app
    spec:
      containers:
        - name: app
          image: ghcr.io/example/nestjs-app:2026.08.25-1
          ports:
            - name: http
              containerPort: 3000
          env:
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: nestjs-app-secrets
                  key: database-url
            - name: DB_POOL_SIZE
              value: "8"
          resources:
            requests:
              cpu: 250m
              memory: 256Mi
            limits:
              cpu: "1"
              memory: 512Mi
          startupProbe:
            httpGet:
              path: /health/startup
              port: http
            periodSeconds: 2
            failureThreshold: 30
          readinessProbe:
            httpGet:
              path: /health/ready
              port: http
            periodSeconds: 5
            timeoutSeconds: 2
            failureThreshold: 3
          livenessProbe:
            httpGet:
              path: /health/live
              port: http
            periodSeconds: 10
            timeoutSeconds: 2
            failureThreshold: 3

apiVersion: v1
kind: Service
metadata:
  name: nestjs-app
spec:
  type: LoadBalancer
  selector:
    app: nestjs-app
  ports:
    - name: http
      protocol: TCP
      port: 80
      targetPort: http

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nestjs-app
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nestjs-app
  minReplicas: 3
  maxReplicas: 12
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 65