Đến nội dung chính
Sổ ôn Backend

Tìm kiếm

Git, DevOps & ToolingMid22 phút đọc

Kubernetes cho backend dev: kiến trúc, Pod, Service, ConfigMap, autoscaling và debug pod lỗi

Ôn 12 thẻ
Trong bài này

Cả bài trong một trang: ý chính, sơ đồ, điểm phỏng vấn.

Kubernetes cho backend dev: kiến trúc, Pod, Service, ConfigMap, autoscaling và debug pod lỗi

1Trạng thái mong muốn

Bạn khai báo trạng thái muốn có bằng YAML; các controller liên tục so với thực tế và làm từng bước cho khớp. Node chết lúc nửa đêm, controller tự tạo pod bù.

flowchart TD
  Y["YAML trong Git"] -->|"kubectl apply"| A["API server lưu vào etcd"]
  A --> C["Controller so mong muốn với thực tế"]
  C -->|"thiếu pod"| P["Tạo pod mới"]
  P --> C

2Ai làm gì trong cluster

Mọi thứ đi qua API server và được lưu trong etcd; các thành phần khác chỉ theo dõi API server và phản ứng.

Thành phần Việc
API server Cửa duy nhất đọc ghi, RBAC
etcd Lưu toàn bộ trạng thái, Raft
Scheduler Chọn node theo requests, taint
kubelet (mỗi node) Chạy container, probe, báo trạng thái

3Pod và các workload

Pod có IP riêng nhưng tạm thời: chết là có pod mới, IP mới. Gần như không tạo pod trực tiếp mà qua workload.

  • Deployment: API không trạng thái, rolling update
  • StatefulSet: kafka-0, kafka-1, mỗi pod một ổ
  • DaemonSet: đúng một pod mỗi node, agent log
  • Job, CronJob: migration, batch chạy xong là thôi

4Service và đường vào

Service cho một tên và IP ổn định, chỉ chia tải tới pod ready. Một Ingress hoặc Gateway API làm cửa vào chung, định tuyến theo host và path.

flowchart TD
  I["Internet"] --> G["Ingress hoặc Gateway API"]
  G -->|"host, path"| S["Service ClusterIP"]
  S --> P1["Pod ready"]
  S --> P2["Pod ready"]

5requests, limits và HPA

requests để xếp lịch và làm mẫu số cho HPA; limits là trần cứng. HPA: desired = ceil(hiện tại × metric / mục tiêu).

Dùng cho Vượt thì
requests Xếp lịch, HPA tính % CPU Không bị phạt
Memory limits Trần RAM OOMKilled, exit 137
CPU limits Trần CPU Bị throttle, p99 tăng

6Debug pod lỗi

Đi đúng thứ tự: get → describe (xem Events) → logs --previous → exec. Mỗi trạng thái có nhóm nguyên nhân quen thuộc.

  • Pending: không node nào đủ requests
  • ImagePullBackOff: sai tag, thiếu imagePullSecrets
  • CrashLoopBackOff: lỗi cấu hình, liveness giết oan
  • 0/1 READY: readiness sai path hoặc port

💡 Ghi nhớ

  • Không bao giờ lưu IP của pod; gọi qua Service.

  • Secret chỉ là base64, không phải mã hoá.

  • Biến môi trường từ ConfigMap không tự cập nhật.

  • Spring Boot khởi động chậm: dùng startupProbe.

⭐ Điểm phỏng vấn

Tự trả lời trước, rồi bấm từng câu để xem đáp án.

  • Deployment khác Service?

    Deployment giữ số pod; Service cho địa chỉ ổn định.

  • requests khác limits?

    requests để xếp lịch, limits là trần cứng.

  • Pod CrashLoopBackOff, điều tra thế nào?

    describe xem Events, logs --previous, exit code.

⚠️ Lỗi thường gặp

  • Chỉ nhìn kubectl get pods; lý do thật nằm trong Events và log cũ.

  • Không đặt requests: xếp lịch mù, HPA theo CPU không chạy.

  • Service không có endpoint vì selector lệch labels của pod.

Backend dev không cần vận hành cluster, nhưng phải đọc được manifest, biết request đi từ Internet vào pod thế nào, và tự debug khi pod của mình không chạy. Bài này đi qua phần lõi đó. Phần deploy không mất request (probe, rolling update, PodDisruptionBudget) nằm ở bài chiến lược deploy.

Sơ đồ tóm tắt:

flowchart LR
  U[kubectl apply] --> API[API server]
  API --> E[(etcd)]
  CM[Controller manager] -->|tạo Pod| API
  S[Scheduler] -->|chọn node| API
  K[kubelet trên node] -->|chạy container| P[Pod]
  API --> K
  C[Client] --> I[Ingress / Gateway] --> SV[Service] --> P

1. Kubernetes giải quyết gì

Ý chính: Docker chạy container trên một máy; Kubernetes vận hành nhiều container trên nhiều máy: tự thay container chết, chia tải, cập nhật dần, cấp cấu hình và tự tăng giảm số bản chạy.

  • Imperative (ra lệnh): kubectl run, kubectl scale — tiện để thử, nhưng không ai biết cluster đang ở trạng thái do lệnh nào tạo ra.
  • Declarative (khai báo): file YAML trong Git, kubectl apply -f hoặc GitOps (Argo CD, Flux) đồng bộ. Đây là cách cho production.
  • Vòng reconcile: mỗi controller đọc trạng thái mong muốn trong API server, nhìn trạng thái thật, làm một bước để kéo gần lại, rồi lặp. Không có “lệnh” nào bị mất: node chết lúc nửa đêm thì controller thấy thiếu pod và tạo bù.
Docker/Compose trên một máy Kubernetes
restart: always trên một host Pod chết hoặc node chết đều được tạo lại ở node khác
Scale bằng tay replicas và HorizontalPodAutoscaler
Gọi nhau qua tên service trong Compose Service + DNS nội bộ, chỉ trỏ tới pod ready
Cập nhật: dừng rồi chạy lại Rolling update, rollback theo revision

2. Kiến trúc: ai làm gì

Ý chính: mọi thứ đi qua API server và được lưu trong etcd; các thành phần còn lại chỉ “xem” API server và phản ứng. Node làm việc nặng: kéo image, chạy container, báo trạng thái.

Thành phần Ở đâu Việc
kube-apiserver control plane cửa duy nhất đọc/ghi trạng thái, xác thực, phân quyền (RBAC)
etcd control plane kho key-value đồng thuận Raft, lưu toàn bộ trạng thái cluster
kube-scheduler control plane chọn node cho pod chưa có node, theo requests, affinity, taint
kube-controller-manager control plane chạy các controller: Deployment, ReplicaSet, Node, Job…
kubelet mỗi node nhận pod được gán, gọi container runtime (containerd), chạy probe, báo trạng thái
kube-proxy mỗi node lập luật iptables/IPVS/nftables để IP của Service tới được pod

Đường đi của kubectl apply -f deployment.yaml:

  1. API server kiểm tra và lưu Deployment vào etcd.
  2. Deployment controller tạo ReplicaSet; ReplicaSet controller tạo đủ số Pod (chưa có node).
  3. Scheduler gán mỗi Pod vào một node còn đủ requests.
  4. kubelet trên node đó kéo image, tạo container, chạy probe; pod ready thì vào danh sách endpoint của Service.

3. Workload: Pod, Deployment và các loại khác

Ý chính: gần như không bao giờ tạo Pod trực tiếp. Service không lưu trạng thái dùng Deployment; cần danh tính và ổ đĩa riêng cho từng bản dùng StatefulSet; chạy xong là thôi dùng Job/CronJob.

  • Pod: một hoặc vài container dùng chung IP, port và volume. Pod không “hồi sinh”: bị xoá hay node chết là có Pod mới với IP mới, nên đừng bao giờ lưu IP của pod.
  • Nhiều container trong một Pod chỉ khi chúng gắn chặt với nhau (sidecar proxy, agent đẩy log). Mỗi service một Deployment riêng, không gộp hai service vào một Pod.
  • ReplicaSet giữ đúng N pod; Deployment quản lý các ReplicaSet để rolling update và rollback (kubectl rollout undo).
Loại Dùng cho Đặc điểm
Deployment API, worker không trạng thái pod thay thế được cho nhau, tên ngẫu nhiên
StatefulSet Kafka, database, ZooKeeper tên cố định kafka-0, kafka-1, mỗi pod một PersistentVolumeClaim, khởi động theo thứ tự
DaemonSet agent log, agent monitoring đúng một pod trên mỗi node
Job / CronJob migration, batch, job theo lịch chạy tới khi xong; CronJob có concurrencyPolicy: Forbid chống chạy chồng

4. Service, DNS và đường vào từ Internet

Ý chính: Service cho một tên và một IP ảo ổn định, chia tải tới các pod khớp selector và đang ready. Loại Service quyết định ai gọi được: chỉ trong cluster, qua port của node, hay qua load balancer của cloud.

Loại Ai gọi được Ghi chú
ClusterIP (mặc định) chỉ trong cluster gọi bằng DNS order-service.shop.svc.cluster.local, cùng namespace thì chỉ cần order-service
NodePort ai tới được IP của node mở cùng một port (mặc định dải 30000–32767) trên mọi node
LoadBalancer Internet hoặc mạng nội bộ cloud cấp một load balancer L4 riêng cho Service đó
Headless (clusterIP: None) trong cluster DNS trả thẳng IP từng pod; StatefulSet dùng để gọi kafka-0.kafka
  • Ingress là bộ luật định tuyến HTTP (host, path, TLS); cần một Ingress controller (Traefik, HAProxy, NGINX của F5, controller của cloud) thực thi. Một load balancer cho cả chục service thay vì mỗi service một cái.
  • Gateway API là thế hệ sau của Ingress: tách Gateway (hạ tầng lo) khỏi HTTPRoute (team service lo), hỗ trợ chia traffic theo trọng số cho canary. Dự án ingress-nginx của cộng đồng Kubernetes đã ngừng bảo trì từ 2026, nên dự án mới nên chọn Gateway API hoặc một controller còn được bảo trì.
  • Service chỉ gửi tới pod ready. “Service không có endpoint” gần như luôn do selector không khớp labels của pod, hoặc mọi pod đều fail readiness.
Manifest: Service, Ingress và HTTPRoute cho cùng một service
apiVersion: v1
kind: Service
metadata: { name: order-service, namespace: shop }
spec:
  type: ClusterIP
  selector: { app: order-service }        # phải khớp labels trong template của Deployment
  ports: [{ name: http, port: 80, targetPort: 8080 }]
---
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata: { name: shop, namespace: shop }
spec:
  ingressClassName: traefik
  tls: [{ hosts: [api.shop.vn], secretName: shop-tls }]
  rules:
    - host: api.shop.vn
      http:
        paths:
          - path: /orders
            pathType: Prefix
            backend: { service: { name: order-service, port: { number: 80 } } }
---
# Cùng ý nghĩa bằng Gateway API (Gateway "public" do team hạ tầng tạo sẵn)
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata: { name: orders, namespace: shop }
spec:
  parentRefs: [{ name: public, namespace: infra }]
  hostnames: [api.shop.vn]
  rules:
    - matches: [{ path: { type: PathPrefix, value: /orders } }]
      backendRefs:
        - { name: order-service, port: 80, weight: 90 }
        - { name: order-service-canary, port: 80, weight: 10 }

kube-proxy không phải proxy theo nghĩa nhận rồi chuyển tiếp request: nó chỉ cài luật NAT trong kernel, nên Service ClusterIP là L4 và không retry, không hiểu HTTP. Chia tải theo connection: client giữ connection lâu (gRPC, HTTP/2, pool keep-alive) có thể dồn hết vào một pod; khi đó cần chia tải phía client hoặc service mesh.

5. ConfigMap và Secret

Ý chính: tách cấu hình khỏi image để cùng một image chạy ở mọi môi trường. ConfigMap cho cấu hình thường, Secret cho thông tin nhạy cảm, nhưng Secret mặc định chỉ là base64 trong etcd.

  • Hai cách đưa vào pod: biến môi trường (envFrom) hoặc file qua volume. Biến môi trường đọc một lần lúc container khởi động; file trong volume được kubelet cập nhật sau một lúc (thường dưới một phút), trừ khi mount bằng subPath.
  • Đổi ConfigMap không làm pod restart. Cách phổ biến: đặt hash của ConfigMap vào annotation của pod template (Helm, Kustomize làm sẵn), đổi config là rollout mới.
  • Secret: bật mã hoá etcd lúc nghỉ (encryption at rest), giới hạn RBAC ai được get secrets, hoặc lấy từ kho bên ngoài (Vault, AWS Secrets Manager qua External Secrets Operator / CSI driver). Đừng commit Secret YAML vào Git dù đã base64.
  • Spring Boot đọc được cả hai: biến môi trường SPRING_DATASOURCE_URL, hoặc spring.config.import=configtree:/etc/config/ để mỗi file thành một property.

6. Resources, QoS và autoscaling

Ý chính: requests là phần node giữ chỗ cho pod (scheduler dùng để xếp, HPA dùng làm mẫu số), limits là trần cứng. Không đặt requests thì xếp lịch mù và HPA theo CPU không chạy được.

  • Memory vượt limits: kernel giết process, pod báo OOMKilled, exit code 137. CPU vượt limits: không bị giết mà bị throttle (CFS quota), p99 tăng vọt. Nhiều team chỉ đặt memory limit, không đặt CPU limit.
  • JVM trong container đọc giới hạn của cgroup; đặt -XX:MaxRAMPercentage=75 để heap chừa chỗ cho metaspace, thread stack, buffer ngoài heap. Xem JVM trong container.
  • QoS class quyết định ai bị đuổi trước khi node thiếu RAM: BestEffort (không đặt gì) trước, rồi Burstable, cuối cùng Guaranteed (mọi container có requests = limits cho cả CPU và memory).

HPA (Horizontal Pod Autoscaler) tính số pod mong muốn:

desired = ceil( currentReplicas × currentMetric / targetMetric )
  • CPU utilization tính theo requests: pod request 500m đang dùng 450m là 90%.
  • Tỉ lệ lệch dưới 10% (tolerance mặc định 0,1) thì giữ nguyên, để không dao động.
  • Scale down có cửa sổ ổn định mặc định 5 phút: lấy đề xuất cao nhất trong 5 phút gần nhất, tránh giảm rồi tăng liên tục.
  • Cần metrics-server cho CPU/memory; theo độ dài hàng đợi hay lag Kafka thì dùng custom/external metrics (Prometheus Adapter, KEDA).

7. Debug pod lỗi

Ý chính: đọc trạng thái, rồi đi đúng thứ tự get → describe (xem Events) → logs (cả --previous) → exec/port-forward. Mỗi trạng thái lỗi có một nhóm nguyên nhân quen thuộc.

Triệu chứng Nghĩa Nguyên nhân hay gặp Xem ở đâu
Pending chưa được xếp vào node không node nào đủ requests, taint không có toleration, PVC chưa bind describe pod → Events FailedScheduling
ImagePullBackOff / ErrImagePull không kéo được image sai tên/tag, registry riêng thiếu imagePullSecrets, image không có cho kiến trúc CPU của node Events
CrashLoopBackOff container khởi động rồi thoát, lặp lại với thời gian chờ tăng dần tới 5 phút lỗi cấu hình, không kết nối được DB lúc khởi động, sai lệnh chạy, liveness giết oan logs --previous, exit code trong describe
OOMKilled (exit 137) vượt memory limit heap + phần ngoài heap lớn hơn limit describe → Last State
Running nhưng 0/1 READY readiness fail endpoint health sai path/port, phụ thuộc chưa sẵn sàng Events Readiness probe failed
Service trả lỗi kết nối Service không có endpoint selector lệch labels, targetPort sai kubectl get endpointslices -l kubernetes.io/service-name=...
Các lệnh debug thường dùng
kubectl get pods -n shop -o wide                    # trạng thái, node, IP, số lần restart
kubectl describe pod order-service-7c9f-abcde -n shop   # Events ở cuối: lý do thật nằm ở đây
kubectl logs order-service-7c9f-abcde -n shop --previous  # log của lần chạy vừa chết
kubectl logs deploy/order-service -n shop -f --since=10m
kubectl get events -n shop --sort-by=.lastTimestamp
kubectl exec -it order-service-7c9f-abcde -n shop -- sh   # image distroless không có shell:
kubectl debug -it order-service-7c9f-abcde -n shop --image=busybox --target=app
kubectl port-forward svc/order-service 8080:80 -n shop    # gọi thử service từ máy mình
kubectl top pods -n shop                             # CPU/memory thật (cần metrics-server)
kubectl rollout status deploy/order-service -n shop
kubectl rollout undo deploy/order-service -n shop

Exit code hay gặp: 1 lỗi ứng dụng (đọc log), 137 = 128 + 9 (SIGKILL, thường là OOM hoặc bị giết vì liveness), 143 = 128 + 15 (SIGTERM, dừng bình thường khi xoá pod).

Bài tập

Bài 1: HPA sẽ chạy bao nhiêu pod

Deployment có 4 pod, mỗi pod request CPU 500m, HPA mục tiêu 70%, minReplicas: 2, maxReplicas: 20. Tính số pod HPA chọn khi CPU trung bình mỗi pod là 450m, 370m, 100m và 2000m. Viết hàm Java tính giúp.

Lời giải Bài 1
public class HpaCalc {
    static final double TOLERANCE = 0.1;   // mặc định của HPA: lệch dưới 10% thì giữ nguyên

    /** desired = ceil(current * currentUtil / targetUtil), kẹp trong [min, max]. */
    static int desired(int current, double avgCpuMillis, double requestMillis, double targetPercent,
                       int min, int max) {
        double utilization = avgCpuMillis / requestMillis * 100;   // % so với requests, không phải limits
        double ratio = utilization / targetPercent;
        if (Math.abs(ratio - 1.0) <= TOLERANCE) return current;
        int want = (int) Math.ceil(current * ratio);
        return Math.max(min, Math.min(max, want));
    }

    public static void main(String[] args) {
        // 4 pod, request 500m, mục tiêu 70%
        System.out.println("TB 450m/pod -> " + desired(4, 450, 500, 70, 2, 20));  // 90% -> ceil(4*1.2857)=6
        System.out.println("TB 370m/pod -> " + desired(4, 370, 500, 70, 2, 20));  // 74% -> lệch 5.7%, giữ 4
        System.out.println("TB 100m/pod -> " + desired(4, 100, 500, 70, 2, 20));  // 20% -> ceil(1.14)=2
        System.out.println("TB 2000m/pod -> " + desired(4, 2000, 500, 70, 2, 20)); // 400% -> 23 -> kẹp 20
    }
}

Chạy java HpaCalc.java (JDK 21):

TB 450m/pod -> 6
TB 370m/pod -> 4
TB 100m/pod -> 2
TB 2000m/pod -> 20

Hai điều bài tập chưa mô phỏng: giảm từ 4 xuống 2 chỉ xảy ra sau cửa sổ ổn định 5 phút; và 2000m/pod chỉ có được khi không đặt CPU limit hoặc limit ≥ 2000m, nên “400%” là dấu hiệu requests đặt quá thấp so với tải thật.

Bài 2: Service không trả lời

Bạn deploy payment-service. Pod Running 1/1, nhưng từ pod khác gọi http://payment-service/actuator/health bị Connection refused. Liệt kê các bước kiểm tra theo thứ tự.

Lời giải Bài 2
  1. kubectl get endpointslices -l kubernetes.io/service-name=payment-service: không có địa chỉ nào → selector của Service không khớp labels của pod (lỗi chính tả app: payment vs app: payment-service), hoặc pod chưa ready.
  2. Có endpoint nhưng vẫn refused → targetPort của Service khác port ứng dụng thật lắng nghe (8080 vs 8081), hoặc ứng dụng chỉ nghe 127.0.0.1 thay vì 0.0.0.0.
  3. Kiểm tra trực tiếp: kubectl port-forward pod/<pod> 8080:8080 rồi gọi; được thì lỗi ở Service, không được thì lỗi ở ứng dụng.
  4. Khác namespace: phải gọi payment-service.<namespace>; có NetworkPolicy chặn thì lỗi thường là timeout chứ không phải refused.
  5. Sửa xong, thêm kiểm tra này vào pipeline: smoke test gọi qua Service sau khi deploy.

Ghi nhớ

  • Giải thích được trạng thái mong muốn và vòng reconcile bằng một ví dụ (node chết).
  • Kể được việc của API server, etcd, scheduler, controller manager, kubelet, kube-proxy.
  • Biết chọn Deployment, StatefulSet, DaemonSet, Job và loại Service phù hợp.
  • Phân biệt được requests và limits, và hệ quả với OOMKilled, throttle, HPA.
  • Debug được Pending, ImagePullBackOff, CrashLoopBackOff, OOMKilled theo đúng thứ tự lệnh.

Câu hỏi phỏng vấn

Junior

Pod là gì? Vì sao không chạy container trực tiếp?

Pod là đơn vị nhỏ nhất Kubernetes quản lý: một hoặc vài container dùng chung IP, port và volume, được xếp lên cùng một node. Kubernetes cần lớp này để nhóm các container gắn chặt nhau và gắn mạng, lưu trữ, probe cho cả nhóm.

Pod là tạm thời: chết là có pod mới với IP mới. Vì vậy không gọi pod bằng IP mà qua Service, và không tạo pod trực tiếp mà qua Deployment để có pod thay thế.

Deployment và Service khác nhau thế nào?

Deployment lo “chạy bao nhiêu bản của phiên bản nào” (tạo, thay, cập nhật pod); Service lo “gọi chúng bằng địa chỉ nào” (tên DNS và IP ổn định, chia tải tới pod ready).

Hai thứ nối với nhau bằng label: Service chọn pod qua selector, không biết gì về Deployment.

Mid

Bạn đưa một service ra ngoài cluster bằng những cách nào?

NodePort (mở port trên mọi node), LoadBalancer (cloud cấp load balancer riêng cho service), hoặc Ingress/Gateway API (một load balancer chung, định tuyến theo host và path tới nhiều Service).

  • API HTTP công khai: Ingress hoặc Gateway API, TLS kết thúc ở đó, một IP cho nhiều service.
  • Giao thức không phải HTTP (TCP thuần, MQTT): LoadBalancer, hoặc Gateway API với TCPRoute.
  • NodePort chủ yếu cho môi trường thử hoặc khi tự đặt load balancer bên ngoài.
  • Debug từ máy mình thì kubectl port-forward, không mở service ra ngoài chỉ để thử.
requests và limits khác nhau thế nào? Đặt sai thì sao?

requests là phần node giữ chỗ cho container, scheduler dùng để xếp và HPA dùng làm mẫu số; limits là trần, vượt memory thì bị OOMKilled, vượt CPU thì bị throttle.

  • Không đặt requests: pod là BestEffort, bị đuổi đầu tiên, node bị xếp quá tải, HPA theo CPU không tính được.
  • Requests quá cao: lãng phí, pod Pending vì không node nào đủ chỗ.
  • CPU limit thấp: throttle làm p99 tăng dù CPU trung bình thấp; nhiều team bỏ CPU limit, giữ memory limit.
  • Memory limit sát heap: JVM cần thêm metaspace, thread stack, direct buffer; dùng MaxRAMPercentage khoảng 75%.
Đổi ConfigMap rồi mà ứng dụng vẫn chạy cấu hình cũ. Vì sao?

Vì cấu hình được đưa vào bằng biến môi trường, mà biến môi trường chỉ đọc lúc container khởi động; Kubernetes không tự restart pod khi ConfigMap đổi.

  • Mount bằng volume thì file được cập nhật sau một lúc (không áp dụng với subPath), nhưng ứng dụng vẫn phải tự đọc lại.
  • Cách chuẩn: đặt hash nội dung ConfigMap vào annotation của pod template (Helm/Kustomize), đổi config là có rollout mới, có lịch sử và rollback được.
  • Hoặc dùng ConfigMap bất biến có tên theo phiên bản (app-config-v42).

Senior

Pod ở trạng thái CrashLoopBackOff. Bạn điều tra thế nào?

Container đang khởi động rồi thoát lặp lại; tìm lý do thoát qua exit code và log của lần chạy trước, rồi phân biệt lỗi ứng dụng với việc bị Kubernetes giết.

  1. kubectl describe pod: Last State, exit code, Events (liveness fail? OOMKilled?).
  2. kubectl logs --previous: stack trace của lần chết.
  3. Exit 1: lỗi ứng dụng (thiếu biến môi trường, không kết nối DB, sai profile). Exit 137 + OOMKilled: vượt memory. Exit 137 không OOM, Events có liveness fail: liveness giết oan, thiếu startup probe.
  4. Không có log: lệnh chạy sai (command/args), image sai kiến trúc, file không có quyền chạy.
  5. Cần vào trong: kubectl debug với image có công cụ, hoặc tạm đổi command thành sleep để kiểm tra môi trường.
HPA theo CPU cho một service Spring Boot hay bị dao động và tăng pod mỗi lần deploy. Vì sao và sửa thế nào?

JVM khởi động tốn CPU (JIT, nạp class), nên pod mới trông như quá tải, HPA thêm pod, pod mới lại tốn CPU. Cộng với requests đặt thấp làm % utilization nhảy mạnh.

  • Đặt requests theo mức dùng thật lúc ổn định, để % có ý nghĩa.
  • Cấu hình behavior của HPA: cửa sổ ổn định khi scale up, giới hạn số pod thêm mỗi phút.
  • Giảm CPU lúc khởi động: CDS/AppCDS, CRaC hoặc native image nếu phù hợp; readiness chỉ bật khi đã làm nóng.
  • Cân nhắc metric bám tải thật hơn CPU: request/giây mỗi pod, độ dài hàng đợi.
Vì sao Secret của Kubernetes chưa đủ an toàn, và bạn quản lý secret thế nào?

Secret mặc định chỉ base64 trong etcd: ai đọc được etcd, backup etcd, hoặc có quyền get secrets trong namespace là có giá trị thật.

  • Bật encryption at rest cho etcd (tốt nhất với KMS), RBAC tối thiểu cho secrets, không cho pod mount ServiceAccount token khi không cần.
  • Lấy secret từ kho chuyên dụng (Vault, AWS Secrets Manager, GCP Secret Manager) qua External Secrets Operator hoặc Secrets Store CSI driver; có xoay vòng và audit.
  • Không commit Secret YAML vào Git; nếu GitOps thì dùng Sealed Secrets hoặc SOPS để chỉ lưu bản đã mã hoá.
  • Ứng dụng không log giá trị cấu hình nhạy cảm, và /actuator/env phải che giá trị (Spring Boot 3 mặc định management.endpoint.env.show-values=never).

Từ vựng tiếng Anh

Term Phát âm Nghĩa Ví dụ câu tiếng Anh dùng trong phỏng vấn
desired state /dɪˈzaɪrd steɪt/ trạng thái mong muốn “Controllers keep reconciling the actual state towards the desired state.”
reconcile /ˈrek.ən.saɪl/ đối chiếu và sửa cho khớp “The ReplicaSet controller reconciles the pod count every time something changes.”
control plane /kənˈtroʊl pleɪn/ phần điều khiển cluster “etcd is the source of truth for the control plane.”
scheduler /ˈskedʒ.uː.lɚ/ bộ xếp lịch “The scheduler places pods based on their resource requests.”
ClusterIP /ˈklʌs.tɚ aɪ piː/ IP ảo nội bộ của Service “Internal services only need a ClusterIP.”
ingress /ˈɪn.ɡres/ cửa vào HTTP “We expose ten services through one ingress and one load balancer.”
resource requests /ˈriː.sɔːrs rɪˈkwests/ tài nguyên giữ chỗ “CPU utilization in the HPA is measured against requests.”
throttling /ˈθrɑː.t̬əl.ɪŋ/ bị bóp CPU “CPU throttling explained the p99 spikes.”
eviction /ɪˈvɪk.ʃən/ bị đuổi khỏi node “BestEffort pods are evicted first under memory pressure.”
crash loop /kræʃ luːp/ khởi động rồi chết lặp lại “The pod was in a crash loop because the liveness probe started too early.”

Ghi chép tự tổng hợp từ tài liệu chính thức và kinh nghiệm thực tế.