Kubernetes là một hệ thống điều khiển theo trạng thái mong muốn: bạn khai báo thứ mình muốn, các controller liên tục kéo thực tế về khớp với khai báo đó. Hiểu mô hình này giải thích gần như mọi hành vi bạn sẽ gặp — kể cả những hành vi trông như lỗi.
Mười mục: mô hình điều khiển (1) → Pod và Deployment (2) → Service và Ingress (3) → cấu hình và volume (4) → probe và resource (5) → autoscaling (6) → scheduling (7) → bảo mật (8) → kubectl và debug (9) → checklist (10).
| Hiện tượng | Giải thích |
|---|---|
Xoá pod bằng kubectl delete pod nhưng nó xuất hiện lại |
ReplicaSet thấy số pod thực tế (2) nhỏ hơn mong muốn (3) nên tạo pod mới. Muốn giảm thật thì
phải sửa replicas trong Deployment. |
Sửa trực tiếp pod bằng kubectl edit pod nhưng thay đổi bị mất |
Pod do ReplicaSet quản lý. Lần sau pod bị tạo lại, nó dùng template từ Deployment — không phải bản bạn vừa sửa. Mọi thay đổi phải ở cấp Deployment. |
| Sửa ConfigMap nhưng pod không nhận giá trị mới | Spec của Deployment không đổi nên controller không thấy việc gì cần làm. Phải làm pod template đổi — đó là lý do cần checksum annotation (xem mục 4). |
ArgoCD tự hoàn tác thay đổi bạn làm bằng kubectl |
Với ArgoCD, Git là trạng thái mong muốn. Thay đổi thủ công bị coi là sai lệch và bị kéo về. Đây là tính năng, không phải lỗi. Xem chặng 07. |
Deployment bạn khai báo: image, replicas, template, chiến lược update
│ tạo và quản lý
▼
ReplicaSet một cái cho MỖI phiên bản pod template
│ tạo và quản lý (deploy 5 lần → 5 ReplicaSet, cũ có 0 pod nhưng vẫn tồn tại
▼ để rollback được)
Pod đơn vị chạy thật, có IP riêng
│ chứa
▼
Container process trong pod
Đây là lý do kubectl rollout undo hoạt động: ReplicaSet cũ vẫn còn, chỉ cần
scale nó lên và scale cái mới về 0. Số ReplicaSet giữ lại do
revisionHistoryLimit quyết định (mặc định 10).
| Thành phần | Ai quản | Điều bạn cần biết |
|---|---|---|
| Control plane API server, etcd, scheduler, controller-manager |
AWS | Chạy trên nhiều AZ, AWS tự vá và scale. Bạn trả phí theo giờ cho mỗi cluster. Không SSH được vào, không xem được log etcd. |
| Node kubelet, containerd, kube-proxy |
Bạn | Managed node group hoặc Karpenter. Bạn chịu trách nhiệm chọn loại instance, nâng AMI, và xử lý khi node NotReady. Xem chặng 01, mục 5. |
| Add-on VPC CNI, CoreDNS, kube-proxy, EBS CSI |
Chia sẻ | AWS cung cấp bản đóng gói (EKS add-on) nhưng bạn quyết định phiên bản và thời điểm nâng. Nâng add-on không tương thích là nguyên nhân thật của sự cố cluster. |
| Ứng dụng | Bạn | Toàn bộ. Đây là nội dung của bộ tài liệu này. |
kubectl delete pod my-app-xyz trên Deployment có 3 replica. Kết quả?Pod là đơn vị nhỏ nhất Kubernetes quản lý — và bạn gần như không bao giờ tạo pod trực tiếp. Bạn khai Deployment, nó lo phần còn lại.
Một pod là một hoặc nhiều container chia sẻ network namespace và IPC namespace, được xếp lên cùng một node, sinh ra và chết cùng nhau.
| Chia sẻ trong pod | Riêng cho từng container |
|---|---|
| Network namespace (cùng IP, cùng không gian port) · IPC · volume được mount · vòng đời | Filesystem từ image riêng · cgroup riêng (nên limits là của từng container)
· process namespace (trừ khi bật shareProcessNamespace) |
localhost và
không được trùng port; còn limits.memory áp cho từng container, nhưng kubelet xét
evict theo cả pod — nên một sidecar thiếu limit có thể kéo cả pod đi.
apiVersion: apps/v1
kind: Deployment
metadata:
name: order-service
namespace: prod
labels:
app.kubernetes.io/name: order-service
app.kubernetes.io/version: "1.4.2"
spec:
replicas: 3
revisionHistoryLimit: 5 # giữ 5 ReplicaSet cũ để rollback; mặc định 10
selector:
matchLabels:
app: order-service # PHẢI khớp template.metadata.labels và BẤT BIẾN
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1 # tạo thêm tối đa 1 pod so với replicas
maxUnavailable: 0 # KHÔNG cho phép tụt dưới replicas → không giảm năng lực
# Thời gian tối đa chờ rollout xong trước khi coi là thất bại
progressDeadlineSeconds: 600
template:
metadata:
labels:
app: order-service
version: "1.4.2"
annotations:
# Làm pod template đổi khi config đổi → kích hoạt rolling update.
# Helm sinh tự động, xem chặng 05.
checksum/config: "8f7a2c1e9b4d5a6f"
checksum/secret: "3b2e9f1a7c4d8e02"
spec:
serviceAccountName: order-service # gắn IAM role qua IRSA
terminationGracePeriodSeconds: 45
# Không cần token API trong pod thì tắt — giảm bề mặt tấn công
automountServiceAccountToken: false
securityContext:
runAsNonRoot: true
runAsUser: 10001
runAsGroup: 10001
fsGroup: 10001
seccompProfile:
type: RuntimeDefault
containers:
- name: app
image: 123456789012.dkr.ecr.ap-southeast-1.amazonaws.com/order-service:a3f8c21
imagePullPolicy: IfNotPresent # tag bất biến nên không cần Always
ports:
- name: http
containerPort: 8080
protocol: TCP
envFrom:
- configMapRef: { name: order-service-config }
- secretRef: { name: order-service-secret }
env:
- name: POD_NAME
valueFrom: { fieldRef: { fieldPath: metadata.name } }
- name: MEMORY_LIMIT
valueFrom:
resourceFieldRef:
containerName: app
resource: limits.memory
resources:
requests:
cpu: 200m
memory: 2560Mi
limits:
cpu: 2000m # 10× request: cho burst lúc khởi động
memory: 3584Mi # = Xmx + ngoài heap + 15%
startupProbe:
httpGet: { path: /actuator/health/readiness, port: http }
periodSeconds: 2
failureThreshold: 60 # cho tới 120 giây để khởi động
livenessProbe:
httpGet: { path: /actuator/health/liveness, port: http }
periodSeconds: 10
timeoutSeconds: 3
failureThreshold: 3
readinessProbe:
httpGet: { path: /actuator/health/readiness, port: http }
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 2
lifecycle:
preStop:
exec:
command: ["sh", "-c", "sleep 5"]
securityContext:
allowPrivilegeEscalation: false
readOnlyRootFilesystem: true
capabilities:
drop: ["ALL"]
volumeMounts:
- { name: tmp, mountPath: /tmp }
- { name: dump, mountPath: /dump }
volumes:
- name: tmp
emptyDir: {}
- name: dump
emptyDir:
sizeLimit: 4Gi # đủ chỗ cho heap dump
maxSurge và maxUnavailable — chọn thế nào| Cấu hình | Hành vi | Dùng khi |
|---|---|---|
maxSurge: 1maxUnavailable: 0 |
Luôn đủ năng lực. Rollout chậm hơn, cần dư tài nguyên cho 1 pod. | Khuyến nghị cho production. Không bao giờ giảm năng lực trong lúc deploy. |
maxSurge: 25%maxUnavailable: 25% |
Mặc định. Rollout nhanh nhưng có lúc năng lực tụt 25%. | Môi trường dev/staging, hoặc service chịu được tụt năng lực. |
maxSurge: 100%maxUnavailable: 0 |
Tạo full bộ pod mới rồi mới gỡ pod cũ. Nhanh nhất, tốn gấp đôi tài nguyên tạm thời. | Service nhỏ cần rollout nhanh, và có đủ quota node. |
type: Recreate |
Xoá hết pod cũ rồi mới tạo pod mới. Có downtime. | App không chạy được hai phiên bản song song (ví dụ migration schema không tương thích). |
| Loại | Đặc điểm | Dùng cho |
|---|---|---|
| Deployment | Pod có thể thay thế lẫn nhau, tên ngẫu nhiên, không trạng thái | Mặc định. Web API, worker không trạng thái, gần như mọi service của bạn. |
| StatefulSet | Tên ổn định (-0, -1), PVC riêng mỗi pod,
khởi động/tắt theo thứ tự |
Database tự quản, Kafka, Elasticsearch. Cân nhắc dùng dịch vụ quản lý của AWS trước — vận hành stateful trên Kubernetes tốn công hơn nhiều. |
| DaemonSet | Đúng một pod trên mỗi node (hoặc mỗi node khớp selector) | Agent thu log (Fluent Bit), agent metric (node-exporter), CNI, CSI driver. |
| Job | Chạy tới hoàn thành rồi dừng | Migration database, backfill dữ liệu, task một lần. Dùng với Helm hook. |
| CronJob | Tạo Job theo lịch | Báo cáo định kỳ, dọn dẹp. Dùng cái này thay vì scheduler trong app — xem chặng 02, mục 1. |
Pod có IP nhưng IP đó thay đổi mỗi lần pod được tạo lại. Service cho một địa chỉ ổn định. Ingress đưa traffic từ internet vào.
Service (ClusterIP 172.20.91.33, port 8080)
│
│ selector: app=order-service
▼
Endpoints / EndpointSlice ← danh sách IP:port của pod ĐANG READY
│ (readiness fail → pod bị gỡ khỏi đây)
▼
kube-proxy trên MỖI node ← dựng iptables/IPVS rule để NAT
│
▼
Pod IP thật: 10.0.3.14:8080, 10.0.4.91:8080, 10.0.5.27:8080
ping ClusterIP luôn thất bại dù service hoạt động bình thường — một nhầm lẫn
rất phổ biến khi debug.
| Loại | Làm gì | Dùng khi |
|---|---|---|
| ClusterIP | IP ảo chỉ truy cập được trong cluster | Mặc định, dùng cho gần như mọi service. Giao tiếp service-to-service. |
HeadlessclusterIP: None |
Không có IP ảo. DNS trả về trực tiếp IP của từng pod. | Khi client cần biết từng pod: StatefulSet, gRPC client tự load-balance, Kafka. |
| NodePort | Mở một port (30000–32767) trên mọi node | Hiếm dùng trực tiếp. Chủ yếu là tầng trung gian cho LoadBalancer. |
| LoadBalancer | Tạo NLB/CLB thật trên AWS | Khi cần phơi TCP/UDP ra ngoài. Cho HTTP thì dùng Ingress với ALB tốt hơn — một ALB phục vụ nhiều service, rẻ hơn nhiều NLB. |
| ExternalName | Chỉ tạo bản ghi CNAME trong DNS | Trỏ tới dịch vụ ngoài cluster (RDS, API bên thứ ba) bằng tên nội bộ, để đổi endpoint không phải sửa app. |
round_robin.maxConnectionAge ở phía server để kết nối bị xoay vòng định kỳ, buộc
client kết nối lại và được phân phối lại.apiVersion: v1
kind: Service
metadata:
name: order-service
namespace: prod
spec:
type: ClusterIP
selector:
app: order-service # PHẢI khớp label của pod, không phải của Deployment
ports:
- name: http
port: 8080 # port của Service
targetPort: http # tên port trong container — bền hơn dùng số
protocol: TCP
# Giữ pod chưa Ready trong Endpoints để StatefulSet có DNS ngay từ đầu
# publishNotReadyAddresses: false (mặc định, đúng cho hầu hết trường hợp)
targetPort theo tên, không theo số. Khi đổi port container, bạn chỉ sửa
Deployment; Service không cần sửa. Giảm một nguồn lỗi do quên đồng bộ hai file.
Trên EKS, AWS Load Balancer Controller đọc Ingress và tạo ALB thật. Một ALB có
thể phục vụ nhiều Ingress nếu chúng cùng group.name — điều này tiết kiệm chi phí đáng kể so
với mỗi service một load balancer.
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
name: order-service
namespace: prod
annotations:
# --- Cơ bản ---
alb.ingress.kubernetes.io/scheme: internet-facing # hoặc 'internal'
alb.ingress.kubernetes.io/target-type: ip # trỏ thẳng pod IP, BỎ QUA kube-proxy
# --- Gom nhiều Ingress vào MỘT ALB (tiết kiệm chi phí) ---
alb.ingress.kubernetes.io/group.name: prod-shared
alb.ingress.kubernetes.io/group.order: "20"
# --- TLS ---
alb.ingress.kubernetes.io/certificate-arn: arn:aws:acm:ap-southeast-1:123456789012:certificate/abc
alb.ingress.kubernetes.io/listen-ports: '[{"HTTP":80},{"HTTPS":443}]'
alb.ingress.kubernetes.io/ssl-redirect: "443"
alb.ingress.kubernetes.io/ssl-policy: ELBSecurityPolicy-TLS13-1-2-2021-06
# --- Health check: dùng READINESS, không dùng liveness ---
alb.ingress.kubernetes.io/healthcheck-path: /actuator/health/readiness
alb.ingress.kubernetes.io/healthcheck-interval-seconds: "10"
alb.ingress.kubernetes.io/healthcheck-timeout-seconds: "5"
alb.ingress.kubernetes.io/healthy-threshold-count: "2"
alb.ingress.kubernetes.io/unhealthy-threshold-count: "3"
# --- Thuộc tính ALB ---
alb.ingress.kubernetes.io/load-balancer-attributes: >-
idle_timeout.timeout_seconds=60,
routing.http2.enabled=true,
access_logs.s3.enabled=true,
access_logs.s3.bucket=my-alb-logs
# QUAN TRỌNG: deregistration delay phải >= preStop + thời gian xử lý request
alb.ingress.kubernetes.io/target-group-attributes: >-
deregistration_delay.timeout_seconds=30,
stickiness.enabled=false
# --- WAF và bảo vệ ---
alb.ingress.kubernetes.io/wafv2-acl-arn: arn:aws:wafv2:ap-southeast-1:123456789012:regional/webacl/prod/abc
spec:
ingressClassName: alb
rules:
- host: api.example.com
http:
paths:
- path: /orders
pathType: Prefix
backend:
service:
name: order-service
port:
name: http
target-type: ip so với instance| Chế độ | Đường đi của gói | Đánh đổi |
|---|---|---|
ipkhuyến nghị |
ALB → thẳng pod IP | Ít một chặng NAT nên độ trễ thấp hơn, giữ được client IP thật, health check đúng pod. Yêu cầu VPC CNI (mặc định trên EKS). |
instance |
ALB → NodePort → kube-proxy → pod (có thể ở node khác) | Thêm một chặng, mất client IP, và health check kiểm node chứ không kiểm pod. Chỉ dùng khi CNI không hỗ trợ chế độ ip. |
Thứ tự phải đảm bảo:
preStop sleep (5s)
≥ thời gian ALB phát hiện và gỡ target
deregistration_delay (30s)
≥ preStop + thời gian xử lý request dài nhất
terminationGracePeriodSeconds (45s)
≥ preStop (5s) + timeout shutdown của app (25s) + biên
idle_timeout của ALB (60s)
≥ thời gian request dài nhất
Sai một mắt là có 502/504 lẻ tẻ mỗi lần deploy — loại lỗi khó tái hiện và dễ bị bỏ qua.
# Dạng tên đầy đủ
<service>.<namespace>.svc.cluster.local
# Trong cùng namespace: chỉ cần tên service
curl http://payment-service:8080/healthz
# Khác namespace: thêm tên namespace
curl http://payment-service.billing:8080/healthz
# Nên dùng FQDN trong cấu hình production để tránh phụ thuộc search domain
curl http://payment-service.billing.svc.cluster.local:8080/healthz
# Kiểm tra: Service có backend nào không — lệnh quan trọng nhất khi gặp 503
kubectl get endpoints payment-service -n billing
kubectl get endpointslice -n billing -l kubernetes.io/service-name=payment-service
selector của Service không khớp label của pod. Hai lệnh xác nhận:
kubectl get endpoints <svc> -n <ns> # rỗng?
kubectl get pods -n <ns> --show-labels | grep <app> # label có khớp selector?
Về bẫy ndots:5 làm DNS chậm, xem chặng 01, mục 7.
ping tới ClusterIP của Service không có phản hồi, nhưng curl tới port đó thì được. Giải thích?Phần cơ chế ConfigMap/Secret đã nói ở chặng 02. Mục này tập trung vào phần Kubernetes: checksum annotation, các loại volume, và storage trên EKS.
Vì spec của Deployment không đổi, controller không thấy việc gì cần làm. Có ba cách xử lý:
| Cách | Cơ chế | Đánh đổi |
|---|---|---|
| Checksum annotation khuyến nghị |
Đưa hash của ConfigMap vào annotation của pod template. Config đổi → hash đổi → template đổi → rolling update. | Tường minh, hoạt động với GitOps, có lịch sử rollback. Helm sinh tự động. |
| Reloader | Controller theo dõi ConfigMap/Secret và tự rollout restart deployment liên quan. |
Không cần sửa chart. Nhưng restart xảy ra ngoài Git nên ArgoCD không thấy lý do. |
| App tự đọc lại file | Mount ConfigMap thành file; kubelet đồng bộ sau ~60s; app watch file. | Không cần restart. Nhưng app phải hỗ trợ, và không hoạt động với subPath. |
apiVersion: apps/v1
kind: Deployment
spec:
template:
metadata:
annotations:
checksum/config: {{ include (print $.Template.BasePath "/configmap.yaml") . | sha256sum }}
checksum/secret: {{ include (print $.Template.BasePath "/secret.yaml") . | sha256sum }}
Chi tiết cách hoạt động ở chặng 05 · Helm. Đây là một trong những lý do dùng Helm thay vì YAML thuần.
| Loại | Vòng đời | Dùng cho |
|---|---|---|
emptyDir | Mất khi pod bị xoá | Dùng nhiều nhất. /tmp khi bật readOnlyRootFilesystem, thư mục
ghi heap dump, cache tạm, chia sẻ file giữa các container trong pod. |
emptyDir vớimedium: Memory | Như trên, nhưng trong RAM | /dev/shm cho Chrome headless, PyTorch. Tính vào limits.memory
— phải nâng limit tương ứng. |
configMap / secret | Theo đối tượng | File cấu hình, certificate, keystore. |
persistentVolumeClaim | Độc lập với pod | Dữ liệu cần bền. Trên EKS là EBS (một AZ, một pod ghi) hoặc EFS (nhiều AZ, nhiều pod ghi). |
projected | Theo pod | Gộp nhiều nguồn vào một thư mục. Dùng cho service account token có TTL. |
| EBS (gp3) | EFS | |
|---|---|---|
| Chế độ truy cập | ReadWriteOnce — một node |
ReadWriteMany — nhiều node, nhiều pod |
| Phạm vi AZ | Gắn với một AZ. Pod phải xếp vào đúng AZ có volume | Truy cập được từ mọi AZ |
| Hiệu năng | Cao, độ trễ thấp. gp3 cấu hình được IOPS/throughput độc lập | Thấp hơn rõ rệt, độ trễ cao hơn (là NFS) |
| Chi phí | Thấp hơn cho dung lượng lớn | Cao hơn, tính cả theo lượng truy cập |
| Dùng cho | Database, dữ liệu một pod ghi | Thư mục chia sẻ giữa nhiều pod, file upload dùng chung |
Pending vĩnh viễn với lỗi
volume node affinity conflict.
volumeBindingMode: WaitForFirstConsumer trong
StorageClass. Khi đó volume chỉ được tạo sau khi scheduler chọn node, nên nó luôn ở đúng AZ.
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
name: gp3
provisioner: ebs.csi.aws.com
volumeBindingMode: WaitForFirstConsumer # BẮT BUỘC với EBS multi-AZ
allowVolumeExpansion: true
parameters:
type: gp3
iops: "3000"
throughput: "125"
encrypted: "true"
kmsKeyId: arn:aws:kms:ap-southeast-1:123456789012:key/abc
Ứng dụng web không trạng thái đúng cách thì chỉ cần emptyDir:
volumes:
- name: tmp
emptyDir: {} # cho /tmp — JVM cần, Python cần cho prometheus multiproc
- name: dump
emptyDir:
sizeLimit: 4Gi # heap dump / core dump
- name: cache
emptyDir:
sizeLimit: 1Gi # cache tạm, mất cũng không sao
- name: dshm
emptyDir:
medium: Memory
sizeLimit: 1Gi # /dev/shm nếu cần
# File upload → S3. Session → Redis. Dữ liệu → RDS.
# Không có gì cần ghi bền trên đĩa pod.
Pending với lỗi volume node affinity conflict. Cách phòng tránh đúng?Hai thứ gây sự cố nhiều nhất trong toàn bộ Kubernetes. Mục này là phần Kubernetes; phần tính toán cho pod Java nằm trong tài liệu JVM, trang 9 và 10.
| Probe | Fail thì sao | Nên kiểm tra gì |
|---|---|---|
| startupProbe | Chờ tiếp. Vượt failureThreshold thì restart container.
Hai probe kia bị tạm dừng cho tới khi cái này xanh. |
App đã khởi tạo xong chưa. Thường dùng chung endpoint với readiness. |
| readinessProbe | Gỡ pod khỏi Endpoints. Pod vẫn chạy, không bị restart, không nhận traffic. | Khả năng xử lý request ngay lúc này: DB kết nối được, cache sẵn sàng, chưa shutdown. |
| livenessProbe | Restart container. Hành động phá hoại nhất. | Chỉ việc process còn phản hồi. Tuyệt đối không kiểm dependency ngoài. |
DB chậm 10 giây
→ liveness timeout trên MỌI pod cùng lúc (chúng dùng cùng một DB)
→ Kubernetes restart TẤT CẢ pod
→ pod mới khởi động, DB vẫn chậm, lại fail
→ CrashLoopBackOff toàn bộ service
→ DB còn bị dồn thêm kết nối từ việc khởi động lại liên tục
Một sự cố DB tạm thời đã biến thành mất dịch vụ hoàn toàn.
Đúng cách: readiness kiểm DB (pod bị rút khỏi traffic nhưng vẫn sống, tự hồi phục khi DB trở
lại), liveness chỉ kiểm process. Cấu hình Spring Boot cụ thể ở
chặng 02, mục 6.
startupProbe:
initialDelaySeconds: 0 # chờ trước lần kiểm đầu. Có startupProbe thì để 0.
periodSeconds: 2 # kiểm mỗi 2 giây
timeoutSeconds: 3 # mỗi lần kiểm chờ tối đa 3 giây
failureThreshold: 60 # fail 60 lần liên tiếp mới restart
# → Tổng thời gian cho phép khởi động = 2 × 60 = 120 giây
livenessProbe:
periodSeconds: 10
timeoutSeconds: 3
failureThreshold: 3
# → Phát hiện treo sau tối đa 10 × 3 = 30 giây
readinessProbe:
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 2
successThreshold: 1 # cần 1 lần thành công để Ready lại
# → Rút khỏi traffic sau tối đa 5 × 2 = 10 giây
failureThreshold và periodSeconds của liveness phải lớn hơn readiness.
timeoutSeconds phải lớn hơn thời gian GC pause tệ nhất — nếu không, pod bị
restart chỉ vì một lần Full GC.
# httpGet — phổ biến nhất. 200-399 là thành công.
livenessProbe:
httpGet:
path: /actuator/health/liveness
port: http
httpHeaders:
- name: Accept
value: application/json
# tcpSocket — chỉ kiểm port mở. Dùng cho service không phải HTTP.
livenessProbe:
tcpSocket:
port: 5432
# exec — chạy lệnh trong container. exit 0 là thành công.
# TỐN KÉM: tạo process mới mỗi lần kiểm. Tránh dùng với periodSeconds nhỏ.
livenessProbe:
exec:
command: ["sh", "-c", "pg_isready -U postgres"]
# grpc — từ Kubernetes 1.24, cần app implement health checking protocol
livenessProbe:
grpc:
port: 9090
service: ""
| Trường | Tác dụng thật | Đặt sai thì sao |
|---|---|---|
requests.cpu |
Giữ chỗ để xếp node. Là mẫu số của ngưỡng HPA/KEDA. Không chặn gì. | Quá cao → autoscaler mất nhạy, tốn tiền node. Quá thấp → pod bị dồn vào node chật. |
limits.cpu |
Trần cứng, sinh CFS quota mỗi chu kỳ 100 ms. | Quá thấp → throttle, p95 cao, probe fail. Bằng request → mất burst, pod restart lúc khởi động. |
requests.memory |
Lượng RAM được bảo đảm. Quyết định thứ tự bị kubelet evict. | Thấp hơn mức dùng thật → pod nằm đầu danh sách bị evict khi node chật. |
limits.memory |
Trần cứng. Working set vượt là OOMKilled ngay. | Thiếu → pod chạy nhiều giờ rồi chết đúng lúc heap giãn hết. Lỗi khó chẩn đoán nhất. |
# ---------- CPU ----------
# Suy NGƯỢC từ ngưỡng autoscaler, không nhân hệ số vào P95.
# Vì ngưỡng = mục_tiêu% × requests.cpu, muốn tải thường nằm dưới ngưỡng thì:
requests.cpu = P95_mỗi_pod ÷ mục_tiêu% × 1.15 (1.15 là biên)
limits.cpu = max(3.5 × requests.cpu, CPU_lúc_khởi_động × 1.25)
nhưng KHÔNG dưới 1000m với pod Java/.NET
# Ví dụ: P95 = 120m, mục tiêu 70%
# requests.cpu = 120 ÷ 0.7 × 1.15 = 197m → làm tròn 200m
# limits.cpu = max(700m, 860×1.25=1075m) → 1100m, nâng lên 2000m cho an toàn
# ngưỡng scale = 70% × 200m = 140m
# tỉ lệ ở tải thường = 120/140 = 0.86 → còn biên, mà tăng 28% là scale out
# ---------- RAM (Java) ----------
requests.memory = Xmx + ngoài_heap (ngoài heap ≈ 600-700 MiB)
limits.memory = (Xmx + ngoài_heap) × 1.15
# Ví dụ: Xmx 2048, ngoài heap 655
# requests.memory = 2703 → làm tròn 2816Mi
# limits.memory = 3108 → làm tròn 3584Mi
Công cụ tính tương tác và giải thích từng bước nằm ở tài liệu JVM, trang 9.
| QoS | Điều kiện | Thứ tự bị evict |
|---|---|---|
| Guaranteed | requests = limits cho mọi container, cả CPU và memory |
Cuối cùng. Nhưng với Java thì limits.cpu = requests.cpu gây throttle lúc
khởi động — phải chọn giữa hai điều. |
| Burstable | Có requests, khác limits |
Giữa. Bị evict nếu dùng vượt request. Đây là mức thực tế của gần như mọi pod. |
| BestEffort | Không khai requests và limits |
Đầu tiên. Không bao giờ để service production ở mức này. |
limits làm cả pod tụt xuống Burstable hoặc BestEffort, dù
container app của bạn khai đầy đủ.
apiVersion: v1
kind: LimitRange
metadata:
name: default-limits
namespace: prod
spec:
limits:
- type: Container
# Áp cho container KHÔNG khai resource → không còn BestEffort
default:
cpu: 500m
memory: 512Mi
defaultRequest:
cpu: 100m
memory: 256Mi
# Chặn giá trị vô lý
max:
cpu: "8"
memory: 16Gi
min:
cpu: 10m
memory: 64Mi
# Chặn tỉ lệ limit/request quá lớn (tránh overcommit node)
maxLimitRequestRatio:
cpu: "10"
memory: "2"
apiVersion: v1
kind: ResourceQuota
metadata:
name: prod-quota
namespace: prod
spec:
hard:
requests.cpu: "50"
requests.memory: 100Gi
limits.cpu: "200"
limits.memory: 200Gi
persistentvolumeclaims: "20"
count/deployments.apps: "50"
pods: "200"
LimitRange giải quyết "ai đó quên khai resource", ResourceQuota
giải quyết "một namespace ăn hết tài nguyên cluster". Cả hai nên có ở mọi namespace production.
Có ba thứ scale, ở ba tầng khác nhau, và chúng phải phối hợp được với nhau.
Ngưỡng KEDA memory 80% × requests.memory 2560Mi = 2048 MiB
Mà pod ở trạng thái ổn định chiếm = Xmx 2048 + ngoài heap 655 = 2703 MiB
Tỉ lệ = 2703 / 2048 = 1,32 → LUÔN > 1, mãi mãi
Ngưỡng này yêu cầu pod dùng RAM ÍT HƠN chính cái heap bạn đã cấp cho nó.
Điều đó không thể xảy ra.
Hệ quả: autoscaler thêm pod tới khi chạm max rồi ghim ở đó, bất kể tải.
Và số pod nhảy theo những biến cố chẳng liên quan tới traffic:
thay node, deploy, restart — vì pod mới có heap "nguội" nên kéo
trung bình memory xuống.
Nguyên nhân gốc: chỉ số memory của JVM là hàm của cấu hình JVM, không phải của tải. Phân tích
đầy đủ ở tài liệu JVM, trang 5.
apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
name: order-service
namespace: prod
spec:
scaleTargetRef:
apiVersion: apps/v1
kind: Deployment
name: order-service
minReplicas: 3
maxReplicas: 20
metrics:
- type: Resource
resource:
name: cpu
target:
type: Utilization
averageUtilization: 70 # 70% của requests.cpu
behavior:
scaleUp:
stabilizationWindowSeconds: 0 # phản ứng ngay khi tải tăng
policies:
- type: Percent
value: 100 # cho phép gấp đôi mỗi 30 giây
periodSeconds: 30
- type: Pods
value: 4 # hoặc thêm 4 pod, lấy giá trị LỚN HƠN
periodSeconds: 30
selectPolicy: Max
scaleDown:
stabilizationWindowSeconds: 300 # chờ 5 phút ổn định mới giảm
policies:
- type: Percent
value: 10 # giảm tối đa 10% mỗi phút — rất thận trọng
periodSeconds: 60
selectPolicy: Min
HPA chỉ dùng CPU/memory được tốt. KEDA mở rộng ra hàng chục nguồn tín hiệu: độ sâu queue, số request/giây, truy vấn Prometheus, lịch theo giờ.
apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
name: order-worker
namespace: prod
spec:
scaleTargetRef:
name: order-worker
minReplicaCount: 2
maxReplicaCount: 50
pollingInterval: 15
cooldownPeriod: 300
triggers:
# Tín hiệu chính: mỗi pod xử lý được khoảng 20 message tồn đọng
- type: aws-sqs-queue
authenticationRef:
name: keda-aws-credentials
metadata:
queueURL: https://sqs.ap-southeast-1.amazonaws.com/123456789012/orders
queueLength: "20"
awsRegion: ap-southeast-1
# Tín hiệu phụ: CPU, để bắt trường hợp message nặng bất thường
- type: cpu
metricType: Utilization
metadata:
value: "70"
# KHÔNG dùng trigger memory cho pod Java/.NET — xem cảnh báo ở trên
triggers:
- type: prometheus
metadata:
serverAddress: http://prometheus.monitoring.svc.cluster.local:9090
query: |
sum(rate(http_server_requests_seconds_count{
namespace="prod", service="order-service"
}[2m]))
threshold: "50" # mỗi pod xử lý 50 req/s
# Giá trị dùng khi Prometheus không trả lời — tránh scale về 0 vì lỗi metric
unsafeSsl: "false"
ignoreNullValues: "false"
| Web API | CPU, hoặc request/giây nếu CPU không nhạy |
| Queue worker | Độ sâu queue — tín hiệu đúng nhất, phản ánh trực tiếp lượng việc tồn đọng |
| Service I/O-bound | Số kết nối đồng thời, hoặc request/giây. CPU thấp nên không nhạy |
| Tải theo giờ biết trước | KEDA cron scaler — nâng
minReplicaCount trước giờ cao điểm, không chờ tải đến mới phản ứng |
apiVersion: karpenter.sh/v1
kind: NodePool
metadata:
name: general
spec:
template:
spec:
requirements:
- key: karpenter.sh/capacity-type
operator: In
values: ["spot", "on-demand"] # ưu tiên spot, fallback on-demand
- key: kubernetes.io/arch
operator: In
values: ["arm64"] # Graviton: rẻ hơn ~20%
- key: karpenter.k8s.aws/instance-category
operator: In
values: ["c", "m", "r"]
- key: karpenter.k8s.aws/instance-generation
operator: Gt
values: ["5"] # chỉ instance đời mới
nodeClassRef:
group: karpenter.k8s.aws
kind: EC2NodeClass
name: default
# Node tự hết hạn để luôn có AMI mới (bản vá bảo mật)
expireAfter: 720h # 30 ngày
disruption:
consolidationPolicy: WhenEmptyOrUnderutilized
consolidateAfter: 1m
budgets:
- nodes: "10%" # tối đa 10% node bị thay cùng lúc
# Không thay node trong giờ cao điểm
- nodes: "0"
schedule: "0 9 * * mon-fri"
duration: 10h
limits:
cpu: "1000"
memory: 4000Gi
minAvailable nhỏ hơn số replica.disruption.budgets theo lịch, chặn thay node trong giờ cao điểm (như ví dụ trên).karpenter.sh/do-not-disrupt: "true" trên pod không được phép gián
đoạn (ví dụ Job dài).Tải tăng vọt
│
├─ 0-15s KEDA/HPA đọc metric, tính số replica mới
├─ 15s Deployment scale lên, pod mới ở trạng thái Pending
│
├─ 20s Karpenter thấy pod Pending → chọn loại instance → gọi EC2 API
├─ 60-90s Node mới join cluster, Ready
│
├─ 95s Pod được xếp lên node, bắt đầu pull image
├─ 100-130s Pull image (phụ thuộc kích thước — đây là lý do image nhỏ quan trọng)
│
├─ 130-190s Container start, JVM khởi động, startupProbe chờ
└─ 190s readinessProbe xanh → pod vào Endpoints → BẮT ĐẦU NHẬN TRAFFIC
Tổng: khoảng 3 phút từ lúc tải tăng tới lúc có năng lực mới.
minReplicas đủ cao để chịu được cú tăng đầu tiên mà không cần scale.minReplicaCount trước giờ cao điểm.Mặc định scheduler tự chọn node và thường chọn khá tốt. Bạn chỉ cần can thiệp khi có yêu cầu cụ thể: phân tán qua nhiều AZ, tách workload nặng, hoặc dùng node đặc biệt.
Đây là thứ nên có ở mọi service production. Không có nó, scheduler có thể dồn cả 3 replica vào một node hoặc một AZ — và mất node đó là mất toàn bộ service.
spec:
template:
spec:
topologySpreadConstraints:
# 1. Phân tán đều qua các AZ — BẮT BUỘC cho production
- maxSkew: 1
topologyKey: topology.kubernetes.io/zone
whenUnsatisfiable: DoNotSchedule # cứng: không xếp nếu vi phạm
labelSelector:
matchLabels:
app: order-service
# 2. Phân tán qua node — mềm hơn, để không chặn việc xếp pod
- maxSkew: 1
topologyKey: kubernetes.io/hostname
whenUnsatisfiable: ScheduleAnyway # mềm: ưu tiên nhưng không bắt buộc
labelSelector:
matchLabels:
app: order-service
| Tham số | Ý nghĩa |
|---|---|
maxSkew: 1 |
Chênh lệch tối đa giữa domain có nhiều pod nhất và ít nhất. Với 3 AZ và 4 pod: 2-1-1 được, 3-1-0 không được. |
DoNotSchedule |
Ràng buộc cứng. Pod nằm Pending nếu không thoả. Dùng cho AZ. |
ScheduleAnyway |
Ràng buộc mềm. Scheduler ưu tiên nhưng vẫn xếp nếu không thoả. Dùng cho node. |
DoNotSchedule cho hostname là bẫy. Nếu số replica lớn hơn số
node khả dụng, pod dư sẽ nằm Pending vĩnh viễn — kể cả khi node còn thừa CPU và RAM. Với
HPA scale lên 20 pod mà cluster chỉ có 8 node, bạn mất 12 pod. Dùng ScheduleAnyway cho
hostname và DoNotSchedule chỉ cho zone.
spec:
template:
spec:
affinity:
# 1. nodeAffinity: chọn loại node
nodeAffinity:
requiredDuringSchedulingIgnoredDuringExecution:
nodeSelectorTerms:
- matchExpressions:
- key: karpenter.sh/capacity-type
operator: In
values: ["on-demand"] # service quan trọng: không dùng spot
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
preference:
matchExpressions:
- key: kubernetes.io/arch
operator: In
values: ["arm64"] # ưu tiên Graviton nếu có
# 2. podAntiAffinity: tránh xếp cùng chỗ với pod khác
podAntiAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 100
podAffinityTerm:
topologyKey: kubernetes.io/hostname
labelSelector:
matchLabels:
app: order-service # tránh hai replica cùng node
# 3. podAffinity: muốn xếp gần pod khác (giảm độ trễ mạng)
podAffinity:
preferredDuringSchedulingIgnoredDuringExecution:
- weight: 50
podAffinityTerm:
topologyKey: topology.kubernetes.io/zone
labelSelector:
matchLabels:
app: redis-cache # cùng AZ với cache để giảm latency
IgnoredDuringExecution nghĩa là gì: ràng buộc chỉ được kiểm lúc xếp pod.
Nếu sau đó label của node đổi và pod không còn thoả, Kubernetes không đuổi pod đi. Đây là hành
vi có chủ ý — tránh việc pod bị di chuyển liên tục.
topologySpreadConstraints thay cho
podAntiAffinity khi chỉ cần phân tán. Nó diễn đạt rõ hơn và scheduler xử lý hiệu quả hơn
(podAntiAffinity có chi phí tính toán cao khi cluster lớn).
# Trên node: đánh dấu "chỉ pod nào chịu được mới vào đây"
kubectl taint nodes ip-10-0-3-117 workload=gpu:NoSchedule
# Ba hiệu lực của taint:
# NoSchedule → không xếp pod mới, pod đang chạy VẪN ở lại
# PreferNoSchedule → cố tránh, nhưng vẫn xếp nếu không còn chỗ khác
# NoExecute → không xếp mới VÀ ĐUỔI pod đang chạy
# Trong pod: khai toleration để được vào
spec:
tolerations:
- key: workload
operator: Equal
value: gpu
effect: NoSchedule
# Chịu được node bị NotReady trong 5 phút trước khi bị đuổi
- key: node.kubernetes.io/not-ready
operator: Exists
effect: NoExecute
tolerationSeconds: 300
nodeAffinity là
pod chọn node; taint là node từ chối pod. Để dành riêng một nhóm node cho
workload cụ thể, bạn cần cả hai: taint để đẩy pod khác ra, affinity để kéo pod của mình vào.
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
name: production-critical
value: 1000000
globalDefault: false
description: "Service ảnh hưởng doanh thu trực tiếp"
---
apiVersion: scheduling.k8s.io/v1
kind: PriorityClass
metadata:
name: batch-low
value: 100
preemptionPolicy: Never # không đẩy pod khác ra, chỉ chờ
description: "Job nền, chịu được chờ"
# Trong pod
spec:
priorityClassName: production-critical
Pod ưu tiên cao có thể đẩy (preempt) pod ưu tiên thấp ra khỏi node khi không còn chỗ. Kỹ thuật hữu ích: tạo pod "giữ chỗ" với ưu tiên âm chạy image rỗng — chúng giữ node sẵn sàng và bị đẩy ra ngay khi pod thật cần, giúp rút ngắn thời gian scale từ 3 phút xuống dưới 1 phút.
Pending — bảng tra| Thông báo trong Events | Nguyên nhân và cách sửa |
|---|---|
Insufficient cpu/memory |
Không node nào còn đủ tài nguyên. Karpenter sẽ thêm node — nếu không thì kiểm
limits của NodePool, hoặc quota EC2 của account. |
didn't match pod anti-affinity rules |
Ràng buộc phân tán quá chặt. Đổi DoNotSchedule thành
ScheduleAnyway cho hostname. |
had volume node affinity conflict |
PVC trên EBS ở AZ khác với node khả dụng. Dùng
volumeBindingMode: WaitForFirstConsumer. |
had taint that the pod didn't tolerate |
Thiếu toleration. Hoặc node bị taint do đang NotReady/DiskPressure. |
Too many pods |
Node đã chạm maxPods. Trên EKS với VPC CNI, giới hạn này do số ENI và IP quyết
định. Bật prefix delegation — xem chặng 01, mục 7. |
exceeded quota |
Chạm ResourceQuota của namespace. Nâng quota hoặc dọn workload cũ. |
Pending dù node còn thừa CPU. Nguyên nhân khả dĩ nhất?Bốn lớp: pod chạy với quyền gì, pod gọi được ai, pod làm được gì với API Kubernetes, và pod có quyền gì trên AWS.
Từ Kubernetes 1.25, PodSecurityPolicy bị loại bỏ và thay bằng Pod Security Admission — cấu hình bằng label trên namespace.
apiVersion: v1
kind: Namespace
metadata:
name: prod
labels:
# enforce: TỪ CHỐI pod vi phạm
pod-security.kubernetes.io/enforce: restricted
pod-security.kubernetes.io/enforce-version: v1.31
# audit + warn: ghi log và cảnh báo, hữu ích khi đang chuyển đổi
pod-security.kubernetes.io/audit: restricted
pod-security.kubernetes.io/warn: restricted
| Mức | Yêu cầu |
|---|---|
privileged | Không giới hạn. Chỉ cho namespace hệ thống. |
baseline | Chặn những thứ rõ ràng nguy hiểm: privileged container, hostNetwork, hostPath, thêm capability. |
restricted | Khuyến nghị cho production. Bắt buộc non-root,
drop: ALL capabilities, allowPrivilegeEscalation: false,
seccompProfile: RuntimeDefault. |
warn và audit ở
restricted trước, giữ enforce ở baseline. Chạy một thời gian,
đọc cảnh báo để biết workload nào chưa tuân thủ, sửa dần, rồi mới nâng enforce. Nâng
enforce ngay có thể làm pod không deploy được vào lúc bạn không ngờ.
kubectl set env daemonset aws-node -n kube-system ENABLE_NETWORK_POLICY=true
# Xác minh đã bật:
kubectl get ds aws-node -n kube-system -o yaml | grep -A2 ENABLE_NETWORK_POLICY
# 1. Chặn mọi traffic vào và ra trong namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: default-deny-all
namespace: prod
spec:
podSelector: {} # áp cho MỌI pod trong namespace
policyTypes: [Ingress, Egress]
---
# 2. Mở DNS — BẮT BUỘC, thiếu là mọi thứ vỡ
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: allow-dns
namespace: prod
spec:
podSelector: {}
policyTypes: [Egress]
egress:
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: kube-system
podSelector:
matchLabels:
k8s-app: kube-dns
ports:
- { protocol: UDP, port: 53 }
- { protocol: TCP, port: 53 }
---
# 3. Mở đường cụ thể cho order-service
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
name: order-service
namespace: prod
spec:
podSelector:
matchLabels:
app: order-service
policyTypes: [Ingress, Egress]
ingress:
# Cho ALB vào (target-type: ip nên traffic đến từ IP của node)
- from:
- ipBlock:
cidr: 10.0.0.0/16
ports:
- { protocol: TCP, port: 8080 }
# Cho api-gateway trong cùng namespace vào
- from:
- podSelector:
matchLabels:
app: api-gateway
ports:
- { protocol: TCP, port: 8080 }
egress:
# Gọi payment-service ở namespace khác
- to:
- namespaceSelector:
matchLabels:
kubernetes.io/metadata.name: billing
podSelector:
matchLabels:
app: payment-service
ports:
- { protocol: TCP, port: 8080 }
# Gọi RDS và HTTPS ra ngoài
- to:
- ipBlock:
cidr: 10.0.0.0/16
ports:
- { protocol: TCP, port: 5432 }
- to:
- ipBlock:
cidr: 0.0.0.0/0
except: [169.254.169.254/32] # chặn IMDS — quan trọng!
ports:
- { protocol: TCP, port: 443 }
169.254.169.254 (IMDS) là biện pháp bảo mật quan trọng. Nếu pod gọi được
IMDS, nó lấy được credential của IAM role gắn với node — thường rộng hơn nhiều so với role của
pod. Ngoài NetworkPolicy, nên đặt httpPutResponseHopLimit=1 trên instance metadata options
để container không tới được IMDS.
apiVersion: v1
kind: ServiceAccount
metadata:
name: order-service
namespace: prod
annotations:
# IRSA: gắn IAM role cho pod — xem chặng 08
eks.amazonaws.com/role-arn: arn:aws:iam::123456789012:role/prod-order-service
---
# Phần lớn app KHÔNG cần quyền gì với API Kubernetes.
# Chỉ cấp khi app thực sự gọi API (ví dụ dùng Spring Cloud Kubernetes).
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
name: order-service
namespace: prod
rules:
- apiGroups: [""]
resources: ["configmaps"]
resourceNames: ["order-service-config"] # giới hạn tới TÊN cụ thể
verbs: ["get", "watch"]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
name: order-service
namespace: prod
subjects:
- kind: ServiceAccount
name: order-service
namespace: prod
roleRef:
kind: Role
name: order-service
apiGroup: rbac.authorization.k8s.io
spec:
template:
spec:
automountServiceAccountToken: false
Mặc định Kubernetes mount một token vào mọi pod. Token đó cho phép gọi API server — và nếu pod bị
chiếm quyền, kẻ tấn công dùng nó để thăm dò cluster. Phần lớn ứng dụng web không cần token này.
# Kiểm tra quyền thực tế — nên chạy sau khi cấu hình RBAC
kubectl auth can-i --list --as=system:serviceaccount:prod:order-service -n prod
kubectl auth can-i get secrets --as=system:serviceaccount:prod:order-service -n prod
# Tìm ServiceAccount có quyền quá rộng trong cluster
kubectl get clusterrolebindings -o json | jq -r '
.items[] | select(.roleRef.name=="cluster-admin") |
"\(.metadata.name): \(.subjects // [] | map(.kind+"/"+.name) | join(", "))"'
Kyverno hoặc OPA Gatekeeper cho bạn áp quy tắc tự động. Ví dụ với Kyverno:
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
name: require-resources
spec:
validationFailureAction: Enforce
rules:
- name: check-resources
match:
any:
- resources:
kinds: ["Pod"]
namespaces: ["prod", "staging"]
validate:
message: "Mọi container phải khai requests và limits cho cả CPU và memory."
pattern:
spec:
containers:
- resources:
requests:
memory: "?*"
cpu: "?*"
limits:
memory: "?*"
Những policy đáng có: bắt buộc khai resource, chặn tag latest, bắt buộc
runAsNonRoot, bắt buộc có PDB cho Deployment nhiều replica, và chặn image không từ ECR của
bạn.
default-deny-all trên EKS nhưng pod vẫn gọi được nhau bình thường. Nguyên nhân?Những lệnh dùng hàng ngày, và quy trình điều tra khi pod có vấn đề. Phần điều tra ở tầng Linux/node nằm ở chặng 01, mục 10.
kubectl describe → exit code → logs --previous →
working set so với limit → throttle → vào trong container.
describe: phần Events ở cuối thường trả lời ngay câu hỏi.
# 1. LUÔN bắt đầu ở đây. Phần Events ở cuối là quan trọng nhất.
kubectl describe pod order-service-7d9f8b-x4k2m -n prod
# 2. Exit code và lý do chết của container TRƯỚC
kubectl get pod order-service-7d9f8b-x4k2m -n prod -o jsonpath='
{range .status.containerStatuses[*]}
container: {.name}
ready: {.ready}
restartCount: {.restartCount}
lastState: {.lastState.terminated.reason} exit={.lastState.terminated.exitCode}
{end}'
# 3. Log của container ĐÃ CHẾT — nơi có stack trace
kubectl logs order-service-7d9f8b-x4k2m -n prod --previous --tail=200
# 4. So mức dùng thật với limit đã khai
kubectl top pod order-service-7d9f8b-x4k2m -n prod --containers
kubectl get pod order-service-7d9f8b-x4k2m -n prod \
-o jsonpath='{.spec.containers[*].resources}' | python -m json.tool
# 5. Đọc cgroup thật bên trong container
kubectl exec order-service-7d9f8b-x4k2m -n prod -- sh -c '
echo "mem.current: $(cat /sys/fs/cgroup/memory.current)"
echo "mem.max: $(cat /sys/fs/cgroup/memory.max)"
echo "mem.events: $(cat /sys/fs/cgroup/memory.events | tr "\n" " ")"
echo "cpu.max: $(cat /sys/fs/cgroup/cpu.max)"
echo "cpu.stat: $(grep -E "nr_periods|nr_throttled" /sys/fs/cgroup/cpu.stat | tr "\n" " ")"'
# 6. Events toàn namespace, sắp theo thời gian
kubectl get events -n prod --sort-by=.lastTimestamp | tail -30
# ---------- Xem nhanh ----------
kubectl get pods -n prod -o wide # kèm node và IP
kubectl get pods -A --field-selector status.phase!=Running
kubectl get pods -A --sort-by='.status.containerStatuses[0].restartCount' | tail -15
kubectl get deploy,sts,ds -n prod
kubectl get all -n prod # không gồm Ingress, PVC, Secret
# ---------- Rollout ----------
kubectl rollout status deploy/order-service -n prod --timeout=300s
kubectl rollout history deploy/order-service -n prod
kubectl rollout undo deploy/order-service -n prod # về bản trước
kubectl rollout undo deploy/order-service -n prod --to-revision=3
kubectl rollout restart deploy/order-service -n prod # restart không đổi gì
kubectl rollout pause deploy/order-service -n prod # dừng giữa rollout
# ---------- Scale ----------
kubectl scale deploy/order-service -n prod --replicas=5
kubectl get hpa,scaledobject -n prod
# ---------- Log ----------
kubectl logs -n prod deploy/order-service --tail=100 -f
kubectl logs -n prod -l app=order-service --max-log-requests=10 --tail=50 --prefix
kubectl logs -n prod pod/X --previous # container đã chết
kubectl logs -n prod pod/X -c sidecar # chọn container
kubectl logs -n prod pod/X --since=10m --timestamps
# ---------- Vào trong ----------
kubectl exec -it -n prod pod/X -- sh
kubectl exec -n prod pod/X -- env | sort
kubectl port-forward -n prod pod/X 8080:8080 # truy cập cục bộ
kubectl cp prod/X:/dump/heap.hprof ./heap.hprof # lấy file ra
# ---------- So sánh và xuất ----------
kubectl get deploy order-service -n prod -o yaml > current.yaml
kubectl diff -f desired.yaml # xem sẽ đổi gì TRƯỚC khi apply
# Ephemeral container: gắn container debug vào pod đang chạy.
# Chia sẻ network namespace nên thấy được port và DNS của app.
kubectl debug -it -n prod order-service-7d9f8b-x4k2m \
--image=nicolaka/netshoot \
--target=app \
--share-processes
# Trong đó:
ps aux # thấy process của app
ss -tulpn # port app đang listen
curl -s localhost:8080/actuator/health
nslookup payment-service.billing.svc.cluster.local
ls /proc/1/root/app # filesystem của app
# Tạo bản copy của pod để thử nghiệm mà không ảnh hưởng pod gốc
kubectl debug -n prod order-service-7d9f8b-x4k2m \
--copy-to=debug-pod --container=app -it -- sh
# Debug ở cấp node
kubectl debug node/ip-10-0-3-117.ap-southeast-1.compute.internal \
-it --image=public.ecr.aws/amazonlinux/amazonlinux:2023
chroot /host # filesystem node mount ở /host
# Thread dump — dùng khi app treo hoặc p99 cao bất thường
kubectl exec -n prod pod/X -- jcmd 1 Thread.print > threads.txt
# Thông tin heap hiện tại
kubectl exec -n prod pod/X -- jcmd 1 GC.heap_info
# Thống kê object theo class — tìm thủ phạm rò rỉ heap
kubectl exec -n prod pod/X -- jcmd 1 GC.class_histogram | head -30
# Bộ nhớ ngoài heap (cần -XX:NativeMemoryTracking=summary bật từ đầu)
kubectl exec -n prod pod/X -- jcmd 1 VM.native_memory summary
# Các cờ JVM đang có hiệu lực — xác nhận cấu hình đã được áp đúng
kubectl exec -n prod pod/X -- jcmd 1 VM.flags
# Heap dump (CẨN THẬN: tạo file bằng cả kích thước heap, có thể gây OOMKilled)
kubectl exec -n prod pod/X -- jcmd 1 GC.heap_dump /dump/heap.hprof
kubectl cp prod/X:/dump/heap.hprof ./heap.hprof
limits.memory → OOMKilled giữa lúc đang
dump. Mất dump, và người điều tra sau chỉ thấy exit 137. Trước khi dump: đảm bảo
/dump là volume riêng và limits.memory có biên ít nhất bằng
-Xmx. Chi tiết ở chặng 01, mục 3.
| Trạng thái | Nghĩa | Kiểm gì |
|---|---|---|
Pending | Chưa được xếp lên node | describe pod → Events. Xem bảng ở mục 7. |
ContainerCreating | Đang pull image hoặc mount volume | Kéo dài nghĩa là image quá lớn, hoặc volume không mount được. |
ImagePullBackOff | Không pull được image | Sai tag, thiếu quyền ECR, node hết đĩa, hoặc ảnh đã bị lifecycle policy xoá. |
CrashLoopBackOff | Chết rồi restart lặp lại | logs --previous để tìm nguyên nhân lần chết đầu tiên. Backoff tăng gấp đôi
tới 5 phút nên pod càng về sau càng vắng lâu. |
Running nhưng 0/1 Ready | Readiness fail | Thử probe bằng tay: kubectl exec pod -- curl -sv localhost:8080/readyz |
Running, Ready, nhưng 503 | Endpoints rỗng, hoặc app listen sai địa chỉ | kubectl get endpoints svc và kubectl exec pod -- ss -tulpn |
Terminating rất lâu | Không nhận SIGTERM, hoặc finalizer treo |
Kiểm ENTRYPOINT có dùng exec form. Xem
chặng 01, mục 2. |
Evicted | kubelet đẩy pod ra vì node thiếu tài nguyên | describe node → Conditions. Nâng requests, không phải
limits. |
OOMKilled (exit 137) | Working set vượt limits.memory |
memory.events có oom_kill > 0. Tìm phần ngoài heap nếu heap vẫn thấp. |
# ~/.bashrc hoặc ~/.zshrc
alias k=kubectl
alias kgp='kubectl get pods'
alias kgpa='kubectl get pods -A'
alias kd='kubectl describe'
alias kl='kubectl logs'
alias klf='kubectl logs -f'
alias klp='kubectl logs --previous'
alias kex='kubectl exec -it'
alias ktp='kubectl top pod'
alias kev='kubectl get events --sort-by=.lastTimestamp'
source <(kubectl completion bash)
complete -o default -F __start_kubectl k
# Công cụ đáng cài
# kubectx / kubens — đổi cluster và namespace nhanh
# stern — xem log nhiều pod cùng lúc, có màu
# kubecolor — tô màu output kubectl
# k9s — giao diện terminal, rất nhanh để khảo sát
# kubectl-neat — bỏ field do hệ thống sinh khi xem YAML
# An toàn: luôn đặt namespace mặc định để không apply nhầm cluster
kubectl config set-context --current --namespace=prod
kubectl config get-contexts
kubectl config current-context. Phần lớn sự cố do con người là chạy đúng lệnh trên
sai cluster. Cân nhắc dùng kubectx với prompt hiển thị cluster hiện tại, hoặc
công cụ như kube-ps1.
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Image tag theo git SHA, không dùng latest |
Không có tag bất biến thì không truy vết và không rollback được. |
| ☐ | replicas ≥ 2 cho service production |
Một replica nghĩa là mọi deploy và mọi lần thay node đều có downtime. |
| ☐ | maxUnavailable: 0 trong rollingUpdate |
Không giảm năng lực xử lý trong lúc deploy. |
| ☐ | Có topologySpreadConstraints theo zone |
Không có thì 3 replica có thể dồn vào một AZ; mất AZ đó là mất service. |
| ☐ | Có PDB với minAvailable < số replica |
Bằng số replica là chặn hoàn toàn drain node, cluster không upgrade được. |
| ☐ | Schema DB tương thích ngược giữa hai phiên bản liền kề | Rolling update luôn có hai phiên bản chạy đồng thời. |
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Liveness KHÔNG kiểm tra DB hay service ngoài | Lỗi tốn kém nhất: DB chậm → mọi pod restart cùng lúc → mất dịch vụ hoàn toàn. |
| ☐ | Có startupProbe cho app JVM/.NET |
Để liveness nhạy lúc chạy mà vẫn khoan dung 60–120 giây lúc khởi động. |
| ☐ | Liveness khoan dung hơn readiness | Pod gặp áp lực nên bị rút khỏi traffic để hồi phục, không bị giết. |
| ☐ | timeoutSeconds > GC pause tệ nhất |
Nếu không, pod bị restart chỉ vì một lần Full GC. |
| ☐ | Mọi container khai đủ requests và limits, kể cả sidecar |
Một sidecar thiếu limit làm cả pod tụt QoS và mất trần ở cấp pod. |
| ☐ | limits.memory = (Xmx + ngoài heap) × 1,15 |
Phần ngoài heap của JVM khoảng 600–700 MB. Tính thiếu là chết sau nhiều giờ chạy ổn. |
| ☐ | limits.cpu ≥ 3× requests.cpu, và ≥ 1000m cho Java/.NET |
Cần burst lúc khởi động. Dưới 1000m thì runtime tưởng chỉ có 1 core. |
| ☐ | Có LimitRange và ResourceQuota ở namespace |
Chặn lỗi "quên khai resource" và "một namespace ăn hết cluster". |
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Có preStop: sleep 5 |
Việc gỡ khỏi Endpoints và gửi SIGTERM xảy ra song song; đây là khoảng đệm. |
| ☐ | terminationGracePeriodSeconds > preStop + request dài nhất |
Thiếu là app luôn bị SIGKILL giữa lúc dọn dẹp. |
| ☐ | Thời gian ALB khớp với pod | deregistration_delay ≥ preStop + xử lý request; idle_timeout ≥
request dài nhất. Sai một mắt là 502 lẻ tẻ mỗi lần deploy. |
| ☐ | Có checksum annotation cho ConfigMap/Secret | Không có thì sửa config pod không restart, và bạn tưởng đã áp dụng. |
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Namespace có label Pod Security restricted |
Chặn pod privileged, hostPath, hostNetwork ngay từ admission. |
| ☐ | runAsNonRoot, readOnlyRootFilesystem,
drop: ["ALL"] |
Nhớ mount emptyDir cho /tmp — JVM cần. |
| ☐ | automountServiceAccountToken: false nếu app không gọi API |
Token cho phép thăm dò cluster nếu pod bị chiếm quyền. |
| ☐ | Có NetworkPolicy, và đã bật ENABLE_NETWORK_POLICY trên VPC CNI |
Chưa bật thì policy không có tác dụng và không có cảnh báo nào. |
| ☐ | NetworkPolicy có luật cho DNS | Thiếu là mọi thứ vỡ — đây là lỗi phổ biến nhất khi mới áp NetworkPolicy. |
| ☐ | Chặn 169.254.169.254 trong egress |
Pod gọi được IMDS sẽ lấy được credential của IAM role gắn với node. |
| ☐ | RBAC giới hạn tới resourceNames cụ thể |
Nguyên tắc đặc quyền tối thiểu. Kiểm bằng kubectl auth can-i --list. |
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Không dùng trigger memory cho pod Java/.NET | Working set là hàm của cấu hình runtime, không phải của tải → pod ghim ở max vĩnh viễn. |
| ☐ | requests.cpu suy ngược từ ngưỡng scale |
request = P95 ÷ mục_tiêu% × 1,15. Đặt quá cao là autoscaler mất nhạy hoàn toàn. |
| ☐ | Scale lên nhanh, scale xuống chậm | behavior bất đối xứng. Scale xuống nhanh gây dao động. |
| ☐ | Queue worker scale theo độ sâu queue, không theo CPU | Độ sâu queue phản ánh trực tiếp lượng việc tồn đọng. |
| ☐ | minReplicas đủ chịu cú tăng đầu tiên |
Scale từ pod tới node mất khoảng 3 phút — quá lâu cho tải tăng đột ngột. |
| ☐ | Karpenter có disruption.budgets chặn giờ cao điểm |
Consolidation có thể thay node bất cứ lúc nào, kể cả lúc cao tải. |
limits.memory tính thiếu phần ngoài heap → OOMKilled sau nhiều giờ chạy ổntopologySpreadConstraints → mất một AZ là mất serviceminAvailable = số replica → chặn hoàn toàn drain và upgradepreStop → 502 lẻ tẻ mỗi lần deploy