DevOps: Docker + Kubernetes Core Concepts (Intermediate++)

VM:
  Hardware ──► Hypervisor ──► Guest OS (kernel riêng) ──► App
  Tốn: ~100–500ms boot, ~128MB RAM/VM overhead

Container:
  Hardware ──► Host OS kernel ──► containerd/runc ──► App (process biệt lập)
  Tốn: ~10–50ms start, ~1–5MB overhead

# Xem cgroup của container đang chạy
cat /sys/fs/cgroup/memory/docker/<container_id>/memory.limit_in_bytes

# Nếu không set limit → unlimited → OOM killer sẽ ngẫu nhiên kill process trên host

Container writable layer  ← ghi ở đây, bị xoá khi container chết
─────────────────────────
Layer 3: COPY . .         (code app)
Layer 2: RUN npm ci       (node_modules)
Layer 1: COPY package.json .
Layer 0: node:20-alpine   (base image)
─────────────────────────
Host filesystem

# ❌ Tệ: thay đổi code → rebuild toàn bộ (npm ci lại từ đầu)
FROM node:20-alpine
WORKDIR /app
COPY . .          # copy tất cả — cache miss mọi lúc
RUN npm ci
RUN npm run build

# ✅ Tốt: layer ổn định ở dưới, layer hay thay đổi ở trên
FROM node:20-alpine AS build
WORKDIR /app
COPY package*.json ./        # Layer này cache đến khi package.json đổi
RUN npm ci                   # Chỉ chạy lại khi dependencies đổi
COPY . .                     # Code thay đổi thường xuyên → đặt sau
RUN npm run build

# Multi-stage: final image không chứa build tools
FROM nginx:1.27-alpine
COPY --from=build /app/dist /usr/share/nginx/html
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

# BuildKit cache mount — npm cache không đi vào image
RUN --mount=type=cache,target=/root/.npm \
    npm ci --prefer-offline

kubelet
  └── containerd (CRI endpoint: /run/containerd/containerd.sock)
        └── containerd-shim-runc-v2
              └── runc (tạo container thực sự bằng syscall clone, pivot_root, ...)

# Liệt kê container đang chạy (trên node K8s)
crictl ps

# Xem logs
crictl logs <container_id>

# Inspect container
crictl inspect <container_id>

┌─────────────────────────────────────────────────────────────────┐
│                         CONTROL PLANE                           │
│                                                                 │
│  kubectl / API ──► kube-apiserver ──► etcd (source of truth)   │
│                          │                                      │
│                    ┌─────┴──────┐                               │
│                    │            │                               │
│              scheduler    controller-manager                    │
│              (chọn node)  (reconciliation loops)                │
└─────────────────────────────────────────────────────────────────┘
         │ watch & notify                 │ watch & notify
         ▼                               ▼
┌────────────────┐              ┌────────────────┐
│  Worker Node 1  │              │  Worker Node 2  │
│  kubelet        │              │  kubelet        │
│  kube-proxy     │              │  kube-proxy     │
│  containerd     │              │  containerd     │
└────────────────┘              └────────────────┘

while true:
    desired_state  = etcd.read(resource)
    current_state  = observe_real_world()
    if current_state != desired_state:
        take_action_to_converge()
    sleep(a_bit)

resources:
  requests:
    cpu: "250m"       # 0.25 core — scheduler dùng để chọn node
    memory: "256Mi"   # kubelet dùng để tính eviction priority
  limits:
    cpu: "1000m"      # throttled nếu vượt (CPU compressible)
    memory: "1Gi"     # OOMKilled nếu vượt (memory incompressible)

affinity:
  nodeAffinity:
    # Cứng: phải chạy trên node có SSD
    requiredDuringSchedulingIgnoredDuringExecution:
      nodeSelectorTerms:
        - matchExpressions:
            - key: disk-type
              operator: In
              values: ["ssd"]
    # Mềm: ưu tiên node ở zone us-east-1a
    preferredDuringSchedulingIgnoredDuringExecution:
      - weight: 80
        preference:
          matchExpressions:
            - key: topology.kubernetes.io/zone
              operator: In
              values: ["us-east-1a"]

topologySpreadConstraints:
  - maxSkew: 1                              # Zone A và B chênh nhau tối đa 1 pod
    topologyKey: topology.kubernetes.io/zone
    whenUnsatisfiable: DoNotSchedule        # Không schedule nếu vi phạm
    labelSelector:
      matchLabels:
        app: payment-api

# Taint node: chỉ pod có toleration mới vào được
kubectl taint nodes node1 dedicated=gpu:NoSchedule

# Toleration trong pod spec
tolerations:
  - key: "dedicated"
    operator: "Equal"
    value: "gpu"
    effect: "NoSchedule"

Pod A (node 1, 10.244.1.5)  ──►  veth pair  ──►  bridge cbr0  ──►  node routing ──►  Pod B (node 2, 10.244.2.8)

Client Pod ──► iptables PREROUTING ──► DNAT đến một pod IP ngẫu nhiên (load balance)

KUBE-SERVICES → KUBE-SVC-XXXXX (selector: app=payment) 
  → KUBE-SEP-AAA (50%) → 10.244.1.5:8080
  → KUBE-SEP-BBB (50%) → 10.244.2.8:8080

# Service "payment-api" trong namespace "payments":
payment-api.payments.svc.cluster.local → ClusterIP của service

# Từ cùng namespace: có thể dùng short form
payment-api → resolve đến payment-api.payments.svc.cluster.local

# Chỉ cho phép payment-api gọi vào postgres, port 5432
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: postgres-ingress
  namespace: payments
spec:
  podSelector:
    matchLabels:
      app: postgres
  policyTypes:
    - Ingress
  ingress:
    - from:
        - podSelector:
            matchLabels:
              app: payment-api
      ports:
        - protocol: TCP
          port: 5432

spec:
  containers:
    - name: payment-api
      
      # startupProbe: chỉ chạy khi container start
      # Tránh liveness kill container đang khởi động
      startupProbe:
        httpGet:
          path: /healthz/startup
          port: 8080
        failureThreshold: 30   # Cho phép fail 30 lần × 10s = 5 phút để start
        periodSeconds: 10

      # livenessProbe: container có đang "sống" không?
      # Fail → kubelet RESTART container (không xoá pod)
      livenessProbe:
        httpGet:
          path: /healthz/live
          port: 8080
        initialDelaySeconds: 5
        periodSeconds: 10
        failureThreshold: 3    # Fail 3 lần liên tiếp → restart

      # readinessProbe: container có sẵn sàng nhận traffic không?
      # Fail → pod bị rút khỏi Service endpoints (không restart)
      readinessProbe:
        httpGet:
          path: /healthz/ready
          port: 8080
        periodSeconds: 5
        failureThreshold: 2    # Fail nhanh hơn liveness

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxUnavailable: 0   # Không giảm capacity (zero-downtime)
    maxSurge: 1         # Tạo thêm 1 pod mới trước khi kill pod cũ

# Đang chạy version blue
kubectl patch service payment-api -p '{"spec":{"selector":{"version":"blue"}}}'

# Deploy green
kubectl apply -f deployment-green.yaml

# Kiểm tra green ổn
kubectl patch service payment-api -p '{"spec":{"selector":{"version":"green"}}}'

# Rollback tức thì nếu lỗi
kubectl patch service payment-api -p '{"spec":{"selector":{"version":"blue"}}}'

# deployment-stable.yaml: replicas: 9
# deployment-canary.yaml: replicas: 1
# → 10% traffic đến canary (vì Service load balance đều theo số pod)

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: payment-api-pdb
spec:
  minAvailable: 2   # Phải còn ít nhất 2 pod "Available" mọi lúc
  selector:
    matchLabels:
      app: payment-api

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: postgres
spec:
  serviceName: postgres-headless  # Headless service cho DNS per-pod
  replicas: 3
  selector:
    matchLabels:
      app: postgres
  template:
    spec:
      containers:
        - name: postgres
          image: postgres:16
          env:
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: postgres-secret
                  key: password
          volumeMounts:
            - name: data
              mountPath: /var/lib/postgresql/data
  volumeClaimTemplates:            # Mỗi pod tự động tạo PVC riêng
    - metadata:
        name: data
      spec:
        accessModes: ["ReadWriteOnce"]
        storageClassName: fast-ssd
        resources:
          requests:
            storage: 100Gi

postgres-0.postgres-headless.default.svc.cluster.local → IP của postgres-0
postgres-1.postgres-headless.default.svc.cluster.local → IP của postgres-1

StorageClass (template)
  └── PVC (yêu cầu storage)
        └── PV (storage thực tế — EBS, GCE PD, NFS...)
              └── Mount vào Pod

apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: fast-ssd
provisioner: ebs.csi.aws.com      # AWS EBS CSI driver
parameters:
  type: gp3
  iops: "3000"
  throughput: "125"
reclaimPolicy: Retain              # Giữ EBS volume khi PVC xoá (an toàn hơn Delete)
volumeBindingMode: WaitForFirstConsumer  # Tạo EBS cùng AZ với pod

spec:
  securityContext:               # Pod-level
    runAsNonRoot: true
    runAsUser: 1000
    runAsGroup: 3000
    fsGroup: 2000                # Files tạo bởi process có group 2000
    seccompProfile:
      type: RuntimeDefault       # Chặn syscall nguy hiểm theo default profile

  containers:
    - name: app
      securityContext:           # Container-level (override pod-level)
        allowPrivilegeEscalation: false   # Chặn setuid, sudo
        readOnlyRootFilesystem: true      # / không ghi được → attacker không thể modify files
        capabilities:
          drop: ["ALL"]                   # Drop tất cả Linux capabilities
          add: ["NET_BIND_SERVICE"]       # Chỉ thêm lại cái thực sự cần

# ServiceAccount cho pod
apiVersion: v1
kind: ServiceAccount
metadata:
  name: payment-api
  namespace: payments

---
# Role: chỉ đọc secrets trong namespace payments
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: secret-reader
  namespace: payments
rules:
  - apiGroups: [""]
    resources: ["secrets"]
    resourceNames: ["payment-api-secret"]   # Chỉ secret cụ thể, không phải tất cả
    verbs: ["get"]

---
# Bind role vào service account
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: payment-api-secret-reader
  namespace: payments
subjects:
  - kind: ServiceAccount
    name: payment-api
    namespace: payments
roleRef:
  kind: Role
  name: secret-reader
  apiGroup: rbac.authorization.k8s.io

kubectl auth can-i get secrets --as=system:serviceaccount:payments:payment-api -n payments

# Enforce: vi phạm → pod bị reject
# Warn: vi phạm → cảnh báo nhưng vẫn cho qua
# Audit: vi phạm → ghi vào audit log
apiVersion: v1
kind: Namespace
metadata:
  name: payments
  labels:
    pod-security.kubernetes.io/enforce: restricted  # Chế độ chặt nhất
    pod-security.kubernetes.io/warn: restricted
    pod-security.kubernetes.io/audit: restricted

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: payment-api-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: payment-api
  minReplicas: 3
  maxReplicas: 50
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60     # Scale khi CPU > 60% của requests
    - type: Resource
      resource:
        name: memory
        target:
          type: AverageValue
          averageValue: 800Mi
    - type: Pods
      pods:
        metric:
          name: http_requests_per_second  # Custom metric từ Prometheus
        target:
          type: AverageValue
          averageValue: "1000"

// Structured log — machine-readable, dễ filter
log.Info("payment processed",
    "order_id", orderID,
    "amount", amount,
    "duration_ms", elapsed.Milliseconds(),
    "trace_id", span.SpanContext().TraceID(),
)

# Fluentd/Fluent Bit DaemonSet: collect logs từ mọi node, forward đến Elasticsearch/Loki
apiVersion: apps/v1
kind: DaemonSet
metadata:
  name: fluentbit
spec:
  selector:
    matchLabels:
      app: fluentbit
  template:
    spec:
      containers:
        - name: fluentbit
          image: fluent/fluent-bit:2.2
          volumeMounts:
            - name: varlog
              mountPath: /var/log
      volumes:
        - name: varlog
          hostPath:
            path: /var/log