Docker Phase 1: Lộ Trình Container Masterclass

Container không còn là "nice-to-have" — nó là điều kiện bắt buộc của kỹ sư phần mềm hiện đại. Mỗi pipeline CI/CD, mỗi microservice deploy, mỗi môi trường staging đều xoay quanh Docker. Nếu bạn không nắm vững container, bạn đang tự đặt mình ra ngoài cuộc chơi DevOps và Cloud-Native.

Phase 1 này đưa bạn từ con số 0 đến khả năng tự tin viết Dockerfile production-grade, hiểu layer caching, và điều phối nhiều service với Compose. Mình thiết kế lộ trình theo 3 tầng (tier) — mỗi tầng xây dựng trên tầng trước, không bỏ sót kiến thức nào. Đây không phải tutorial copy-paste; đây là hành trình hiểu tại sao mọi thứ hoạt động, để khi production cháy lúc 3 giờ sáng, bạn biết chính xác phải debug ở đâu.

🎯 Mục tiêu

Sau khi hoàn thành Phase 1, bạn sẽ:

Phân biệt rõ ràng virtualization vs containerization — và giải thích được cho đồng nghiệp tại sao container nhẹ hơn VM
Nắm kiến trúc Docker từ Docker Daemon, containerd, runc đến OCI image spec — không chỉ dùng lệnh mà hiểu cơ chế bên dưới
Thành thạo Docker CLI lifecycle — run, exec, stop, rm, logs, inspect trở thành phản xạ tự nhiên
Viết Dockerfile chuẩn production — multi-stage build, layer caching tối ưu, hadolint không lỗi, .dockerignore gọn gàng
Chuyển đổi Dockerfile xấu → tốt — nhận diện anti-pattern và refactor với tư duy image-size + build-speed
Điều phối multi-container bằng Docker Compose — service discovery, environment handling, depends_on, healthchecks

🏗️ Tổng quan 3 Tier — Kiến trúc lộ trình

Phase 1 chia thành 3 tier, mỗi tier tập trung vào một nhóm kỹ năng cốt lõi. Thiết kế theo tier giúp bạn đạt milestone rõ ràng — hoàn thành Tier 1 là đã có thể dùng Docker, hoàn thành Tier 2 là tạo Docker image production, hoàn thành Tier 3 là điều phối cả hệ thống.

Tier 1: Nền Tảng Container (Trang 01–03)

"Trước khi xây nhà, phải hiểu nền móng."

Tier đầu tiên xây dựng mental model về container. Bạn sẽ hiểu container thực sự là gì ở cấp kernel (namespaces, cgroups), cách Docker daemon giao tiếp với containerd và runc, rồi mới bắt tay vào CLI lifecycle.

Trang	Chủ đề	Nội dung chính
01	Virtualization vs Containerization	Hypervisor vs container runtime, namespaces, cgroups, so sánh overhead
02	Kiến trúc Docker	Docker Daemon → containerd → runc, OCI spec, image registry flow
03	Docker CLI Lifecycle	`run`, `exec`, `stop`, `rm`, `logs`, `inspect`, `cp`, `stats`

Tier 2: Xây Dựng Image (Trang 04–07)

"Image tốt = deploy nhanh + ít lỗ hổng bảo mật."

Tier này biến bạn từ người dùng image thành người tạo image chất lượng. Từ cách viết Dockerfile instruction-by-instruction, đến hiểu UnionFS layer caching, rồi tối ưu với multi-stage build và static analysis bằng hadolint.

Trang	Chủ đề	Nội dung chính
04	Dockerfile Anatomy	`FROM`, `RUN`, `COPY`, `CMD` vs `ENTRYPOINT`, `ARG` vs `ENV`, `WORKDIR`, `EXPOSE`
05	Layer Caching & UnionFS	OverlayFS, copy-on-write, cache invalidation, instruction ordering strategy
06	Multi-stage + Hadolint + .dockerignore	Builder pattern, scratch/distroless base, lint rules, context exclusion
07	Bad → Good Dockerfile Transformation	Anti-patterns thực tế, refactor step-by-step, benchmark trước/sau

Tier 3: Điều Phối (Trang 08)

"Một container thì đơn giản. Mười container cần orchestration."

Tier cuối đưa bạn ra khỏi single-container thinking. Bạn sẽ học cách khai báo multi-service stack bằng docker-compose.yml, hiểu service discovery qua internal DNS, quản lý environment variables an toàn, và đảm bảo service health trước khi nhận traffic.

Trang	Chủ đề	Nội dung chính
08	Docker Compose Orchestration	`docker-compose.yml` syntax, service discovery, `env_file`, `depends_on`, healthchecks, volumes, networks

🗺️ Dependency Map — Bản đồ phụ thuộc

Dưới đây là toàn cảnh 8 trang Phase 1 và cách chúng kết nối. Mỗi mũi tên nghĩa là "nên học trước khi sang trang tiếp":

        ┌──────────────────────────────────────────────────┐
        │   00  Bản đồ Docker  (📍 BẠN ĐANG Ở ĐÂY)        │
        └────────────────────────┬─────────────────────────┘
                                 │
                                 ▼
        ┌──────────────────────────────────────────────────┐
        │   01  Virtualization vs Containerization          │
        │   Hypervisor · Namespaces · Cgroups               │
        └────────────────────────┬─────────────────────────┘
                                 │
                                 ▼
        ┌──────────────────────────────────────────────────┐
        │   02  Kiến Trúc Docker                            │
        │   Daemon · containerd · runc · OCI Spec           │
        └────────────────────────┬─────────────────────────┘
                                 │
                                 ▼
        ┌──────────────────────────────────────────────────┐
        │   03  Docker CLI Lifecycle                        │
        │   run · exec · stop · rm · logs · inspect         │
        └────────────────────────┬─────────────────────────┘
                                 │
          ┌──────────────────────┘
          │    TIER 2: Xây Dựng Image
          ▼
        ┌──────────────────────────────────────────────────┐
        │   04  Dockerfile Anatomy                          │
        │   FROM · RUN · COPY · CMD · ENTRYPOINT            │
        └────────────────────────┬─────────────────────────┘
                                 │
                                 ▼
        ┌──────────────────────────────────────────────────┐
        │   05  Layer Caching & UnionFS                     │
        │   OverlayFS · Copy-on-Write · Cache Invalidation  │
        └────────────────────────┬─────────────────────────┘
                                 │
                                 ▼
        ┌──────────────────────────────────────────────────┐
        │   06  Multi-stage + Hadolint + .dockerignore      │
        │   Builder Pattern · Distroless · Lint · Context   │
        └────────────────────────┬─────────────────────────┘
                                 │
                                 ▼
        ┌──────────────────────────────────────────────────┐
        │   07  Bad → Good Dockerfile Transformation        │
        │   Anti-patterns · Refactor · Benchmark            │
        └────────────────────────┬─────────────────────────┘
                                 │
          ┌──────────────────────┘
          │    TIER 3: Điều Phối
          ▼
        ┌──────────────────────────────────────────────────┐
        │   08  Docker Compose Orchestration                 │
        │   Services · Discovery · Healthchecks · Volumes   │
        └──────────────────────────────────────────────────┘

💡 HPN Pro Tip

Hãy đi tuần tự từ 01 → 08. Mỗi trang xây dựng trên kiến thức của trang trước. Nếu bạn đã quen Docker CLI, có thể skim nhanh Tier 1 rồi tập trung vào Tier 2 — nhưng đừng bỏ qua bài 05 (Layer Caching) vì đó là nền tảng để hiểu tại sao image bạn build chậm hoặc nặng.

📖 Tổng quan từng bài học

#	Tên bài	Khái niệm chính	Thời gian
01	Virtualization vs Containerization	Hypervisor Type 1/2, container runtime, Linux namespaces (pid, net, mnt), cgroups, so sánh tài nguyên VM vs container	~30 phút
02	Kiến Trúc Docker	Docker Engine (daemon), containerd, runc, OCI image/runtime spec, image registry pull flow, Docker Desktop internals	~35 phút
03	Docker CLI Lifecycle	Container states (created → running → paused → stopped → removed), `docker run` flags, `exec` debug, `logs --follow`, `inspect --format`	~40 phút
04	Dockerfile Anatomy	Mỗi instruction tạo một layer, `CMD` vs `ENTRYPOINT` (exec form vs shell form), `ARG` build-time vs `ENV` run-time, `WORKDIR` best practices	~35 phút
05	Layer Caching & UnionFS	OverlayFS lowerdir/upperdir/merged, copy-on-write, cache invalidation triggers, instruction ordering để tối ưu rebuild	~40 phút
06	Multi-stage + Hadolint + .dockerignore	Builder stage → production stage, `FROM scratch`/distroless, hadolint rules (DL3008, DL3003…), `.dockerignore` patterns	~45 phút
07	Bad → Good Dockerfile	5 anti-patterns phổ biến (`apt-get` không `--no-install-recommends`, `COPY . .` quá sớm, root user, no health check, fat base image), refactor kèm benchmark	~40 phút
08	Docker Compose Orchestration	`docker-compose.yml` version 3.x, `services`, `networks`, `volumes`, internal DNS service discovery, `env_file` vs `environment`, `depends_on` + `condition: service_healthy`, healthcheck config	~50 phút

🚫 Phase 1 KHÔNG bao gồm

Để tránh kỳ vọng sai, dưới đây là những gì nằm ngoài phạm vi Phase 1:

Kubernetes / Docker Swarm — Orchestration ở quy mô cluster thuộc Phase 2+
CI/CD pipeline integration — GitHub Actions, GitLab CI với Docker sẽ nằm trong track riêng
Container networking nâng cao — Overlay networks, macvlan, CNI plugins thuộc Phase 2
Docker security hardening — Rootless mode, seccomp profiles, image signing → tham khảo Module 5 — Security nếu cần trước
Kubernetes-native build tools — Buildpacks, Kaniko, ko thuộc phạm vi nâng cao

Phase 1 tập trung hoàn toàn vào single-host Docker workflow: hiểu container, viết Dockerfile, và compose multi-service trên một máy. Đây là nền tảng bắt buộc trước khi nghĩ đến Kubernetes.

⚡ Ba Learning Tracks — Chọn tốc độ phù hợp

Track	Thời gian	Phong cách	Phù hợp với
🏃 Sprint	2 ngày	4 pages/ngày, focus CLI + Dockerfile	Đã biết Linux, cần Docker nhanh cho dự án
📚 Standard	1 tuần	1-2 pages/ngày, làm đủ lab exercises	Muốn hiểu sâu từng layer, xây nền vững
🔬 Deep	2 tuần	1 page/ngày + đọc reference modules	Muốn hiểu cả internals: containerd, runc, OCI spec

Gợi ý: Nếu bạn chưa từng dùng Docker, bắt đầu với Standard. Nếu đã quen docker run nhưng chưa hiểu layer caching, hãy sprint qua Tier 1 rồi chuyển Standard ở Tier 2.

⏱️ Ước tính tổng thời gian

Track	Đọc lý thuyết	Lab thực hành	Tổng cộng
🏃 Sprint	~4 giờ	~3 giờ	~7 giờ
📚 Standard	~5.5 giờ	~5 giờ	~10.5 giờ
🔬 Deep	~7 giờ	~8 giờ	~15 giờ

Thời gian trên dành cho developer đã có nền tảng Linux cơ bản. Nếu bạn mới bắt đầu với terminal, hãy hoàn thành Linux Phase 1 trước — nó sẽ tiết kiệm rất nhiều thời gian debug.

🔗 Tham chiếu chéo — Reference Modules

Phase 1 kết nối với hệ thống Reference Modules đã có sẵn trên Penalgo. Khi cần đào sâu hơn một chủ đề, hãy tham khảo:

Module	Mô tả	Liên kết
Module 1 — Genesis	Nguồn gốc Docker, lịch sử container, tại sao Docker thắng	Đọc →
Module 2 — Builder	Dockerfile deep-dive, build context, BuildKit	Đọc →
Module 3 — Compose	Docker Compose nâng cao, profiles, extends	Đọc →
Module 4 — Storage	Volumes, bind mounts, tmpfs, storage drivers	Đọc →
Module 5 — Security	Rootless mode, seccomp, AppArmor, image scanning	Đọc →
Module 6 — Internal	containerd internals, runc, OCI runtime spec, shim v2	Đọc →

💡 HPN Pro Tip

Bạn không cần đọc hết Reference Modules trước khi bắt đầu Phase 1. Hãy coi chúng như "sách tra cứu" — đọc khi Phase 1 gợi ý, hoặc khi bạn muốn hiểu sâu hơn một chủ đề cụ thể.

🌐 Lộ trình liên quan — Cross-Pillar Links

Docker không tồn tại trong chân không. Kiến thức container đan xen với Linux fundamentals, networking, và cả tư duy algorithmic khi thiết kế service topology. Dưới đây là các Phase 1 pack liên quan mà bạn nên kết hợp:

Pillar	Phase 1 Pack	Tại sao liên quan?
🐧 Linux	Linux Phase 1: Infra & DevOps Map	Docker chạy trên Linux kernel — namespaces, cgroups, filesystem đều là kiến thức Linux. Nắm vững Linux = debug Docker nhanh gấp 3 lần
🧮 Algorithms	DSA Phase 1: Course Map	Hiểu data structures giúp bạn thiết kế service communication patterns tốt hơn — từ queue-based messaging đến graph-based service dependencies

🏋️ Practice Lab — Thực hành tổng hợp

Sau khi hoàn thành Phase 1, hãy kiểm tra kiến thức với lab tổng hợp:

Lab	Mô tả	Khi nào làm
Container Lab — Phase 1	Build multi-stage image cho Node.js app, viết Compose stack 3 services (web + api + db), cấu hình healthchecks và volume persistence	Sau khi hoàn thành trang 08

Luyện tập theo tier

Sau tier	Bài thực hành đề xuất	Mục tiêu
Tier 1 (01–03)	Tạo, chạy, inspect 5 container từ các base image khác nhau (alpine, ubuntu, nginx, node, python)	Thành thạo CLI lifecycle, đọc `docker inspect` output
Tier 2 (04–07)	Viết Dockerfile cho một REST API, tối ưu từ 800MB → dưới 100MB bằng multi-stage + distroless	Chứng minh hiểu layer caching và multi-stage build
Tier 3 (08)	Dựng full-stack: React frontend + Express API + PostgreSQL + Redis bằng Compose	Thành thạo service discovery, healthchecks, volume persistence

Quy tắc 70-30: Dành 30% thời gian đọc lý thuyết, 70% thời gian thực hành trên terminal. Docker là kỹ năng tay nghề — bạn không thể "đọc" mà giỏi được. Hãy mở terminal ngay bên cạnh trang học và gõ mọi lệnh thay vì copy-paste.

🧭 Lời khuyên trước khi bắt đầu

Cài Docker Desktop trước. Đảm bảo docker version và docker compose version chạy được trên máy bạn trước khi đọc trang 01. Không gì tệ hơn đọc lý thuyết mà không chạy được code.
Đừng sợ phá. Container là ephemeral — xóa rồi tạo lại chỉ mất vài giây. Hãy thử mọi flag, mọi option. Phá hỏng container là cách học nhanh nhất.
Đọc error message. Docker error messages cực kỳ descriptive. 90% lỗi bạn gặp đã có câu trả lời ngay trong dòng error — chỉ cần đọc kỹ thay vì Google ngay lập tức.
Ghi chú Dockerfile patterns. Mỗi khi học một best practice mới, hãy tạo snippet riêng. Đến cuối Phase 1, bạn sẽ có bộ sưu tập Dockerfile templates cá nhân.
Kết nối kiến thức. Khi học về namespaces (trang 01), hãy mở terminal và chạy lsns trên Linux. Khi học Dockerfile (trang 04), hãy docker history <image> để xem layers. Mỗi khái niệm trừu tượng đều có lệnh tương ứng để bạn nhìn thấy nó hoạt động.

📚 Bài liên quan

Trang	Mô tả
Virtualization vs Containerization →	Bắt đầu Phase 1 với câu hỏi nền tảng: VM và container khác nhau ở đâu? Tại sao container thắng trong cuộc đua cloud-native?

Docker Phase 1: Lộ Trình Container Masterclass ​

🏗️ Tổng quan 3 Tier — Kiến trúc lộ trình ​

Tier 1: Nền Tảng Container (Trang 01–03) ​

Tier 2: Xây Dựng Image (Trang 04–07) ​

Tier 3: Điều Phối (Trang 08) ​

🗺️ Dependency Map — Bản đồ phụ thuộc ​

📖 Tổng quan từng bài học ​

🚫 Phase 1 KHÔNG bao gồm ​

⚡ Ba Learning Tracks — Chọn tốc độ phù hợp ​

⏱️ Ước tính tổng thời gian ​

🔗 Tham chiếu chéo — Reference Modules ​

🌐 Lộ trình liên quan — Cross-Pillar Links ​

🏋️ Practice Lab — Thực hành tổng hợp ​

Luyện tập theo tier ​

🧭 Lời khuyên trước khi bắt đầu ​