ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Đánh giá & Quan sát hệ thống AI

AI Builder

Canary & Shadow Rollout — Triển khai LLM an toàn

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Đổi model LLM trong production không thể 'big bang'. Học cách triển khai gradient: shadow traffic (so sánh không ảnh hưởng user) → 1% canary → 10% → 50% → 100%, với gate theo eval, user-feedback, và cost; cùng rollback tự động khi metric vi phạm SLO.

lesson120 minĐánh giá & Quan sát hệ thống AIAI Engineer

Dự đoán

Vendor vừa release Claude Sonnet 4.7. Bạn sẽ switch chatbot của một ngân hàng sang model mới như thế nào?

Flip env var = 'big bang', không có rollback nhanh khi LLM mới vi phạm SLO. A/B 50/50 ngay lập tức đưa 50% user vào vùng chưa kiểm chứng — rủi ro cao. Chờ 1 năm thì vendor đã release model mới hơn. Đáp án đúng: gradient rollout — shadow để kiểm crash/format, rồi 1% canary để bắt tín hiệu thật ở cỡ mẫu an toàn, rồi ramp dần với guardrail.

Khoảnh khắc aha

LLM không deterministic. Thay đổi model → phân phối output thay đổi → downstream metric thay đổi theo cách khó đoán trước. Chính vì vậy rollout gradient là cách duy nhất an toàn : shadow để bắt lỗi crash/format, canary 1% để bắt tín hiệu thật trên user ở cỡ mẫu đủ nhỏ mà không gây hại, rồi ramp dần với guardrail tự động. "Big bang" một model mới vào production là đặt cược business trên thay đổi mà bạn không thể lường hết hệ quả.

Bốn lưu ý quan trọng

Thử thách 1

Bạn đang canary 10% candidate. Quan sát: cost tăng 15% nhưng CSAT tăng 8%. Ngưỡng guardrail cost = 1.2× baseline. Rollback hay tiếp tục ramp?

Guardrail CHƯA vi phạm (15% < 20%) nên technically được phép ramp. Nhưng quyết định cuối thuộc business: CSAT +8pp có đáng trade 15% cost dài hạn không? Đây là lúc cần breakdown theo segment (high-value user có chấp nhận chi phí cao hơn?) và ngưỡng nên có 2 mức: soft (warn + escalate) và hard (auto-rollback).

Thử thách 2

Shadow traffic 1 ngày: v_candidate ĐÔI KHI output JSON khác format (thiếu field optional). Downstream parser fail 0.4% request. Bạn làm gì?

Đây chính là lý do có bước shadow. Lỗi format JSON ở shadow = incident thật ở canary vì downstream vẫn parse cùng cách. Pattern chuẩn: (1) gate canary start bằng 'shadow must be clean 48h', (2) dùng structured output / JSON schema với retry khi parse fail, (3) parser bên downstream tolerant với schema evolve. Đừng bao giờ ramp một format bug — nó không tự hết khi tăng %.

Các pattern rollout

Canary release là pattern triển khai trong đó phiên bản mới (v_candidate) nhận một tỷ lệ nhỏ traffic production, được đo đạc so với baseline (v_current), và được ramp dần hoặc rollback tự động dựa trên metric. Khác với A/B test (tối đa hoá statistical power để so sánh), canary tối ưu cho an toàn triển khai: phát hiện regression sớm, ảnh hưởng user tối thiểu, rollback nhanh.

Bảng so sánh 5 pattern thường gặp:

PatternUser nhận outputCapacityRollbackDùng cho
Shadow / Dark launchKhông (chỉ log)2× (chạy song song)Không cầnKiểm format, crash, cost trước canary
Canary% nhỏ user1× + bufferGiây (flip flag)Ramp dần, bắt regression thật
Blue-greenToàn bộ (sau flip)2× (2 environment)Giây (flip LB)Cần cutover atomic, rollback tức thời
RollingThay dần instance~1×PhútInfra (pod/node), ít phù hợp cho model version
Progressive deliveryRamp theo segment1× + bufferTự động theo SLOCanary + flag + auto-rollback — mẫu chuẩn LLM

Đánh giá thống kê hai variant

Đánh giá thống kê hai variant. Khi có đủ sample, ta dùng Welch t-test vì variance giữa 2 model thường khác nhau:

t=Xˉa−Xˉbsa2/na+sb2/nbt = \frac{\bar{X}_a - \bar{X}_b}{\sqrt{s_a^2/n_a + s_b^2/n_b}}

Trong đó X̄ là mean metric (vd task success rate) mỗi variant, s² là variance mẫu, n là sample size. p-value tính từ phân phối t với bậc tự do theo công thức Welch-Satterthwaite. Nhớ rằng với LLM: (1) peeking (nhìn kết quả sớm rồi quyết định) làm phát sinh false positive — dùng sequential testing; (2) variance của temp > 0 khá cao — CUPED (control with pre-experiment data) giúp giảm 30-50% sample size.

Goal metric vs guardrail metric

Goal metric vs Guardrail metric. Quy tắc vàng của rollout:

  • Goal metric (a.k.a. north-star, primary): để chọn v_candidate có đáng rollout hay không. Ví dụ: task success rate, CSAT, revenue per session, số lượt chuyển đổi.
  • Guardrail metric: để chặn v_candidate nếu vi phạm, bất kể goal. Ví dụ: p95 latency, $/req, safety violations, error rate.

Công thức quyết định: rollout = goal_improved AND all_guardrails_pass . Nếu goal tốt nhưng guardrail vi phạm → rollback hoặc block, không bao giờ đánh đổi. Guardrail là lằn ranh "do no harm", không phải số để mặc cả.

Code kiểm soát canary

canary_controller.py — per-request sampling + SLO check + rollback

import random
import time
from dataclasses import dataclass, field
from typing import Callable


@dataclass
class SLO:
    name: str
    check: Callable[[dict, dict], bool]   # (candidate_stats, baseline_stats) -> bool
    rule_desc: str


@dataclass
class CanaryController:
    """Điều khiển canary: quyết định route request nào đi v_candidate,
    giám sát SLO, tự động rollback khi bị vi phạm."""

    weight: float = 0.0              # % traffic đi v_candidate, 0..1
    baseline_stats: dict = field(default_factory=dict)
    candidate_stats: dict = field(default_factory=dict)
    slos: list[SLO] = field(default_factory=list)
    on_rollback: Callable[[str], None] | None = None
    min_sample_for_slo: int = 200    # ít mẫu quá thì đừng trigger rollback

    def route(self, request_id: str) -> str:
        """Trả về 'candidate' hoặc 'baseline'. Dùng hash stable theo
        request/user để một user luôn rơi vào một variant."""
        bucket = stable_hash(request_id) % 10_000 / 10_000.0
        return "candidate" if bucket < self.weight else "baseline"

    def record(self, variant: str, metrics: dict) -> None:
        """Ghi metric (success, latency_ms, cost, safety_viol) cho mỗi
        request hoàn thành. Gọi từ request middleware sau khi response
        về."""
        store = (
            self.candidate_stats if variant == "candidate" else self.baseline_stats
        )
        for k, v in metrics.items():
            store.setdefault(k, []).append(v)
        if variant == "candidate":
            self._check_slos()

    def _check_slos(self) -> None:
        n = len(self.candidate_stats.get("success", []))
        if n < self.min_sample_for_slo:
            return  # chưa đủ sample — bỏ qua vòng này
        for slo in self.slos:
            if not slo.check(self.candidate_stats, self.baseline_stats):
                self._rollback(f"SLO {slo.name!r} vi phạm: {slo.rule_desc}")
                return

    def _rollback(self, reason: str) -> None:
        prev_weight = self.weight
        self.weight = 0.0
        # Giữ stats để postmortem — KHÔNG clear candidate_stats.
        if self.on_rollback:
            self.on_rollback(f"Rollback từ {prev_weight:.1%} → 0%: {reason}")

    def ramp(self, target_weight: float, step: float = 0.01, dwell_s: int = 60):
        """Ramp dần đến target với dwell time giữa các bước."""
        while self.weight < target_weight:
            self.weight = min(self.weight + step, target_weight)
            time.sleep(dwell_s)
            self._check_slos()
            if self.weight == 0.0:
                break  # đã rollback trong vòng này


def stable_hash(s: str) -> int:
    # Ổn định — một user luôn rơi vào cùng bucket trong suốt canary.
    import hashlib
    return int(hashlib.md5(s.encode()).hexdigest(), 16)


# ────────── Ví dụ sử dụng ──────────

def slo_success(cand, base):
    from statistics import mean
    return mean(cand["success"]) >= 0.90 * mean(base["success"])


def slo_p95_latency(cand, base):
    p95c = percentile(cand["latency_ms"], 95)
    p95b = percentile(base["latency_ms"], 95)
    return p95c <= 1.1 * p95b


ctl = CanaryController(
    slos=[
        SLO("task_success", slo_success, "cand success ≥ 90% baseline"),
        SLO("p95_latency",  slo_p95_latency, "cand p95 ≤ 1.1× baseline"),
    ],
    on_rollback=lambda msg: page_oncall(msg),
)
ctl.ramp(target_weight=0.50, step=0.05, dwell_s=900)  # 5%/15min

Nếu bạn dùng Kubernetes, stack chuẩn là Argo Rollouts hoặc Flagger — chúng wrap logic trên thành resource declarative và tích hợp sẵn với Prometheus cho SLO check:

flagger-canary.yaml

apiVersion: flagger.app/v1beta1
kind: Canary
metadata:
  name: chatbot-llm
  namespace: prod
spec:
  targetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: chatbot-llm
  service:
    port: 8080
  analysis:
    interval: 5m
    threshold: 3          # 3 check fail liên tiếp → rollback
    maxWeight: 50         # canary tối đa 50% trước khi promote
    stepWeight: 5         # tăng 5% mỗi vòng
    stepWeights: [1, 5, 10, 25, 50]

    # Metric tuỳ chỉnh — hỏi Prometheus theo query chứa model version
    metrics:
      - name: llm-task-success
        thresholdRange:
          min: 0.88
        query: |
          sum(rate(llm_task_success{model="candidate",app="chatbot"}[5m]))
          /
          sum(rate(llm_task_total{model="candidate",app="chatbot"}[5m]))

      - name: llm-p95-latency
        thresholdRange:
          max: 2.0        # giây
        query: |
          histogram_quantile(0.95,
            sum(rate(llm_latency_seconds_bucket{model="candidate"}[5m]))
            by (le))

      - name: llm-cost-per-request
        thresholdRange:
          max: 0.0144     # = 1.2 × baseline 0.012
        query: |
          sum(rate(llm_cost_usd{model="candidate"}[5m]))
          /
          sum(rate(llm_requests{model="candidate"}[5m]))

      - name: llm-safety-violations
        thresholdRange:
          max: 0
        query: |
          sum(rate(llm_safety_violation_total{model="candidate"}[5m]))

    # Nếu bất kỳ metric nào fail threshold 3 vòng liên tiếp → Flagger
    # giảm weight về 0 và rollback.

Sample size cho LLM A/B

Công thức two-sample test với power 1−β, độ tin cậy 1−α:

n≈2σ2(zα/2+zβ)2δ2n \approx \frac{2 \sigma^2 (z_{\alpha/2} + z_{\beta})^2}{\delta^2}

Ví dụ: σ (SD của task success) = 0.35, δ (minimum detectable effect) = 0.02 (2 điểm phần trăm), α = 0.05, β = 0.20 (power 80%). Khi đó z_{α/2} = 1.96, z_β = 0.84. Tính ra n ≈ 2 × 0.35² × (1.96+0.84)² / 0.02² ≈ 4800 request mỗi nhánh. Với traffic 10k req/giờ và canary 5%, cần khoảng 10 giờ để đạt power.

Mẹo rút ngắn trong thực tế:

  • CUPED: dùng pre-period success rate làm covariate → giảm σ² 30-50% → cần ít sample hơn.
  • Sequential testing (alpha spending): peek dữ liệu liên tục mà vẫn kiểm soát false positive — dừng sớm khi có tín hiệu mạnh.
  • Stratified sampling: chia segment user trước, cân bằng giữa canary và baseline → giảm variance do segment mix.

Multi-armed bandit thay vì A/B

A/B test: cố định tỷ lệ traffic, chạy đủ sample, rồi quyết định. Khi test chạy, cost của việc đẩy user vào nhánh xấu là cố định. Multi-armed bandit (Thompson sampling, UCB, ε-greedy): cập nhật tỷ lệ liên tục, đẩy nhiều traffic hơn vào nhánh đang thắng → giảm tổng regret.

Phù hợp khi:

  • Goal metric đo được nhanh (vd click, thumbs-up) — không phải retention tuần sau.
  • Nhiều hơn 2 variant (3-10 model / prompt) — A/B multi-arm quá tốn sample, bandit tự phân bổ tốt hơn.
  • Muốn ship nhanh, chấp nhận ít rigorous về statistical test.

Không phù hợp khi:

  • Cần báo cáo thống kê chính thức (compliance, y khoa) — bandit khó giải trình p-value.
  • Delayed reward (feedback đến sau hàng giờ/ngày).
  • Guardrail nghiêm ngặt — bandit có thể đẩy traffic vào nhánh nhất thời tốt nhưng safety kém.

Canary không đứng một mình — nó phụ thuộc vào hệ thống đo đạc. Xem llm-evaluation để thiết kế bộ metric offline/online, observability for AI để capture trace + feedback làm tín hiệu SLO, và mlops cho phần pipeline từ train đến deploy.

Case study minh hoạ: Sendo

Case study minh hoạ: các số liệu và sự kiện dưới đây không phải dữ liệu công khai của Sendo.

Bối cảnh. Sendo chạy chatbot tư vấn sản phẩm trên gpt-4o-mini (cost ~$0.0025/req). Tháng 3, team nhận thấy chatbot hay đưa gợi ý lạc đề khi user hỏi sâu về thông số sản phẩm. Vendor vừa release claude-sonnet-4.5 — team quyết định thử upgrade.

Day 1 — Shadow. Chạy song song 2 model trên 100% traffic (chỉ log candidate). Kết quả sau 24 giờ, 180k request:

  • Faithfulness (LLM-as-judge đối chiếu với catalog): +6pp (76% → 82%).
  • p95 latency: +1.1s (0.8s → 1.9s).
  • Cost/request: ×3.2 ($0.0025 → $0.008).
  • Format JSON: OK, không có downstream parser fail.

Day 2-4 — Canary. Ramp 1% → 5%. Goal metric (CSAT) thật sự tăng 4-5 điểm trong nhóm canary. Nhưng guardrail cost của team đặt ≤ 1.2× baseline = $0.003. Candidate ở mức $0.008 — vượt hơn 2.6× ngưỡng. Auto-rollback không kích hoạt vì guard cost được config là "warn" chứ không phải "hard stop". Team quyết định dừng ở 5% thay vì ramp tiếp, và họp với PM.

Đổi chiến thuật — Prompt distillation. Thay vì cutover sang sonnet cho 100% user, team chạy offline:

  • Dùng sonnet-4.5 làm teacher: sinh 5000 câu trả lời gold trên tập query đại diện.
  • Soạn lại system prompt cho gpt-4o-mini, chèn few-shot từ output sonnet + checklist các điểm faithfulness hay sai.
  • Chạy eval lại: mini với prompt mới đạt faithfulness 80% (vs sonnet 82%, mini cũ 76%).

Kết quả. Shadow lại với mini-prompt-v2: faithfulness +4pp, cost gần bằng mini cũ, latency giữ nguyên. Canary 1% → 5% → 25% → 100% trong 6 ngày, không rollback. Chatbot improve mà không đốt 3× ngân sách.

Bài học. "Model xịn hơn" không phải lúc nào cũng thắng trong production. Đo toàn hệ metric (goal + guardrail), đừng chỉ so chất lượng. Đôi khi giải pháp là giữ model cũ với prompt đã học từ model mới — rẻ hơn, ổn hơn, và vẫn cải thiện. Canary không chỉ dùng để deploy, mà còn để học xem candidate có đáng deploy không.

Tóm tắt

  • LLM không deterministic → rollout gradient (shadow → canary 1% → ramp) là cách duy nhất an toàn để đổi model trong production.
  • Shadow = log cả hai output, user chỉ nhận baseline; canary = một % user thật nhận candidate. Dùng shadow TRƯỚC canary để bắt crash/format.
  • Goal metric (CSAT, success) để chọn; guardrail metric (latency, cost, safety) để chặn. Rollout khi goal tốt VÀ guardrail pass — không đánh đổi.
  • Auto-rollback: flip feature flag về 0% trong giây, giữ artifact để postmortem, page on-call. Dùng Flagger/Argo Rollouts hoặc tự viết CanaryController.
  • A/B LLM cần sample lớn hơn UI A/B vì output variance cao — dùng Welch t-test, sequential testing, hoặc CUPED để rút ngắn thời gian.
  • Pattern 'model version as feature flag' (LaunchDarkly/Unleash/Postgres): tách chọn model khỏi deploy code, rollback tính bằng giây.

Continue the module

Lesson 6 of 7