BÀI 1: GIỚI THIỆU KUBERNETES VÀ CONTAINER ORCHESTRATION

🎯 MỤC TIÊU BÀI HỌC

Sau khi hoàn thành bài học này, bạn sẽ:

✅ Hiểu được Container Orchestration là gì và tại sao cần nó
✅ Nắm được vai trò và tầm quan trọng của Kubernetes
✅ So sánh được Kubernetes với các công cụ khác
✅ Hiểu kiến trúc tổng quan của Kubernetes
✅ Biết về Kubernetes ecosystem và cộng đồng

PHẦN 1: CONTAINER ORCHESTRATION LÀ GÌ?

1.1. Vấn đề với Containers khi Scale

Hãy tưởng tượng bạn có một ứng dụng web đơn giản chạy trong Docker container:

docker run -d -p 8080:80 my-web-app

Mọi thứ hoạt động tốt... cho đến khi:

❌ Vấn đề 1: Traffic tăng đột biến

1 container không đủ xử lý
Cần scale lên 10, 20, 100 containers
Làm thế nào để phân phối traffic?

❌ Vấn đề 2: Container bị crash

Ai sẽ phát hiện và restart?
Làm sao đảm bảo uptime 99.9%?

❌ Vấn đề 3: Nhiều servers

Làm sao deploy containers lên nhiều máy chủ?
Làm sao quản lý tài nguyên (CPU, RAM) hiệu quả?

❌ Vấn đề 4: Update ứng dụng

Làm sao rolling update không downtime?
Rollback nếu có lỗi?

❌ Vấn đề 5: Service Discovery

Containers có IP động
Làm sao các services tìm và gọi nhau?

❌ Vấn đề 6: Configuration Management

Quản lý secrets, configs cho hàng trăm containers
Môi trường dev, staging, production khác nhau

1.2. Container Orchestration là giải pháp

Container Orchestration là việc tự động hóa deployment, management, scaling, và networking của containers.

Orchestrator làm gì:

┌─────────────────────────────────────────────────────────┐
│         CONTAINER ORCHESTRATION PLATFORM                │
├─────────────────────────────────────────────────────────┤
│  ✓ Scheduling         - Chọn node phù hợp cho container│
│  ✓ Scaling            - Auto scale up/down              │
│  ✓ Self-healing       - Restart containers failed       │
│  ✓ Load Balancing     - Phân phối traffic đều          │
│  ✓ Service Discovery  - Tìm và kết nối services        │
│  ✓ Rolling Updates    - Update không downtime           │
│  ✓ Rollback           - Quay lại version cũ             │
│  ✓ Secret Management  - Quản lý credentials an toàn    │
│  ✓ Resource Management- Tối ưu CPU, RAM, Storage        │
└─────────────────────────────────────────────────────────┘

1.3. Ví dụ thực tế

Trước khi có Orchestration:

# Trên server 1
ssh server1
docker run -d app:v1
docker run -d app:v1
docker run -d app:v1

# Trên server 2
ssh server2
docker run -d app:v1
docker run -d app:v1

# Manual monitoring
while true; do
  docker ps | grep app
  # Nếu container die -> manual restart
done

Với Container Orchestration:

# Khai báo mong muốn
apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 5  # Muốn 5 containers
  template:
    spec:
      containers:
      - name: app
        image: app:v1

Orchestrator tự động:

Deploy 5 containers lên các servers khác nhau
Monitor và restart nếu crash
Load balance traffic
Scale khi cần

PHẦN 2: TẠI SAO CẦN KUBERNETES?

2.1. Bối cảnh ra đời

Google's Borg (2003-2015)

Google chạy hàng tỷ containers mỗi tuần
Borg: hệ thống internal để quản lý containers
Kinh nghiệm 15+ năm vận hành large-scale systems

Kubernetes ra đời (2014)

Google open-source Kubernetes (K8s)
Dựa trên kinh nghiệm từ Borg và Omega
Được thiết kế cho cloud-native applications
Donate cho CNCF (Cloud Native Computing Foundation)

2.2. Tại sao Kubernetes thắng thế?

1. Production-Proven

Google → 15+ năm kinh nghiệm
         ↓
      Kubernetes → Battle-tested tại Google
         ↓
    Cộng đồng → Hàng nghìn companies đóng góp

2. Vendor Agnostic

Chạy được ở mọi nơi: on-premise, cloud, hybrid
Không bị lock-in với 1 cloud provider
Portable giữa AWS, GCP, Azure, bare metal

3. Extensible và Flexible

Plugin architecture
Custom Resource Definitions (CRDs)
Operator pattern
Rich ecosystem

4. Large Community

100,000+ contributors
Hàng triệu users
Mature tooling và documentation
Active development

5. Industry Standard

CNCF Graduated Project
    ↓
Được tích hợp bởi:
- AWS (EKS)
- Google (GKE)
- Azure (AKS)
- IBM (IKS)
- DigitalOcean
- và nhiều vendor khác

2.3. Con số ấn tượng

📊 Kubernetes Adoption (2024)

96% organizations đang dùng hoặc đánh giá K8s
5.6 triệu developers sử dụng K8s
Top 2 most wanted platform (Stack Overflow)
89% containers chạy trên K8s

🚀 Use Cases

Microservices architecture
CI/CD pipelines
Machine Learning workloads
Big Data processing
Hybrid/Multi-cloud deployments

PHẦN 3: SO SÁNH KUBERNETES VỚI CÁC CÔNG CỤ KHÁC

3.1. Kubernetes vs Docker Swarm

Tiêu chí	Kubernetes	Docker Swarm
Độ phức tạp	Cao, nhiều concepts	Đơn giản, dễ học
Setup	Phức tạp hơn	Rất đơn giản
Scalability	Rất tốt (1000+ nodes)	Tốt (100+ nodes)
Ecosystem	Rất rộng	Hạn chế
Auto-scaling	Native HPA, VPA	Limited
Load Balancing	Advanced (Ingress)	Basic
Community	Rất lớn	Nhỏ hơn nhiều
Enterprise Support	Tất cả cloud providers	Limited
Learning Curve	Steep	Gentle
Production Ready	Yes	Yes (nhưng ít dùng)

Kết luận: Docker Swarm dễ hơn nhưng K8s mạnh hơn và là industry standard.

3.2. Kubernetes vs Apache Mesos

Tiêu chí	Kubernetes	Apache Mesos
Focus	Container orchestration	General purpose cluster manager
Architecture	Monolithic	Two-level (Mesos + Marathon)
Adoption	Rất cao	Trung bình
Use Cases	Containers, microservices	Containers, Big Data, analytics
Complexity	Cao	Rất cao
Container Support	Native	Via Marathon/DC/OS

Kết luận: Mesos linh hoạt hơn nhưng phức tạp hơn. K8s tập trung vào containers.

3.3. Kubernetes vs Nomad

Tiêu chí	Kubernetes	HashiCorp Nomad
Simplicity	Complex	Simple
Workload Types	Containers	Containers, VMs, binaries
Ecosystem	Huge	Growing
Multi-cloud	Excellent	Excellent
Adoption	Very high	Moderate
HashiCorp Integration	Limited	Native (Vault, Consul)

Kết luận: Nomad đơn giản hơn và đa dạng workloads, nhưng ecosystem nhỏ hơn.

3.4. Khi nào dùng gì?

Chọn Kubernetes khi:

✅ Production workloads quan trọng
✅ Cần scale lớn (100+ services)
✅ Team có kinh nghiệm DevOps
✅ Cần ecosystem phong phú
✅ Multi-cloud strategy

Chọn Docker Swarm khi:

✅ Team nhỏ, dự án đơn giản
✅ Cần deploy nhanh
✅ Đã quen với Docker CLI
✅ Không cần scale quá lớn

Chọn Nomad khi:

✅ Workloads đa dạng (không chỉ containers)
✅ Đã dùng HashiCorp stack
✅ Cần simplicity
✅ Edge computing

PHẦN 4: KIẾN TRÚC KUBERNETES TỔNG QUAN

4.1. Kubernetes Cluster

┌────────────────────────────────────────────────────────────┐
│                    KUBERNETES CLUSTER                      │
├────────────────────────────────────────────────────────────┤
│                                                            │
│  ┌──────────────────────┐      ┌────────────────────────┐│
│  │   CONTROL PLANE      │      │      WORKER NODES      ││
│  │   (Master Nodes)     │      │                        ││
│  │                      │      │  ┌──────────────────┐  ││
│  │  ┌────────────────┐ │      │  │  Node 1          │  ││
│  │  │  API Server    │ │◄────►│  │  - kubelet       │  ││
│  │  └────────────────┘ │      │  │  - kube-proxy    │  ││
│  │                      │      │  │  - Container     │  ││
│  │  ┌────────────────┐ │      │  │    Runtime       │  ││
│  │  │  etcd          │ │      │  │  - Pods          │  ││
│  │  │  (Database)    │ │      │  └──────────────────┘  ││
│  │  └────────────────┘ │      │                        ││
│  │                      │      │  ┌──────────────────┐  ││
│  │  ┌────────────────┐ │      │  │  Node 2          │  ││
│  │  │  Scheduler     │ │      │  │  - kubelet       │  ││
│  │  └────────────────┘ │      │  │  - kube-proxy    │  ││
│  │                      │      │  │  - Container     │  ││
│  │  ┌────────────────┐ │      │  │    Runtime       │  ││
│  │  │  Controller    │ │      │  │  - Pods          │  ││
│  │  │  Manager       │ │      │  └──────────────────┘  ││
│  │  └────────────────┘ │      │                        ││
│  └──────────────────────┘      │  ┌──────────────────┐  ││
│                                 │  │  Node N          │  ││
│                                 │  │  ...             │  ││
│                                 │  └──────────────────┘  ││
│                                 └────────────────────────┘│
└────────────────────────────────────────────────────────────┘

4.2. Control Plane Components (Master)

1. API Server 🚪

"Cổng vào" của Kubernetes
Xử lý tất cả REST requests
Authentication & Authorization
Validate và process requests
Frontend cho etcd

kubectl → API Server → etcd
  ↑          ↓
  └──── Response

2. etcd 💾

Key-value database
Lưu trữ toàn bộ cluster state
Source of truth
Highly available (HA setup)
Only API Server talks to etcd

3. Scheduler 📅

Quyết định Pod chạy trên Node nào
Xem xét: resources, constraints, affinity
Không thực hiện deploy (kubelet làm)

Flow:
1. User tạo Pod
2. Scheduler xem Pods chưa assign
3. Chọn Node tốt nhất
4. Update Pod spec với nodeName

4. Controller Manager 🎮

Chạy nhiều controllers
Monitor cluster state
Thực hiện changes để đạt desired state

Các controllers quan trọng:

Node Controller: Monitor nodes health
Replication Controller: Đảm bảo số Pods đúng
Endpoints Controller: Populate Endpoints objects
ServiceAccount Controller: Tạo default ServiceAccounts

4.3. Worker Node Components

1. kubelet 👷

Agent chạy trên mỗi node
Nhận Pod specs từ API Server
Đảm bảo containers đang chạy
Report node/pod status về API Server
Execute liveness/readiness probes

2. kube-proxy 🔀

Network proxy trên mỗi node
Maintain network rules
Implement Kubernetes Service abstraction
Load balancing cho Services
Modes: iptables, IPVS, userspace

3. Container Runtime 🐳

Software chạy containers
Implement Kubernetes CRI (Container Runtime Interface)
Phổ biến:
- containerd (recommended)
- CRI-O
- Docker (deprecated in K8s 1.24+)

4.4. Add-ons (Optional but Important)

DNS (CoreDNS)

Service discovery
Resolve service names to IPs
Mỗi Service có DNS name

Dashboard

Web UI để quản lý cluster
Visualize resources

Monitoring (Metrics Server)

Collect resource metrics
CPU, Memory usage
Enable HPA (Horizontal Pod Autoscaler)

Logging

EFK Stack (Elasticsearch, Fluentd, Kibana)
Centralized logging

PHẦN 5: KUBERNETES ECOSYSTEM

5.1. CNCF Landscape

Kubernetes là một phần của CNCF ecosystem:

┌─────────────────────────────────────────────┐
│         CNCF CLOUD NATIVE LANDSCAPE         │
├─────────────────────────────────────────────┤
│  Container Orchestration                    │
│  └─ Kubernetes ⭐                           │
│                                             │
│  Container Runtime                          │
│  └─ containerd, CRI-O                      │
│                                             │
│  Service Mesh                               │
│  └─ Istio, Linkerd, Consul                 │
│                                             │
│  Monitoring                                 │
│  └─ Prometheus, Grafana                    │
│                                             │
│  Logging                                    │
│  └─ Fluentd, Loki                          │
│                                             │
│  CI/CD                                      │
│  └─ Argo, Flux, Tekton                     │
│                                             │
│  Security                                   │
│  └─ Falco, OPA, Trivy                      │
└─────────────────────────────────────────────┘

5.2. Core Tools

Package Management

Helm: Package manager for K8s
Kustomize: Configuration management

GitOps

ArgoCD: Declarative GitOps CD
Flux: GitOps toolkit

Service Mesh

Istio: Complete service mesh
Linkerd: Simple, lightweight

Monitoring & Observability

Prometheus: Metrics collection
Grafana: Visualization
Jaeger: Distributed tracing

Security

Falco: Runtime security
OPA: Policy engine
Trivy: Vulnerability scanner

5.3. Managed Kubernetes Services

Major Cloud Providers:

AWS: EKS (Elastic Kubernetes Service)
Google Cloud: GKE (Google Kubernetes Engine)
Azure: AKS (Azure Kubernetes Service)
IBM Cloud: IKS
DigitalOcean: DOKS
Linode: LKE

Lợi ích:

Control plane được managed
Automatic upgrades
Integrated với cloud services
Easy setup
Cost: chỉ trả tiền worker nodes

PHẦN 6: KUBERNETES CONCEPTS QUAN TRỌNG

6.1. Declarative vs Imperative

Imperative (Cách cũ):

# Nói K8s phải làm GÌ và NHƯ THẾ NÀO
kubectl run nginx --image=nginx
kubectl expose deployment nginx --port=80
kubectl scale deployment nginx --replicas=3

Declarative (Cách K8s):

# Nói K8s muốn KẾT QUẢ gì
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx
spec:
  replicas: 3
  template:
    spec:
      containers:
      - name: nginx
        image: nginx
---
apiVersion: v1
kind: Service
metadata:
  name: nginx
spec:
  ports:
  - port: 80

kubectl apply -f nginx.yaml

Tại sao Declarative tốt hơn:

✅ Infrastructure as Code
✅ Version control friendly
✅ Idempotent (chạy nhiều lần = kết quả giống nhau)
✅ Self-healing
✅ Easy rollback

6.2. Desired State vs Current State

┌──────────────────────────────────────────────┐
│  KUBERNETES RECONCILIATION LOOP              │
├──────────────────────────────────────────────┤
│                                              │
│  ┌────────────────┐      ┌────────────────┐│
│  │ DESIRED STATE  │      │ CURRENT STATE  ││
│  │                │      │                ││
│  │ replicas: 3    │  VS  │ replicas: 2    ││
│  │ image: v2      │      │ image: v1      ││
│  └────────────────┘      └────────────────┘│
│          │                       │          │
│          └───────────┬───────────┘          │
│                      ↓                      │
│            ┌──────────────────┐             │
│            │   CONTROLLER     │             │
│            │   Takes Action   │             │
│            └──────────────────┘             │
│                      ↓                      │
│            ┌──────────────────┐             │
│            │  Start 1 Pod     │             │
│            │  Update 2 Pods   │             │
│            └──────────────────┘             │
└──────────────────────────────────────────────┘

Controllers liên tục:

Watch current state
Compare với desired state
Take actions để match
Repeat (reconciliation loop)

6.3. Labels và Selectors

Labels = Key-value pairs để organize objects

metadata:
  labels:
    app: nginx
    tier: frontend
    environment: production
    version: v1.0

Selectors = Query để tìm objects

selector:
  matchLabels:
    app: nginx
    tier: frontend

Use cases:

Services tìm Pods
Deployments quản lý Pods
NetworkPolicies áp dụng rules
Queries và filtering

PHẦN 7: KUBERNETES IN ACTION - VÍ DỤ THỰC TẾ

Scenario: E-commerce Website

Requirements:

Frontend: React app (3 replicas)
Backend API: Node.js (5 replicas, auto-scale)
Database: PostgreSQL (1 instance, persistent)
Cache: Redis (3 replicas)
High availability
Zero-downtime updates
Auto-scaling based on traffic

Kubernetes giải quyết như thế nào:

# Frontend Deployment
apiVersion: apps/v1
kind: Deployment
metadata:
  name: frontend
spec:
  replicas: 3
  selector:
    matchLabels:
      app: frontend
  template:
    metadata:
      labels:
        app: frontend
    spec:
      containers:
      - name: react-app
        image: myapp/frontend:v1.0
        ports:
        - containerPort: 3000
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "200m"

---
# Backend API with Auto-scaling
apiVersion: apps/v1
kind: Deployment
metadata:
  name: backend
spec:
  replicas: 5
  selector:
    matchLabels:
      app: backend
  template:
    metadata:
      labels:
        app: backend
    spec:
      containers:
      - name: api
        image: myapp/backend:v1.0
        ports:
        - containerPort: 8080

---
# Auto-scaler
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: backend-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: backend
  minReplicas: 5
  maxReplicas: 20
  metrics:
  - type: Resource
    resource:
      name: cpu
      target:
        type: Utilization
        averageUtilization: 70

---
# Database with Persistent Storage
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: postgres
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
      - name: postgres
        image: postgres:14
        ports:
        - containerPort: 5432
        volumeMounts:
        - name: postgres-storage
          mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:
  - metadata:
      name: postgres-storage
    spec:
      accessModes: [ "ReadWriteOnce" ]
      resources:
        requests:
          storage: 20Gi

---
# Load Balancer Service
apiVersion: v1
kind: Service
metadata:
  name: frontend-lb
spec:
  type: LoadBalancer
  selector:
    app: frontend
  ports:
  - port: 80
    targetPort: 3000

Kubernetes tự động:

✅ Deploy 3 frontend + 5 backend + 1 DB
✅ Distribute across nodes
✅ Restart nếu crash
✅ Scale backend từ 5→20 khi traffic tăng
✅ Load balance requests
✅ Persistent data cho database
✅ Rolling update không downtime

💡 KEY TAKEAWAYS

Điểm quan trọng cần nhớ:

Container Orchestration giải quyết vấn đề scale và manage containers
- Auto-scaling, self-healing, load balancing
- Service discovery, rolling updates
Kubernetes là industry standard
- Production-proven từ Google
- Largest community
- Vendor agnostic
K8s Architecture có 2 phần chính:
- Control Plane: API Server, etcd, Scheduler, Controllers
- Worker Nodes: kubelet, kube-proxy, Container Runtime
Declarative > Imperative
- Khai báo desired state
- K8s tự động reconcile
Rich Ecosystem
- CNCF landscape
- Tools cho mọi needs
- Managed services available

🎯 BÀI TẬP

Bài tập 1: Research và So sánh

Tìm hiểu và viết so sánh chi tiết (200-300 từ) giữa:

Kubernetes
Docker Swarm
Amazon ECS

Tập trung vào: ease of use, scalability, ecosystem, cost.

Bài tập 2: Mindmap

Vẽ mindmap (có thể dùng tool hoặc tay) về:

Kubernetes Architecture
Bao gồm tất cả components
Mô tả vai trò mỗi component

Bài tập 3: Use Case Analysis

Chọn 1 application bạn đang làm việc hoặc biết:

Mô tả architecture hiện tại
Vẽ diagram nếu deploy lên K8s
List benefits và challenges

Bài tập 4: Video Learning

Xem video "Kubernetes in 100 seconds" và "Kubernetes Explained in 15 minutes"

Tóm tắt 5 điểm chính
Note những điểm chưa hiểu để tìm hiểu thêm

📖 TÀI LIỆU THAM KHẢO

Bài viết

Videos

Interactive

⏭️ BÀI TIẾP THEO

Bài 2: Cài đặt và Cấu hình Kubernetes

Trong bài tiếp theo, chúng ta sẽ:

Cài đặt Minikube và kubectl
Khởi động cluster đầu tiên
Explore Kubernetes dashboard
Chạy các lệnh kubectl cơ bản
Hiểu về kubeconfig

Chuẩn bị:

Máy tính với ít nhất 4GB RAM
Cài đặt Docker
Cài đặt VirtualBox hoặc VMware

Menu

BÀI 1: GIỚI THIỆU KUBERNETES VÀ CONTAINER ORCHESTRATION

DUY TRAN