12 thứ cần check trước khi zero-downtime deploy

-- SAI: rename trực tiếp sẽ break code cũ ngay lập tức
ALTER TABLE users RENAME COLUMN phone TO phone_number;

-- ĐÚNG: quy trình 3 bước qua nhiều deploy cycle
-- Deploy 1: thêm column mới, code mới ghi cả hai column
ALTER TABLE users ADD COLUMN phone_number VARCHAR(20);

-- Code thời điểm này: đọc phone, ghi cả phone VÀ phone_number
-- (backfill job chạy song song để sync data cũ)

-- Deploy 2: code mới chỉ đọc/ghi phone_number, code cũ vẫn dùng phone
-- Hai version có thể song song vì phone vẫn còn

-- Deploy 3 (sau khi deploy 2 stable ≥2 tuần): xóa column cũ
ALTER TABLE users DROP COLUMN phone;

# Ví dụ dùng LaunchDarkly, Flagsmith, hoặc config đơn giản trong Redis
def process_payment(payment_data):
    if feature_flags.is_enabled("new_payment_processor", user_id=payment_data["user_id"]):
        # code mới: dùng payment processor V2
        return payment_processor_v2.charge(payment_data)
    else:
        # code cũ: fallback về V1
        return payment_processor_v1.charge(payment_data)

# KHÔNG ĐỦ: chỉ kiểm tra HTTP server đang chạy
readinessProbe:
  httpGet:
    path: /health
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 10

# Endpoint /ready phải kiểm tra thật sự
from fastapi import FastAPI, HTTPException
import asyncpg
import redis.asyncio as aioredis

app = FastAPI()

@app.get("/ready")
async def readiness_check():
    checks = {}
    overall_healthy = True

    # Kiểm tra database connection
    try:
        async with app.state.db_pool.acquire() as conn:
            await conn.fetchval("SELECT 1")
        checks["database"] = "ok"
    except Exception as e:
        checks["database"] = f"error: {str(e)}"
        overall_healthy = False

    # Kiểm tra Redis connection
    try:
        await app.state.redis.ping()
        checks["redis"] = "ok"
    except Exception as e:
        checks["redis"] = f"error: {str(e)}"
        overall_healthy = False

    # Kiểm tra background workers đã init chưa
    if not app.state.workers_initialized:
        checks["workers"] = "not_ready"
        overall_healthy = False
    else:
        checks["workers"] = "ok"

    if not overall_healthy:
        raise HTTPException(status_code=503, detail=checks)

    return {"status": "ready", "checks": checks}

# ĐÚNG: hai probe, hai endpoint, hai mục đích khác nhau
livenessProbe:
  httpGet:
    path: /healthz # chỉ kiểm tra process còn sống, không kiểm tra external deps
    port: 8080
  initialDelaySeconds: 30
  periodSeconds: 15
  failureThreshold: 3 # fail 3 lần liên tiếp mới restart — tránh restart do blip

readinessProbe:
  httpGet:
    path: /ready # kiểm tra DB, Redis, dependencies
    port: 8080
  initialDelaySeconds: 10
  periodSeconds: 10
  failureThreshold: 3 # fail 3 lần mới remove khỏi load balancer

@app.get("/healthz")
async def liveness_check():
    # Chỉ kiểm tra process không bị deadlock
    # Không kiểm tra external dependencies
    return {"status": "alive"}

spec:
  minReadySeconds: 30 # chờ 30 giây pod ổn định trước khi move sang pod tiếp
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1 # cho phép tối đa 1 pod extra trong lúc rolling
      maxUnavailable: 0 # không bao giờ giảm số pod available — đây là key để zero-downtime

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: api-pdb
spec:
  minAvailable: "60%" # luôn phải có ít nhất 60% pods chạy
  selector:
    matchLabels:
      app: api-service

spec:
  maxUnavailable: 2 # tối đa 2 pods có thể down cùng lúc (cho cluster 10 pods = 20%)

import signal
import asyncio
from contextlib import asynccontextmanager

# Flag để track graceful shutdown state
shutdown_event = asyncio.Event()
active_requests = 0

async def graceful_shutdown(sig, loop):
    """Nhận SIGTERM: stop accept new, drain existing, exit"""
    print(f"Nhận signal {sig.name}, bắt đầu graceful shutdown...")

    # Bước 1: báo với health check rằng pod không còn ready nhận traffic mới
    # /ready sẽ return 503, Kubernetes sẽ remove pod khỏi load balancer
    shutdown_event.set()

    # Bước 2: chờ active requests hoàn thành (tối đa 30 giây)
    deadline = asyncio.get_event_loop().time() + 30
    while active_requests > 0:
        remaining = deadline - asyncio.get_event_loop().time()
        if remaining <= 0:
            print(f"Timeout graceful shutdown: còn {active_requests} requests đang xử lý")
            break
        await asyncio.sleep(0.5)

    print("Graceful shutdown hoàn thành, đang exit...")
    loop.stop()

@app.get("/ready")
async def readiness_check():
    # Fail readiness ngay khi nhận shutdown signal
    if shutdown_event.is_set():
        raise HTTPException(status_code=503, detail="shutting_down")
    # ... các checks khác

spec:
  terminationGracePeriodSeconds: 90 # >= p99 request duration + 30s buffer
  containers:
    - name: api
      lifecycle:
        preStop:
          exec:
            # sleep nhỏ để đảm bảo load balancer deregister xong
            # trước khi container bắt đầu refuse connections
            command: ["/bin/sh", "-c", "sleep 5"]

# KHÔNG DÙNG CHO PRODUCTION: in-memory session
from flask import session
app.secret_key = "..."
# session được lưu trong cookie phía client (ok) hoặc server memory (không ok)

# DÙNG: JWT stateless
import jwt
from datetime import datetime, timedelta

def create_access_token(user_id: int) -> str:
    payload = {
        "sub": str(user_id),
        "iat": datetime.utcnow(),
        "exp": datetime.utcnow() + timedelta(hours=1),
    }
    return jwt.encode(payload, settings.JWT_SECRET, algorithm="HS256")

# HOẶC: server-side session với Redis shared store
from redis import Redis
from flask_session import Session

app.config["SESSION_TYPE"] = "redis"
app.config["SESSION_REDIS"] = Redis(host="redis-cluster", port=6379)
# Session được lưu trong Redis — tất cả pods đọc cùng một store

# Không an toàn: assume exclusive access
def send_daily_report():
    users = db.query("SELECT id FROM users WHERE last_report_sent < NOW() - INTERVAL '24 hours'")
    for user in users:
        # Hai instances chạy song song sẽ gửi email 2 lần cho cùng user
        email_service.send_daily_report(user.id)
        db.execute("UPDATE users SET last_report_sent = NOW() WHERE id = ?", user.id)

# An toàn: idempotent với distributed lock và idempotency key
import uuid
from datetime import date

def send_daily_report():
    today = date.today().isoformat()

    # Chỉ một instance có thể chạy job này tại một thời điểm
    with redis_lock(f"daily_report_job:{today}", ttl=3600):
        # Dùng idempotency key để mark email đã gửi TRƯỚC khi gửi
        # (nếu crash sau gửi nhưng trước update DB, lần sau vẫn gửi — chấp nhận được)
        users = db.query("""
            SELECT id FROM users
            WHERE last_report_date < ? AND is_active = true
        """, today)

        for user in users:
            idempotency_key = f"daily_report:{user.id}:{today}"
            if not redis.exists(f"sent:{idempotency_key}"):
                email_service.send_daily_report(user.id, idempotency_key=idempotency_key)
                redis.setex(f"sent:{idempotency_key}", 86400 * 2, "1")
                db.execute("UPDATE users SET last_report_date = ? WHERE id = ?", today, user.id)

apiVersion: apps/v1
kind: Deployment
metadata:
  name: api-service
spec:
  replicas: 10
  minReadySeconds: 30
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0 # zero-downtime: không bao giờ giảm số pod
  selector:
    matchLabels:
      app: api-service
  template:
    metadata:
      labels:
        app: api-service
    spec:
      terminationGracePeriodSeconds: 90 # đủ cho p99 request + buffer
      containers:
        - name: api
          image: api-service:v2.1.3
          ports:
            - containerPort: 8080
          lifecycle:
            preStop:
              exec:
                command: ["/bin/sh", "-c", "sleep 5"] # cho kube-proxy sync
          livenessProbe:
            httpGet:
              path: /healthz # chỉ kiểm tra process còn sống
              port: 8080
            initialDelaySeconds: 30
            periodSeconds: 15
            failureThreshold: 3
          readinessProbe:
            httpGet:
              path: /ready # kiểm tra DB, Redis, external deps
              port: 8080
            initialDelaySeconds: 10
            periodSeconds: 10
            failureThreshold: 3
          resources:
            requests:
              memory: "256Mi"
              cpu: "250m"
            limits:
              memory: "512Mi"
              cpu: "1000m"
---
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: api-pdb
spec:
  minAvailable: "60%" # luôn có ít nhất 6/10 pods running
  selector:
    matchLabels:
      app: api-service