Skip to main content
HashnodeLearn DevOps

Command Palette

Search for a command to run...

Học Platform engineering (5)

Updated
•72 min read•View as Markdown
H
Hải Yến Trịnh
Part of seriesKnowledge

LAYER 8 - SECURITY ENGINEERING

KHỐI A - Threat Modeling & Fundamentals (Ngày 1-24)

Ngày 1: Khởi động Layer 8

  • Mục tiêu: Đặt security mindset + lab an toàn.

  • Lý thuyết: tư duy kẻ tấn công, assume breach, security là quá trình.

  • Thực hành: Repo security/; dựng lab cluster để tấn công/phòng thủ.

Ngày 2: Nguyên lý bảo mật

  • Mục tiêu: Nền tư duy.

  • Lý thuyết: CIA (confidentiality/integrity/availability), least privilege, defense in depth, fail-secure.

  • Thực hành: Áp nguyên lý vào một kiến trúc.

Ngày 3: Zero Trust

  • Mục tiêu: Không tin ngầm (nối Layer 5).

  • Lý thuyết: assume breach, verify liên tục, identity-centric.

  • Thực hành: Đối chiếu perimeter vs zero-trust.

Ngày 4: Attack surface & trust boundary

  • Mục tiêu: Biết bề mặt tấn công.

  • Lý thuyết: attack surface, trust boundary, entry points.

  • Thực hành: Vẽ trust boundary cho một hệ thống.

Ngày 5: Threat modeling - STRIDE

  • Mục tiêu: Khung liệt kê mối đe doạ.

  • Lý thuyết: Spoofing/Tampering/Repudiation/Info disclosure/DoS/Elevation.

  • Thực hành: Áp STRIDE cho một service.

Ngày 6: Threat modeling - DFD

  • Mục tiêu: Mô hình luồng dữ liệu.

  • Lý thuyết: data flow diagram, trust boundary trên DFD.

  • Thực hành: Vẽ DFD + đánh dấu điểm rủi ro.

Ngày 7: Attack trees

  • Mục tiêu: Suy nghĩ theo mục tiêu kẻ tấn công.

  • Lý thuyết: attack tree, path phân rã.

  • Thực hành: Dựng attack tree cho một tài sản.

Ngày 8: MITRE ATT&CK

  • Mục tiêu: Ngôn ngữ chung về kỹ thuật tấn công.

  • Lý thuyết: tactics/techniques, matrix (đặc biệt containers/cloud).

  • Thực hành: Map vài technique vào hệ của mình.

Ngày 9: Kill chain & phòng thủ

  • Mục tiêu: Nối tấn công với kiểm soát.

  • Lý thuyết: kill chain, defense mapping theo giai đoạn.

  • Thực hành: Đặt kiểm soát cho từng giai đoạn.

Ngày 10: Risk & prioritization

  • Mục tiêu: Ưu tiên đúng.

  • Lý thuyết: likelihood × impact, risk acceptance.

  • Thực hành: Xếp hạng rủi ro từ threat model.

Ngày 11: Threat model thực hành

  • Mục tiêu: Làm trọn một threat model.

  • Lý thuyết: quy trình đầu-cuối.

  • Thực hành: Threat model một hệ thống thật (app + k8s).

Ngày 12: Security trong SDLC

  • Mục tiêu: Shift-left (nối Layer 6).

  • Lý thuyết: security từ design → build → deploy → run.

  • Thực hành: Thêm security gate vào vòng đời.

Ngày 13: OWASP Top 10

  • Mục tiêu: Lỗ hổng ứng dụng phổ biến.

  • Lý thuyết: injection, broken auth, misconfig, SSRF…

  • Thực hành: Rà một app theo OWASP.

Ngày 14: Misconfig cloud/k8s

  • Mục tiêu: Sai cấu hình hay gặp.

  • Lý thuyết: public bucket, over-permissive IAM, exposed API.

  • Thực hành: Tìm misconfig trong lab.

Ngày 15: Secret exposure

  • Mục tiêu: Rò rỉ credential (nối Layer 5).

  • Lý thuyết: secret trong code/log/image, credential theft.

  • Thực hành: Scan repo/image tìm secret.

Ngày 16: Identity là perimeter

  • Mục tiêu: Danh tính là ranh giới (nối Layer 5).

  • Lý thuyết: phishing, token theft, MFA, least privilege.

  • Thực hành: Rà quyền thừa; siết.

Ngày 17: Blast radius & segmentation

  • Mục tiêu: Giới hạn thiệt hại.

  • Lý thuyết: segmentation, isolation, containment.

  • Thực hành: Phân đoạn một hệ để giảm blast radius.

Ngày 18: Incident response cơ bản

  • Mục tiêu: Khi bị tấn công (nối Layer 11).

  • Lý thuyết: detect → contain → eradicate → recover, forensics.

  • Thực hành: Phác IR playbook.

Ngày 19: Security logging & audit

  • Mục tiêu: Bằng chứng & phát hiện (nối Layer 7).

  • Lý thuyết: audit log, tamper-evident, retention.

  • Thực hành: Bật audit log tập trung, bảo vệ.

Ngày 20: Detection vs prevention

  • Mục tiêu: Chọn chiến lược.

  • Lý thuyết: ngăn chặn vs phát hiện, đánh đổi.

  • Thực hành: Quyết định control nào ngăn/phát hiện.

Ngày 21: Security như capability nền tảng

  • Mục tiêu: Paved secure road (nối Layer 6).

  • Lý thuyết: secure by default, guardrail thay gatekeeper.

  • Thực hành: Ý tưởng golden path an toàn.

Ngày 22: Threat intel & CVE

  • Mục tiêu: Theo dõi lỗ hổng.

  • Lý thuyết: CVE/CVSS, CISA KEV, vòng đời vá.

  • Thực hành: Quy trình theo dõi + phản ứng CVE.

Ngày 23: Ôn Khối A

  • Mục tiêu: Chốt tư duy.

  • Lý thuyết: rà STRIDE/ATT&CK/risk.

  • Thực hành: Chuẩn bị threat model doc.

Ngày 24: Threat model doc cho platform

  • Mục tiêu: Kim chỉ nam.

  • Lý thuyết: threat model + controls + risk register.

  • Thực hành: Viết threat model doc (dùng xuyên layer).

KHỐI B - Platform Security (Ngày 25-58) → P1

Ngày 25: Linux security recap

  • Mục tiêu: Nền (nối Layer 2).

  • Lý thuyết: user/group/perm, setuid/setgid, sudo.

  • Thực hành: Rà quyền hệ thống; loại setuid thừa.

Ngày 26: Capabilities

  • Mục tiêu: Chia nhỏ root (nối Layer 2).

  • Lý thuyết: POSIX capabilities, drop, least privilege.

  • Thực hành: Drop caps cho một process/container.

Ngày 27: seccomp

  • Mục tiêu: Lọc syscall (nối Layer 2).

  • Lý thuyết: seccomp-BPF, allow-list.

  • Thực hành: Áp seccomp profile chặn syscall nguy hiểm.

Ngày 28: LSM: SELinux vs AppArmor

  • Mục tiêu: MAC (nối Layer 2).

  • Lý thuyết: type enforcement vs path-based.

  • Thực hành: Chọn + bật một LSM.

Ngày 29: AppArmor profiles

  • Mục tiêu: Giới hạn theo path.

  • Lý thuyết: profile, enforce vs complain.

  • Thực hành: Viết + áp profile cho một app.

Ngày 30: CỘT MỐC 30

  • Mục tiêu: Chốt threat modeling + vào platform security.

  • Lý thuyết: Ôn A + đầu B; kiểm kê: threat model doc + Linux hardening cơ bản.

  • Thực hành: Đề thi #1 (threat modeling/Linux security) + tự chấm; blog #81 ("Threat modeling & Linux hardening: nền của security"); tag layer8-day030; nghỉ nửa ngày. Đã đi 30/150 (20%).

Ngày 31: SELinux

  • Mục tiêu: MAC mạnh.

  • Lý thuyết: type enforcement, context, booleans.

  • Thực hành: Đọc context; xử lý một denial.

Ngày 32: Linux hardening

  • Mục tiêu: Siết hệ điều hành.

  • Lý thuyết: auditd, PAM, sysctl hardening, minimal packages.

  • Thực hành: Áp một baseline hardening + auditd.

Ngày 33: Kernel hardening

  • Mục tiêu: Bảo vệ nhân (nối Layer 2).

  • Lý thuyết: lockdown, KASLR, module signing, sysctl bảo mật.

  • Thực hành: Bật các biện pháp hardening kernel.

Ngày 34: Container security - threat model

  • Mục tiêu: Rủi ro container.

  • Lý thuyết: shared kernel, escape, image risk.

  • Thực hành: Threat model một container.

Ngày 35: Image security

  • Mục tiêu: Image nhỏ & sạch.

  • Lý thuyết: minimal/distroless, non-root, pinned base.

  • Thực hành: Chuyển sang distroless + non-root.

Ngày 36: Image scanning

  • Mục tiêu: Tìm lỗ hổng image.

  • Lý thuyết: Trivy/Grype, severity, fixable.

  • Thực hành: Scan + vá image.

Ngày 37: Rootless & no-new-privileges

  • Mục tiêu: Giảm đặc quyền.

  • Lý thuyết: rootless (nối Layer 4), no-new-privileges.

  • Thực hành: Chạy container rootless + no-new-privs.

Ngày 38: Container hardening

  • Mục tiêu: Container tối thiểu quyền.

  • Lý thuyết: read-only rootfs, drop caps, seccomp.

  • Thực hành: securityContext chặt cho pod.

Ngày 39: Runtime isolation

  • Mục tiêu: Cách ly mạnh (nối Layer 2).

  • Lý thuyết: gVisor/Kata cho workload nhạy cảm.

  • Thực hành: Chạy workload nhạy cảm dưới gVisor.

Ngày 40: CIS container benchmark

  • Mục tiêu: Chuẩn hardening.

  • Lý thuyết: CIS Docker/container.

  • Thực hành: Áp + kiểm CIS container.

Ngày 41: Kubernetes security - 4C

  • Mục tiêu: Bản đồ bảo mật k8s.

  • Lý thuyết: Cloud/Cluster/Container/Code.

  • Thực hành: Rà từng lớp.

Ngày 42: RBAC hardening

  • Mục tiêu: Quyền tối thiểu (nối Layer 4).

  • Lý thuyết: least-privilege RBAC, tránh cluster-admin.

  • Thực hành: Siết RBAC; audit quyền thừa.

Ngày 43: Pod Security Admission

  • Mục tiêu: Chuẩn pod an toàn (nối Layer 4).

  • Lý thuyết: PSA baseline/restricted, Pod Security Standards.

  • Thực hành: Áp restricted; chặn pod privileged.

Ngày 44: NetworkPolicy

  • Mục tiêu: Cô lập mạng (nối Layer 4).

  • Lý thuyết: default-deny, ingress/egress rules.

  • Thực hành: Default-deny + allow tối thiểu.

Ngày 45: k8s secrets

  • Mục tiêu: Bảo vệ secret (nối Layer 5).

  • Lý thuyết: encryption at rest, external secrets, tránh env leak.

  • Thực hành: Bật encryption + external secret operator.

Ngày 46: etcd & API server hardening

  • Mục tiêu: Bảo vệ control plane.

  • Lý thuyết: etcd encryption, API server flags, audit.

  • Thực hành: Bật etcd encryption + audit policy.

Ngày 47: Service account tokens

  • Mục tiêu: Token an toàn.

  • Lý thuyết: bound/projected token, automount off.

  • Thực hành: Tắt automount thừa; dùng bound token.

Ngày 48: Admission control cho security

  • Mục tiêu: Chặn cấu hình xấu (nối Layer 4).

  • Lý thuyết: Gatekeeper/Kyverno cho security policy.

  • Thực hành: Policy chặn hostPath/privileged/latest image.

Ngày 49: CIS Kubernetes benchmark

  • Mục tiêu: Chuẩn cluster.

  • Lý thuyết: CIS k8s, kube-bench.

  • Thực hành: Chạy kube-bench; sửa fail.

Ngày 50: Tấn công cluster

  • Mục tiêu: Hiểu bằng cách tấn công.

  • Lý thuyết: kube-hunter, common attack path.

  • Thực hành: Chạy kube-hunter; vá lỗ hổng tìm được.

Ngày 51: Multi-tenancy security

  • Mục tiêu: Cách ly tenant (nối Layer 4).

  • Lý thuyết: RBAC + NetworkPolicy + quota + PSA + node isolation.

  • Thực hành: Cô lập một tenant đầy đủ.

Ngày 52: Node & kubelet hardening

  • Mục tiêu: Bảo vệ node.

  • Lý thuyết: kubelet auth, read-only port, node isolation.

  • Thực hành: Hardening kubelet + node.

Ngày 53: Cloud security posture

  • Mục tiêu: CSPM (nối Layer 5).

  • Lý thuyết: posture management, misconfig detection.

  • Thực hành: Scan tài khoản cloud tìm misconfig.

Ngày 54: P1 - thiết kế baseline

  • Mục tiêu: Đóng khung P1.

  • Lý thuyết: hardening Linux + container + k8s theo CIS.

  • Thực hách: hardened-baseline-design.md.

Ngày 55: P1 - Linux/container hardening

  • Mục tiêu: Nền OS/container an toàn.

  • Lý thuyết: caps/seccomp/AppArmor/distroless.

  • Thực hành: Áp baseline OS + container.

Ngày 56: P1 - k8s hardening

  • Mục tiêu: Cluster an toàn.

  • Lý thuyết: RBAC/PSA/NetworkPolicy/admission.

  • Thực hành: Áp baseline k8s.

Ngày 57: P1 - CIS + kube-bench

  • Mục tiêu: Đạt chuẩn.

  • Lý thuyết: đo tuân thủ, sửa fail.

  • Thực hành: kube-bench/CIS pass mức mục tiêu.

Ngày 58: P1 - Hardened baseline

  • Mục tiêu: Release P1.

  • Lý thuyết: rà "done": threat model + Linux/container/k8s hardening đo được.

  • Thực hành: Đóng gói + blog #82 ("Hardening một nền tảng: từ Linux tới Kubernetes theo CIS"). P1 done.

KHỐI C - Runtime Security (Ngày 59-82) → P2

Ngày 59: Runtime security - vì sao

  • Mục tiêu: Phát hiện lúc chạy.

  • Lý thuyết: hardening không đủ; cần detect hành vi bất thường runtime.

  • Thực hành: Liệt kê hành vi cần phát hiện.

Ngày 60: CỘT MỐC 60

  • Mục tiêu: Chốt platform security.

  • Lý thuyết: Ôn B; kiểm kê: hardened baseline (P1).

  • Thực hành: Đề thi #2 (container/k8s security/CIS) + tự chấm; blog #83 ("Kubernetes security: 4C, RBAC, PSA, NetworkPolicy"); tag layer8-day060; nghỉ nửa ngày. Đã đi 60/150 (40%).

Ngày 61: Falco

  • Mục tiêu: Phát hiện theo syscall.

  • Lý thuyết: Falco, syscall events, driver (eBPF/kmod).

  • Thực hành: Dựng Falco; xem sự kiện.

Ngày 62: Falco - rules

  • Mục tiêu: Định nghĩa phát hiện.

  • Lý thuyết: rule, condition, macro, list, output.

  • Thực hành: Đọc + tinh chỉnh rule mặc định.

Ngày 63: Falco - custom rules

  • Mục tiêu: Phát hiện mối đe doạ riêng.

  • Lý thuyết: viết rule cho threat cụ thể (shell trong container, mount nhạy cảm).

  • Thực hành: Viết rule + kích hoạt bằng hành vi test.

Ngày 64: Falco - alerting

  • Mục tiêu: Đưa vào vận hành (nối Layer 7).

  • Lý thuyết: output → SIEM/alert, Falcosidekick.

  • Thực hành: Route alert Falco tới observability.

Ngày 65: Tetragon

  • Mục tiêu: eBPF-based (nối Layer 2).

  • Lý thuyết: Tetragon, eBPF observability + enforcement.

  • Thực hành: Dựng Tetragon; quan sát process/network.

Ngày 66: Tetragon - observe + enforce

  • Mục tiêu: Không chỉ phát hiện.

  • Lý thuyết: enforcement (block/kill) tại kernel.

  • Thực hành: Chặn một hành vi bằng Tetragon.

Ngày 67: Tetragon - TracingPolicy

  • Mục tiêu: Chính sách chi tiết (nối Layer 2).

  • Lý thuyết: kprobe/tracepoint, filter, action.

  • Thực hành: Viết TracingPolicy phát hiện + chặn.

Ngày 68: Falco vs Tetragon

  • Mục tiêu: Chọn công cụ.

  • Lý thuyết: detection (Falco) vs enforcement eBPF (Tetragon).

  • Thực hành: Bảng đánh đổi + kịch bản.

Ngày 69: seccomp profiles

  • Mục tiêu: Sinh & áp profile thật.

  • Lý thuyết: ghi profile theo hành vi thật, allow-list.

  • Thực hành: Sinh seccomp profile cho một app.

Ngày 70: Security Profiles Operator

  • Mục tiêu: Quản seccomp/AppArmor ở k8s.

  • Lý thuyết: SPO, ghi profile tự động.

  • Thực hành: Dùng SPO sinh + áp profile.

Ngày 71: AppArmor/SELinux cho workload

  • Mục tiêu: MAC cho pod.

  • Lý thuyết: áp profile vào workload k8s.

  • Thực hành: Gắn AppArmor profile cho pod.

Ngày 72: NetworkPolicy enforcement

  • Mục tiêu: Cô lập mạng thật (nối Layer 2/4).

  • Lý thuyết: Cilium enforcement, identity-based.

  • Thực hành: Default-deny + policy L3/L4.

Ngày 73: Cilium L7 policy

  • Mục tiêu: Chính sách tầng ứng dụng.

  • Lý thuyết: L7 policy (HTTP), identity-aware.

  • Thực hành: Giới hạn HTTP method/path giữa service.

Ngày 74: Egress & DNS policy

  • Mục tiêu: Chặn exfiltration.

  • Lý thuyết: egress control, DNS-based policy.

  • Thực hành: Chỉ cho egress tới đích cho phép.

Ngày 75: Drift detection

  • Mục tiêu: Phát hiện bất thường.

  • Lý thuyết: baseline hành vi, phát hiện lệch.

  • Thực hành: Cảnh báo khi container chạy binary lạ.

Ngày 76: Runtime response

  • Mục tiêu: Phản ứng tự động.

  • Lý thuyết: block/kill/isolate pod khi bị xâm nhập.

  • Thực hành: Tự cô lập pod đáng ngờ.

Ngày 77: File integrity monitoring

  • Mục tiêu: Phát hiện tamper.

  • Lý thuyết: FIM, thay đổi file nhạy cảm.

  • Thực hành: Cảnh báo khi file hệ thống đổi.

Ngày 78: Phát hiện container escape

  • Mục tiêu: Mối đe doạ nặng nhất.

  • Lý thuyết: dấu hiệu escape, kỹ thuật phổ biến.

  • Thực hành: Phát hiện thử nghiệm escape trong lab.

Ngày 79: P2 - thiết kế

  • Mục tiêu: Đóng khung P2.

  • Lý thuyết: detection (Falco/Tetragon) + enforcement (seccomp/NetworkPolicy).

  • Thực hách: runtime-enforcement-design.md.

Ngày 80: P2 - detection + rules

  • Mục tiêu: Phát hiện threat.

  • Lý thuyết: Falco/Tetragon rules + alerting.

  • Thực hành: Bộ rule phát hiện + route alert.

Ngày 81: P2 - enforcement

  • Mục tiêu: Ngăn chặn thật.

  • Lý thuyết: seccomp + NetworkPolicy + Tetragon enforce.

  • Thực hành: Chặn hành vi nguy hiểm end-to-end.

Ngày 82: P2 - Runtime enforcement

  • Mục tiêu: Release P2.

  • Lý thuyết: rà "done": detection + enforcement + response + test.

  • Thực hành: Đóng gói + blog #84 ("Runtime security: phát hiện với Falco và ngăn chặn bằng eBPF/Tetragon"). P2 done.

KHỐI D - Supply Chain Security (Ngày 83-112) → P3

Ngày 83: Bối cảnh supply chain

  • Mục tiêu: Vì sao là mặt trận nóng.

  • Lý thuyết: SolarWinds, xz backdoor, dependency confusion.

  • Thực hành: Vẽ chuỗi cung ứng phần mềm của mình.

Ngày 84: Rủi ro dependency

  • Mục tiêu: Nguy cơ từ phụ thuộc.

  • Lý thuyết: transitive deps, typosquatting, malicious package.

  • Thực hành: Rà cây dependency một dự án.

Ngày 85: Dependency scanning

  • Mục tiêu: Vá lỗ hổng thư viện.

  • Lý thuyết: SCA, Dependabot/Renovate, auto-update.

  • Thực hành: Bật scan + auto PR update.

Ngày 86: SBOM - vì sao

  • Mục tiêu: Biết mình dùng gì.

  • Lý thuyết: Software Bill of Materials, minh bạch thành phần.

  • Thực hành: Liệt kê lợi ích SBOM cho một release.

Ngày 87: SBOM formats

  • Mục tiêu: Chuẩn hoá.

  • Lý thuyết: SPDX vs CycloneDX.

  • Thực hành: Đọc một SBOM mẫu.

Ngày 88: Sinh SBOM

  • Mục tiêu: Tạo SBOM.

  • Lý thuyết: Syft, SBOM cho image/repo.

  • Thực hành: Sinh SBOM cho một image.

Ngày 89: Scan từ SBOM

  • Mục tiêu: Lỗ hổng theo thành phần.

  • Lý thuyết: Grype quét SBOM.

  • Thực hành: Quét SBOM tìm CVE.

Ngày 90: CỘT MỐC 90

  • Mục tiêu: Chốt runtime + vào supply chain.

  • Lý thuyết: Ôn C + đầu D; kiểm kê: runtime enforcement (P2) + SBOM/scan.

  • Thực hành: Đề thi #3 (runtime security/SBOM) + tự chấm; blog #85 ("SBOM và quét lỗ hổng: minh bạch chuỗi cung ứng"); tag layer8-day090; nghỉ nửa ngày. Đã đi 90/150 (60%).

Ngày 91: SLSA framework

  • Mục tiêu: Chuẩn toàn vẹn build.

  • Lý thuyết: SLSA levels, threats trong build pipeline.

  • Thực hành: Đánh giá pipeline theo SLSA.

Ngày 92: SLSA provenance

  • Mục tiêu: Nguồn gốc artifact.

  • Lý thuyết: provenance = ai build, từ gì, thế nào.

  • Thực hành: Sinh provenance cho một build.

Ngày 93: Build security

  • Mục tiêu: Build đáng tin.

  • Lý thuyết: hermetic/reproducible build, ephemeral runner.

  • Thực hành: Làm một build reproducible hơn.

Ngày 94: CI/CD security

  • Mục tiêu: Bảo vệ pipeline.

  • Lý thuyết: pipeline threats, OIDC không key (nối Layer 5), least privilege runner.

  • Thực hành: Siết quyền pipeline + OIDC.

Ngày 95: Sigstore - overview

  • Mục tiêu: Ký artifact hiện đại.

  • Lý thuyết: cosign + Fulcio + Rekor.

  • Thực hành: Đọc kiến trúc Sigstore.

Ngày 96: cosign - signing

  • Mục tiêu: Ký image/artifact.

  • Lý thuyết: ký bằng key, verify.

  • Thực hành: Ký + verify một image.

Ngày 97: Keyless signing

  • Mục tiêu: Ký không giữ key.

  • Lý thuyết: Fulcio + OIDC identity, short-lived cert.

  • Thực hành: Keyless sign trong CI.

Ngày 98: Rekor

  • Mục tiêu: Minh bạch chữ ký.

  • Lý thuyết: transparency log, tamper-evident.

  • Thực hành: Kiểm một entry trong Rekor.

Ngày 99: in-toto attestations

  • Mục tiêu: Chứng thực từng bước.

  • Lý thuyết: attestation framework, predicate.

  • Thực hành: Tạo một attestation (test/scan result).

Ngày 100:

  • Mục tiêu: Kiểm kê lớn giữa Layer 8.

  • Lý thuyết: Ôn A→D; kiểm kê lớn: threat model + hardened baseline (P1) + runtime (P2) + SBOM/sign đang thành hình; đối chiếu "biết dùng+".

  • Thực hành: Đề thi #4 tích lũy (threat/platform/runtime/supply chain) + tự chấm theo rubric; blog #86 ("100 ngày security: hardening, runtime, và chuỗi cung ứng có chữ ký"); tag layer8-day100; nghỉ nửa ngày. Đã đi 100/150 (67%).

Ngày 101: Provenance attestation

  • Mục tiêu: Gắn provenance vào artifact.

  • Lý thuyết: SLSA provenance attestation, cosign attach.

  • Thực hành: Gắn provenance đã ký cho image.

Ngày 102: Signing trong pipeline

  • Mục tiêu: Tự động ký.

  • Lý thuyết: ký + attest ở bước build.

  • Thực hành: Pipeline tự sign + attest.

Ngày 103: Admission verification

  • Mục tiêu: Chỉ chạy artifact tin cậy (nối Layer 4).

  • Lý thuyết: verify signature/provenance tại admission.

  • Thực hành: Cài verification tại admission.

Ngày 104: policy-controller/Kyverno verifyImages

  • Mục tiêu: Enforce chữ ký.

  • Lý thuyết: Sigstore policy-controller, Kyverno verifyImages.

  • Thực hành: Chặn image không ký.

Ngày 105: Only-signed-images

  • Mục tiêu: Chính sách nền tảng.

  • Lý thuyết: enforce toàn cluster, exception.

  • Thực hành: Toàn cluster chỉ chạy image đã ký.

Ngày 106: Vulnerability admission

  • Mục tiêu: Chặn CVE nặng.

  • Lý thuyết: block image có critical CVE.

  • Thực hành: Admission từ chối image nhiều CVE.

Ngày 107: VEX

  • Mục tiêu: Giảm nhiễu CVE.

  • Lý thuyết: Vulnerability Exploitability eXchange, "không ảnh hưởng".

  • Thực hành: Đọc/áp một VEX statement.

Ngày 108: Registry security

  • Mục tiêu: Bảo vệ kho artifact (nối Layer 4).

  • Lý thuyết: access control, immutability, mirror tin cậy.

  • Thực hành: Siết quyền + bật immutability registry.

Ngày 109: P3 - thiết kế

  • Mục tiêu: Đóng khung P3.

  • Lý thuyết: SBOM + scan + sign + provenance + admission.

  • Thực hách: supply-chain-design.md.

Ngày 110: P3 - CI: SBOM+scan+sign+provenance

  • Mục tiêu: Pipeline an toàn.

  • Lý thuyết: ghép mọi bước vào build.

  • Thực hành: Pipeline sinh SBOM + scan + keyless sign + provenance.

Ngày 111: P3 - admission verification

  • Mục tiêu: Enforce ở runtime.

  • Lý thuyết: chỉ chạy image ký + có provenance.

  • Thực hành: Admission chặn artifact không đạt.

Ngày 112: P3 - Signed supply chain

  • Mục tiêu: Release P3.

  • Lý thuyết: rà "done": SBOM + scan + sign + provenance + admission.

  • Thực hành: Đóng gói + blog #87 ("Chuỗi cung ứng có chữ ký: SBOM, cosign, SLSA provenance và admission"). P3 done.

KHỐI E - Cryptography & Hardware (Ngày 113-136)

Ngày 113: Crypto fundamentals

  • Mục tiêu: Đủ để dùng đúng.

  • Lý thuyết: symmetric vs asymmetric, khi nào dùng.

  • Thực hành: Mã hoá/giải mã một mẩu dữ liệu.

Ngày 114: Hashing & HMAC

  • Mục tiêu: Toàn vẹn.

  • Lý thuyết: hash, salt, HMAC, password hashing (argon2/bcrypt).

  • Thực hành: HMAC + hash password đúng cách.

Ngày 115: Digital signatures

  • Mục tiêu: Xác thực nguồn.

  • Lý thuyết: sign/verify, non-repudiation.

  • Thực hành: Ký + verify một message.

Ngày 116: Key exchange

  • Mục tiêu: Trao khoá an toàn.

  • Lý thuyết: Diffie-Hellman, forward secrecy.

  • Thực hành: Đọc handshake trao khoá.

Ngày 117: TLS

  • Mục tiêu: Bảo mật truyền (nối Layer 3).

  • Lý thuyết: handshake, cipher suite, TLS 1.3.

  • Thực hành: Kiểm cấu hình TLS một service (testssl).

Ngày 118: mTLS

  • Mục tiêu: Xác thực hai chiều (nối Layer 4).

  • Lý thuyết: mutual TLS, workload identity.

  • Thực hành: Bật mTLS giữa hai service.

Ngày 119: Key management & rotation

  • Mục tiêu: Quản khoá đúng (nối Layer 5).

  • Lý thuyết: rotation, envelope encryption, Vault.

  • Thực hành: Rotate key + đo tác động.

Ngày 120: CỘT MỐC 120

  • Mục tiêu: Chốt supply chain + nửa crypto.

  • Lý thuyết: Ôn D + đầu E; kiểm kê: signed supply chain (P3) + crypto cơ bản.

  • Thực hành: Đề thi #5 (supply chain/crypto/TLS) + tự chấm; blog #88 ("Đủ crypto để làm platform: hashing, chữ ký, TLS/mTLS, key rotation"); tag layer8-day120; nghỉ nửa ngày. Đã đi 120/150 (80%).

Ngày 121: Đừng tự cài crypto

  • Mục tiêu: Tránh lỗi chết người.

  • Lý thuyết: pitfalls (nonce reuse, timing, padding), dùng thư viện chuẩn.

  • Thực hành: Rà một đoạn crypto sai; sửa bằng lib chuẩn.

Ngày 122: PKI sâu

  • Mục tiêu: Hạ tầng khoá công khai (nối Layer 5).

  • Lý thuyết: CA hierarchy, cert lifecycle, revocation (CRL/OCSP).

  • Thực hành: Dựng CA + cấp/rotate cert (Vault PKI).

Ngày 123: Certificate transparency & ACME

  • Mục tiêu: Cert minh bạch, tự động.

  • Lý thuyết: CT log, ACME/Let's Encrypt, cert-manager (nối Layer 4).

  • Thực hành: Tự động cấp cert bằng ACME.

Ngày 124: Post-quantum (nhận thức)

  • Mục tiêu: Chuẩn bị tương lai.

  • Lý thuyết: PQC, hybrid, migration.

  • Thực hành: Ghi chú lộ trình PQC.

Ngày 125: TPM

  • Mục tiêu: Gốc tin cậy phần cứng (nối Layer 3).

  • Lý thuyết: PCR, measured boot, sealing, attestation.

  • Thực hành: Đọc PCR; seal một secret theo trạng thái boot.

Ngày 126: HSM

  • Mục tiêu: Lưu khoá cứng.

  • Lý thuyết: HSM, key never leaves, PKCS#11.

  • Thực hành: Đọc mô hình HSM; use case.

Ngày 127: Attestation

  • Mục tiêu: Chứng minh trạng thái tin cậy.

  • Lý thuyết: remote attestation, quote.

  • Thực hành: Luồng attestation cơ bản (khái niệm/lab).

Ngày 128: Confidential Computing - overview

  • Mục tiêu: Bảo vệ dữ liệu đang dùng.

  • Lý thuyết: data-in-use encryption, TEE.

  • Thực hành: Xác định use case cần confidential computing.

Ngày 129: Intel SGX

  • Mục tiêu: Enclave.

  • Lý thuyết: enclave, sealed memory, hạn chế.

  • Thực hành: Đọc mô hình SGX; ưu/nhược.

Ngày 130: AMD SEV/SEV-SNP

  • Mục tiêu: Confidential VM.

  • Lý thuyết: memory encryption per-VM, SNP integrity (nối Layer 2).

  • Thực hành: Đọc kiến trúc SEV-SNP.

Ngày 131: Intel TDX

  • Mục tiêu: Trust domain.

  • Lý thuyết: TDX, VM-level isolation khỏi hypervisor.

  • Thực hành: So SGX vs SEV vs TDX.

Ngày 132: Confidential VMs/containers

  • Mục tiêu: Ứng dụng thực tế (nối Layer 2/4).

  • Lý thuyết: confidential containers, cloud CVM.

  • Thực hành: Đọc cách chạy confidential container.

Ngày 133: Attestation cho confidential computing

  • Mục tiêu: Tin trước khi trao dữ liệu.

  • Lý thuyết: remote attestation của TEE, release key sau attest.

  • Thực hành: Luồng "attest rồi mới cấp secret".

Ngày 134: Use cases

  • Mục tiêu: Khi nào đáng dùng.

  • Lý thuyết: multi-party computation, dữ liệu nhạy cảm/quy định.

  • Thực hành: Chọn use case phù hợp confidential computing.

Ngày 135: Secure boot end-to-end

  • Mục tiêu: Chuỗi tin cậy đầy đủ (nối Layer 3).

  • Lý thuyết: secure boot → measured boot → attestation → workload.

  • Thực hành: Vẽ chuỗi tin cậy từ firmware tới workload.

Ngày 136: Ôn Khối E

  • Mục tiêu: Chốt crypto/hardware.

  • Lý thuyết: rà crypto/PKI/TPM/HSM/confidential computing.

  • Thực hành: Chuẩn bị compliance.

KHỐI F - Compliance (Ngày 137-144)

Ngày 137: Compliance overview

  • Mục tiêu: Vì sao & khung nào.

  • Lý thuyết: compliance vs security, các framework.

  • Thực hành: Xác định framework liên quan.

Ngày 138: CIS Benchmarks

  • Mục tiêu: Chuẩn hardening đo được.

  • Lý thuyết: CIS cho OS/container/k8s/cloud (recap + áp).

  • Thực hành: Đo tuân thủ CIS toàn stack.

Ngày 139: NIST

  • Mục tiêu: Khung kiểm soát.

  • Lý thuyết: NIST CSF, 800-53 controls.

  • Thực hành: Map một số control NIST vào hệ.

Ngày 140: SOC2

  • Mục tiêu: Chứng nhận tin cậy.

  • Lý thuyết: trust service criteria, evidence.

  • Thực hành: Liệt kê evidence cần cho một criteria.

Ngày 141: PCI-DSS/khác (nhận thức)

  • Mục tiêu: Biết bối cảnh ngành.

  • Lý thuyết: PCI-DSS, HIPAA, GDPR (khái niệm).

  • Thực hành: Xác định yêu cầu áp dụng.

Ngày 142: Control mapping

  • Mục tiêu: Từ framework tới triển khai.

  • Lý thuyết: control → implementation → evidence.

  • Thực hành: Bảng mapping control → cấu hình thực tế.

Ngày 143: Compliance-as-code

  • Mục tiêu: Tuân thủ liên tục (nối Layer 5).

  • Lý thuyết: policy-as-code, config rules, continuous compliance.

  • Thực hành: Tự động kiểm một control.

Ngày 144: Audit evidence

  • Mục tiêu: Sẵn sàng audit.

  • Lý thuyết: thu thập evidence tự động, attestation.

  • Thực hành: Sinh evidence tự động cho một control.

KHỐI G - Secure Platform capstone (Ngày 145-150) → P4 flagship

Ngày 145: P4 - tích hợp

  • Mục tiêu: Ghép mọi mảnh.

  • Lý thuyết: hardened baseline (P1) + runtime (P2) + supply chain (P3).

  • Thực hành: Nối 3 project vào một nền tảng an toàn.

Ngày 146: P4 - policy-as-code có test

  • Mục tiêu: Guardrail kiểm chứng được.

  • Lý thuyết: OPA/Kyverno policy + unit test (nối Layer 4/5).

  • Thực hành: Bộ policy an toàn có test tự động.

Ngày 147: P4 - crypto/secrets baseline

  • Mục tiêu: Nền mật mã.

  • Lý thuyết: Vault/PKI + mTLS + encryption at rest.

  • Thực hành: Baseline secrets/crypto cho platform.

Ngày 148: P4 - compliance

  • Mục tiêu: Tuân thủ liên tục.

  • Lý thuyết: control mapping + continuous checks.

  • Thực hành: Dashboard tuân thủ (nối Layer 7).

Ngày 149: P4 - red-team drill; ôn Layer 8

  • Mục tiêu: Chứng minh phòng thủ.

  • Lý thuyết: tấn công → phát hiện → chặn → điều tra.

  • Thực hành: Red-team drill: thử tấn công, xác nhận detect+block; rà toàn layer.

Ngày 150: HOÀN THÀNH LAYER 8

  • Mục tiêu: Chốt Security Engineering ở mức "biết dùng+ vững".

  • Lý thuyết: Ôn toàn layer; kiểm kê tổng: threat model + P1 hardened baseline + P2 runtime enforcement + P3 signed supply chain + P4 Secure Platform (policy-as-code có test + crypto/compliance).

  • Thực hành: P4 done; đề thi #6 tích lũy (toàn layer) + tự chấm theo rubric; blog #89 ("Nhìn lại 150 ngày security: một Secure Platform với supply chain có chữ ký và runtime enforcement"); tag layer8-complete; nghỉ nửa ngày.

LAYER 9 - DATA PLATFORM ENGINEERING

Tài nguyên: Fundamentals of Data Engineering (Reis & Housley), Designing Data-Intensive Applications (Kleppmann), Streaming Systems (Akidau et al.), The Data Warehouse Toolkit (Kimball), docs Kafka/Iceberg/Delta/Hudi/Trino/dbt/Airflow/Dagster/DataHub.

KHỐI A - Fundamentals & Architecture (Ngày 1-24)

Ngày 1: Khởi động Layer 9

  • Mục tiêu: Data platform là gì + dựng lab.

  • Lý thuyết: vai trò nền tảng dữ liệu, các thành phần chính.

  • Thực hành: Repo data-platform/; dựng lab (object storage + Kafka + engine local).

Ngày 2: Data lifecycle

  • Mục tiêu: Vòng đời dữ liệu.

  • Lý thuyết: generation → ingestion → storage → transform → serve.

  • Thực hành: Vẽ lifecycle cho một use case.

Ngày 3: OLTP vs OLAP

  • Mục tiêu: Hai thế giới (nối Layer 3).

  • Lý thuyết: transactional vs analytical, row vs columnar.

  • Thực hành: Phân loại workload OLTP/OLAP.

Ngày 4: Warehouse vs lake vs lakehouse

  • Mục tiêu: Ba kiến trúc lưu trữ.

  • Lý thuyết: warehouse (schema-on-write) vs lake (schema-on-read) vs lakehouse (kết hợp).

  • Thực hành: Bảng đánh đổi.

Ngày 5: Batch vs streaming

  • Mục tiêu: Hai chế độ xử lý.

  • Lý thuyết: Lambda vs Kappa architecture.

  • Thực hành: Chọn kiến trúc cho một bài toán.

Ngày 6: Medallion architecture

  • Mục tiêu: Tổ chức tầng dữ liệu.

  • Lý thuyết: bronze (raw) → silver (cleaned) → gold (curated).

  • Thực hành: Thiết kế 3 tầng cho một domain.

Ngày 7: ETL vs ELT

  • Mục tiêu: Thứ tự transform.

  • Lý thuyết: ETL (transform trước) vs ELT (load rồi transform), vì sao ELT lên ngôi.

  • Thực hành: Phác ELT flow.

Ngày 8: Dimensional modeling

  • Mục tiêu: Mô hình cho analytics.

  • Lý thuyết: Kimball: fact/dimension, star/snowflake schema.

  • Thực hành: Thiết kế star schema cho một domain.

Ngày 9: Modeling khác

  • Mục tiêu: Ngoài Kimball.

  • Lý thuyết: Inmon (normalized), Data Vault (khái niệm).

  • Thực hành: So sánh khi nào dùng gì.

Ngày 10: File formats - row vs columnar

  • Mục tiêu: Nền lưu trữ analytics.

  • Lý thuyết: vì sao columnar nhanh cho OLAP (nối Layer 3).

  • Thực hành: So kích thước/tốc độ row vs columnar.

Ngày 11: Parquet

  • Mục tiêu: Format columnar chủ đạo.

  • Lý thuyết: row group, column chunk, encoding, predicate pushdown.

  • Thực hành: Ghi/đọc Parquet; xem metadata.

Ngày 12: ORC & Avro

  • Mục tiêu: Các format khác.

  • Lý thuyết: ORC (columnar), Avro (row, schema evolution), tradeoff.

  • Thực hành: So Parquet/ORC/Avro cho use case.

Ngày 13: Compression & encoding

  • Mục tiêu: Tiết kiệm & nhanh.

  • Lý thuyết: dictionary/RLE/delta (nối Layer 3), codec (zstd/snappy).

  • Thực hành: Đo dung lượng theo codec.

Ngày 14: Partitioning & clustering

  • Mục tiêu: Truy vấn nhanh, quét ít.

  • Lý thuyết: partition pruning, clustering/sorting.

  • Thực hành: Partition một dataset; đo tác động query.

Ngày 15: Object storage foundation

  • Mục tiêu: Nền của lake/lakehouse (nối Layer 3).

  • Lý thuyết: S3 semantics, list cost, eventual→strong consistency.

  • Thực hành: Layout dữ liệu trên object storage.

Ngày 16: Data mesh

  • Mục tiêu: Tổ chức dữ liệu phân tán.

  • Lý thuyết: domain ownership, data-as-product, federated governance.

  • Thực hành: Phác data mesh cho một tổ chức.

Ngày 17: Architecture patterns

  • Mục tiêu: Mẫu kiến trúc.

  • Lý thuyết: ingestion → lakehouse → serving; streaming-first.

  • Thực hành: Vẽ kiến trúc mục tiêu.

Ngày 18: Schema management

  • Mục tiêu: Quản lý schema (preview).

  • Lý thuyết: schema evolution, compatibility (backward/forward).

  • Thực hành: Kịch bản đổi schema an toàn.

Ngày 19: Governance overview

  • Mục tiêu: Bắc cầu Khối F.

  • Lý thuyết: catalog, lineage, quality, contracts.

  • Thực hành: Liệt kê nhu cầu governance.

Ngày 20: Data platform trên k8s

  • Mục tiêu: Vận hành (nối Layer 4).

  • Lý thuyết: operators (Strimzi/Flink/Trino), storage.

  • Thực hành: Chuẩn bị chạy stack trên k8s.

Ngày 21: Cost model

  • Mục tiêu: Kinh tế dữ liệu (nối Layer 11).

  • Lý thuyết: storage vs compute, egress, query cost.

  • Thực hành: Ước tính chi phí một platform.

Ngày 22: Security & privacy overview

  • Mục tiêu: Dữ liệu an toàn (nối Layer 8).

  • Lý thuyết: PII, masking, access control, encryption.

  • Thực hành: Phân loại dữ liệu nhạy cảm.

Ngày 23: Ôn Khối A

  • Mục tiêu: Chốt nền kiến trúc.

  • Lý thuyết: rà lifecycle → format → lake/warehouse → mesh.

  • Thực hành: Chuẩn bị architecture doc.

Ngày 24: Data platform architecture doc

  • Mục tiêu: Kim chỉ nam.

  • Lý thuyết: kiến trúc + tầng + format + governance.

  • Thực hành: Viết architecture doc (dùng xuyên layer).

KHỐI B - Streaming (Ngày 25-60) → P1

Ngày 25: Streaming fundamentals

  • Mục tiêu: Tư duy log/event.

  • Lý thuyết: event, immutable log, pub/sub, append-only.

  • Thực hành: Mô hình hoá một domain theo event.

Ngày 26: Kafka - kiến trúc

  • Mục tiêu: Nền streaming chủ đạo.

  • Lý thuyết: broker, topic, partition, offset.

  • Thực hành: Dựng Kafka; tạo topic; produce/consume.

Ngày 27: Kafka - producer

  • Mục tiêu: Ghi tin cậy.

  • Lý thuyết: acks, idempotent producer, batching, partitioner.

  • Thực hành: Producer với acks=all + idempotence.

Ngày 28: Kafka - consumer

  • Mục tiêu: Đọc đúng.

  • Lý thuyết: consumer group, rebalance, offset commit.

  • Thực hành: Consumer group; quan sát rebalance.

Ngày 29: Kafka - replication

  • Mục tiêu: Độ bền.

  • Lý thuyết: replication factor, ISR, leader/follower.

  • Thực hành: Hạ một broker; quan sát failover.

Ngày 30: CỘT MỐC 30

  • Mục tiêu: Chốt nền kiến trúc + Kafka cơ bản.

  • Lý thuyết: Ôn A + đầu B; kiểm kê: architecture doc + Kafka produce/consume/replication.

  • Thực hành: Đề thi #1 (architecture/format/Kafka basics) + tự chấm; blog #90 ("Kiến trúc data platform và nền tảng streaming với Kafka"); tag layer9-day030; nghỉ nửa ngày. Đã đi 30/150 (20%).

Ngày 31: Kafka - exactly-once

  • Mục tiêu: Không trùng, không mất.

  • Lý thuyết: transactions, idempotence, read-process-write.

  • Thực hành: Pipeline exactly-once đơn giản.

Ngày 32: Kafka - KRaft & vận hành

  • Mục tiêu: Kafka hiện đại.

  • Lý thuyết: KRaft (bỏ ZooKeeper), controller, ops.

  • Thực hành: Cluster KRaft; kiểm tra metadata.

Ngày 33: Kafka - retention & storage

  • Mục tiêu: Giữ dữ liệu đúng.

  • Lý thuyết: retention, log compaction, tiered storage.

  • Thực hành: Cấu hình compaction + retention.

Ngày 34: Schema Registry

  • Mục tiêu: Schema cho stream.

  • Lý thuyết: Avro/Protobuf, compatibility mode.

  • Thực hành: Đăng ký schema; test evolution.

Ngày 35: Kafka Connect

  • Mục tiêu: Nối nguồn/đích không code.

  • Lý thuyết: source/sink connector, converter.

  • Thực hành: Connect từ DB → Kafka → object storage.

Ngày 36: Kafka trên k8s

  • Mục tiêu: Vận hành (nối Layer 4).

  • Lý thuyết: Strimzi operator.

  • Thực hành: Dựng Kafka bằng Strimzi.

Ngày 37: Kafka performance

  • Mục tiêu: Nhanh & bền.

  • Lý thuyết: zero-copy (nối Layer 2), page cache, batching, partition count.

  • Thực hành: Benchmark throughput; tuning.

Ngày 38: Pulsar - kiến trúc

  • Mục tiêu: Lựa chọn khác.

  • Lý thuyết: broker + BookKeeper, tách compute/storage.

  • Thực hành: Dựng Pulsar; produce/consume.

Ngày 39: Pulsar - tính năng

  • Mục tiêu: Điểm mạnh Pulsar.

  • Lý thuyết: segment, tiered storage, multi-tenancy, geo-replication.

  • Thực hành: Thử multi-tenancy.

Ngày 40: Kafka vs Pulsar

  • Mục tiêu: Chọn công cụ.

  • Lý thuyết: kiến trúc, ecosystem, vận hành.

  • Thực hành: Bảng đánh đổi.

Ngày 41: CDC - khái niệm

  • Mục tiêu: Bắt thay đổi DB.

  • Lý thuyết: change data capture, log-based vs query-based.

  • Thực hành: So sánh phương pháp CDC.

Ngày 42: Debezium

  • Mục tiêu: CDC thực chiến (nối Layer 3).

  • Lý thuyết: đọc WAL/binlog, connector, tombstone.

  • Thực hành: Debezium capture thay đổi Postgres → Kafka.

Ngày 43: CDC patterns

  • Mục tiêu: Dùng CDC đúng.

  • Lý thuyết: outbox pattern, snapshot + streaming, ordering.

  • Thực hành: Cài outbox pattern.

Ngày 44: CDC → lakehouse

  • Mục tiêu: Đồng bộ vào lake (preview C).

  • Lý thuyết: upsert từ CDC vào table format.

  • Thực hành: Phác luồng CDC → Iceberg.

Ngày 45: Stream processing - nền

  • Mục tiêu: Xử lý dòng.

  • Lý thuyết: stateless vs stateful, time (event/processing).

  • Thực hành: Phân loại phép xử lý stream.

Ngày 46: Kafka Streams

  • Mục tiêu: Xử lý trong app.

  • Lý thuyết: KStream/KTable, topology, state store.

  • Thực hành: App Kafka Streams đếm/aggregate.

  • Mục tiêu: Stream processor mạnh.

  • Lý thuyết: JobManager/TaskManager, dataflow, operator.

  • Thực hành: Dựng Flink; chạy job.

  • Mục tiêu: Trạng thái tin cậy.

  • Lý thuyết: state backend, checkpoint, savepoint, exactly-once.

  • Thực hành: Job có state + checkpoint; recover.

  • Mục tiêu: Gom theo thời gian.

  • Lý thuyết: tumbling/sliding/session window, watermark, event time.

  • Thực hành: Aggregate theo window với watermark.

Ngày 50: Streaming joins & aggregations

  • Mục tiêu: Kết hợp dòng.

  • Lý thuyết: stream-stream/stream-table join.

  • Thực hành: Join hai stream.

Ngày 51: Streaming SQL

  • Mục tiêu: SQL cho stream.

  • Lý thuyết: ksqlDB/Flink SQL.

  • Thực hành: Xử lý stream bằng SQL.

Ngày 52: Backpressure

  • Mục tiêu: Ổn định dưới tải.

  • Lý thuyết: backpressure, flow control.

  • Thực hành: Quan sát backpressure trong Flink.

Ngày 53: Error handling

  • Mục tiêu: Không mất dữ liệu.

  • Lý thuyết: dead letter queue, retry, poison message.

  • Thực hành: DLQ cho message lỗi.

Ngày 54: Stream observability

  • Mục tiêu: Nhìn thấy pipeline (nối Layer 7).

  • Lý thuyết: lag, throughput, consumer lag alert.

  • Thực hành: Dashboard + alert consumer lag.

Ngày 55: Streaming data quality

  • Mục tiêu: Dữ liệu sạch từ đầu.

  • Lý thuyết: validation trong stream, schema enforcement.

  • Thực hành: Validate + route bad record.

Ngày 56: P1 - thiết kế

  • Mục tiêu: Đóng khung P1.

  • Lý thuyết: ingest streaming + CDC + processing.

  • Thực hách: streaming-ingest-design.md.

Ngày 57: P1 - Kafka + Registry + Connect

  • Mục tiêu: Nền ingest.

  • Lý thuyết: topic + schema + connector.

  • Thực hành: Kafka + Schema Registry + Connect chạy.

Ngày 58: P1 - CDC

  • Mục tiêu: Bắt thay đổi DB.

  • Lý thuyết: Debezium từ một DB thật.

  • Thực hành: CDC → Kafka topic.

Ngày 59: P1 - stream processing + test

  • Mục tiêu: Xử lý dòng.

  • Lý thuyết: Flink/Kafka Streams transform + aggregate.

  • Thực hành: Xử lý + test exactly-once.

Ngày 60: CỘT MỐC 60

  • Mục tiêu: Chốt streaming; release P1.

  • Lý thuyết: Ôn B; kiểm kê: Kafka + CDC + stream processing.

  • Thực hành: P1 done; đề thi #2 (Kafka/CDC/Flink) + tự chấm; blog #91 ("Streaming ingestion: Kafka, CDC với Debezium, và xử lý dòng bằng Flink"); tag layer9-day060; nghỉ nửa ngày. Đã đi 60/150 (40%).

KHỐI C - Lakehouse (Ngày 61-90) → P2

Ngày 61: Lakehouse - vì sao

  • Mục tiêu: ACID trên data lake.

  • Lý thuyết: kết hợp linh hoạt của lake + tin cậy của warehouse.

  • Thực hành: So lake thuần vs lakehouse.

Ngày 62: Table format

  • Mục tiêu: Lớp metadata trên file.

  • Lý thuyết: table format = metadata + snapshot trên file Parquet.

  • Thực hành: Vẽ layers: files → metadata → table.

Ngày 63: Iceberg - kiến trúc

  • Mục tiêu: Table format hàng đầu.

  • Lý thuyết: metadata file, manifest list, manifest, data files.

  • Thực hành: Tạo bảng Iceberg; xem metadata.

Ngày 64: Iceberg - snapshot & time travel

  • Mục tiêu: Lịch sử dữ liệu.

  • Lý thuyết: snapshot, time travel, rollback.

  • Thực hành: Query bảng ở thời điểm quá khứ.

Ngày 65: Iceberg - hidden partitioning

  • Mục tiêu: Partition không lộ cho user.

  • Lý thuyết: partition transform, partition evolution.

  • Thực hành: Đổi partition scheme không rewrite.

Ngày 66: Iceberg - schema evolution

  • Mục tiêu: Đổi schema an toàn.

  • Lý thuyết: add/drop/rename column, type promotion.

  • Thực hành: Evolve schema; đọc dữ liệu cũ + mới.

Ngày 67: Iceberg - catalog

  • Mục tiêu: Quản lý bảng.

  • Lý thuyết: Hive/REST/Polaris/Gravitino catalog.

  • Thực hành: Cấu hình REST catalog.

Ngày 68: Delta Lake - transaction log

  • Mục tiêu: ACID kiểu Delta.

  • Lý thuyết: _delta_log, optimistic concurrency.

  • Thực hành: Tạo bảng Delta; xem log.

Ngày 69: Delta Lake - DML & time travel

  • Mục tiêu: Cập nhật dữ liệu lake.

  • Lý thuyết: MERGE/UPDATE/DELETE, time travel.

  • Thực hành: MERGE (upsert) vào Delta.

Ngày 70: Hudi - COW vs MOR

  • Mục tiêu: Format tối ưu upsert.

  • Lý thuyết: copy-on-write vs merge-on-read (nối Layer 3 LSM/B-tree).

  • Thực hành: So COW vs MOR cho write-heavy.

Ngày 71: Hudi - incremental

  • Mục tiêu: Đọc thay đổi.

  • Lý thuyết: incremental query, upsert.

  • Thực hành: Incremental read từ Hudi.

Ngày 72: Iceberg vs Delta vs Hudi

  • Mục tiêu: Chọn format.

  • Lý thuyết: tính năng, ecosystem, engine support.

  • Thực hành: Bảng đánh đổi.

Ngày 73: Catalog & metastore

  • Mục tiêu: Nơi biết bảng ở đâu.

  • Lý thuyết: Hive Metastore, REST catalog, interoperability.

  • Thực hành: Đăng ký bảng vào catalog dùng chung.

Ngày 74: Ghi batch

  • Mục tiêu: Nạp dữ liệu lớn.

  • Lý thuyết: batch append/overwrite, file sizing.

  • Thực hành: Batch load vào lakehouse.

Ngày 75: Ghi streaming

  • Mục tiêu: Nạp liên tục (nối Khối B).

  • Lý thuyết: streaming write từ Kafka/Flink → table format.

  • Thực hành: Stream từ Kafka → Iceberg/Delta.

Ngày 76: CDC → lakehouse

  • Mục tiêu: Đồng bộ DB → lake.

  • Lý thuyết: upsert từ CDC, dedup, ordering.

  • Thực hành: CDC (P1) → upsert vào lakehouse.

Ngày 77: Small files problem

  • Mục tiêu: Giữ hiệu năng.

  • Lý thuyết: small files, compaction.

  • Thực hành: Compaction; đo cải thiện query.

Ngày 78: Partitioning & performance

  • Mục tiêu: Query nhanh.

  • Lý thuyết: partition pruning, file skipping, statistics.

  • Thực hành: Tối ưu layout cho một query.

Ngày 79: Schema evolution & governance

  • Mục tiêu: Đổi an toàn ở quy mô.

  • Lý thuyết: compatibility, contract (nối Khối F).

  • Thực hành: Evolve schema có kiểm soát.

Ngày 80: Time travel use cases

  • Mục tiêu: Ứng dụng lịch sử.

  • Lý thuyết: audit, rollback, reproducibility.

  • Thực hành: Rollback sau một ghi sai.

Ngày 81: Lakehouse trên object storage

  • Mục tiêu: Nền lưu trữ (nối Layer 3).

  • Lý thuyết: S3 semantics, consistency, cost.

  • Thực hành: Cấu hình lakehouse trên object storage.

Ngày 82: Table maintenance

  • Mục tiêu: Bảng khoẻ.

  • Lý thuyết: expire snapshots, compaction, orphan cleanup.

  • Thực hành: Lịch maintenance tự động.

Ngày 83: Lakehouse + query engine

  • Mục tiêu: Bắc cầu Khối D.

  • Lý thuyết: engine đọc table format (Trino/Spark/DuckDB).

  • Thực hành: Query lakehouse bằng một engine.

Ngày 84: Data layout optimization

  • Mục tiêu: Tối ưu vật lý.

  • Lý thuyết: Z-order/sorting, clustering.

  • Thực hành: Sắp xếp lại; đo query.

Ngày 85: Governance trên lakehouse

  • Mục tiêu: Kiểm soát truy cập (nối Layer 8).

  • Lý thuyết: table/column ACL, masking.

  • Thực hành: Áp access control lên bảng.

Ngày 86: P2 - thiết kế

  • Mục tiêu: Đóng khung P2.

  • Lý thuyết: table format + catalog + ingest + maintenance.

  • Thực hách: lakehouse-design.md.

Ngày 87: P2 - Iceberg/Delta trên object storage

  • Mục tiêu: Nền lakehouse.

  • Lý thuyết: bảng + catalog + object storage.

  • Thực hành: Lakehouse chạy được.

Ngày 88: P2 - batch + streaming ingest

  • Mục tiêu: Nạp đủ đường.

  • Lý thuyết: batch + streaming (từ P1) vào lakehouse.

  • Thực hành: Cả hai luồng ghi vào bảng.

Ngày 89: P2 - schema evolution + time travel + test

  • Mục tiêu: Tin cậy.

  • Lý thuyết: evolution + rollback.

  • Thực hành: Test evolution + time travel.

Ngày 90: CỘT MỐC 90

  • Mục tiêu: Chốt lakehouse; release P2.

  • Lý thuyết: Ôn C; kiểm kê: Iceberg/Delta + catalog + ingest + maintenance.

  • Thực hành: P2 done; đề thi #3 (table formats/lakehouse) + tự chấm; blog #92 ("Lakehouse: ACID trên object storage với Iceberg/Delta"); tag layer9-day090; nghỉ nửa ngày. Đã đi 90/150 (60%).

KHỐI D - Query & Warehouse (Ngày 91-114) → P3

Ngày 91: Query engines - MPP

  • Mục tiêu: Xử lý song song lớn.

  • Lý thuyết: massively parallel processing, shared-nothing.

  • Thực hành: Vẽ mô hình MPP.

Ngày 92: Trino - kiến trúc

  • Mục tiêu: Query engine federated.

  • Lý thuyết: coordinator/worker, connector.

  • Thực hành: Dựng Trino; query một nguồn.

Ngày 93: Trino - federated query

  • Mục tiêu: Query xuyên nguồn.

  • Lý thuyết: connector (lakehouse/DB/object), join across sources.

  • Thực hành: Join dữ liệu từ 2 nguồn khác nhau.

Ngày 94: Trino - distributed execution

  • Mục tiêu: Hiểu để tối ưu.

  • Lý thuyết: stage, split, exchange, memory.

  • Thực hành: Đọc query plan Trino.

Ngày 95: Trino - optimization

  • Mục tiêu: Query nhanh.

  • Lý thuyết: cost-based optimizer, statistics, pushdown.

  • Thực hành: Tối ưu một query chậm.

Ngày 96: Trino trên lakehouse

  • Mục tiêu: Query Iceberg/Delta.

  • Lý thuyết: Iceberg/Delta connector, metadata pruning.

  • Thực hành: Query lakehouse (P2) bằng Trino.

Ngày 97: Trino - tuning

  • Mục tiêu: Hiệu năng production.

  • Lý thuyết: resource group, memory, spill.

  • Thực hành: Tuning + benchmark.

Ngày 98: ClickHouse

  • Mục tiêu: Real-time OLAP (nối Layer 3).

  • Lý thuyết: MergeTree, columnar, materialized view.

  • Thực hành: Nạp + query analytic nhanh.

Ngày 99: ClickHouse - real-time

  • Mục tiêu: Analytics tức thời.

  • Lý thuyết: ingest streaming, aggregating engine.

  • Thực hành: Dashboard real-time trên ClickHouse.

Ngày 100:

  • Mục tiêu: Kiểm kê lớn giữa Layer 9.

  • Lý thuyết: Ôn A→C + đầu D; kiểm kê lớn: streaming (P1) + lakehouse (P2) + query khởi đầu; đối chiếu "biết dùng tốt".

  • Thực hành: Đề thi #4 tích lũy (streaming+lakehouse+query) + tự chấm theo rubric; blog #93 ("100 ngày data platform: từ streaming ingest tới query trên lakehouse"); tag layer9-day100; nghỉ nửa ngày. Đã đi 100/150 (67%).

Ngày 101: DuckDB

  • Mục tiêu: OLAP nhúng (nối Layer 3).

  • Lý thuyết: embedded, vectorized, đọc Parquet/Iceberg trực tiếp.

  • Thực hành: Query lakehouse local bằng DuckDB.

Ngày 102: DuckDB - lakehouse local

  • Mục tiêu: Phân tích không cần cluster.

  • Lý thuyết: query object storage trực tiếp.

  • Thực hành: Phân tích một dataset lớn local.

Ngày 103: StarRocks

  • Mục tiêu: Real-time OLAP + MV.

  • Lý thuyết: MPP, materialized view, lakehouse query.

  • Thực hành: So StarRocks với ClickHouse/Trino.

Ngày 104: Warehouse vs query engine vs lakehouse

  • Mục tiêu: Chọn đúng công cụ.

  • Lý thuyết: khi nào warehouse, khi nào query engine, khi nào lakehouse.

  • Thực hành: Bảng quyết định.

Ngày 105: Federated query

  • Mục tiêu: Một query nhiều nguồn.

  • Lý thuyết: federation, pushdown, data movement cost.

  • Thực hành: Federated query tối ưu.

Ngày 106: Query caching

  • Mục tiêu: Nhanh & rẻ.

  • Lý thuyết: result cache, materialized view, acceleration.

  • Thực hành: Cache/MV cho query lặp.

Ngày 107: Semantic layer

  • Mục tiêu: Định nghĩa metric nhất quán.

  • Lý thuyết: metrics layer, tránh mỗi nơi tính khác.

  • Thực hành: Định nghĩa metric dùng chung.

Ngày 108: Serving analytics

  • Mục tiêu: Đưa tới người dùng.

  • Lý thuyết: BI tools, dashboard, API serving.

  • Thực hành: Nối một BI tool vào query layer.

Ngày 109: Query cost & resource

  • Mục tiêu: Kiểm soát chi phí (nối Layer 11).

  • Lý thuyết: resource group, quota, chargeback.

  • Thực hành: Giới hạn tài nguyên theo team.

Ngày 110: Query observability

  • Mục tiêu: Nhìn thấy query (nối Layer 7).

  • Lý thuyết: query log, slow query, metrics.

  • Thực hành: Dashboard query performance.

Ngày 111: P3 - thiết kế

  • Mục tiêu: Đóng khung P3.

  • Lý thuyết: Trino federated + warehouse serving.

  • Thực hách: query-layer-design.md.

Ngày 112: P3 - Trino federated + lakehouse

  • Mục tiêu: Query xuyên nguồn.

  • Lý thuyết: Trino trên lakehouse + nguồn khác.

  • Thực hành: Federated query hoạt động.

Ngày 113: P3 - warehouse serving + test

  • Mục tiêu: Analytics tốc độ cao.

  • Lý thuyết: ClickHouse/StarRocks cho serving.

  • Thực hành: Serving layer + test hiệu năng.

Ngày 114: P3 - Query layer

  • Mục tiêu: Release P3.

  • Lý thuyết: rà "done": federated query + serving + tuning.

  • Thực hành: Đóng gói + blog #94 ("Query layer: Trino federated và warehouse cho serving"). P3 done.

KHỐI E - Workflow/Orchestration (Ngày 115-132) → P4

Ngày 115: Orchestration - nền

  • Mục tiêu: Điều phối pipeline.

  • Lý thuyết: DAG, dependency, scheduling.

  • Thực hành: Vẽ DAG một pipeline.

Ngày 116: Airflow - kiến trúc

  • Mục tiêu: Orchestrator phổ biến.

  • Lý thuyết: scheduler/executor/webserver/metadata DB.

  • Thực hành: Dựng Airflow; chạy DAG mẫu.

Ngày 117: Airflow - DAG & operators

  • Mục tiêu: Xây pipeline.

  • Lý thuyết: DAG, task, operator, dependency.

  • Thực hành: Viết DAG ingest → transform.

Ngày 118: Airflow - sensors/hooks/XCom

  • Mục tiêu: Chờ & nối.

  • Lý thuyết: sensor (chờ điều kiện), hook (nối hệ), XCom (truyền dữ liệu).

  • Thực hành: DAG chờ dữ liệu sẵn rồi chạy.

Ngày 119: Airflow - executors

  • Mục tiêu: Chạy ở quy mô (nối Layer 4).

  • Lý thuyết: Celery/Kubernetes executor.

  • Thực hành: KubernetesExecutor chạy task trên k8s.

Ngày 120: CỘT MỐC 120

  • Mục tiêu: Chốt query + vào orchestration.

  • Lý thuyết: Ôn D + đầu E; kiểm kê: query layer (P3) + Airflow cơ bản.

  • Thực hành: Đề thi #5 (Trino/warehouse/Airflow) + tự chấm; blog #95 ("Query engine và bước vào orchestration với Airflow"); tag layer9-day120; nghỉ nửa ngày. Đã đi 120/150 (80%).

Ngày 121: Airflow - backfill & idempotency

  • Mục tiêu: Chạy lại an toàn.

  • Lý thuyết: backfill, idempotent task, retry.

  • Thực hành: Backfill một khoảng thời gian.

Ngày 122: Dagster - asset-based

  • Mục tiêu: Orchestration theo tài sản.

  • Lý thuyết: software-defined assets, khác task-based.

  • Thực hành: Định nghĩa asset + materialize.

Ngày 123: Dagster - lineage

  • Mục tiêu: Phụ thuộc rõ ràng.

  • Lý thuyết: asset lineage, observability tích hợp.

  • Thực hành: Xem lineage giữa assets.

Ngày 124: Airflow vs Dagster

  • Mục tiêu: Chọn công cụ.

  • Lý thuyết: task vs asset, DX, ecosystem.

  • Thực hành: Bảng đánh đổi.

Ngày 125: dbt - transformation

  • Mục tiêu: Transform bằng SQL.

  • Lý thuyết: model, ref, materialization (view/table/incremental).

  • Thực hành: dbt model trên warehouse/lakehouse.

Ngày 126: dbt - test, docs, lineage

  • Mục tiêu: Transform tin cậy.

  • Lý thuyết: schema/data test, docs, lineage graph.

  • Thực hành: Thêm test + docs cho model.

Ngày 127: dbt + lakehouse/warehouse

  • Mục tiêu: ELT thực chiến.

  • Lý thuyết: dbt chạy trên Trino/ClickHouse/lakehouse.

  • Thực hành: dbt build medallion (silver→gold).

Ngày 128: Pipeline patterns

  • Mục tiêu: Pipeline bền.

  • Lý thuyết: idempotency, incremental, backfill, checkpoint.

  • Thực hành: Áp pattern cho một pipeline.

Ngày 129: Data quality trong pipeline

  • Mục tiêu: Chặn dữ liệu xấu (preview F).

  • Lý thuyết: quality check trong DAG, fail-fast vs quarantine.

  • Thực hành: Thêm quality gate vào pipeline.

Ngày 130: Pipeline observability

  • Mục tiêu: Nhìn thấy pipeline (nối Layer 7).

  • Lý thuyết: SLA, freshness, failure alert.

  • Thực hành: Alert khi pipeline trễ/hỏng.

Ngày 131: P4 - thiết kế + build

  • Mục tiêu: Đóng khung P4.

  • Lý thuyết: Airflow/Dagster DAG + dbt transform.

  • Thực hành: Pipeline ingest → transform (dbt) orchestrated.

Ngày 132: P4 - Orchestrated pipeline

  • Mục tiêu: Release P4.

  • Lý thuyết: rà "done": orchestration + dbt + data quality + test.

  • Thực hành: Đóng gói + blog #96 ("Orchestration với Airflow/Dagster và transform bằng dbt"). P4 done.

KHỐI F - Metadata & Governance (Ngày 133-144)

Ngày 133: Data governance - vì sao

  • Mục tiêu: Kiểm soát dữ liệu ở quy mô.

  • Lý thuyết: discovery, trust, compliance, ownership.

  • Thực hành: Liệt kê nhu cầu governance.

Ngày 134: Metadata management

  • Mục tiêu: Biết mình có dữ liệu gì.

  • Lý thuyết: technical/business/operational metadata.

  • Thực hành: Phân loại metadata cần thu.

Ngày 135: DataHub

  • Mục tiêu: Catalog & discovery.

  • Lý thuyết: ingestion, entity, search.

  • Thực hành: Dựng DataHub; ingest metadata.

Ngày 136: OpenMetadata

  • Mục tiêu: Lựa chọn khác.

  • Lý thuyết: catalog, lineage, quality tích hợp.

  • Thực hành: So DataHub vs OpenMetadata.

Ngày 137: Data lineage

  • Mục tiêu: Truy vết nguồn gốc.

  • Lý thuyết: table-level & column-level lineage.

  • Thực hành: Xem lineage một bảng gold về nguồn.

Ngày 138: Data quality - Great Expectations

  • Mục tiêu: Đảm bảo chất lượng.

  • Lý thuyết: expectation, validation, data docs.

  • Thực hành: Bộ expectation cho một dataset.

Ngày 139: Data quality - Soda & as-code

  • Mục tiêu: Quality trong CI.

  • Lý thuyết: Soda checks, quality as code.

  • Thực hành: Quality check trong pipeline CI.

Ngày 140: Data contracts

  • Mục tiêu: Thoả thuận schema (nối Layer 6).

  • Lý thuyết: producer/consumer contract, schema + SLA.

  • Thực hành: Viết một data contract.

Ngày 141: Data contracts - enforcement

  • Mục tiêu: Chặn phá vỡ contract.

  • Lý thuyết: CI check, break glass, versioning.

  • Thực hành: Enforce contract ở CI (nối Layer 6).

Ngày 142: PII, masking, access

  • Mục tiêu: Dữ liệu an toàn (nối Layer 8).

  • Lý thuyết: classification, masking, column ACL, row-level.

  • Thực hành: Mask PII + access control theo role.

Ngày 143: Governance ở quy mô

  • Mục tiêu: Governance không cản.

  • Lý thuyết: federated governance (data mesh), automation.

  • Thực hành: Chính sách governance tự động.

Ngày 144: Ôn Khối F

  • Mục tiêu: Chốt governance.

  • Lý thuyết: rà catalog/lineage/quality/contract/security.

  • Thực hành: Chuẩn bị capstone.

KHỐI G - Enterprise Data Platform capstone (Ngày 145-150) → P5 flagship

Ngày 145: P5 - tích hợp

  • Mục tiêu: Ghép mọi mảnh.

  • Lý thuyết: ingest → lakehouse → query → catalog + governance.

  • Thực hành: Nối P1/P2/P3/P4 vào một platform.

Ngày 146: P5 - ingest → lakehouse

  • Mục tiêu: Đường dữ liệu vào.

  • Lý thuyết: streaming (P1) + CDC → lakehouse (P2), medallion.

  • Thực hành: Bronze→silver→gold chạy end-to-end.

Ngày 147: P5 - query + orchestration

  • Mục tiêu: Phục vụ & điều phối.

  • Lý thuyết: query layer (P3) + orchestration (P4).

  • Thực hành: Pipeline orchestrated + query serving.

Ngày 148: P5 - catalog + lineage + quality

  • Mục tiêu: Governance sống.

  • Lý thuyết: catalog + column lineage + data quality/contracts.

  • Thực hành: Catalog tự cập nhật + lineage + quality gate.

Ngày 149: P5 - governance & security; ôn Layer 9

  • Mục tiêu: An toàn & tuân thủ.

  • Lý thuyết: PII masking + access control (nối Layer 8); rà toàn layer.

  • Thực hành: Áp governance/security toàn platform; rà.

Ngày 150: HOÀN THÀNH LAYER 9

  • Mục tiêu: Chốt Data Platform Engineering ở mức "biết dùng vững".

  • Lý thuyết: Ôn toàn layer; kiểm kê tổng: P1 streaming + P2 lakehouse + P3 query + P4 orchestration + P5 Enterprise Data Platform (ingest→lakehouse→query→catalog + governance).

  • Thực hành: P5 done; đề thi #6 tích lũy (toàn layer) + tự chấm theo rubric; blog #97 ("Nhìn lại 150 ngày data platform: một Enterprise Data Platform từ streaming tới catalog"); tag layer9-complete; nghỉ nửa ngày.

LAYER 10 - AI PLATFORM ENGINEERING

Tài nguyên: Designing Machine Learning Systems (Chip Huyen), docs Kubeflow/Ray/MLflow/Feast/KServe/Triton/vLLM, các paper DeepSpeed ZeRO/Megatron-LM/FSDP/PagedAttention, NVIDIA GPU/MIG/DCGM docs.

KHỐI A - Fundamentals & GPU Infrastructure (Ngày 1-30) → P1

Ngày 1: Khởi động Layer 10

  • Mục tiêu: AI platform là gì + dựng lab.

  • Lý thuyết: vai trò nền tảng AI, thành phần (train/serve/GPU/lifecycle/RAG).

  • Thực hành: Repo ai-platform/; dựng lab k8s có GPU (hoặc mô phỏng).

Ngày 2: Loại workload AI

  • Mục tiêu: Phân biệt nhu cầu.

  • Lý thuyết: training vs inference vs batch, đặc tính tài nguyên khác nhau.

  • Thực hành: Bảng nhu cầu tài nguyên từng loại.

Ngày 3: Kiến trúc AI platform

  • Mục tiêu: Bức tranh tổng.

  • Lý thuyết: data → train → registry → serve → monitor.

  • Thực hành: Vẽ kiến trúc mục tiêu.

Ngày 4: GPU architecture recap

  • Mục tiêu: Hiểu phần cứng (nối Layer 0).

  • Lý thuyết: SIMT, tensor core, warp, occupancy.

  • Thực hành: Đọc spec một GPU; hiểu tensor core.

Ngày 5: GPU memory

  • Mục tiêu: Ràng buộc then chốt.

  • Lý thuyết: HBM, bandwidth vs capacity, memory-bound workloads.

  • Thực hành: Tính bộ nhớ cần cho một model.

Ngày 6: Multi-GPU interconnect

  • Mục tiêu: GPU nói chuyện với nhau.

  • Lý thuyết: NVLink, NVSwitch, PCIe, bandwidth.

  • Thực hành: Đo bandwidth giữa GPU (nếu có).

Ngày 7: Distributed interconnect

  • Mục tiêu: Nối nhiều node (nối Layer 2/3).

  • Lý thuyết: InfiniBand, RDMA, RoCE cho training.

  • Thực hành: Đọc kiến trúc mạng training cluster.

Ngày 8: GPU trên k8s

  • Mục tiêu: Cấp GPU cho pod (nối Layer 4).

  • Lý thuyết: NVIDIA device plugin, resource nvidia.com/gpu.

  • Thực hành: Chạy pod dùng GPU.

Ngày 9: NVIDIA GPU Operator

  • Mục tiêu: Quản lý GPU khai báo.

  • Lý thuyết: driver/toolkit/plugin/DCGM tự động.

  • Thực hành: Cài GPU Operator.

Ngày 10: GPU scheduling

  • Mục tiêu: Phân bổ GPU.

  • Lý thuyết: requests/limits, GPU node pool, taints.

  • Thực hành: Schedule workload lên GPU node.

Ngày 11: MIG

  • Mục tiêu: Chia một GPU thành nhiều.

  • Lý thuyết: Multi-Instance GPU (A100/H100), partition cứng.

  • Thực hành: Bật MIG; chạy nhiều workload cách ly.

Ngày 12: Time-slicing & MPS

  • Mục tiêu: Chia GPU mềm.

  • Lý thuyết: time-slicing, MPS, fractional GPU.

  • Thực hành: Time-slice một GPU cho nhiều pod.

Ngày 13: Topology-aware scheduling

  • Mục tiêu: Đặt gần nhau.

  • Lý thuyết: NVLink topology, NUMA (nối Layer 0/2).

  • Thực hành: Schedule theo topology.

Ngày 14: DCGM

  • Mục tiêu: Giám sát GPU (nối Layer 7).

  • Lý thuyết: DCGM metrics (util/mem/temp/power).

  • Thực hành: Export DCGM → Prometheus; dashboard.

Ngày 15: GPU utilization

  • Mục tiêu: Không lãng phí.

  • Lý thuyết: util thật vs allocated, idle GPU.

  • Thực hành: Đo + tìm GPU idle.

Ngày 16: GPU cost model

  • Mục tiêu: Kinh tế GPU (nối Layer 11).

  • Lý thuyết: GPU đắt, cost per training/inference.

  • Thực hành: Ước tính chi phí GPU một job.

Ngày 17: Mixed CPU/GPU

  • Mục tiêu: Ghép tài nguyên.

  • Lý thuyết: pipeline CPU (data) + GPU (compute).

  • Thực hành: Cân bằng CPU/GPU cho một job.

Ngày 18: Driver, CUDA, container toolkit

  • Mục tiêu: Nền phần mềm.

  • Lý thuyết: CUDA version, driver compat, container toolkit.

  • Thực hành: Container GPU chạy đúng CUDA.

Ngày 19: GPU health & failure

  • Mục tiêu: Bền với lỗi.

  • Lý thuyết: XID error, GPU fallout, node drain.

  • Thực hành: Phát hiện + xử lý GPU lỗi.

Ngày 20: Bin-packing GPU

  • Mục tiêu: Giảm phân mảnh.

  • Lý thuyết: bin-packing, fragmentation.

  • Thực hành: Tối ưu packing cho cụm GPU.

Ngày 21: Spot GPU

  • Mục tiêu: Giảm chi phí (nối Layer 5).

  • Lý thuyết: spot/preemptible GPU, checkpoint để chịu preempt.

  • Thực hành: Chạy job chịu được preemption.

Ngày 22: Multi-tenancy GPU

  • Mục tiêu: Dùng chung an toàn (nối Layer 4).

  • Lý thuyết: tenant isolation, MIG per tenant.

  • Thực hành: Chia GPU theo tenant.

Ngày 23: GPU quota & fair share

  • Mục tiêu: Công bằng.

  • Lý thuyết: quota, gang scheduling, fair sharing.

  • Thực hành: Áp quota GPU theo team.

Ngày 24: Autoscaling GPU node

  • Mục tiêu: Co giãn GPU (nối Layer 4).

  • Lý thuyết: Karpenter/Cluster Autoscaler cho GPU, scale-to-zero.

  • Thực hành: Auto-scale GPU node theo pending job.

Ngày 25: GPU observability

  • Mục tiêu: Nhìn toàn cụm (nối Layer 7).

  • Lý thuyết: util/mem/queue dashboard.

  • Thực hành: Dashboard GPU fleet.

Ngày 26: P1 - thiết kế

  • Mục tiêu: Đóng khung P1.

  • Lý thuyết: device plugin + operator + MIG/time-slice + DCGM.

  • Thực hách: gpu-infra-design.md.

Ngày 27: P1 - device plugin + operator

  • Mục tiêu: Cấp GPU.

  • Lý thuyết: GPU Operator setup.

  • Thực hành: GPU sẵn sàng cho workload.

Ngày 28: P1 - MIG/time-slicing

  • Mục tiêu: Chia GPU.

  • Lý thuyết: fractional GPU cho nhiều workload.

  • Thực hành: MIG + time-slicing hoạt động.

Ngày 29: P1 - DCGM + test

  • Mục tiêu: Giám sát.

  • Lý thuyết: DCGM → observability.

  • Thực hành: Dashboard + alert GPU; test.

Ngày 30: CỘT MỐC 30

  • Mục tiêu: Chốt GPU infra; release P1.

  • Lý thuyết: Ôn A; kiểm kê: GPU trên k8s + MIG/time-slice + DCGM.

  • Thực hành: P1 done; đề thi #1 (GPU/MIG/scheduling) + tự chấm; blog #98 ("GPU infrastructure trên Kubernetes: MIG, time-slicing, DCGM"); tag layer10-day030; nghỉ nửa ngày. Đã đi 30/150 (20%).

KHỐI B - Training Infrastructure (Ngày 31-60) → P2

Ngày 31: Distributed training - nền

  • Mục tiêu: Vì sao phải phân tán.

  • Lý thuyết: model/data quá lớn cho một GPU, các loại parallelism.

  • Thực hành: Vẽ bản đồ parallelism.

Ngày 32: Data parallelism

  • Mục tiêu: Nhân bản model, chia data.

  • Lý thuyết: replica model, all-reduce gradient.

  • Thực hành: Data-parallel training nhỏ.

Ngày 33: Tensor parallelism

  • Mục tiêu: Chia model theo chiều.

  • Lý thuyết: chia layer/matmul across GPU.

  • Thực hành: Đọc cơ chế tensor parallel.

Ngày 34: Pipeline parallelism

  • Mục tiêu: Chia model theo tầng.

  • Lý thuyết: stage, micro-batch, bubble.

  • Thực hành: Đọc pipeline schedule.

Ngày 35: FSDP

  • Mục tiêu: Shard tham số.

  • Lý thuyết: Fully Sharded Data Parallel, shard param/grad/optimizer.

  • Thực hành: Train một model bằng FSDP.

Ngày 36: DeepSpeed ZeRO

  • Mục tiêu: Tiết kiệm bộ nhớ.

  • Lý thuyết: ZeRO stage 1/2/3, offload.

  • Thực hành: Train với ZeRO stage 3.

Ngày 37: Megatron-LM

  • Mục tiêu: Tensor + pipeline parallel.

  • Lý thuyết: kiến trúc Megatron.

  • Thực hành: Đọc cấu hình Megatron.

Ngày 38: 3D parallelism

  • Mục tiêu: Kết hợp cả ba.

  • Lý thuyết: data + tensor + pipeline cho model rất lớn.

  • Thực hành: Thiết kế parallelism cho một model.

Ngày 39: Mixed precision

  • Mục tiêu: Nhanh & nhẹ.

  • Lý thuyết: bf16/fp16/fp8, loss scaling.

  • Thực hành: Train mixed precision; đo tốc độ/bộ nhớ.

Ngày 40: Memory optimization

  • Mục tiêu: Nhét model to hơn.

  • Lý thuyết: gradient checkpointing, activation offload.

  • Thực hành: Bật checkpointing; đo bộ nhớ.

Ngày 41: NCCL

  • Mục tiêu: Giao tiếp GPU.

  • Lý thuyết: collective ops (all-reduce/all-gather), NCCL.

  • Thực hành: Đo hiệu năng all-reduce.

Ngày 42: Communication + RDMA

  • Mục tiêu: Giảm nghẽn mạng (nối Layer 2/3).

  • Lý thuyết: InfiniBand/RDMA, GPUDirect.

  • Thực hành: Đọc cấu hình mạng training tối ưu.

Ngày 43: Checkpointing & fault tolerance

  • Mục tiêu: Không mất tiến độ.

  • Lý thuyết: checkpoint, resume, elastic recovery.

  • Thực hành: Kill giữa training → resume từ checkpoint.

Ngày 44: Ray - core

  • Mục tiêu: Framework phân tán đa dụng.

  • Lý thuyết: task/actor, Ray cluster.

  • Thực hành: Dựng Ray cluster.

Ngày 45: Ray Train

  • Mục tiêu: Training phân tán.

  • Lý thuyết: Ray Train, integration PyTorch.

  • Thực hành: Distributed training bằng Ray Train.

Ngày 46: Ray Data

  • Mục tiêu: Data loading phân tán.

  • Lý thuyết: streaming dataset, không nghẽn GPU.

  • Thực hành: Ray Data feed training.

Ngày 47: Ray Tune

  • Mục tiêu: Tối ưu siêu tham số.

  • Lý thuyết: search algorithm, scheduler (ASHA).

  • Thực hành: HPO bằng Ray Tune.

Ngày 48: Kubeflow - overview

  • Mục tiêu: ML trên k8s.

  • Lý thuyết: components, training operator, pipelines.

  • Thực hành: Cài Kubeflow.

Ngày 49: Training Operator

  • Mục tiêu: Job training khai báo (nối Layer 4).

  • Lý thuyết: PyTorchJob/TFJob, gang scheduling.

  • Thực hành: Chạy PyTorchJob multi-GPU.

Ngày 50: Kubeflow Pipelines

  • Mục tiêu: Pipeline ML.

  • Lý thuyết: component, DAG, artifact.

  • Thực hành: Pipeline train → eval.

Ngày 51: Katib

  • Mục tiêu: HPO trên k8s.

  • Lý thuyết: experiment, trial, metric.

  • Thực hành: HPO bằng Katib.

Ngày 52: Gang scheduling

  • Mục tiêu: Chạy job all-or-nothing.

  • Lý thuyết: Volcano/gang scheduling, tránh deadlock GPU.

  • Thực hành: Gang schedule một job phân tán.

Ngày 53: Elastic training

  • Mục tiêu: Chịu thay đổi tài nguyên.

  • Lý thuyết: elastic (torch elastic), preemption.

  • Thực hành: Training co giãn số worker.

Ngày 54: Data loading bottleneck

  • Mục tiêu: GPU không đói data (nối Layer 9).

  • Lý thuyết: data pipeline, prefetch, sharding.

  • Thực hành: Tìm + sửa nghẽn data loading.

Ngày 55: Training observability

  • Mục tiêu: Nhìn training (nối Layer 7).

  • Lý thuyết: loss curve, throughput, GPU util, TensorBoard/W&B.

  • Thực hành: Dashboard training metrics.

Ngày 56: Reproducibility

  • Mục tiêu: Chạy lại ra kết quả cũ.

  • Lý thuyết: seed, config, env, data version.

  • Thực hành: Config-driven reproducible run.

Ngày 57: P2 - thiết kế

  • Mục tiêu: Đóng khung P2.

  • Lý thuyết: Ray/Kubeflow + FSDP/DeepSpeed + checkpoint.

  • Thực hách: training-infra-design.md.

Ngày 58: P2 - training job

  • Mục tiêu: Chạy phân tán.

  • Lý thuyết: Ray Train hoặc Kubeflow PyTorchJob.

  • Thực hành: Multi-GPU training job.

Ngày 59: P2 - FSDP/DeepSpeed + checkpoint + test

  • Mục tiêu: Bền & hiệu quả.

  • Lý thuyết: FSDP/ZeRO + fault tolerance.

  • Thực hành: Train + kill + resume; test.

Ngày 60: CỘT MỐC 60

  • Mục tiêu: Chốt training infra; release P2.

  • Lý thuyết: Ôn B; kiểm kê: distributed training + Ray/Kubeflow + checkpoint.

  • Thực hành: P2 done; đề thi #2 (parallelism/FSDP/Ray/Kubeflow) + tự chấm; blog #99 ("Distributed training: FSDP/DeepSpeed trên Ray và Kubeflow"); tag layer10-day060; nghỉ nửa ngày. Đã đi 60/150 (40%).

KHỐI C - ML Lifecycle (Ngày 61-78) → P3

Ngày 61: ML lifecycle overview

  • Mục tiêu: Vòng đời mô hình.

  • Lý thuyết: data → train → track → register → deploy → monitor.

  • Thực hành: Vẽ lifecycle.

Ngày 62: Experiment tracking

  • Mục tiêu: Ghi lại mọi lần chạy.

  • Lý thuyết: MLflow tracking, run, experiment.

  • Thực hành: Track một training run.

Ngày 63: MLflow - chi tiết

  • Mục tiêu: Params/metrics/artifacts.

  • Lý thuyết: log param/metric/artifact/model.

  • Thực hành: So sánh nhiều run.

Ngày 64: Model registry

  • Mục tiêu: Quản lý model version.

  • Lý thuyết: MLflow registry, stages.

  • Thực hành: Register model + promote.

Ngày 65: Model versioning & stages

  • Mục tiêu: Quản lý vòng đời model.

  • Lý thuyết: staging/production/archived, approval.

  • Thực hành: Workflow promote model.

Ngày 66: Model lineage

  • Mục tiêu: Truy vết model.

  • Lý thuyết: lineage: data → code → model.

  • Thực hành: Ghi lineage cho một model.

Ngày 67: Feature store - vì sao

  • Mục tiêu: Feature nhất quán train/serve.

  • Lý thuyết: training-serving skew, reuse feature.

  • Thực hành: Xác định feature dùng chung.

Ngày 68: Feast - offline/online

  • Mục tiêu: Store hai tầng.

  • Lý thuyết: offline store (train), online store (serve).

  • Thực hành: Dựng Feast; định nghĩa feature.

Ngày 69: Feast - serving & PIT

  • Mục tiêu: Feature đúng thời điểm.

  • Lý thuyết: point-in-time correctness, online serving latency.

  • Thực hành: Serve feature online + PIT join.

Ngày 70: Feature pipelines

  • Mục tiêu: Tính feature (nối Layer 9).

  • Lý thuyết: batch + streaming feature (từ Layer 9).

  • Thực hành: Pipeline tính feature vào Feast.

Ngày 71: Data & model versioning

  • Mục tiêu: Tái lập được.

  • Lý thuyết: DVC, data version + model version.

  • Thực hành: Version một dataset + model.

Ngày 72: ML metadata & lineage

  • Mục tiêu: Governance ML (nối Layer 9).

  • Lý thuyết: metadata store, lineage end-to-end.

  • Thực hành: Lineage từ data tới model deployed.

Ngày 73: Model packaging

  • Mục tiêu: Đóng gói để serve.

  • Lý thuyết: MLflow model format, container, artifact.

  • Thực hành: Package model để deploy.

Ngày 74: CI/CD cho ML

  • Mục tiêu: Tự động hoá (nối Layer 6).

  • Lý thuyết: train→eval→register→deploy pipeline, gate.

  • Thực hành: Pipeline CI/CD ML.

Ngày 75: ML golden path

  • Mục tiêu: Đường chuẩn cho ML team (nối Layer 6).

  • Lý thuyết: scaffold từ train tới serve.

  • Thực hành: Golden path cho một model.

Ngày 76: P3 - thiết kế

  • Mục tiêu: Đóng khung P3.

  • Lý thuyết: MLflow tracking+registry + Feast.

  • Thực hách: ml-lifecycle-design.md.

Ngày 77: P3 - MLflow + Feast

  • Mục tiêu: Lifecycle hoạt động.

  • Lý thuyết: track+register + feature store.

  • Thực hành: Train → track → register + feature serving.

Ngày 78: P3 - ML lifecycle

  • Mục tiêu: Release P3.

  • Lý thuyết: rà "done": tracking + registry + feature store + lineage.

  • Thực hành: Đóng gói + blog #100 ("ML lifecycle: MLflow tracking/registry và feature store với Feast"). P3 done.

KHỐI D - Serving (Ngày 79-96) → P4

Ngày 79: Model serving - patterns

  • Mục tiêu: Cách phục vụ model.

  • Lý thuyết: online (realtime) vs batch vs streaming.

  • Thực hành: Chọn pattern theo use case.

Ngày 80: Serving requirements

  • Mục tiêu: Ràng buộc serving.

  • Lý thuyết: latency, throughput, scale, cost.

  • Thực hành: Đặt SLO serving (nối Layer 7).

Ngày 81: KServe - InferenceService

  • Mục tiêu: Serving trên k8s.

  • Lý thuyết: InferenceService CRD (nối Layer 4), predictor/transformer.

  • Thực hành: Deploy model bằng KServe.

Ngày 82: KServe - autoscaling

  • Mục tiêu: Co giãn serving.

  • Lý thuyết: serverless, scale-to-zero, concurrency (nối Layer 4).

  • Thực hành: Scale-to-zero + autoscale theo tải.

Ngày 83: KServe - canary/A-B

  • Mục tiêu: Rollout an toàn (nối Layer 6).

  • Lý thuyết: canary traffic, A/B model.

  • Thực hành: Canary một model version mới.

Ngày 84: Triton - multi-framework

  • Mục tiêu: Serving hiệu năng cao.

  • Lý thuyết: multi-backend (PyTorch/TF/ONNX/TensorRT).

  • Thực hành: Serve model bằng Triton.

Ngày 85: Triton - dynamic batching

  • Mục tiêu: Tăng throughput.

  • Lý thuyết: dynamic batching, gộp request.

  • Thực hành: Bật dynamic batching; đo throughput.

Ngày 86: Triton - ensemble

  • Mục tiêu: Pipeline model.

  • Lý thuyết: model ensemble, pre/post-processing.

  • Thực hành: Ensemble pre → model → post.

Ngày 87: Model optimization

  • Mục tiêu: Serve nhanh hơn.

  • Lý thuyết: ONNX, TensorRT, graph optimization.

  • Thực hành: Convert + tối ưu một model.

Ngày 88: Autoscaling inference

  • Mục tiêu: GPU serving co giãn (nối Layer 4).

  • Lý thuyết: GPU autoscaling, KEDA cho GPU.

  • Thực hành: Auto-scale GPU serving theo tải.

Ngày 89: Serving observability

  • Mục tiêu: Nhìn serving (nối Layer 7).

  • Lý thuyết: latency/throughput/error, model metrics.

  • Thực hành: Dashboard serving + alert.

Ngày 90: CỘT MỐC 90

  • Mục tiêu: Chốt serving nền.

  • Lý thuyết: Ôn C + đầu D; kiểm kê: ML lifecycle (P3) + KServe/Triton serving.

  • Thực hành: Đề thi #3 (KServe/Triton/serving) + tự chấm; blog #101 ("Model serving trên Kubernetes với KServe và Triton"); tag layer10-day090; nghỉ nửa ngày. Đã đi 90/150 (60%).

Ngày 91: Multi-model & GPU sharing

  • Mục tiêu: Nhiều model một GPU.

  • Lý thuyết: multi-model serving, MIG/MPS cho serving.

  • Thực hành: Nhiều model chia sẻ GPU.

Ngày 92: Batch inference

  • Mục tiêu: Suy luận khối lượng lớn.

  • Lý thuyết: batch job, throughput-optimized.

  • Thực hành: Batch inference trên dataset lớn.

Ngày 93: Serving cost optimization

  • Mục tiêu: Rẻ hơn (nối Layer 11).

  • Lý thuyết: right-sizing, spot, scale-to-zero, batching.

  • Thực hành: Giảm cost serving.

Ngày 94: Model gateway/routing

  • Mục tiêu: Một cửa cho nhiều model.

  • Lý thuyết: routing theo version/model, fallback.

  • Thực hành: Gateway route tới nhiều model.

Ngày 95: P4 - thiết kế

  • Mục tiêu: Đóng khung P4.

  • Lý thuyết: KServe/Triton + autoscaling + observability.

  • Thực hách: serving-design.md.

Ngày 96: P4 - Model serving

  • Mục tiêu: Release P4.

  • Lý thuyết: rà "done": deploy từ registry + autoscale + canary + observ.

  • Thực hành: Serve model từ registry (P3) + test; blog #102 ("Model serving production: autoscaling, batching, canary"). P4 done.

KHỐI E - LLM Serving (Ngày 97-126) → P5

Ngày 97: LLM inference - khác biệt

  • Mục tiêu: Vì sao LLM serving khó.

  • Lý thuyết: autoregressive, memory-bound, variable length.

  • Thực hành: So LLM serving vs model thường.

Ngày 98: KV cache

  • Mục tiêu: Bộ nhớ chủ đạo của LLM.

  • Lý thuyết: KV cache, tại sao tốn bộ nhớ, scale theo context.

  • Thực hành: Tính KV cache cho một model + context.

Ngày 99: Prefill vs decode

  • Mục tiêu: Hai pha inference.

  • Lý thuyết: prefill (compute-bound) vs decode (memory-bound).

  • Thực hành: Đo latency prefill vs decode.

Ngày 100:

  • Mục tiêu: Kiểm kê lớn giữa Layer 10.

  • Lý thuyết: Ôn A→D + đầu E; kiểm kê lớn: GPU (P1) + training (P2) + lifecycle (P3) + serving (P4); đối chiếu "biết dùng tốt".

  • Thực hành: Đề thi #4 tích lũy (GPU+training+lifecycle+serving) + tự chấm theo rubric; blog #103 ("100 ngày AI platform: từ GPU tới serving model"); tag layer10-day100; nghỉ nửa ngày. Đã đi 100/150 (67%).

Ngày 101: Continuous batching

  • Mục tiêu: Tăng throughput LLM.

  • Lý thuyết: continuous/in-flight batching, khác static batching.

  • Thực hành: So static vs continuous batching.

Ngày 102: vLLM - PagedAttention

  • Mục tiêu: Quản lý KV cache hiệu quả.

  • Lý thuyết: PagedAttention (paging KV như virtual memory, nối Layer 2).

  • Thực hành: Deploy vLLM; quan sát KV cache.

Ngày 103: vLLM - throughput

  • Mục tiêu: Serve nhiều request.

  • Lý thuyết: continuous batching + PagedAttention.

  • Thực hành: Benchmark throughput vLLM.

Ngày 104: vLLM - deployment

  • Mục tiêu: Vận hành vLLM.

  • Lý thuyết: OpenAI-compatible API, config.

  • Thực hành: Serve một LLM qua vLLM API.

Ngày 105: TGI

  • Mục tiêu: Lựa chọn khác.

  • Lý thuyết: Text Generation Inference.

  • Thực hành: So TGI với vLLM.

Ngày 106: SGLang

  • Mục tiêu: Structured + hiệu năng.

  • Lý thuyết: RadixAttention (prefix cache), structured output.

  • Thực hành: Serve bằng SGLang; test prefix caching.

Ngày 107: TensorRT-LLM

  • Mục tiêu: Kernel tối ưu NVIDIA.

  • Lý thuyết: optimized kernels, compile model.

  • Thực hành: So hiệu năng TensorRT-LLM.

Ngày 108: So sánh engine LLM

  • Mục tiêu: Chọn engine.

  • Lý thuyết: vLLM/TGI/SGLang/TensorRT-LLM tradeoff.

  • Thực hành: Bảng đánh đổi.

Ngày 109: Quantization - INT8/INT4

  • Mục tiêu: Model nhỏ hơn, nhanh hơn.

  • Lý thuyết: GPTQ, AWQ, weight-only quant.

  • Thực hành: Quantize model; đo bộ nhớ/tốc độ.

Ngày 110: Quantization - FP8/GGUF

  • Mục tiêu: Định dạng khác.

  • Lý thuyết: FP8, GGUF, KV cache quantization.

  • Thực hành: Serve model FP8.

Ngày 111: Quantization tradeoff

  • Mục tiêu: Chất lượng vs tốc độ.

  • Lý thuyết: accuracy drop, khi nào chấp nhận.

  • Thực hành: Đo chất lượng trước/sau quant.

Ngày 112: Speculative decoding

  • Mục tiêu: Giảm latency.

  • Lý thuyết: draft model + verify, tăng tốc decode.

  • Thực hành: Bật speculative decoding; đo.

Ngày 113: Prefix/prompt caching

  • Mục tiêu: Tái dùng compute.

  • Lý thuyết: prefix cache, prompt caching, system prompt reuse.

  • Thực hành: Bật prefix caching; đo cải thiện.

Ngày 114: Tensor parallelism (inference)

  • Mục tiêu: Model to hơn một GPU.

  • Lý thuyết: TP cho inference, chia layer.

  • Thực hành: Serve model lớn với TP.

Ngày 115: Multi-GPU LLM serving

  • Mục tiêu: Serve model rất lớn.

  • Lý thuyết: TP + pipeline cho serving.

  • Thực hành: Multi-GPU serving.

Ngày 116: KV cache management

  • Mục tiêu: Tối ưu bộ nhớ.

  • Lý thuyết: cache offload, eviction, swapping.

  • Thực hành: Cấu hình KV cache lớn.

Ngày 117: Throughput vs latency

  • Mục tiêu: Cân bằng mục tiêu.

  • Lý thuyết: batch size vs latency, SLA (nối Layer 7).

  • Thực hành: Tuning theo mục tiêu latency/throughput.

Ngày 118: LLM autoscaling

  • Mục tiêu: Co giãn LLM serving (nối Layer 4).

  • Lý thuyết: autoscale theo queue/latency, cold start GPU.

  • Thực hành: Autoscale LLM endpoint.

Ngày 119: LLM serving cost

  • Mục tiêu: Kinh tế LLM (nối Layer 11).

  • Lý thuyết: cost per token, batching để rẻ, right model.

  • Thực hành: Ước tính + giảm cost/token.

Ngày 120: CỘT MỐC 120

  • Mục tiêu: Chốt LLM serving core.

  • Lý thuyết: Ôn E tới giờ; kiểm kê: vLLM/PagedAttention + quantization + batching.

  • Thực hành: Đề thi #5 (KV cache/vLLM/quantization) + tự chấm; blog #104 ("LLM serving: PagedAttention, continuous batching, quantization"); tag layer10-day120; nghỉ nửa ngày. Đã đi 120/150 (80%).

Ngày 121: LLM observability

  • Mục tiêu: Nhìn LLM serving (nối Layer 7).

  • Lý thuyết: token/s, TTFT, latency, GPU util, cost.

  • Thực hành: Dashboard LLM serving.

Ngày 122: LoRA serving

  • Mục tiêu: Nhiều fine-tune, một base.

  • Lý thuyết: LoRA adapter, multi-LoRA serving.

  • Thực hành: Serve nhiều LoRA trên một base model.

Ngày 123: Model router/gateway

  • Mục tiêu: Một cửa cho nhiều LLM.

  • Lý thuyết: route theo model/cost/latency, fallback.

  • Thực hành: Gateway route LLM requests.

Ngày 124: P5 - thiết kế

  • Mục tiêu: Đóng khung P5.

  • Lý thuyết: vLLM + KV cache + quantization + batching + autoscale.

  • Thực hách: llm-serving-design.md.

Ngày 125: P5 - vLLM + quant + batching

  • Mục tiêu: LLM serving tối ưu.

  • Lý thuyết: deploy vLLM tối ưu.

  • Thực hành: LLM endpoint throughput cao + test.

Ngày 126: P5 - LLM serving

  • Mục tiêu: Release P5.

  • Lý thuyết: rà "done": vLLM + KV cache + quant + batching + observ.

  • Thực hành: Đóng gói + blog #105 ("Một LLM serving stack production với vLLM"). P5 done.

KHỐI F - Retrieval & LLMOps (Ngày 127-144)

Ngày 127: RAG - kiến trúc

  • Mục tiêu: Tăng cường LLM bằng truy xuất.

  • Lý thuyết: retrieve → augment → generate, vì sao RAG.

  • Thực hành: Vẽ kiến trúc RAG.

Ngày 128: Embeddings

  • Mục tiêu: Biểu diễn ngữ nghĩa.

  • Lý thuyết: embedding model, dimension, similarity.

  • Thực hành: Sinh embedding cho một corpus.

Ngày 129: Vector database

  • Mục tiêu: Lưu & tìm vector (nối Layer 3).

  • Lý thuyết: vector DB (Qdrant/Milvus/pgvector), ANN.

  • Thực hành: Dựng vector DB; index embedding.

Ngày 130: Vector index recap

  • Mục tiêu: Bên trong ANN (nối Layer 3).

  • Lý thuyết: HNSW/IVF, filtering, recall vs latency.

  • Thực hành: Tuning index; đo recall/latency.

Ngày 131: Chunking

  • Mục tiêu: Chia tài liệu đúng.

  • Lý thuyết: chunk size, overlap, semantic chunking.

  • Thực hành: So chiến lược chunking.

Ngày 132: Retrieval - semantic + hybrid

  • Mục tiêu: Tìm đúng ngữ cảnh.

  • Lý thuyết: semantic + keyword (hybrid) search.

  • Thực hành: Hybrid search; so recall.

Ngày 133: Reranking

  • Mục tiêu: Tăng chất lượng retrieval.

  • Lý thuyết: cross-encoder rerank.

  • Thực hành: Thêm reranker; đo cải thiện.

Ngày 134: RAG pipeline

  • Mục tiêu: Ghép end-to-end.

  • Lý thuyết: retrieve → rerank → context → generate.

  • Thực hành: RAG pipeline hoàn chỉnh.

Ngày 135: RAG ở quy mô

  • Mục tiêu: RAG production.

  • Lý thuyết: ingestion pipeline (nối Layer 9), caching, freshness.

  • Thực hành: RAG với ingestion tự động.

Ngày 136: LLM evaluation

  • Mục tiêu: Đo chất lượng.

  • Lý thuyết: benchmark, task metric, RAG eval (faithfulness/relevance).

  • Thực hành: Eval một RAG system.

Ngày 137: LLM-as-judge

  • Mục tiêu: Đánh giá tự động.

  • Lý thuyết: LLM-as-judge, eval framework, pitfalls.

  • Thực hành: Eval bằng LLM-as-judge.

Ngày 138: Guardrails

  • Mục tiêu: An toàn đầu vào/ra (nối Layer 8).

  • Lý thuyết: input/output filtering, safety, topic control.

  • Thực hành: Áp guardrails cho một endpoint.

Ngày 139: PII & prompt injection

  • Mục tiêu: Chống tấn công (nối Layer 8).

  • Lý thuyết: prompt injection, jailbreak, PII leak.

  • Thực hành: Phòng thủ prompt injection cơ bản.

Ngày 140: LLM observability

  • Mục tiêu: Nhìn LLMOps (nối Layer 7).

  • Lý thuyết: trace (prompt/response), token/cost, quality drift.

  • Thực hành: Trace + cost dashboard cho LLM app.

Ngày 141: Prompt management

  • Mục tiêu: Quản lý prompt.

  • Lý thuyết: prompt versioning, template, A/B.

  • Thực hành: Versioning + A/B prompt.

Ngày 142: Agent infrastructure

  • Mục tiêu: LLM dùng công cụ.

  • Lý thuyết: tool calling, orchestration, memory.

  • Thực hành: Một agent gọi tool đơn giản.

Ngày 143: Fine-tuning infra

  • Mục tiêu: Tuỳ biến model.

  • Lý thuyết: LoRA/PEFT, fine-tune pipeline (nối Khối B).

  • Thực hành: Fine-tune LoRA; serve (nối P5).

Ngày 144: Ôn Khối F

  • Mục tiêu: Chốt RAG & LLMOps.

  • Lý thuyết: rà RAG + eval + guardrails + observability.

  • Thực hành: Chuẩn bị capstone.

KHỐI G - Enterprise AI Platform capstone (Ngày 145-150) → P6 flagship

Ngày 145: P6 - tích hợp

  • Mục tiêu: Ghép mọi mảnh.

  • Lý thuyết: train → registry → serve → RAG, dùng chung nhiều team.

  • Thực hành: Nối P1-P5 vào một platform.

Ngày 146: P6 - train → registry

  • Mục tiêu: Từ training tới model registered.

  • Lý thuyết: training (P2) → MLflow registry (P3).

  • Thực hành: Pipeline train → register.

Ngày 147: P6 - serve from registry

  • Mục tiêu: Deploy từ registry.

  • Lý thuyết: serving (P4/P5) lấy model từ registry.

  • Thực hành: Serve model/LLM từ registry.

Ngày 148: P6 - RAG

  • Mục tiêu: RAG dùng chung.

  • Lý thuyết: vector DB + LLM serving (P5) + retrieval.

  • Thực hành: RAG endpoint trên platform.

Ngày 149: P6 - eval + guardrails + observability; ôn Layer 10

  • Mục tiêu: Vận hành an toàn.

  • Lý thuyết: eval + guardrails (nối Layer 8) + observability (nối Layer 7); rà toàn layer.

  • Thực hành: Áp eval/guardrails/observability toàn platform; rà.

Ngày 150: HOÀN THÀNH LAYER 10

  • Mục tiêu: Chốt AI Platform Engineering ở mức "biết dùng vững".

  • Lý thuyết: Ôn toàn layer; kiểm kê tổng: P1 GPU infra + P2 training + P3 lifecycle + P4 serving + P5 LLM serving + P6 Enterprise AI Platform (train→registry→serve→RAG).

  • Thực hành: P6 done; đề thi #6 tích lũy (toàn layer) + tự chấm theo rubric; blog #106 ("Nhìn lại 150 ngày AI platform: từ GPU tới một Enterprise AI Platform với RAG"); tag layer10-complete; nghỉ nửa ngày.

Comments

Join the discussion

No comments yet. Be the first to comment.

Knowledge

Part 17 of 50
Up next

Học Platform engineering (4)

LAYER 6 - PLATFORM ENGINEERING Tài nguyên: Team Topologies (Skelton & Pais), Accelerate (Forsgren/Humble/Kim), DevEx framework (Forsgren et al.), Backstage docs, CNCF Platform Engineering white paper/

More from this blog

Learn DevOps

416 posts