《TypeScript编程实战》5.3 优雅关闭与健康检查

setInterval(async () => {
  await db.query('UPDATE counters SET value = value + 1 WHERE id = 1')
}, 1000)

let closing: Promise<void> | undefined

export function shutdownOnce(signal: string) {
  // 后续信号复用同一个 Promise，天然幂等
  closing ??= doShutdown(signal)
  return closing
}

import Fastify from 'fastify'

const app = Fastify({ logger: true })
const shutdownHooks: Array<() => Promise<void>> = []

async function shutdown(signal: string) {
  app.log.info({ signal }, '开始优雅关闭')

  // 1. 停止健康检查返回 200（让 LB 先把流量摘走）
  setUnhealthy()

  // 2. 关闭 HTTP 服务器：等待在途请求结束，拒绝新连接
  await app.close()

  // 3. 逆序释放资源：先停消费者，再关连接池
  for (const hook of shutdownHooks.reverse()) {
    await hook()
  }

  app.log.info('优雅关闭完成')
  process.exit(0)
}

process.on('SIGTERM', () => void shutdown('SIGTERM'))
process.on('SIGINT', () => void shutdown('SIGINT'))

import closeWithGrace from 'close-with-grace'

closeWithGrace({ delay: 10_000 }, async ({ signal, err }) => {
  if (err) app.log.error({ err }, '未捕获异常触发关闭')
  app.log.info({ signal }, '收到关闭信号')
  await app.close()
  await redis.quit()
  await db.destroy()   // Prisma / Knex 的连接池销毁
})

import type { FastifyInstance } from 'fastify'

let shuttingDown = false
let started = false

export function setUnhealthy() {
  shuttingDown = true
}

export function markStarted() {
  started = true
}

export function registerHealth(app: FastifyInstance) {
  // liveness：只证明进程没死，绝不查依赖
  app.get('/healthz', async () => ({ status: 'ok' }))

  // startup：启动探针，完成后编排系统才启用另外两个
  app.get('/startupz', async (_req, reply) => {
    if (!started) return reply.code(503).send({ status: 'starting' })
    return { status: 'started' }
  })

  // readiness：能否接流量
  app.get('/readyz', async (_req, reply) => {
    if (shuttingDown) {
      return reply.code(503).send({ status: 'shutting-down' })
    }
    const checks = await Promise.all([
      checkDb(),
      checkRedis(),
    ])
    const ok = checks.every((c) => c.ok)
    return reply.code(ok ? 200 : 503).send({
      status: ok ? 'ready' : 'degraded',
      checks,
    })
  })
}

type CheckResult = { name: string; ok: boolean; latencyMs: number; error?: string }

async function withTimeout<T>(p: Promise<T>, ms: number): Promise<T> {
  let timer: NodeJS.Timeout
  const timeout = new Promise<never>((_, reject) => {
    timer = setTimeout(() => reject(new Error(`探活超时 ${ms}ms`)), ms)
  })
  try {
    return await Promise.race([p, timeout])
  } finally {
    clearTimeout(timer!)
  }
}

async function checkDb(): Promise<CheckResult> {
  const start = performance.now()
  try {
    await withTimeout(db.query('SELECT 1'), 800)
    return { name: 'postgres', ok: true, latencyMs: performance.now() - start }
  } catch (e) {
    return {
      name: 'postgres',
      ok: false,
      latencyMs: performance.now() - start,
      error: (e as Error).message,
    }
  }
}

# Dockerfile 中的 HEALTHCHECK（单机 / Compose 场景）
HEALTHCHECK --interval=10s --timeout=1s --start-period=20s --retries=3 \
  CMD node -e "fetch('http://127.0.0.1:3000/healthz').then(r=>process.exit(r.ok?0:1)).catch(()=>process.exit(1))"

# Kubernetes Deployment 片段
spec:
  terminationGracePeriodSeconds: 30
  containers:
    - name: api
      ports:
        - containerPort: 3000
      startupProbe:
        httpGet: { path: /startupz, port: 3000 }
        failureThreshold: 30
        periodSeconds: 2
      livenessProbe:
        httpGet: { path: /healthz, port: 3000 }
        periodSeconds: 10
        failureThreshold: 3
      readinessProbe:
        httpGet: { path: /readyz, port: 3000 }
        periodSeconds: 5
        failureThreshold: 2
      lifecycle:
        preStop:
          exec:
            command: ["sh", "-c", "sleep 5"]