일반 시스템:
PID 1 (systemd) → PID 100 (nginx) → PID 101 (worker)
                                  → PID 102 (worker)
  ↑ 신호 전달 + 좀비 회수 담당

컨테이너 (tini 없이):
PID 1 (node server.js) → PID 50 (child process)
  ↑ 앱이 직접 PID 1 — init 역할 수행 불가

# 방법 1: tini를 Dockerfile에 포함
FROM node:20-alpine

# Alpine에서 tini 설치
RUN apk add --no-cache tini

ENTRYPOINT ["/sbin/tini", "--"]
CMD ["node", "server.js"]

# 방법 2: Docker --init 플래그 (Docker에 내장된 tini 사용)
# Dockerfile 변경 불필요, 실행 시 플래그 추가
# docker run --init myapp
# docker-compose에서:
# services:
#   app:
#     init: true

# 방법 3: dumb-init (GitHub star 더 많음)
RUN apk add --no-cache dumb-init
ENTRYPOINT ["/usr/bin/dumb-init", "--"]
CMD ["node", "server.js"]

# 실습 디렉토리 준비
mkdir -p /tmp/docker/part5/exam_27 && cd /tmp/docker/part5/exam_27

# tini 없이 실행 — 좀비 프로세스 시뮬레이션
docker run --rm --name zombie-test alpine sh -c '
  # 자식 프로세스를 생성하고 부모가 wait() 호출 안 함
  sleep 5 & sleep 5 & sleep 5 &
  sleep 30
' &

# 다른 터미널에서 프로세스 상태 확인 (Z = 좀비)
docker exec zombie-test ps aux

# tini 사용 시
docker run --rm --init --name tini-test alpine sh -c '
  sleep 5 & sleep 5 & sleep 5 &
  sleep 30
' &
docker exec tini-test ps aux
# 좀비 없음 — tini가 자동으로 회수

docker stop mycontainer
         │
         ▼
  SIGTERM 전송 → 앱이 처리할 시간 (기본 10초)
         │
         ▼ (10초 후 응답 없으면)
  SIGKILL 전송 → 강제 종료 (진행 중 요청 모두 끊김)

// server.js — 프로덕션 수준 Graceful Shutdown
const http = require('http');

const server = http.createServer((req, res) => {
  // 실제 요청 처리 로직 (예: DB 조회, 외부 API 호출)
  setTimeout(() => {
    res.writeHead(200, { 'Content-Type': 'application/json' });
    res.end(JSON.stringify({ status: 'ok' }));
  }, 100);  // 100ms 처리 시간 시뮬레이션
});

// 현재 진행 중인 연결 추적
let connections = new Set();
server.on('connection', (socket) => {
  connections.add(socket);
  socket.on('close', () => connections.delete(socket));
});

server.listen(3000, () => {
  console.log('서버 시작: http://localhost:3000');
});

// Graceful Shutdown 함수
function gracefulShutdown(signal) {
  console.log(`[${signal}] Graceful Shutdown 시작...`);

  // 1. 새 연결 수락 중단
  server.close((err) => {
    if (err) {
      console.error('서버 종료 오류:', err);
      process.exit(1);
    }
    console.log('모든 요청 완료 — 프로세스 종료');
    process.exit(0);
  });

  // 2. 기존 keep-alive 연결에 연결 종료 헤더 전송
  for (const socket of connections) {
    socket.end();  // 즉시 파괴하지 않고 현재 요청 완료 후 종료
  }

  // 3. 타임아웃 설정 — 8초 내 완료 안 되면 강제 종료
  // (Docker의 10초 SIGKILL보다 2초 여유)
  setTimeout(() => {
    console.error('타임아웃 — 강제 종료');
    process.exit(1);
  }, 8000);
}

// 신호 핸들러 등록
process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));
process.on('SIGINT', () => gracefulShutdown('SIGINT'));  // Ctrl+C 로컬 개발용

// 예상치 못한 오류 처리
process.on('uncaughtException', (err) => {
  console.error('처리되지 않은 오류:', err);
  gracefulShutdown('uncaughtException');
});

# main.py — FastAPI Graceful Shutdown
import asyncio
import signal
import sys
from contextlib import asynccontextmanager
import uvicorn
from fastapi import FastAPI

# 진행 중인 요청 카운터
active_requests = 0
shutting_down = False

@asynccontextmanager
async def lifespan(app: FastAPI):
    # 시작 시 초기화
    print("서버 시작")
    yield
    # 종료 시 정리
    print("서버 종료 중...")
    # DB 연결 종료, 큐 플러시 등
    await asyncio.sleep(0.1)  # 정리 작업 시간
    print("정리 완료")

app = FastAPI(lifespan=lifespan)

@app.middleware("http")
async def track_requests(request, call_next):
    global active_requests
    if shutting_down:
        from fastapi.responses import JSONResponse
        return JSONResponse(
            status_code=503,
            content={"detail": "서버 종료 중"}
        )
    active_requests += 1
    try:
        response = await call_next(request)
        return response
    finally:
        active_requests -= 1

@app.get("/health")
async def health():
    if shutting_down:
        return {"status": "shutting_down"}
    return {"status": "ok", "active_requests": active_requests}

def handle_sigterm(signum, frame):
    global shutting_down
    print(f"SIGTERM 수신 — Graceful Shutdown 시작")
    shutting_down = True

    async def shutdown():
        # 진행 중인 요청 완료 대기 (최대 8초)
        for _ in range(80):  # 0.1초 * 80 = 8초
            if active_requests == 0:
                break
            await asyncio.sleep(0.1)
        print(f"종료 (잔여 요청: {active_requests})")
        sys.exit(0)

    asyncio.create_task(shutdown())

signal.signal(signal.SIGTERM, handle_sigterm)

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

# docker-compose.yml
services:
  api:
    image: myapi:1.2.3
    init: true  # tini 활성화
    stop_grace_period: 30s  # 기본 10초에서 30초로 확장
    # 위 설정은 docker stop -t 30과 동일

┌──────────────────┬─────────────────────┬──────────────────────┐
│    방식          │    적합한 용도       │    주의사항          │
├──────────────────┼─────────────────────┼──────────────────────┤
│ 환경 변수        │ 비민감 설정값        │ docker inspect로 노출│
│                  │ (포트, URL, 플래그)  │ 가능                 │
├──────────────────┼─────────────────────┼──────────────────────┤
│ 설정 파일        │ 복잡한 구조화 설정   │ 볼륨 마운트 필요     │
│ (볼륨 마운트)    │ (nginx.conf 등)     │ 파일 권한 관리       │
├──────────────────┼─────────────────────┼──────────────────────┤
│ Docker secrets   │ 비밀번호, API 키,   │ Swarm/Compose 전용   │
│                  │ 인증서              │ K8s는 별도 시크릿    │
└──────────────────┴─────────────────────┴──────────────────────┘

# docker-compose.yml — secrets 사용 예시
version: "3.8"

services:
  db:
    image: postgres:15-alpine
    environment:
      POSTGRES_DB: myapp
      POSTGRES_USER: myuser
      # 비밀번호는 환경변수 대신 secrets 사용
      POSTGRES_PASSWORD_FILE: /run/secrets/db_password
    secrets:
      - db_password
    volumes:
      - pgdata:/var/lib/postgresql/data

  api:
    image: myapi:1.2.3
    environment:
      DATABASE_HOST: db
      DATABASE_PORT: "5432"
      DATABASE_NAME: myapp
      DATABASE_USER: myuser
      # 앱 코드에서 /run/secrets/db_password 파일을 읽어 사용
    secrets:
      - db_password
      - jwt_secret
    depends_on:
      - db

secrets:
  db_password:
    file: ./secrets/db_password.txt  # 로컬 파일에서 읽기
  jwt_secret:
    file: ./secrets/jwt_secret.txt

volumes:
  pgdata:

// Node.js에서 Docker secrets 읽기
const fs = require('fs');

function readSecret(name) {
  const secretPath = `/run/secrets/${name}`;
  try {
    // secrets는 파일로 마운트됨 — trim()으로 개행 문자 제거
    return fs.readFileSync(secretPath, 'utf8').trim();
  } catch (err) {
    // 로컬 개발 환경 fallback: 환경변수 사용
    const envVar = name.toUpperCase().replace(/-/g, '_');
    const value = process.env[envVar];
    if (!value) {
      throw new Error(`시크릿 없음: ${name} (파일: ${secretPath}, 환경변수: ${envVar})`);
    }
    return value;
  }
}

// 사용 예시
const dbPassword = readSecret('db_password');
const jwtSecret = readSecret('jwt_secret');

# 디렉토리 구조
config/
├── default.json      # 모든 환경 공통 기본값
├── development.json  # 개발 환경 오버라이드
├── staging.json      # 스테이징 환경 오버라이드
└── production.json   # 프로덕션 환경 오버라이드

# docker-compose.prod.yml
services:
  api:
    image: myapi:1.2.3
    environment:
      NODE_ENV: production
      CONFIG_FILE: /etc/myapp/config.json
    volumes:
      # 프로덕션 설정 파일을 읽기 전용으로 마운트
      - ./config/production.json:/etc/myapp/config.json:ro
    secrets:
      - db_password

# 오늘 배포
docker pull node:20-alpine
# SHA256: abc123...

# 3개월 후 동일 명령
docker pull node:20-alpine
# SHA256: def456...  ← 다른 이미지!
# 새 Node.js 패치 포함, 예상치 못한 동작 변경 가능

# 현재 이미지의 다이제스트 확인
docker pull node:20-alpine
docker inspect node:20-alpine --format='{{index .RepoDigests 0}}'
# node@sha256:a1b2c3d4e5f6...

# 다이제스트로 Dockerfile 작성
FROM node@sha256:a1b2c3d4e5f6789abcdef0123456789abcdef0123456789abcdef0123456789

# 실무 권장 패턴: 태그 + 다이제스트 병기 (가독성 + 안전성)
FROM node:20-alpine@sha256:a1b2c3d4e5f6789abcdef0123456789abcdef0123456789abcdef0123456789

# 베이스 이미지 메타데이터 레이블 추가 (추적용)
LABEL base.image="node:20-alpine" \
      base.digest="sha256:a1b2c3d4e5f6..."

# 나쁜 예
services:
  api:
    image: myapi:latest      # 롤백 불가능
  db:
    image: postgres:latest   # 언제든 메이저 업그레이드 될 수 있음

# 좋은 예
services:
  api:
    image: myapi:1.2.3       # 명시적 semver
  db:
    image: postgres:15.4-alpine  # 패치 버전까지 고정

# 가장 안전한 예 (프로덕션 크리티컬 서비스)
services:
  db:
    image: postgres:15.4-alpine@sha256:abc123...

# Docker Scout로 취약점 스캔 (Docker Desktop 포함)
docker scout cves myapi:1.2.3

# 요약만 출력
docker scout quickview myapi:1.2.3

# Trivy 사용 (오픈소스 대안)
docker run --rm \
  -v /var/run/docker.sock:/var/run/docker.sock \
  aquasec/trivy:latest image myapi:1.2.3

# docker-compose.yml 리소스 제한
services:
  api:
    image: myapi:1.2.3
    deploy:
      resources:
        limits:
          cpus: '1.0'      # 최대 1 CPU 코어
          memory: 512M     # 최대 512MB
        reservations:
          cpus: '0.25'     # 최소 0.25 CPU 보장
          memory: 128M     # 최소 128MB 보장

# 실행 중 컨테이너 리소스 제한 변경 (재시작 불필요)
docker update --memory 1g --memory-swap 1g mycontainer
docker update --cpus 2.0 mycontainer

# 현재 리소스 사용량 확인
docker stats mycontainer

# 컨테이너 메모리 한도 확인
docker inspect mycontainer --format='{{.HostConfig.Memory}}'

# 메모리 한도 초과로 컨테이너가 종료된 경우 확인
docker inspect mycontainer --format='{{.State.OOMKilled}}'
# true → OOM으로 종료됨

# 적절한 메모리 한도 설정을 위한 사용량 모니터링
docker stats --no-stream --format \
  "table {{.Name}}\t{{.MemUsage}}\t{{.MemPerc}}" mycontainer

# docker-compose.yml 로그 설정
services:
  api:
    image: myapi:1.2.3
    logging:
      driver: json-file        # 기본값: 로컬 JSON 파일
      options:
        max-size: "10m"        # 파일당 최대 10MB
        max-file: "5"          # 최대 5개 파일 로테이션
        compress: "true"       # 이전 파일 gzip 압축

  # 로그 수집 서버 사용 시 (Fluentd/Loki 등)
  worker:
    image: myworker:1.0.0
    logging:
      driver: fluentd
      options:
        fluentd-address: "localhost:24224"
        fluentd-async: "true"   # non-blocking 모드 (권장)
        fluentd-buffer-limit: "8MB"
        tag: "myapp.worker"

# 로그 드라이버별 docker logs 명령 지원 여부
# json-file, journald: docker logs 사용 가능
# fluentd, syslog, splunk: docker logs 사용 불가
# → 로그는 해당 수집 시스템에서 조회해야 함

# 로그 파일 위치 확인 (json-file 드라이버)
docker inspect mycontainer \
  --format='{{.LogPath}}'
# /var/lib/docker/containers/<id>/<id>-json.log