apt update -y

swapoff -a
# Sau đó mở file và xóa dòng có chứa 'swap'
vi /etc/fstab

printf "overlay\nbr_netfilter\n" >> /etc/modules-load.d/containerd.conf
modprobe overlay
modprobe br_netfilter

printf "net.bridge.bridge-nf-call-iptables = 1\nnet.ipv4.ip_forward = 1\nnet.bridge.bridge-nf-call-ip6tables = 1\n" >> /etc/sysctl.d/99-kubernetes-cri.conf
sysctl --system

wget https://github.com/containerd/containerd/releases/download/v2.2.2/containerd-2.2.2-linux-amd64.tar.gz -P /tmp/
tar Cxzvf /usr/local /tmp/containerd-2.2.2-linux-amd64.tar.gz
mkdir -p /usr/local/lib/systemd/system/
wget https://raw.githubusercontent.com/containerd/containerd/main/containerd.service -P /usr/local/lib/systemd/system/
systemctl daemon-reload
systemctl restart containerd
systemctl enable containerd

wget https://github.com/opencontainers/runc/releases/download/v1.4.2/runc.amd64 -P /tmp/
install -m 755 /tmp/runc.amd64 /usr/local/sbin/runc

wget https://github.com/containernetworking/plugins/releases/download/v1.9.1/cni-plugins-linux-amd64-v1.9.1.tgz -P /tmp/
mkdir -p /opt/cni/bin
tar Cxzvf /opt/cni/bin /tmp/cni-plugins-linux-amd64-v1.9.1.tgz

mkdir -p /etc/containerd
containerd config default | tee /etc/containerd/config.toml
# Mở file và đổi SystemdCgroup = false -> SystemdCgroup = true (dòng ~109)
vi /etc/containerd/config.toml

sudo apt update
sudo apt install -y apt-transport-https ca-certificates curl gpg
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.35/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg

echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.35/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list

apt update -y
apt install -y kubelet kubeadm kubectl
apt-mark hold kubelet kubeadm kubectl
systemctl enable --now kubelet
reboot

kubeadm init --pod-network-cidr 192.168.0.0/16

mkdir -p $HOME/.kube
cp -i /etc/kubernetes/admin.conf $HOME/.kube/config
sudo chown $(id -u):$(id -g) $HOME/.kube/config

kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.30.3/manifests/tigera-operator.yaml
sleep 10
kubectl apply -f https://raw.githubusercontent.com/projectcalico/calico/v3.30.3/manifests/custom-resources.yaml

# Xem thông tin node
kubectl get nodes -o wide

# Kiểm tra sức khỏe control plane components
kubectl get componentstatuses

# Kiểm tra trạng thái các system pod
kubectl get pods --all-namespaces -o wide

# Lấy join command để thêm worker node (chạy lệnh này trên master)
kubeadm token create --print-join-command

apt update -y
apt upgrade -y
swapoff -a

printf "overlay\nbr_netfilter\n" >> /etc/modules-load.d/containerd.conf
modprobe overlay
modprobe br_netfilter
printf "net.bridge.bridge-nf-call-iptables = 1\nnet.ipv4.ip_forward = 1\nnet.bridge.bridge-nf-call-ip6tables = 1\n" >> /etc/sysctl.d/99-kubernetes-cri.conf
sysctl --system

# Cài containerd
wget https://github.com/containerd/containerd/releases/download/v1.7.13/containerd-1.7.13-linux-amd64.tar.gz -P /tmp/
tar Cxzvf /usr/local /tmp/containerd-1.7.13-linux-amd64.tar.gz
wget https://raw.githubusercontent.com/containerd/containerd/main/containerd.service -P /etc/systemd/system/
systemctl daemon-reload
systemctl enable --now containerd

# Cài runc
wget https://github.com/opencontainers/runc/releases/download/v1.1.12/runc.amd64 -P /tmp/
install -m 755 /tmp/runc.amd64 /usr/local/sbin/runc

# Cài CNI plugins
wget https://github.com/containernetworking/plugins/releases/download/v1.4.0/cni-plugins-linux-amd64-v1.4.0.tgz -P /tmp/
mkdir -p /opt/cni/bin
tar Cxzvf /opt/cni/bin /tmp/cni-plugins-linux-amd64-v1.4.0.tgz

# Cấu hình containerd
mkdir -p /etc/containerd
containerd config default | tee /etc/containerd/config.toml
# Sửa SystemdCgroup = true (~dòng 137)
vi /etc/containerd/config.toml

apt-get install ca-certificates curl gnupg lsb-release apt-transport-https gpg
sudo mkdir -m 0755 -p /etc/apt/keyrings
curl -fsSL https://pkgs.k8s.io/core:/stable:/v1.29/deb/Release.key | sudo gpg --dearmor -o /etc/apt/keyrings/kubernetes-apt-keyring.gpg
echo 'deb [signed-by=/etc/apt/keyrings/kubernetes-apt-keyring.gpg] https://pkgs.k8s.io/core:/stable:/v1.29/deb/ /' | sudo tee /etc/apt/sources.list.d/kubernetes.list
apt update -y
reboot

apt install -y kubelet=1.29.1-1.1 kubeadm=1.29.1-1.1 kubectl=1.29.1-1.1
apt-mark hold kubelet kubeadm kubectl
systemctl enable --now kubelet

# Lấy join command từ master:
# kubeadm token create --print-join-command

# Chạy lệnh join trên worker node (ví dụ):
kubeadm join <MASTER_IP>:6443 --token <TOKEN> \
  --discovery-token-ca-cert-hash sha256:<HASH>

wget https://raw.githubusercontent.com/kbuor/containerization/refs/heads/main/kubernetes/manifest/dashboard.yaml
kubectl apply -f dashboard.yaml

mkdir certs && chmod -R 777 certs
openssl req -nodes -newkey rsa:2048 -keyout certs/dashboard.key -out certs/dashboard.csr \
  -subj "/C=/ST=/L=/O=/OU=/CN=kubernetes-dashboard"
openssl x509 -req -sha256 -days 365 -in certs/dashboard.csr -signkey certs/dashboard.key -out certs/dashboard.crt
kubectl create secret generic kubernetes-dashboard-certs --from-file=certs -n kubernetes-dashboard

wget https://raw.githubusercontent.com/kbuor/containerization/refs/heads/main/kubernetes/manifest/service-account.yaml
kubectl apply -f service-account.yaml

wget https://raw.githubusercontent.com/kbuor/containerization/refs/heads/main/kubernetes/manifest/cluster-role-binding.yaml
kubectl apply -f cluster-role-binding.yaml

# Lấy token để đăng nhập vào Dashboard
kubectl -n kubernetes-dashboard create token admin-user

curl -sS https://webinstall.dev/k9s | bash

kubeadm version -o short
kubectl version --short

apt-mark unhold kubeadm
apt install -y kubeadm=1.27.3-00
apt-mark hold kubeadm

kubeadm upgrade plan

kubeadm upgrade apply v1.27.3

# Nâng cấp kubelet
apt-mark unhold kubelet
apt install -y kubelet=1.27.3-00
apt-mark hold kubelet

# Nâng cấp kubectl
apt-mark unhold kubectl
apt install -y kubectl=1.27.3-00
apt-mark hold kubectl

# Chạy trên master node:
kubectl cordon k8s-node-01
kubectl drain k8s-node-01 --ignore-daemonsets --delete-emptydir-data

# Trên worker node:
apt-mark unhold kubelet
apt install -y kubelet=1.27.3-00
apt-mark hold kubelet

apt-mark unhold kubectl
apt install -y kubectl=1.27.3-00
apt-mark hold kubectl

# Quay lại master node, uncordon worker:
kubectl uncordon k8s-node-01

# Kiểm tra kết quả
kubectl get nodes -o wide

Kubernetes Workload Resources
│
├── Pod                  → Đơn vị cơ bản, ít dùng trực tiếp trong production
│
├── ReplicaSet           → Đảm bảo số lượng Pod replica (thường không dùng trực tiếp)
│
├── Deployment           → Stateless app: web, API, worker (phổ biến nhất)
│   └── manages → ReplicaSet → manages → Pods
│
├── DaemonSet            → Chạy 1 Pod trên mỗi node: log agent, monitoring agent
│
├── StatefulSet          → Stateful app: database, message queue (cần stable identity)
│
├── Job                  → Tác vụ chạy 1 lần đến khi hoàn thành: batch, migration
│
└── CronJob              → Tác vụ chạy định kỳ theo lịch: backup, report, cleanup

kubectl get events --watch

apiVersion: v1
kind: Pod
metadata:
  name: hello-world-pod
  labels:
    app: hello-world
spec:
  containers:
    - name: hello-world
      image: gcr.io/google-samples/hello-app:1.0
      ports:
        - containerPort: 8080

kubectl apply -f hello-world-pod.yaml
kubectl get pods -o wide

# Chạy port-forward ở nền (dùng & để background)
kubectl port-forward hello-world-pod 8080:8080 &

# Test kết nối — kubectl forward traffic qua API Server đến Pod
curl http://localhost:8080

# Dừng port-forward khi xong
fg
# Nhấn Ctrl+C

apiVersion: v1
kind: Pod
metadata:
  name: multicontainer-pod
spec:
  containers:
    - name: producer
      image: ubuntu
      command: ["/bin/bash"]
      args: ["-c", "while true; do echo $(date) >> /var/log/index.html; sleep 10; done"]
      volumeMounts:
        - name: webcontent
          mountPath: /var/log
    - name: consumer
      image: nginx
      ports:
        - containerPort: 80
      volumeMounts:
        - name: webcontent
          mountPath: /usr/share/nginx/html
  volumes:
    - name: webcontent
      emptyDir: {}

kubectl apply -f multicontainer-pod.yaml

# Vào container đầu tiên (producer) - không cần chỉ định tên
kubectl exec -it multicontainer-pod -- /bin/sh
ls -la /var/log
tail /var/log/index.html
exit

# Vào container thứ hai (consumer) - phải chỉ định tên
kubectl exec -it multicontainer-pod --container consumer -- /bin/sh
ls -la /usr/share/nginx/html
tail /usr/share/nginx/html/index.html
exit

# Test qua port-forward
kubectl port-forward multicontainer-pod 8080:80 &
curl http://localhost:8080
fg  # Ctrl+C để dừng

# Dọn dẹp
kubectl delete pod multicontainer-pod

apiVersion: v1
kind: Pod
metadata:
  name: hello-world-never-pod
spec:
  restartPolicy: Never
  containers:
    - name: hello-world
      image: gcr.io/google-samples/hello-app:1.0
---
apiVersion: v1
kind: Pod
metadata:
  name: hello-world-onfailure-pod
spec:
  restartPolicy: OnFailure
  containers:
    - name: hello-world
      image: gcr.io/google-samples/hello-app:1.0

kubectl apply -f pod-restart-policy.yaml
kubectl get pods

# Kill process trong pod restartPolicy=Never
kubectl exec -it hello-world-never-pod -- /usr/bin/killall hello-app
kubectl get pods hello-world-never-pod
# STATUS: Completed hoặc Error — không restart

# Xem chi tiết: Containers->State, Reason, Exit Code
kubectl describe pod hello-world-never-pod

# Kill process trong pod restartPolicy=OnFailure
kubectl exec -it hello-world-onfailure-pod -- /usr/bin/killall hello-app
kubectl get pods hello-world-onfailure-pod
# RESTARTS tăng lên 1 — container đã được restart

apiVersion: v1
kind: Pod
metadata:
  name: myapp-pod
spec:
  initContainers:
    - name: init-wait-db
      image: busybox
      command: ['sh', '-c', 'until nslookup mydb; do echo waiting for mydb; sleep 2; done']
    - name: init-copy-config
      image: busybox
      command: ['sh', '-c', 'echo config data > /config/app.conf']
      volumeMounts:
        - name: config-vol
          mountPath: /config
  containers:
    - name: myapp
      image: nginx
      volumeMounts:
        - name: config-vol
          mountPath: /etc/config
  volumes:
    - name: config-vol
      emptyDir: {}

apiVersion: v1
kind: Pod
metadata:
  name: hello-world-probe
  labels:
    app: hello-world
spec:
  containers:
    - name: hello-world
      image: gcr.io/google-samples/hello-app:1.0
      ports:
        - containerPort: 8080
      startupProbe:
        httpGet:
          path: /
          port: 8080
        initialDelaySeconds: 5   # Chờ 5s sau khi container start
        periodSeconds: 5          # Probe mỗi 5s
        failureThreshold: 30      # Cho phép fail 30 lần (= 150s để khởi động)
      livenessProbe:
        httpGet:
          path: /
          port: 8080              # ⚠️ Phải khớp với containerPort!
        initialDelaySeconds: 10
        periodSeconds: 10
        failureThreshold: 3       # Fail 3 lần → restart container
        timeoutSeconds: 5
      readinessProbe:
        httpGet:
          path: /
          port: 8080
        initialDelaySeconds: 10
        periodSeconds: 10
        failureThreshold: 3       # Fail 3 lần → xóa khỏi Service endpoints
        successThreshold: 1

kubectl apply -f container-probes.yaml

# Xem Pod đang khởi động
kubectl get pods --selector app=hello-world --watch

# Xem chi tiết probe configuration và trạng thái
# Tìm: Containers > Liveness / Readiness / Startup section
# Tìm: Conditions > Ready, ContainersReady
# Tìm: Events > probe failure messages
kubectl describe pod hello-world-probe

# Nếu probe fail: Pod sẽ hiện RESTARTS tăng (liveness)
# hoặc READY 0/1 (readiness)

kubectl delete pod hello-world-probe

ReplicaSet: hello-world-rs
  replicas: 3   ← desired state

  Trạng thái thực tế: 3 Pod đang chạy ✓
  
  → Pod A crash
  
  Trạng thái thực tế: 2 Pod đang chạy ✗
  ReplicaSet Controller phát hiện: 2 ≠ 3
  → Tạo Pod D mới
  
  Trạng thái thực tế: 3 Pod đang chạy ✓

Label Selector — cơ chế ReplicaSet tìm Pod của mình:
  ReplicaSet selector: app=hello-world
  Pod labels: app=hello-world  → Pod thuộc về RS này

Deployment: hello-world
  └── ReplicaSet: hello-world-7d9b4c8f6  (version hiện tại)
      ├── Pod: hello-world-7d9b4c8f6-abcde
      ├── Pod: hello-world-7d9b4c8f6-fghij
      └── Pod: hello-world-7d9b4c8f6-klmno
  └── ReplicaSet: hello-world-5c6b3a2e1  (version cũ, scale=0 sau update)

Khi update image:
  Deployment tạo ReplicaSet MỚI → scale up từ từ
  Đồng thời scale down ReplicaSet CŨ
  → Zero downtime rolling update

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hello-world
  labels:
    app: hello-world
spec:
  replicas: 3
  selector:
    matchLabels:
      app: hello-world          # ReplicaSet dùng label này để tìm Pod
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1               # Tối đa 1 Pod tạo thêm khi update
      maxUnavailable: 0         # Không cho phép Pod nào unavailable
  template:                     # Đây là Pod template
    metadata:
      labels:
        app: hello-world        # Label phải khớp với selector ở trên
    spec:
      containers:
        - name: hello-world
          image: gcr.io/google-samples/hello-app:1.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              cpu: "100m"       # 0.1 CPU core (tối thiểu cần)
              memory: "128Mi"   # 128 MB RAM (tối thiểu cần)
            limits:
              cpu: "200m"       # 0.2 CPU core (tối đa cho phép)
              memory: "256Mi"   # 256 MB RAM (tối đa cho phép)

kubectl apply -f deployment.yaml

# Theo dõi quá trình rollout
kubectl rollout status deployment hello-world

# Xem Deployment, ReplicaSet và Pod
kubectl get deployment hello-world
kubectl get replicaset
kubectl get pods -l app=hello-world -o wide

# Scale lên 5 replica
kubectl scale deployment hello-world --replicas=5
kubectl get pods -l app=hello-world

# Scale xuống 2 replica
kubectl scale deployment hello-world --replicas=2
kubectl get pods -l app=hello-world

# Xem lịch sử scale trong events
kubectl describe deployment hello-world

# Cập nhật image lên version 2.0
kubectl set image deployment hello-world hello-world=gcr.io/google-samples/hello-app:2.0

# Theo dõi tiến trình rolling update
kubectl rollout status deployment hello-world

# Xem ReplicaSet — sẽ thấy RS cũ (replicas=0) và RS mới (replicas=3)
kubectl get replicaset

# Xem lịch sử rollout
kubectl rollout history deployment hello-world

# Rollback về version trước nếu có vấn đề
kubectl rollout undo deployment hello-world

# Xác nhận đã rollback thành công
kubectl rollout status deployment hello-world
kubectl describe deployment hello-world | grep Image

apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentd
  namespace: kube-system
  labels:
    app: fluentd
spec:
  selector:
    matchLabels:
      app: fluentd
  template:
    metadata:
      labels:
        app: fluentd
    spec:
      tolerations:
        - key: node-role.kubernetes.io/control-plane
          operator: Exists
          effect: NoSchedule        # Cho phép chạy trên master node
      containers:
        - name: fluentd
          image: fluent/fluentd:v1.16
          resources:
            limits:
              memory: 200Mi
            requests:
              cpu: 100m
              memory: 200Mi
          volumeMounts:
            - name: varlog
              mountPath: /var/log   # Mount log directory từ node
      volumes:
        - name: varlog
          hostPath:
            path: /var/log          # Thư mục log thực tế trên node OS

kubectl apply -f daemonset-fluentd.yaml

# Số Pod = số node trong cluster (kể cả master nếu có toleration)
kubectl get pods -n kube-system -l app=fluentd -o wide

# Mô tả DaemonSet: thấy số Desired, Current, Ready
kubectl describe daemonset fluentd -n kube-system

# Dọn dẹp
kubectl delete daemonset fluentd -n kube-system

StatefulSet tên: mysql
Headless Service tên: mysql-svc
Namespace: default

Mỗi Pod có DNS riêng và ổn định:
  mysql-0.mysql-svc.default.svc.cluster.local
  mysql-1.mysql-svc.default.svc.cluster.local
  mysql-2.mysql-svc.default.svc.cluster.local

→ mysql-1 có thể luôn liên lạc với mysql-0 qua DNS
→ Kể cả khi mysql-0 bị restart, DNS vẫn trỏ đúng Pod mới

# Headless Service — bắt buộc phải có trước StatefulSet
apiVersion: v1
kind: Service
metadata:
  name: mysql-svc
spec:
  clusterIP: None           # Headless: không có VIP, DNS trả về Pod IP
  selector:
    app: mysql
  ports:
    - port: 3306
---
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: mysql
spec:
  serviceName: mysql-svc    # Tên Headless Service ở trên
  replicas: 3
  selector:
    matchLabels:
      app: mysql
  template:
    metadata:
      labels:
        app: mysql
    spec:
      containers:
        - name: mysql
          image: mysql:8.0
          ports:
            - containerPort: 3306
          env:
            - name: MYSQL_ROOT_PASSWORD
              value: "password123"
          volumeMounts:
            - name: mysql-data
              mountPath: /var/lib/mysql  # Mỗi Pod mount PVC riêng của mình
  volumeClaimTemplates:          # Template tự tạo PVC cho từng Pod
    - metadata:
        name: mysql-data
      spec:
        accessModes: ["ReadWriteOnce"]
        resources:
          requests:
            storage: 1Gi

kubectl apply -f statefulset-mysql.yaml

# Quan sát Pod tạo tuần tự: mysql-0 → mysql-1 → mysql-2
kubectl get pods -l app=mysql --watch

# Xem PVC được tạo tự động cho từng Pod
kubectl get pvc

# Pod có tên ổn định và thứ tự
kubectl get pods -l app=mysql -o wide

apiVersion: batch/v1
kind: Job
metadata:
  name: pi-calculator
spec:
  completions: 1            # Cần 1 lần chạy thành công
  parallelism: 1            # Chạy 1 Pod tại một thời điểm
  backoffLimit: 4           # Retry tối đa 4 lần nếu fail
  activeDeadlineSeconds: 120 # Timeout 2 phút — Job bị hủy nếu quá
  template:
    spec:
      restartPolicy: OnFailure  # Job phải dùng OnFailure hoặc Never
      containers:
        - name: pi
          image: perl:5.34
          command: ["perl", "-Mbignum=bpi", "-wle", "print bpi(2000)"]

kubectl apply -f job-pi.yaml

# Theo dõi Job cho đến khi Complete
kubectl get jobs --watch

# Xem Pod do Job tạo ra
kubectl get pods -l job-name=pi-calculator

# Xem kết quả tính toán trong log
kubectl logs -l job-name=pi-calculator

# Xem chi tiết Job: Completions, Duration
kubectl describe job pi-calculator

# Dọn dẹp
kubectl delete job pi-calculator

Cú pháp: "Phút  Giờ  Ngày  Tháng  Thứ"

┌───── Phút (0-59)
│ ┌───── Giờ (0-23)
│ │ ┌───── Ngày trong tháng (1-31)
│ │ │ ┌───── Tháng (1-12)
│ │ │ │ ┌───── Thứ trong tuần (0-6, 0=Chủ nhật)
│ │ │ │ │
* * * * *

Ví dụ:
"*/5 * * * *"      → Mỗi 5 phút
"0 * * * *"        → Mỗi giờ (vào đầu giờ)
"0 2 * * *"        → Hàng ngày lúc 2:00 AM
"0 2 * * 0"        → Hàng tuần vào CN lúc 2:00 AM
"0 2 1 * *"        → Ngày 1 hàng tháng lúc 2:00 AM
"0 9-18 * * 1-5"   → Mỗi giờ từ 9AM-6PM, thứ 2 đến thứ 6

apiVersion: batch/v1
kind: CronJob
metadata:
  name: daily-backup
spec:
  schedule: "0 2 * * *"          # Mỗi ngày lúc 2:00 AM
  concurrencyPolicy: Forbid       # Không cho phép chạy song song nếu trùng lịch
  successfulJobsHistoryLimit: 3   # Giữ lại 3 Job thành công gần nhất
  failedJobsHistoryLimit: 1       # Giữ lại 1 Job thất bại gần nhất
  startingDeadlineSeconds: 300    # Nếu trễ quá 5 phút thì bỏ qua lần này
  jobTemplate:
    spec:
      template:
        spec:
          restartPolicy: OnFailure
          containers:
            - name: backup
              image: alpine
              command:
                - /bin/sh
                - -c
                - |
                  echo "Starting backup at $(date)"
                  echo "Backing up database..."
                  sleep 30
                  echo "Backup completed successfully at $(date)"

kubectl apply -f cronjob-backup.yaml

# Xem CronJob — cột SCHEDULE và LAST SCHEDULE
kubectl get cronjob daily-backup

# Trigger thủ công để test ngay (không cần chờ đến 2AM)
kubectl create job backup-manual-test --from=cronjob/daily-backup

# Xem Job và Pod được tạo
kubectl get jobs
kubectl get pods -l job-name=backup-manual-test

# Xem log của Job
kubectl logs -l job-name=backup-manual-test

# Dọn dẹp
kubectl delete cronjob daily-backup
kubectl delete job backup-manual-test

Lớp 1: Node Network (vật lý / VM)
  master-01:   10.236.0.10/24
  worker-01:   10.236.0.11/24
  worker-02:   10.236.0.12/24
  → Đây là IP thực của máy chủ, do hạ tầng cấp

Lớp 2: Pod Network (do CNI Plugin quản lý — Calico)
  Pod A trên worker-01:  192.168.154.243/32
  Pod B trên worker-01:  192.168.154.244/32
  Pod C trên worker-02:  192.168.44.215/32
  → Mỗi Pod nhận 1 IP duy nhất, định tuyến qua Calico

Lớp 3: Service Network (virtual IP — do kube-proxy quản lý)
  ClusterIP Service:     10.96.x.x/12  (ví dụ: 10.102.161.178)
  kube-dns Service:      10.96.0.10
  → IP ảo, không gắn với interface thật, xử lý bởi iptables/IPVS

kubectl get nodes -o wide

kubectl apply -f Deployment.yaml
kubectl get pods -o wide

# Output mẫu:
# NAME                           READY   IP                NODE
# hello-world-75d6d8cfd7-bxqj7   1/1     192.168.154.243   k8s-node-01
# hello-world-75d6d8cfd7-p2559   1/1     192.168.44.215    k8s-node-02
# hello-world-75d6d8cfd7-qlzjw   1/1     192.168.154.244   k8s-node-01

# Vào Pod và kiểm tra network interface
kubectl exec -it <POD_NAME> -- ip addr

# Kết quả: eth0 với IP /32 — đặc trưng của Calico
# 3: eth0@if57: inet 192.168.154.243/32

# Test Pod-to-Pod connectivity (thay IP bằng IP của Pod khác)
kubectl exec -it <POD_NAME> -- ping 192.168.44.215 -c 3

# SSH vào worker node
ssh worker-01

# Xem routing table — Calico thêm route cho từng Pod
route -n
# 192.168.154.243  0.0.0.0  255.255.255.255  UH  0  0  0  cali6833ab5953b
# 192.168.154.244  0.0.0.0  255.255.255.255  UH  0  0  0  cali72039afe81f
# 192.168.44.192   10.236.0.12  255.255.255.192  UG  0  0  0  ens160
#                  ↑ Route đến Pod subnet trên node-02 qua node-02 IP

# Xem Calico interfaces
ip link show | grep cali

Pod A (192.168.154.243) trên worker-01
  │  Gói tin gửi đến 192.168.44.215 (Pod B)
  ▼
veth pair: cali6833ab5953b ← kết nối Pod A vào node network
  │  Kernel tra routing table trên worker-01
  │  Route: 192.168.44.192/26 via 10.236.0.12 (worker-02)
  ▼
vxlan.calico interface (IP: 192.168.154.192)
  │  VXLAN encapsulation: bọc gói tin gốc vào UDP/VXLAN frame
  │  Outer IP: src=10.236.0.11 dst=10.236.0.12 (node IPs)
  ▼
ens160 (10.236.0.11) → ens160 (10.236.0.12) qua node network
  │  VXLAN decapsulation tại worker-02
  ▼
cali interface trên worker-02 → Pod B (192.168.44.215)

Kết quả: Pod A thấy mình giao tiếp trực tiếp với Pod B
         Không có NAT — IP nguồn giữ nguyên 192.168.154.243

Service: hello-world (ClusterIP: 10.102.161.178, port: 8080)
  │  Label Selector: app=hello-world
  │
  ▼
Endpoints object (tự động cập nhật)
  ├── 192.168.154.243:80  (Pod A — Running, Healthy)
  ├── 192.168.44.215:80   (Pod B — Running, Healthy)
  └── 192.168.154.244:80  (Pod C — Running, Healthy)
  [Pod D đang Terminating → bị xóa khỏi Endpoints ngay]

kube-proxy trên mỗi node (watch API Server liên tục)
  → Khi Endpoints thay đổi, cập nhật iptables rules ngay
  → iptables DNAT: 10.102.161.178:8080 → random Pod IP:80

Traffic flow:
  Client → 10.102.161.178:8080 (ClusterIP)
         → iptables DNAT → 192.168.154.243:80 (Pod A)

Bên ngoài cluster
      ✗ Không thể truy cập ClusterIP từ bên ngoài

Bên trong cluster (Pod, node)
      ✓ Pod A → ClusterIP 10.102.161.178:8080 → kube-proxy → Pod B/C/D

ClusterIP flow:
  1. Nguồn: Pod A gửi đến 10.102.161.178:8080
  2. iptables PREROUTING: DNAT → Pod B IP (random, round-robin)
  3. Packet đến Pod B:80
  4. Reply đi ngược lại (conntrack tự track session)

apiVersion: v1
kind: Service
metadata:
  name: robusta-svc-01
spec:
  type: ClusterIP          # Mặc định — có thể bỏ qua field này
  ports:
    - port: 8080           # Port Service lắng nghe (client kết nối vào đây)
      targetPort: 80       # Port container thực sự đang chạy
      protocol: TCP
  selector:
    robusta: web-app       # Chỉ forward đến Pod có label này

kubectl apply -f 1-clusterip.yaml

# Xem Service — cột CLUSTER-IP, PORT(S)
kubectl get service robusta-svc-01

# Xem Endpoints — danh sách Pod IP thực sự phía sau Service
kubectl get endpoints robusta-svc-01

# Chi tiết Service: Selector, TargetPort, Endpoints
kubectl describe service robusta-svc-01

# Test từ bên trong cluster (chạy busybox Pod tạm)
kubectl run -it --rm test --image=busybox -- wget -qO- http://robusta-svc-01:8080

Bên ngoài cluster (browser, curl, external tool)
      ↓  http://10.236.0.11:30080  (worker-01 IP : nodePort)
      ↓  http://10.236.0.12:30080  (worker-02 IP : nodePort) — cả hai đều hoạt động!
      ↓  http://10.236.0.10:30080  (master IP : nodePort)    — kể cả master

kube-proxy trên node nhận request
      → iptables forward đến ClusterIP:8080
      → ClusterIP DNAT đến Pod IP:80

Port ranges:
  nodePort: 30000-32767   ← range mặc định, có thể cấu hình lại
  Không được dùng port ngoài range này

apiVersion: v1
kind: Service
metadata:
  name: robusta-svc-02
spec:
  type: NodePort
  ports:
    - port: 8080          # ClusterIP port (giao tiếp nội bộ)
      targetPort: 80      # Container port
      nodePort: 30080     # Port mở trên mỗi node (30000-32767)
      protocol: TCP
  selector:
    robusta: web-app

kubectl apply -f 2-nodeport.yaml

# Xem Service — PORT(S) hiện dạng 8080:30080/TCP
kubectl get service robusta-svc-02

# Test từ bên ngoài cluster (thay NODE_IP bằng IP thực của node)
curl http://NODE_IP:30080

# Test từ bất kỳ node nào trong cluster
curl http://10.236.0.11:30080  # worker-01
curl http://10.236.0.12:30080  # worker-02
curl http://10.236.0.10:30080  # master — cũng hoạt động!

Internet
      ↓  http://203.0.113.10:80  (External IP do cloud cấp)
      ↓
Cloud Load Balancer (AWS ELB / GCP LB / Azure LB)
      ↓  health check node, round-robin giữa các healthy node
      ↓  → 10.236.0.11:30080  (worker-01)
      ↓    10.236.0.12:30080  (worker-02)
      ↓
kube-proxy → ClusterIP → Pod

LoadBalancer tự động tạo NodePort phía sau:
  LoadBalancer (External IP) → NodePort (30000-32767) → ClusterIP → Pod

Trong on-premise không có cloud:
  type: LoadBalancer → Service sẽ pending EXTERNAL-IP mãi
  Giải pháp: dùng MetalLB để giả lập cloud LB trong on-premise

apiVersion: v1
kind: Service
metadata:
  name: robusta-svc-lb
spec:
  type: LoadBalancer        # Cloud provider sẽ tạo LB và cấp External IP
  ports:
    - port: 80
      targetPort: 80
      protocol: TCP
  selector:
    robusta: web-app

kubectl apply -f loadbalancer.yaml

# Watch cho đến khi EXTERNAL-IP xuất hiện (trên cloud)
kubectl get service robusta-svc-lb --watch

# Trên on-premise: EXTERNAL-IP sẽ <pending> mãi
# Cần cài MetalLB để giải quyết

# Nếu có EXTERNAL-IP, test từ internet:
# curl http://EXTERNAL_IP:80

=== ClusterIP Service ===
DNS query: robusta-svc-01.default.svc.cluster.local
DNS response: 10.102.161.178  ← 1 IP duy nhất (ClusterIP)
kube-proxy load balance đến Pod phía sau

=== Headless Service ===
DNS query: robusta-svc-03.default.svc.cluster.local
DNS response:
  192.168.154.243   ← Pod A IP
  192.168.44.215    ← Pod B IP
  192.168.154.244   ← Pod C IP
Client nhận tất cả IP và tự quyết định kết nối đến Pod nào

=== StatefulSet với Headless ===
DNS query: mysql-0.mysql-svc.default.svc.cluster.local → IP của mysql-0
DNS query: mysql-1.mysql-svc.default.svc.cluster.local → IP của mysql-1
Mỗi Pod có DNS riêng và ổn định → critical cho distributed systems

apiVersion: v1
kind: Service
metadata:
  name: robusta-svc-03
spec:
  clusterIP: None      # Đây là điều duy nhất làm cho Service trở thành Headless
  selector:
    robusta: web-app   # CoreDNS sẽ trả về IP của tất cả Pod có label này

kubectl apply -f 3-headless.yaml

# Headless Service không có CLUSTER-IP — hiện 'None'
kubectl get service robusta-svc-03

# So sánh DNS response trong busybox Pod
kubectl run -it --rm dnstest --image=busybox -- /bin/sh

# Trong busybox shell:
# ClusterIP → trả về 1 IP (ClusterIP)
nslookup robusta-svc-01
# Headless → trả về nhiều IP (Pod IPs trực tiếp)
nslookup robusta-svc-03

exit

Use case: App trong cluster cần gọi external database
         hoặc API bên ngoài cluster

Cách thông thường (hard-code):
  App → http://robusta.vn/api  ← hard-coded URL

Cách dùng ExternalName:
  App → http://external-01/api  ← dùng tên Service nội bộ
  CoreDNS: external-01.default.svc.cluster.local → CNAME → robusta.vn
  Sau đó DNS client resolve robusta.vn → IP thực của server bên ngoài

Lợi ích:
  → Khi endpoint bên ngoài thay đổi, chỉ cần đổi ExternalName Service
  → App không cần biết hostname thực — giảm coupling
  → Dễ dàng swap sang internal service sau này (chỉ đổi Service type)

apiVersion: v1
kind: Service
metadata:
  name: external-01
spec:
  type: ExternalName
  externalName: robusta.vn   # Hostname bên ngoài — phải là FQDN hợp lệ
  # Không có selector, không có ports, không có clusterIP
  # Hoàn toàn là DNS CNAME alias

kubectl apply -f 4-externalName.yaml

# ExternalName không có CLUSTER-IP
kubectl get service external-01

# Kiểm tra DNS CNAME từ trong cluster
kubectl run -it --rm dnstest --image=busybox -- nslookup external-01
# Kết quả mẫu:
# Name: external-01.default.svc.cluster.local
# Address: CNAME → robusta.vn → [external IP]

Pod /etc/resolv.conf (tự động inject bởi kubelet):
  nameserver 10.96.0.10          ← ClusterIP của kube-dns Service
  search default.svc.cluster.local svc.cluster.local cluster.local
  options ndots:5

Pod query: nslookup hello-world
  → search list: hello-world.default.svc.cluster.local  ← thử đầu tiên
                 hello-world.svc.cluster.local
                 hello-world.cluster.local
  → Tìm thấy ở: hello-world.default.svc.cluster.local → 10.102.161.178

Pod query: nslookup hello-world.default.svc.cluster.local  ← FQDN
  → CoreDNS lookup ngay, không cần search list
  → Trả về: 10.102.161.178

Từ namespace khác (myns):
  nslookup hello-world            → NXDOMAIN (tìm trong myns, không thấy)
  nslookup hello-world.default    → NXDOMAIN
  nslookup hello-world.default.svc.cluster.local → 10.102.161.178 ✓

# Xem CoreDNS pods và service
kubectl get pods -n kube-system -l k8s-app=kube-dns
kubectl get service -n kube-system kube-dns

# Xem chi tiết CoreDNS deployment
kubectl describe deployment coredns -n kube-system

# Xem cấu hình CoreDNS (Corefile)
kubectl get configmap coredns -n kube-system -o yaml

# Xem DNS config trong Pod bình thường
kubectl exec -it <POD_NAME> -- cat /etc/resolv.conf
# nameserver 10.96.0.10
# search default.svc.cluster.local svc.cluster.local cluster.local

# Test DNS từ cùng namespace (default)
kubectl run -it --rm bb --image=busybox -- /bin/sh
/ # nslookup hello-world
# → Tìm được: hello-world.default.svc.cluster.local → ClusterIP
/ # nslookup hello-world.default.svc.cluster.local
# → Trực tiếp, không qua search list
exit

# Tạo namespace mới và test cross-namespace DNS
kubectl create ns myns
kubectl run -n myns -it --rm bb1 --image=busybox -- /bin/sh
/ # nslookup hello-world
# → NXDOMAIN (Service không có trong myns)
/ # nslookup hello-world.default.svc.cluster.local
# → Thành công! FQDN hoạt động cross-namespace
exit

apiVersion: v1
kind: Pod
metadata:
  name: custom-dns-pod
spec:
  dnsPolicy: None            # Tắt DNS mặc định của cluster
  dnsConfig:
    nameservers:
      - 9.9.9.9              # Dùng Quad9 thay vì CoreDNS
    searches:
      - my-custom-domain.local
    options:
      - name: ndots
        value: '5'
  containers:
    - name: app
      image: nginx

# Khi tạo ClusterIP Service 10.102.161.178:8080 với 3 Pod phía sau:

# PREROUTING chain — bắt traffic đến ClusterIP
-A KUBE-SERVICES -d 10.102.161.178/32 -p tcp --dport 8080 \
   -j KUBE-SVC-XXXX

# Load balance — random 33% cho mỗi Pod
-A KUBE-SVC-XXXX -m statistic --mode random --probability 0.33 \
   -j KUBE-SEP-POD-A
-A KUBE-SVC-XXXX -m statistic --mode random --probability 0.5 \
   -j KUBE-SEP-POD-B
-A KUBE-SVC-XXXX -j KUBE-SEP-POD-C

# DNAT đến Pod thực
-A KUBE-SEP-POD-A -p tcp -j DNAT --to-destination 192.168.154.243:80
-A KUBE-SEP-POD-B -p tcp -j DNAT --to-destination 192.168.44.215:80
-A KUBE-SEP-POD-C -p tcp -j DNAT --to-destination 192.168.154.244:80

# Khi Pod bị xóa → kube-proxy ngay lập tức xóa rule tương ứng

# SSH vào worker node
ssh worker-01

# Xem các chain KUBE-* trong iptables
sudo iptables -t nat -L KUBE-SERVICES --line-numbers
sudo iptables -t nat -L | grep -A5 KUBE-SVC

# Xem tất cả rule liên quan đến Service IP
sudo iptables -t nat -L -n | grep 10.102.161.178

Mặc định (không có NetworkPolicy):
  Pod A → Pod B  ✓ (bất kỳ Pod nào cũng giao tiếp được)
  Pod A → Pod C  ✓
  Internet → Pod ✓ (qua NodePort)

Sau khi áp dụng NetworkPolicy cho Pod B (deny-all):
  Pod A → Pod B  ✗ (bị block)
  Pod C → Pod B  ✗ (bị block)
  Chỉ những source được whitelist mới vào được

Nguyên tắc:
  → Khi có ít nhất 1 NetworkPolicy select Pod
    Tất cả traffic không được allow sẽ bị DENY
  → Nhiều NetworkPolicy cùng select 1 Pod → rules được union (OR)

# Deny tất cả ingress traffic đến database Pod
# Chỉ cho phép traffic từ frontend Pod
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-frontend-to-db
  namespace: default
spec:
  podSelector:
    matchLabels:
      role: database         # Policy này áp dụng cho Pod có label role=database
  policyTypes:
    - Ingress                # Chỉ kiểm soát traffic vào
  ingress:
    - from:
        - podSelector:
            matchLabels:
              role: frontend # Chỉ cho phép từ Pod có label role=frontend
      ports:
        - protocol: TCP
          port: 3306         # Chỉ cho phép port MySQL
---
# Deny tất cả ingress traffic đến namespace production
# (áp dụng cho mọi Pod trong namespace)
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny-all
  namespace: production
spec:
  podSelector: {}            # {} = select tất cả Pod trong namespace
  policyTypes:
    - Ingress
    - Egress                 # Block cả traffic ra ngoài