Một ứng dụng chạy tốt trên máy lập trình viên có thể hoàn toàn không phù hợp để chạy trên Kubernetes. Khác biệt không nằm ở code nghiệp vụ mà ở cách ứng dụng nhận cấu hình, báo cáo sức khoẻ, ghi log và tắt đi. Trang này là danh sách những thứ phải sửa, kèm cấu hình cụ thể cho Java, Python và .NET.
Mười mục: 12-factor (1) → cấu hình và biến môi trường (2) → secret (3) → health check và probe (4) → vòng đời ứng dụng (5) → Java (6) · Python (7) · .NET (8) → observability (9) → checklist (10).
12-Factor App là bộ nguyên tắc có từ 2011. Không phải điều nào cũng còn quan trọng như nhau. Bấm từng nguyên tắc để xem nó ảnh hưởng gì cụ thể khi chạy trên EKS, và mức ưu tiên thực tế.
SIGTERM, và log ra stdout dạng JSON. Bốn thứ này quyết định ứng dụng có vận hành được
trên Kubernetes hay không. Những điều còn lại là tối ưu.
| Thói quen | Vì sao vỡ trên Kubernetes | Sửa thế nào |
|---|---|---|
| Session lưu trong RAM của app | Request tiếp theo có thể vào pod khác → user bị đăng xuất ngẫu nhiên. Rolling update xoá hết session. | Lưu session vào Redis/ElastiCache, hoặc dùng JWT không trạng thái. Tránh dựa vào sticky session. |
| Upload file vào đĩa cục bộ | Pod khác không thấy file. Pod chết là mất file. | Ghi lên S3. Dùng presigned URL để client upload trực tiếp, giảm tải cho app. |
| Cache trong bộ nhớ process | Mỗi pod một bản cache riêng → tỉ lệ hit thấp, dữ liệu không nhất quán giữa các pod. | Cache tầng hai dùng Redis. Cache cục bộ chỉ cho dữ liệu bất biến và có TTL ngắn. |
| Cron job chạy bằng scheduler trong app | Có 3 pod thì job chạy 3 lần. Gửi email 3 lần, trừ tiền 3 lần. | Dùng CronJob của Kubernetes. Nếu buộc phải trong app thì cần distributed lock (ShedLock, Redis lock). |
@Scheduled gửi báo cáo hàng ngày, deploy với 3 replica. Chuyện gì xảy ra?Nguyên tắc duy nhất: một image, nhiều môi trường. Cùng một ảnh container phải chạy được ở dev, staging và production mà chỉ khác cấu hình được tiêm vào lúc chạy.
myapp:1.2.3-prod, myapp:1.2.3-staging). Hệ quả: ảnh bạn test ở staging
không phải ảnh chạy ở production, nên việc test mất phần lớn giá trị. Mọi khác biệt môi trường
phải nằm trong cấu hình, không nằm trong image.
| Cách | Dùng khi | Đánh đổi |
|---|---|---|
| Biến môi trường từ ConfigMap/Secret |
Giá trị đơn lẻ: URL, feature flag, mức log, số worker | Đơn giản, mọi runtime đọc được.
Nhưng đổi là phải restart pod, và giá trị hiện trong kubectl describe pod —
không dùng cho secret thật. |
| File mount ConfigMap/Secret làm volume |
Cấu hình có cấu trúc: application.yaml, appsettings.json, cert, keystore |
Cập nhật được mà không restart (kubelet đồng bộ lại file sau ~60s)
— nhưng app phải tự biết đọc lại. Không áp dụng cho subPath. |
| Lấy lúc chạy SDK gọi Secrets Manager / SSM |
Secret cần luân chuyển (rotation), credential sinh động của DB | Cần IAM, cần xử lý lỗi mạng, app khởi động chậm hơn. Nhưng là cách duy nhất đúng cho secret tự động đổi. |
Thấp ──────────────────────────────────────────────────────► Cao
giá trị file cấu hình file theo biến môi tham số
mặc định < trong image < môi trường < trường < dòng lệnh
trong code (application.yml) (mount) (env) (args)
Quy tắc: thứ gì CỤ THỂ hơn và GẦN lúc chạy hơn thì thắng.
Cả Spring Boot, .NET Configuration và Pydantic Settings đều theo đúng mô hình này. Biết thứ tự này là biết chỗ nào đang ghi đè giá trị của bạn khi cấu hình "không có tác dụng".
apiVersion: v1
kind: ConfigMap
metadata:
name: order-service-config
namespace: prod
data:
# Kiểu 1: cặp key-value, dùng làm biến môi trường
LOG_LEVEL: "INFO"
SPRING_PROFILES_ACTIVE: "prod"
PAYMENT_SERVICE_URL: "http://payment-service.prod.svc.cluster.local:8080"
FEATURE_NEW_CHECKOUT: "true"
DB_POOL_MAX: "20"
# Kiểu 2: cả một file, dùng để mount
application-prod.yaml: |
server:
port: 8080
shutdown: graceful
spring:
datasource:
hikari:
maximum-pool-size: 20
connection-timeout: 3000
management:
endpoints:
web:
exposure:
include: health,prometheus,info
spec:
template:
metadata:
annotations:
# Thay đổi ConfigMap KHÔNG tự restart pod. Annotation chứa checksum
# làm pod template đổi → rolling update tự xảy ra khi config đổi.
# Helm sinh dòng này tự động, xem chặng 05.
checksum/config: "8f7a2c1e9b4d..."
spec:
containers:
- name: app
# Cách A: nạp TOÀN BỘ ConfigMap thành biến môi trường
envFrom:
- configMapRef:
name: order-service-config
- secretRef:
name: order-service-secret
# Cách B: chọn từng biến, hoặc đổi tên
env:
- name: JAVA_TOOL_OPTIONS
valueFrom:
configMapKeyRef:
name: order-service-config
key: JAVA_OPTS
optional: true
# Lấy thông tin pod từ Downward API — rất hữu ích cho log và metric
- name: POD_NAME
valueFrom:
fieldRef:
fieldPath: metadata.name
- name: POD_NAMESPACE
valueFrom:
fieldRef:
fieldPath: metadata.namespace
- name: NODE_NAME
valueFrom:
fieldRef:
fieldPath: spec.nodeName
# Đọc chính limit của mình — dùng để tự tính thread pool
- name: CPU_LIMIT
valueFrom:
resourceFieldRef:
containerName: app
resource: limits.cpu
- name: MEMORY_LIMIT
valueFrom:
resourceFieldRef:
containerName: app
resource: limits.memory
# Cách C: mount thành file
volumeMounts:
- name: config
mountPath: /config
readOnly: true
volumes:
- name: config
configMap:
name: order-service-config
items:
- key: application-prod.yaml
path: application-prod.yaml
resourceFieldRef cho app tự đọc được limit của chính nó. Đây là cách sạch nhất để
giải quyết bẫy "Python không đọc cgroup": truyền limits.cpu vào biến môi trường rồi tính
số worker từ đó, thay vì gọi nproc.
# entrypoint.sh — tính số worker từ limit thật, không từ nproc
WORKERS=$(( ${CPU_LIMIT:-1} * 2 + 1 ))
exec gunicorn app:app --workers "$WORKERS" --threads 2 -b 0.0.0.0:8000
subPath — file mount không bao giờ cập nhậtsubPath để mount một file đơn lẻ vào thư mục có file khác, thì
file đó không bao giờ được cập nhật — vĩnh viễn giữ giá trị lúc pod khởi động.
# KHÔNG cập nhật được — subPath phá vỡ cơ chế đồng bộ
volumeMounts:
- name: config
mountPath: /app/application.yaml
subPath: application.yaml
# Cập nhật được — mount cả thư mục
volumeMounts:
- name: config
mountPath: /config # rồi trỏ app vào /config/application.yaml
Đây là nguyên nhân thường gặp của "đã sửa ConfigMap mà app không nhận".
| Runtime | Cách map env → config | Ví dụ |
|---|---|---|
| Spring Boot | Dấu chấm → gạch dưới, chữ hoa. Relaxed binding. | spring.datasource.url→ SPRING_DATASOURCE_URL |
| .NET | Dấu hai chấm → hai gạch dưới (dấu hai chấm không hợp lệ trên Linux). | ConnectionStrings:Default→ ConnectionStrings__Default |
| Python (Pydantic) | Theo env_prefix, lồng nhau bằng __. |
db.host với prefix APP_→ APP_DB__HOST |
subPath. Nguyên nhân?Secret bị rò rỉ thường không phải vì bị tấn công tinh vi, mà vì nó bị commit vào Git, in ra log, hoặc để nguyên dạng base64 trong một file YAML công khai. Mục này đi từ cái tệ nhất tới cái nên dùng.
| Bậc | Cách làm | Vấn đề |
|---|---|---|
| 0 | Hardcode trong code hoặc Dockerfile | Nằm trong image vĩnh viễn, ai pull được image là đọc được. Nằm trong Git history mãi mãi. Đổi secret phải build lại image. |
| 1 | Secret YAML commit vào Git | base64 không phải mã hoá — chỉ là encoding, giải ra trong một lệnh.
Ai đọc được repo là có secret. |
| 2 | Secret tạo tay bằng kubectl create secret |
Không nằm trong Git nên an toàn hơn, nhưng không ai biết secret nào đang tồn tại, không có lịch sử thay đổi, và không tái tạo được cluster từ Git. Phá vỡ GitOps. |
| 3 | Sealed Secrets hoặc SOPS | Mã hoá được, commit vào Git an toàn. Nhưng vẫn phải tự quản lý việc luân chuyển khoá. |
| 4 | External Secrets Operator + AWS Secrets Manager | Khuyến nghị cho EKS. Secret nằm ở AWS, Git chỉ chứa tham chiếu. Có rotation, có audit qua CloudTrail, có IAM phân quyền. |
kubectl get secret db-credentials -o jsonpath='{.data.password}' | base64 -d
# Trả về mật khẩu dạng chữ thường. Không cần khoá, không cần giải mã.
# Secret của Kubernetes mặc định CHỈ được encode base64, không mã hoá.
# Nó được bảo vệ bằng RBAC, không bằng mật mã.
Nghĩa là: ai có quyền get secret trong namespace đó là đọc được mọi thứ. Và nếu etcd
không bật encryption-at-rest, secret nằm dạng gần như trần trong etcd.
Mô hình: secret thật nằm trong AWS Secrets Manager. Operator đọc nó bằng IAM role (IRSA) rồi tạo Kubernetes Secret tương ứng. Git chỉ chứa mô tả "lấy secret nào, đặt tên gì".
apiVersion: external-secrets.io/v1beta1
kind: SecretStore
metadata:
name: aws-secrets-manager
namespace: prod
spec:
provider:
aws:
service: SecretsManager
region: ap-southeast-1
auth:
jwt:
serviceAccountRef:
# ServiceAccount này được gắn IAM role qua IRSA
name: external-secrets-sa
apiVersion: external-secrets.io/v1beta1
kind: ExternalSecret
metadata:
name: order-service-secret
namespace: prod
spec:
# Đọc lại mỗi giờ — bắt được việc secret bị luân chuyển ở AWS
refreshInterval: 1h
secretStoreRef:
name: aws-secrets-manager
kind: SecretStore
target:
# Tên Kubernetes Secret sẽ được tạo ra
name: order-service-secret
creationPolicy: Owner
template:
type: Opaque
data:
# Ghép thành connection string hoàn chỉnh từ nhiều field
SPRING_DATASOURCE_URL: "jdbc:postgresql://{{ .host }}:{{ .port }}/{{ .dbname }}"
SPRING_DATASOURCE_USERNAME: "{{ .username }}"
SPRING_DATASOURCE_PASSWORD: "{{ .password }}"
data:
# Secret do RDS tự tạo và tự luân chuyển có sẵn các field này
- secretKey: host
remoteRef:
key: prod/order-service/db
property: host
- secretKey: port
remoteRef:
key: prod/order-service/db
property: port
- secretKey: dbname
remoteRef:
key: prod/order-service/db
property: dbname
- secretKey: username
remoteRef:
key: prod/order-service/db
property: username
- secretKey: password
remoteRef:
key: prod/order-service/db
property: password
# Hoặc lấy cả secret JSON thành nhiều key một lần:
# dataFrom:
# - extract:
# key: prod/order-service/db
refreshInterval.| Chỗ rò rỉ | Cách phòng |
|---|---|
| Log của app in cả object cấu hình | Không bao giờ log.info("config: {}", config). Đánh dấu field secret để che:
Spring dùng @ToString.Exclude, Pydantic dùng SecretStr,
.NET tránh log IConfiguration. |
| Stack trace chứa connection string | Driver DB thường in URL đầy đủ khi lỗi kết nối. Tách mật khẩu khỏi URL, truyền riêng qua
username/password. |
kubectl describe pod |
Biến môi trường từ configMapKeyRef hiện giá trị. Từ secretKeyRef chỉ
hiện tên khoá. Đừng để secret trong ConfigMap. |
| Log của CI | Jenkins dùng withCredentials để tự che. Tuyệt đối không
echo $PASSWORD, và tránh set -x trong script có secret. |
| Layer trong image | ARG trong Dockerfile còn trong lịch sử layer. Dùng
--mount=type=secret của BuildKit. Chi tiết ở chặng
03 · Docker. |
| Biến môi trường bị con cháu kế thừa | Mọi process con đọc được /proc/<pid>/environ. Nếu app gọi process ngoài,
hãy xoá biến secret khỏi môi trường của nó. |
Probe là cách Kubernetes biết pod có khoẻ không. Cấu hình sai không chỉ vô dụng mà tự tạo ra sự cố: pod bị restart khi chỉ đang chậm, hoặc traffic được gửi vào pod chưa sẵn sàng.
| Probe | Fail thì sao | Trả lời câu hỏi |
|---|---|---|
startupProbe |
Container bị restart. Trong lúc chạy, hai probe kia bị tạm dừng. | "App đã khởi động xong chưa?" Dùng cho app khởi động lâu — JVM nạp Spring context có thể mất 30-90 giây. Đây là probe cứu bạn khỏi vòng restart vô hạn. |
readinessProbe |
Pod bị gỡ khỏi Endpoints → không nhận traffic nữa. Pod vẫn chạy. | "Có nên gửi request vào pod này lúc này không?" Dùng để tạm rút pod ra khi nó quá tải hoặc mất kết nối tới dependency. |
livenessProbe |
Container bị KILL và restart. | "Process này có bị treo vĩnh viễn không?" Chỉ dùng cho trạng thái không thể tự hồi phục — deadlock, event loop chết. Dùng sai là tự tạo CrashLoop. |
livenessProbe kiểm tra cả database.
# /health trả về DOWN khi DB không kết nối được
livenessProbe:
httpGet:
path: /actuator/health # ← mặc định bao gồm DB, Redis, Kafka
Khi DB có sự cố 2 phút: mọi pod cùng fail liveness → toàn bộ bị restart cùng lúc →
mất hết cache và connection pool → khi DB hồi phục thì tất cả pod cùng khởi động lại và cùng mở kết
nối → DB bị dồn tải và sập lần hai. Một sự cố DB ngắn biến thành sự cố toàn hệ thống kéo dài.
spec:
template:
spec:
containers:
- name: app
ports:
- name: http
containerPort: 8080
# ---- 1. startupProbe: cho app thời gian khởi động ----
startupProbe:
httpGet:
path: /actuator/health/liveness
port: http
# Chờ 10s trước lần kiểm đầu — JVM chưa mở port trước đó
initialDelaySeconds: 10
periodSeconds: 5
# 5s × 30 = 150 giây tổng thời gian cho phép khởi động.
# Tính rộng: lần deploy đầu sau khi scale node có thể rất chậm.
failureThreshold: 30
timeoutSeconds: 3
# ---- 2. readinessProbe: có nhận traffic không ----
readinessProbe:
httpGet:
path: /actuator/health/readiness
port: http
periodSeconds: 5
timeoutSeconds: 3
# Fail 3 lần (15s) mới rút ra — tránh rút vì một lần chậm ngẫu nhiên
failureThreshold: 3
# Chỉ cần 1 lần OK là cho vào lại
successThreshold: 1
# ---- 3. livenessProbe: có treo vĩnh viễn không ----
livenessProbe:
httpGet:
path: /actuator/health/liveness
port: http
periodSeconds: 10
timeoutSeconds: 3
# Khoan dung HƠN readiness nhiều. 6 × 10s = 60 giây liên tục
# không phản hồi mới restart. Pod đang GC nặng vẫn sống sót.
failureThreshold: 6
# KHÔNG cần initialDelaySeconds vì đã có startupProbe
liveness phải khoan dung hơn
readiness. Khi pod gặp áp lực, ta muốn nó bị rút khỏi traffic (readiness fail) để
có cơ hội hồi phục, chứ không phải bị giết (liveness fail). Nếu liveness nhạy hơn readiness thì
pod bị restart trước khi kịp được bảo vệ — đúng điều ta không muốn.
management:
endpoint:
health:
show-details: when-authorized
# Tách thành hai nhóm riêng cho hai probe khác nhau
group:
liveness:
# CHỈ kiểm tra process còn sống. Không có DB, không có Redis.
include: livenessState
readiness:
# Có thể gửi traffic chưa: cần DB và cache sẵn sàng
include: readinessState,db,redis
# Nhưng không để một dependency phụ làm cả pod NotReady
additional-path: "server:/readyz"
endpoints:
web:
exposure:
include: health,info,prometheus,metrics
health:
# Bật probe dựa trên ApplicationAvailability của Spring
livenessstate:
enabled: true
readinessstate:
enabled: true
# Tắt health check của những thứ không quyết định được sức khoẻ pod
mail:
enabled: false
diskspace:
enabled: false
from fastapi import FastAPI, Response
app = FastAPI()
_ready = {"ok": False}
@app.on_event("startup")
async def startup():
await db.connect() # mở pool
_ready["ok"] = True
@app.on_event("shutdown")
async def shutdown():
_ready["ok"] = False # rút khỏi LB trước
await db.disconnect()
# liveness: CHỈ xác nhận process còn phục vụ
@app.get("/healthz")
def healthz():
return {"status": "ok"}
# readiness: có đủ điều kiện nhận traffic chưa
@app.get("/readyz")
async def readyz(response: Response):
if not _ready["ok"]:
response.status_code = 503
return {"status": "starting"}
try:
await db.execute("SELECT 1")
except Exception:
response.status_code = 503
return {"status": "db_down"}
return {"status": "ready"}
builder.Services.AddHealthChecks()
// Gắn tag để tách hai nhóm probe
.AddCheck("self", () =>
HealthCheckResult.Healthy(),
tags: new[] { "live" })
.AddNpgSql(connStr,
name: "postgres",
tags: new[] { "ready" })
.AddRedis(redisConn,
name: "redis",
tags: new[] { "ready" });
var app = builder.Build();
// liveness: chỉ check "self"
app.MapHealthChecks("/healthz", new()
{
Predicate = r => r.Tags.Contains("live")
});
// readiness: check dependency
app.MapHealthChecks("/readyz", new()
{
Predicate = r => r.Tags.Contains("ready")
});
| Triệu chứng | Nguyên nhân | Sửa |
|---|---|---|
Pod CrashLoopBackOff ngay sau deploy, log bình thường |
livenessProbe fail trước khi app kịp khởi động |
Thêm startupProbe, hoặc nâng failureThreshold của liveness |
| Pod restart ngẫu nhiên khi tải cao | Probe timeout vì app đang GC hoặc bị throttle; probe cũng phải xếp hàng | Nâng timeoutSeconds và failureThreshold. Kiểm CPU throttle |
| Mọi pod restart cùng lúc khi DB có sự cố | Liveness kiểm tra cả DB | Tách liveness khỏi dependency. Chỉ kiểm process |
| Deploy xong có 502 vài giây | Readiness báo OK trước khi app thật sự nhận được request, hoặc thiếu preStop |
Thêm preStop: sleep 5. Kiểm readiness có phản ánh đúng trạng thái |
Pod Running nhưng không nhận traffic |
Readiness fail liên tục, hoặc Service selector không khớp label | kubectl get endpoints <svc> — rỗng là xác nhận |
| Pod Ready nhưng request trả 503 | App listen 127.0.0.1 thay vì 0.0.0.0 |
kubectl exec pod -- ss -tulpn để xác nhận |
Pod bị tạo và xoá liên tục: deploy, scale, thay node, spot interruption. Ứng dụng phải coi việc bị tắt là chuyện bình thường, không phải sự cố. Cơ chế Linux phía sau đã giải thích ở chặng 01, mục 2; mục này nói phần ứng dụng phải làm.
| Mốc | Probe tương ứng | Nghĩa |
|---|---|---|
| Process đã chạy | chưa probe nào | Container đã start. Chưa nói được gì về việc app có dùng được hay không. |
| App đã khởi tạo xong | startupProbe xanh |
Spring context đã nạp, DI đã xong, kết nối DB đã mở. Từ lúc này mới bắt đầu tính
liveness và readiness. |
| App sẵn sàng nhận traffic | readinessProbe xanh |
Pod được thêm vào Endpoints. Traffic bắt đầu vào. |
startupProbe quan trọng với app JVM và .NET: chúng cần 20–60 giây để khởi
động (nạp class, JIT, dựng DI container). Không có startupProbe, bạn buộc phải đặt
initialDelaySeconds của liveness thật lớn — và khi đó app treo lúc đang chạy cũng
mất cả khoảng delay đó mới bị phát hiện. startupProbe tách hai mối quan tâm: khoan dung
lúc khởi động, nhạy lúc đang chạy.
| Runtime | Kỹ thuật | Hiệu quả và đánh đổi |
|---|---|---|
| Java | -XX:TieredStopAtLevel=1 |
Chỉ dùng JIT tầng thấp. Khởi động nhanh hơn rõ rệt nhưng throughput lúc chạy kém hơn. Chỉ dùng cho job ngắn hoặc CLI, không dùng cho service. |
| CDS / AppCDS | Lưu sẵn class đã nạp vào archive. Giảm thời gian khởi động 10–30% mà không ảnh hưởng throughput. Đáng làm cho service lớn. | |
| Spring Boot lazy init | spring.main.lazy-initialization=true. Nhanh hơn nhưng dồn chi phí sang request đầu
tiên — và request đầu đó có thể timeout. Cân nhắc kỹ. | |
| Python | Tránh import nặng ở top-level | import torch, import pandas ở đầu file làm khởi động chậm vài giây.
Chuyển vào trong hàm nếu chỉ dùng ở một nhánh. |
| .NET | ReadyToRun (R2R) | Biên dịch trước sang mã máy. Khởi động nhanh hơn đáng kể, image lớn hơn một chút.
<PublishReadyToRun>true</PublishReadyToRun> |
| Native AOT | Khởi động gần như tức thì, RAM thấp hơn nhiều. Nhưng không dùng được reflection động, nên nhiều thư viện (EF Core cũ, một số serializer) không tương thích. |
App phải làm đúng bốn việc này khi nhận SIGTERM, theo thứ tự:
spec:
template:
spec:
# Tổng thời gian cho phép tắt. Phải > preStop + thời gian request dài nhất
terminationGracePeriodSeconds: 45
containers:
- name: app
lifecycle:
preStop:
exec:
# Đệm để ALB/kube-proxy kịp gỡ pod khỏi backend trước khi app từ chối
command: ["sh", "-c", "sleep 5"]
# Khoan dung lúc khởi động: cho phép tới 60 × 2 = 120 giây
startupProbe:
httpGet: { path: /actuator/health/readiness, port: 8080 }
periodSeconds: 2
failureThreshold: 60
# Nhạy lúc đang chạy, nhưng KHÔNG kiểm tra dependency ngoài
livenessProbe:
httpGet: { path: /actuator/health/liveness, port: 8080 }
periodSeconds: 10
timeoutSeconds: 3
failureThreshold: 3
# Phản ánh đúng khả năng xử lý request ngay lúc này
readinessProbe:
httpGet: { path: /actuator/health/readiness, port: 8080 }
periodSeconds: 5
timeoutSeconds: 3
failureThreshold: 2
timeout shutdown của app (25s)
< terminationGracePeriodSeconds − preStop (45 − 5 = 40s)
< idle timeout của ALB / client (60s)
Nếu app cần 30s mà grace period chỉ 30s thì app luôn bị SIGKILL giữa lúc đang dọn.
Nếu grace period lớn hơn idle timeout của ALB thì client đã timeout trước khi app kịp trả lời.
Trên EKS dùng Spot, node có thể bị thu hồi với thông báo trước 2 phút. Karpenter nhận tín hiệu và drain node. Hai thứ bảo vệ bạn:
apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
name: order-service
namespace: prod
spec:
# Luôn giữ ít nhất 2 pod sẵn sàng trong mọi thao tác tự nguyện
# (drain node, Karpenter consolidation, cluster upgrade)
minAvailable: 2
selector:
matchLabels:
app: order-service
minAvailable bằng đúng số replica (ví dụ minAvailable: 3
với 3 replica) sẽ chặn hoàn toàn mọi thao tác drain — node không bao giờ được thay, cluster
không upgrade được, Karpenter không consolidate được. Quy tắc: minAvailable phải
nhỏ hơn số replica, hoặc dùng maxUnavailable: 1.
preStop là sleep 5. Nên đặt terminationGracePeriodSeconds bao nhiêu?Phần này bổ sung cho tài liệu JVM: ở đó là vì sao JVM dùng RAM như vậy, ở đây là cấu hình gì để nó chạy đúng trên Kubernetes.
-XX:+UseContainerSupport # Đọc cgroup để biết limit thật. Bật sẵn từ JDK 10,
# nhưng ghi tường minh để rõ ý định.
-Xms2048M -Xmx2048M # Đặt BẰNG NHAU: bỏ nhịp giãn heap kéo dài hàng giờ,
# GC hành xử giống nhau từ phút đầu. Vì requests.memory
# đã giữ chỗ RAM nên không mất gì thật.
-XX:MaxMetaspaceSize=384m # PHẢI đặt trần. Không đặt thì Metaspace giãn tới khi
# working set vượt limit → OOMKilled không log.
-XX:ReservedCodeCacheSize=256m # JDK mới mặc định 240m. Đặt tay 128m dễ chạm trần →
# JIT tắt → throughput sụp mà KHÔNG có lỗi nào.
-XX:MaxDirectMemorySize=128m # Đặt sát mức dùng thật. Để quá cao làm phép tính
# capacity bị phồng và che mất việc limit đã thiếu.
-XX:+UseG1GC # Mặc định và phù hợp cho phần lớn service.
-XX:MaxGCPauseMillis=200 # Mục tiêu pause. G1 điều chỉnh để cố đạt.
-XX:+ExitOnOutOfMemoryError # BẮT BUỘC. Không có cờ này, JVM OOM mà process vẫn
# sống → pod vẫn Ready → trả 500 cho mọi request.
# Đây là trạng thái tệ nhất có thể.
-XX:+HeapDumpOnOutOfMemoryError
-XX:HeapDumpPath=/dump # Phải trỏ vào VOLUME RIÊNG. Trỏ vào filesystem
# container thì dirty page đẩy working set vượt limit
# → bị kill giữa lúc dump → mất luôn bằng chứng.
-Djava.security.egd=file:/dev/./urandom # Tránh treo khi thiếu entropy lúc khởi động.
-Dfile.encoding=UTF-8
-Duser.timezone=Asia/Ho_Chi_Minh
JAVA_TOOL_OPTIONS hay JAVA_OPTS?
JAVA_OPTS chỉ có tác dụng nếu script khởi động của bạn truyền nó vào lệnh
java. JAVA_TOOL_OPTIONS được chính JVM đọc tự động, không cần script
hợp tác — nên nó hoạt động cả với image mà bạn không kiểm soát entrypoint. Đánh đổi: nó áp cho
mọi tiến trình Java trong container, kể cả lệnh jcmd bạn chạy để debug.
server:
port: 8080
shutdown: graceful
tomcat:
threads:
max: 100 # Đặt theo CPU limit, không để mặc định 200
accept-count: 100
connection-timeout: 5s
spring:
application:
name: order-service
lifecycle:
timeout-per-shutdown-phase: 25s # PHẢI nhỏ hơn terminationGracePeriodSeconds
datasource:
hikari:
maximum-pool-size: 20
minimum-idle: 5
connection-timeout: 3000 # Thà fail nhanh hơn treo request
validation-timeout: 2000
max-lifetime: 1200000 # 20 phút, ngắn hơn timeout của RDS/proxy
management:
endpoints:
web:
exposure:
include: health,prometheus,info,metrics
endpoint:
health:
# Bật hai nhóm riêng cho liveness và readiness
probes:
enabled: true
group:
# LIVENESS: chỉ kiểm process còn sống. KHÔNG kiểm DB.
liveness:
include: livenessState
# READINESS: kiểm cả thứ cần để xử lý request
readiness:
include: readinessState,db
show-details: when-authorized
metrics:
tags:
application: ${spring.application.name}
pod: ${POD_NAME:unknown} # Lấy từ Downward API
tracing:
sampling:
probability: 0.1
CrashLoopBackOff toàn bộ service. Bạn vừa biến một sự cố DB tạm thời
thành một sự cố mất dịch vụ hoàn toàn, và còn làm DB bị dồn thêm kết nối lúc nó đang yếu.
# Tomcat max threads nên theo CPU limit, không để mặc định 200.
# 200 thread trên limit 2 core nghĩa là 200 MB thread stack và
# context switch khổng lồ, trong khi chỉ 2 thread chạy thật cùng lúc.
Công thức thực dụng cho service I/O-bound (gọi DB, gọi API khác):
max threads ≈ CPU limit (core) × 25 ÷ (tỉ lệ thời gian dùng CPU)
Ví dụ: limit 2 core, mỗi request dùng CPU 20% thời gian (80% chờ I/O)
→ 2 × 25 ÷ 0.2 ≈ 250 ... nhưng trần lại ở mức connection pool DB cho phép.
→ Thực tế đặt 100, và maximum-pool-size 20 là nút cổ chai thật.
Quy tắc đơn giản: max threads KHÔNG nên lớn hơn 5 × maximum-pool-size,
vì quá số đó thì thread chỉ xếp hàng chờ connection, không làm gì có ích.
# Spring Boot relaxed binding: dấu chấm → gạch dưới, chữ hoa
spring.datasource.url → SPRING_DATASOURCE_URL
spring.datasource.hikari.max-pool → SPRING_DATASOURCE_HIKARI_MAXPOOL
management.server.port → MANAGEMENT_SERVER_PORT
spring.profiles.active → SPRING_PROFILES_ACTIVE
# Danh sách dùng chỉ số
spring.kafka.bootstrap-servers[0] → SPRING_KAFKA_BOOTSTRAPSERVERS_0_
# Kiểm tra cấu hình thực tế app đang dùng (bật endpoint env, chỉ ở môi trường thấp):
curl -s localhost:8080/actuator/env | jq '.propertySources[] | select(.name|contains("environment"))'
Python có một vấn đề mà Java và .NET không có: CPython không đọc cgroup. Mọi thư viện tự động chọn số worker theo số CPU đều sai trong container. Mục này xử lý điều đó và các đặc thù khác của Python trên Kubernetes.
nproc:
# Công thức "chuẩn" từ tài liệu Gunicorn, nhưng SAI trong container
workers = multiprocessing.cpu_count() * 2 + 1
# Trên node c6g.4xlarge (16 core) với limits.cpu: 1000m:
# cpu_count() trả về 16 (số core của NODE, không phải limit)
# → 16 × 2 + 1 = 33 worker process
# → 33 process tranh nhau 1 core → throttle thảm hoạ
# → RAM × 33 vì mỗi worker là một process riêng → OOMKilled
Lý do: os.cpu_count() và multiprocessing.cpu_count() đọc
/proc/cpuinfo, phản ánh phần cứng của node. Chúng không đọc
/sys/fs/cgroup/cpu.max.
# Cách 1 (tốt nhất): truyền limit vào qua Downward API, tính từ đó
# deployment.yaml
env:
- name: CPU_LIMIT
valueFrom:
resourceFieldRef:
containerName: app
resource: limits.cpu # trả về số core đã làm tròn lên, ví dụ "1"
- name: GUNICORN_WORKERS
value: "4" # hoặc đặt tường minh, đơn giản nhất
# Cách 2: đọc cgroup trong code
def cpu_quota():
try: # cgroup v2
with open("/sys/fs/cgroup/cpu.max") as f:
quota, period = f.read().split()
if quota != "max":
return max(1, int(int(quota) / int(period)))
except FileNotFoundError:
pass
try: # cgroup v1
q = int(open("/sys/fs/cgroup/cpu/cpu.cfs_quota_us").read())
p = int(open("/sys/fs/cgroup/cpu/cpu.cfs_period_us").read())
if q > 0:
return max(1, q // p)
except FileNotFoundError:
pass
return os.cpu_count() or 1
# Cách 3: dùng thư viện đã xử lý sẵn
# pip install cgroup-utils hoặc dùng gunicorn/conf.py với logic trên
| Loại ứng dụng | Cấu hình nên dùng | Lý do |
|---|---|---|
| API async FastAPI, Starlette |
uvicorn workers, số worker nhỏ--workers 2 --loop uvloop |
Async xử lý đồng thời bằng event loop, không cần nhiều process. Mỗi worker lo được hàng nghìn kết nối chờ I/O. |
| API sync Django, Flask |
gunicorn + gthread--workers 2 --threads 4 |
Code sync chặn thread khi chờ I/O. Thread rẻ hơn process nên dùng thread để tăng đồng thời, process để dùng được nhiều core. |
| CPU-bound xử lý ảnh, ML inference |
--workers <= CPU limit>,1 thread mỗi worker |
GIL làm thread không giúp gì cho tải CPU. Số worker vượt số core chỉ gây context switch. |
| Background task Celery, RQ, Arq |
Deployment riêng, scale độc lập theo độ sâu queue | Tách khỏi web để scale theo tín hiệu khác nhau. Dùng KEDA với queue length, không dùng CPU. |
import os
bind = f"0.0.0.0:{os.getenv('PORT', '8000')}" # 0.0.0.0, KHÔNG phải 127.0.0.1
# Đọc từ env, KHÔNG dùng cpu_count()
workers = int(os.getenv("GUNICORN_WORKERS", "4"))
threads = int(os.getenv("GUNICORN_THREADS", "2"))
worker_class = os.getenv("GUNICORN_WORKER_CLASS", "gthread")
# --- Vòng đời ---
graceful_timeout = 25 # Thời gian cho worker xử lý xong request khi nhận SIGTERM.
# Phải NHỎ HƠN terminationGracePeriodSeconds.
timeout = 30 # Worker không phản hồi quá lâu thì master giết và tạo lại.
keepalive = 65 # LỚN HƠN idle timeout của ALB (60s) để ALB chủ động đóng,
# tránh race condition gây 502.
# --- Chống rò rỉ bộ nhớ ---
max_requests = 1000 # Tự khởi động lại worker sau N request. Cách thực dụng để
max_requests_jitter = 100 # sống chung với rò rỉ ở thư viện C. jitter để các worker
# không restart cùng lúc.
# --- Log ra stdout ---
accesslog = "-"
errorlog = "-"
loglevel = os.getenv("LOG_LEVEL", "info")
# Tắt access log cho health check để không nhiễu log
def pre_request(worker, req):
if req.path in ("/healthz", "/readyz", "/metrics"):
worker.cfg.set("accesslog", None)
# --- Quan trọng với Prometheus multiprocess ---
def child_exit(server, worker):
from prometheus_client import multiprocess
multiprocess.mark_process_dead(worker.pid)
# Dockerfile / deployment env
ENV PROMETHEUS_MULTIPROC_DIR=/tmp/prometheus
# Trong app
from prometheus_client import CollectorRegistry, multiprocess, generate_latest
@app.get("/metrics")
def metrics():
registry = CollectorRegistry()
multiprocess.MultiProcessCollector(registry)
return Response(generate_latest(registry), media_type="text/plain")
Và cần mount emptyDir vào /tmp/prometheus nếu bật
readOnlyRootFilesystem.
ENV PYTHONUNBUFFERED=1 # BẮT BUỘC. Không có thì stdout bị buffer →
# log chỉ xuất hiện khi buffer đầy hoặc process chết.
# Pod bị kill là mất toàn bộ log chưa flush.
ENV PYTHONDONTWRITEBYTECODE=1 # Không ghi .pyc → không cần quyền ghi vào thư mục source,
# tương thích readOnlyRootFilesystem.
ENV PYTHONFAULTHANDLER=1 # In traceback khi crash vì segfault — cực hữu ích khi
# dùng thư viện C (numpy, pillow, grpc).
ENV PIP_NO_CACHE_DIR=1 # Không giữ cache pip trong image.
ENV PYTHONHASHSEED=random # Giữ mặc định an toàn.
from pydantic import Field, PostgresDsn
from pydantic_settings import BaseSettings, SettingsConfigDict
class DatabaseSettings(BaseSettings):
model_config = SettingsConfigDict(env_prefix="APP_DB__")
host: str
port: int = 5432
name: str
user: str
password: str = Field(..., repr=False) # repr=False: không bao giờ in ra log
class Settings(BaseSettings):
model_config = SettingsConfigDict(
env_prefix="APP_",
env_nested_delimiter="__",
case_sensitive=False,
)
env: str = "production"
log_level: str = "INFO"
workers: int = 4
payment_service_url: str
db: DatabaseSettings
# Fail nhanh lúc khởi động nếu thiếu cấu hình, thay vì lỗi giữa lúc chạy production
settings = Settings()
Lợi ích lớn nhất: thiếu biến môi trường thì pod không khởi động được và lỗi hiện
rõ trong log. Tốt hơn nhiều so với việc app chạy bình thường rồi lỗi None ở request đầu tiên
lúc 2 giờ sáng.
from contextlib import asynccontextmanager
from fastapi import FastAPI
@asynccontextmanager
async def lifespan(app: FastAPI):
# --- startup ---
app.state.db = await create_pool()
app.state.ready = True
yield
# --- shutdown: chạy khi nhận SIGTERM ---
app.state.ready = False # readiness fail ngay → Kubernetes gỡ khỏi Endpoints
await app.state.db.close() # đóng pool sau khi đã rút khỏi traffic
app = FastAPI(lifespan=lifespan)
@app.get("/healthz") # liveness: chỉ cần process trả lời
async def healthz():
return {"status": "ok"}
@app.get("/readyz") # readiness: phản ánh khả năng xử lý thật
async def readyz():
if not app.state.ready:
raise HTTPException(status_code=503, detail="shutting down")
await app.state.db.fetchval("SELECT 1")
return {"status": "ready"}
kubectl logs không có dòng log nào của những giây cuối. Nguyên nhân khả dĩ nhất?.NET là runtime thân thiện với container nhất trong ba cái: tự đọc cgroup, tự bắt
SIGTERM, có health check tích hợp. Nhưng có vài điểm đặc thù về GC và port cần biết.
| Biến | Ý nghĩa và giá trị nên dùng |
|---|---|
ASPNETCORE_ENVIRONMENT |
Production. Quyết định file appsettings.{Env}.json nào được nạp. |
ASPNETCORE_HTTP_PORTS |
8080. Từ .NET 8, image mặc định chạy non-root nên không bind được port 80.
Đây là thay đổi hay gây lỗi khi nâng từ .NET 6/7 lên 8. |
DOTNET_gcServer |
1 cho service throughput cao, 0 cho pod nhỏ. Xem phần GC bên dưới —
đây là cờ ảnh hưởng RAM nhiều nhất. |
DOTNET_GCHeapHardLimitPercent |
Hex, ví dụ 4B = 75%. Giới hạn heap theo phần trăm limits.memory.
Tương đương -Xmx của Java. |
DOTNET_TieredPGO |
1. Profile-guided optimization, tăng throughput sau khi app chạy ấm. |
DOTNET_ReadyToRun |
1 nếu publish với R2R. Giảm thời gian khởi động. |
DOTNET_SYSTEM_GLOBALIZATION_INVARIANT |
1 nếu dùng image Alpine mà không cài icu-libs. Lưu ý: tắt
globalization làm so sánh chuỗi theo văn hoá không còn đúng. |
# Kiểm tra .NET đang thấy bao nhiêu CPU và heap limit bao nhiêu
kubectl exec POD -- dotnet-counters ps
kubectl exec POD -- printenv | grep -i dotnet
# Trong code, xác nhận:
Console.WriteLine($"ProcessorCount: {Environment.ProcessorCount}");
Console.WriteLine($"ServerGC: {System.Runtime.GCSettings.IsServerGC}");
Console.WriteLine($"TotalMemory: {GC.GetTotalMemory(false) / 1024 / 1024} MB");
Quy tắc: pod có limits.cpu dưới 2000m thì nên đặt DOTNET_gcServer=0
(workstation GC) — RAM thấp hơn đáng kể, và với ít core thì server GC không mang lại lợi ích.
env:
- name: ASPNETCORE_ENVIRONMENT
value: "Production"
- name: ASPNETCORE_HTTP_PORTS
value: "8080"
# --- GC ---
- name: DOTNET_gcServer
value: "1" # pod >= 2 core; đặt "0" nếu pod nhỏ
- name: DOTNET_GCHeapHardLimitPercent
value: "4B" # hex 0x4B = 75 → heap tối đa 75% của limits.memory
- name: DOTNET_GCConserveMemory
value: "5" # 0-9, cao hơn = nhả RAM về OS tích cực hơn
- name: DOTNET_TieredPGO
value: "1"
# --- Chẩn đoán ---
- name: DOTNET_DbgEnableMiniDump
value: "1"
- name: DOTNET_DbgMiniDumpType
value: "2" # heap dump
- name: DOTNET_DbgMiniDumpName
value: "/dump/coredump.%p" # volume riêng, giống HeapDumpPath của Java
resources:
requests:
cpu: 200m
memory: 512Mi
limits:
cpu: 2000m # >= 1000m để .NET thấy đủ core
memory: 1Gi # heap hard limit = 75% × 1Gi = 768Mi
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddHealthChecks()
// Tag "ready": thứ cần để XỬ LÝ request được
.AddNpgSql(
builder.Configuration.GetConnectionString("Default")!,
name: "postgres",
timeout: TimeSpan.FromSeconds(3),
tags: new[] { "ready" })
.AddRedis(
builder.Configuration.GetConnectionString("Redis")!,
name: "redis",
tags: new[] { "ready" })
// Tag "live": chỉ kiểm process, KHÔNG kiểm dependency ngoài
.AddCheck("self", () => HealthCheckResult.Healthy(), tags: new[] { "live" });
// Thời gian chờ shutdown — phải nhỏ hơn terminationGracePeriodSeconds
builder.Services.Configure<HostOptions>(o =>
o.ShutdownTimeout = TimeSpan.FromSeconds(25));
var app = builder.Build();
app.MapHealthChecks("/healthz", new HealthCheckOptions {
Predicate = c => c.Tags.Contains("live")
});
app.MapHealthChecks("/readyz", new HealthCheckOptions {
Predicate = c => c.Tags.Contains("ready"),
ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});
// Dọn tài nguyên khi nhận SIGTERM — .NET bắt signal sẵn, không cần thêm gì
var lifetime = app.Services.GetRequiredService<IHostApplicationLifetime>();
lifetime.ApplicationStopping.Register(() => {
Log.Information("SIGTERM received, draining connections");
});
app.Run();
# Dấu hai chấm KHÔNG hợp lệ trong tên biến môi trường Linux → dùng hai gạch dưới
ConnectionStrings:Default → ConnectionStrings__Default
Logging:LogLevel:Default → Logging__LogLevel__Default
Serilog:MinimumLevel:Default → Serilog__MinimumLevel__Default
# Thứ tự ưu tiên của .NET Configuration (sau thắng trước):
# 1. appsettings.json
# 2. appsettings.{Environment}.json
# 3. User secrets (chỉ Development)
# 4. Biến môi trường ← ConfigMap/Secret vào đây
# 5. Tham số dòng lệnh
new HttpClient(). Tạo HttpClient mới cho
mỗi request làm cạn socket và đẩy conntrack lên — triệu chứng là timeout ngẫu nhiên sau một thời gian
chạy (xem chặng 01, mục 7). Đăng ký một lần:
builder.Services.AddHttpClient("payment", c => {
c.BaseAddress = new Uri(builder.Configuration["PaymentServiceUrl"]!);
c.Timeout = TimeSpan.FromSeconds(5);
})
.SetHandlerLifetime(TimeSpan.FromMinutes(5)) // xoay handler để nhận thay đổi DNS
.AddStandardResilienceHandler(); // retry + circuit breaker + timeout
| Khía cạnh | Java / Spring Boot | Python | .NET |
|---|---|---|---|
| Đọc cgroup CPU | Có từ 8u191+ | Không phải tự xử lý | Có từ Core 3.0 |
| Đọc cgroup memory | Có, heap = 1/4 limit | Không | Có, qua GCHeapHardLimit |
| Bắt SIGTERM mặc định | Cần cấu hình shutdown: graceful |
Gunicorn có, app thuần thì không | Có sẵn |
| Giới hạn heap | -Xmx |
Không có khái niệm — RAM do allocator quyết | GCHeapHardLimitPercent |
| Thời gian khởi động | 20–60s | 1–5s | 2–10s (R2R nhanh hơn) |
| RAM nền | Cao: heap + metaspace + code cache + native | Thấp mỗi worker, nhân với số worker | Trung bình, phụ thuộc server/workstation GC |
| Mô hình đồng thời | Thread pool (hoặc virtual thread từ JDK 21) | Process × thread, hoặc async event loop | async/await trên thread pool |
| Bẫy đặc thù lớn nhất | Working set lớn hơn -Xmx khoảng 650 MB |
Số worker theo nproc của node |
Server GC tạo heap theo số core |
| Metric endpoint | Micrometer → /actuator/prometheus |
prometheus_client, cần multiprocess mode |
OpenTelemetry hoặc prometheus-net |
limits.cpu: 500m và limits.memory: 512Mi bị OOMKilled liên tục dù app rất đơn giản. Thử gì trước?Log, metric và trace trả lời ba câu hỏi khác nhau. Giá trị thật xuất hiện khi chúng
nối được với nhau qua trace_id — từ một biểu đồ bất thường nhảy sang trace cụ thể,
rồi sang log của đúng request đó.
| Trụ cột | Trả lời câu hỏi | Chi phí lưu trữ | Công cụ trên EKS |
|---|---|---|---|
| Metric | Có đang xảy ra vấn đề không? Mức độ nào? | Thấp — số liệu tổng hợp, giữ được hàng tháng | Prometheus / AMP, Grafana |
| Trace | Request chậm ở bước nào trong chuỗi service? | Trung bình — phải lấy mẫu (sampling) | Tempo, AWS X-Ray |
| Log | Chính xác chuyện gì đã xảy ra với request này? | Cao — thường là mục chi phí lớn nhất | Loki, CloudWatch Logs |
| Metric | Đo gì | PromQL |
|---|---|---|
| Traffic | Số request mỗi giây | |
| Errors | Tỉ lệ lỗi | |
| Latency | p95, p99 — không dùng trung bình | |
| Saturation | Mức dùng tài nguyên so với trần | |
// pom.xml
micrometer-registry-prometheus
// application.yml
management:
endpoints:
web:
exposure:
include: prometheus
metrics:
distribution:
percentiles-histogram:
http.server.requests: true
slo:
http.server.requests:
100ms,500ms,1s
Endpoint:
/actuator/prometheus
from prometheus_fastapi_
instrumentator import
Instrumentator
Instrumentator().instrument(
app).expose(app)
# Nhiều worker: BẮT BUỘC
# PROMETHEUS_MULTIPROC_DIR
# và mount emptyDir vào đó
Endpoint: /metrics
builder.Services
.AddOpenTelemetry()
.WithMetrics(m => m
.AddAspNetCoreInstrumentation()
.AddRuntimeInstrumentation()
.AddPrometheusExporter());
app.MapPrometheusScraping
Endpoint();
Endpoint: /metrics
metadata:
annotations:
prometheus.io/scrape: "true"
prometheus.io/port: "8080"
prometheus.io/path: "/actuator/prometheus"
Nếu dùng Prometheus Operator thì khai ServiceMonitor thay vì annotation —
cách này rõ ràng hơn và cho phép đặt interval riêng cho từng service.
# SAI — mỗi user_id và mỗi order_id tạo một series mới
http_requests_total{user_id="18422", order_id="ORD-9f3a2b", path="/orders/ORD-9f3a2b"}
# 100.000 user × 50 endpoint = 5.000.000 series → Prometheus chết
# ĐÚNG — label chỉ chứa giá trị có miền HỮU HẠN và NHỎ
http_requests_total{method="GET", uri="/orders/{id}", status="200"}
# 5 method × 50 uri × 6 status = 1.500 series → hoàn toàn ổn
# user_id và order_id thuộc về LOG và TRACE, không thuộc về metric.
Quy tắc: label phải có dưới khoảng 100 giá trị khả dĩ. ID, email, URL đầy đủ, message lỗi,
timestamp đều không được làm label. Spring Boot tự chuẩn hoá URI thành
/orders/{id} — đừng ghi đè việc đó.
# Biến môi trường chuẩn OTel, giống nhau cho mọi runtime
env:
- name: OTEL_SERVICE_NAME
value: "order-service"
- name: OTEL_EXPORTER_OTLP_ENDPOINT
value: "http://otel-collector.observability.svc.cluster.local:4317"
- name: OTEL_TRACES_SAMPLER
value: "parentbased_traceidratio"
- name: OTEL_TRACES_SAMPLER_ARG
value: "0.1" # 10% — đủ để điều tra, không nổ chi phí
- name: OTEL_RESOURCE_ATTRIBUTES
value: "deployment.environment=prod,service.version=$(APP_VERSION)"
# Gắn metadata pod vào mọi span — truy vết được pod nào gây lỗi
- name: OTEL_RESOURCE_ATTRIBUTES_POD_NAME
valueFrom:
fieldRef:
fieldPath: metadata.name
# Dockerfile
ADD https://github.com/open-telemetry/opentelemetry-java-instrumentation/\
releases/latest/download/opentelemetry-javaagent.jar /otel/agent.jar
# deployment env
JAVA_TOOL_OPTIONS: "-javaagent:/otel/agent.jar"
Agent tự instrument HTTP, JDBC, Kafka, Redis và chèn trace_id vào MDC để log có sẵn.
Python có opentelemetry-instrument tương tự; .NET dùng package OTel.
| Alert | Nên? | Lý do |
|---|---|---|
| Tỉ lệ 5xx > 1% trong 5 phút | Có | Ảnh hưởng trực tiếp tới user. Đây là alert quan trọng nhất. |
| p99 > SLO trong 10 phút | Có | Phát hiện suy giảm trước khi thành lỗi hẳn. |
| Pod restart > 3 lần trong 1 giờ | Có | Dấu hiệu OOM hoặc crash lặp. Có thể còn chưa ảnh hưởng user. |
| Working set > 90% limit | Có | Cảnh báo trước khi OOMKilled, còn kịp xử lý. |
| CPU throttle > 25% | Có | Nguyên nhân thầm lặng của p95 cao. |
| CPU usage > 80% | Không | CPU cao không phải vấn đề nếu độ trễ vẫn tốt — đó là dùng tài nguyên hiệu quả. Alert theo triệu chứng user cảm nhận được, không theo mức dùng tài nguyên. |
| Heap usage > 70% | Không | Heap cao là bình thường — GC chạy khi gần đầy rồi dọn. Alert cái này sinh ra hàng loạt báo động giả. Thay bằng GC overhead > 10% hoặc live data sau GC dốc lên. |
| Disk usage > 80% trên node | Tuỳ | Hữu ích nhưng nên để đội hạ tầng nhận, không phải đội ứng dụng. |
Danh sách rà soát trước khi đưa một service lên production. Mỗi dòng là một lỗi thật đã từng gây sự cố ở đâu đó.
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Không có secret nào trong image hoặc Git | Quét bằng gitleaks/trufflehog trong CI. Secret vào Git là nằm đó mãi. |
| ☐ | Một image dùng cho mọi môi trường | Image test ở staging phải đúng là image chạy production, nếu không việc test mất giá trị. |
| ☐ | App fail nhanh khi thiếu cấu hình bắt buộc | Thà pod không khởi động được còn hơn chạy rồi lỗi null lúc 2 giờ sáng. |
| ☐ | Có checksum annotation cho ConfigMap/Secret | Không có thì sửa config pod không restart, và bạn tưởng config đã được áp dụng. |
| ☐ | Không mount file config bằng subPath |
subPath làm file không bao giờ được cập nhật. |
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Mọi container khai đủ requests và limits |
Thiếu là QoS BestEffort, bị giết đầu tiên. Kể cả sidecar — một sidecar thiếu limit làm pod mất trần ở cấp pod. |
| ☐ | limits.memory ≥ heap + ngoài heap + 15% |
Với Java, phần ngoài heap khoảng 600–700 MB. Tính thiếu là pod chạy nhiều giờ rồi chết đúng lúc heap giãn hết. |
| ☐ | limits.cpu ≥ 3 × requests.cpu |
JVM và .NET cần burst mạnh lúc khởi động. Đặt bằng nhau là throttle ngay lúc start, probe fail, restart, lặp lại. |
| ☐ | limits.cpu ≥ 1000m cho pod Java/.NET |
Dưới mức này runtime tưởng chỉ có 1 core và thu nhỏ hàng loạt thread pool không liên quan. |
| ☐ | Python/Node đặt số worker tường minh | Không đọc được cgroup nên nproc trả về số core node. |
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Dockerfile dùng exec form, hoặc script có exec |
Thiếu là sh làm PID 1 và nuốt SIGTERM. |
| ☐ | Có preStop: sleep 5 |
Sửa được hiện tượng 502 lẻ tẻ mỗi lần deploy. |
| ☐ | terminationGracePeriodSeconds > preStop + thời gian request dài nhất |
Thiếu là app luôn bị SIGKILL giữa lúc dọn dẹp. |
| ☐ | Timeout shutdown của app nhỏ hơn grace period | Để app chủ động thoát trước khi bị giết. |
| ☐ | Có startupProbe cho app JVM/.NET |
Để liveness nhạy lúc chạy mà vẫn khoan dung lúc khởi động. |
| ☐ | Liveness KHÔNG kiểm tra DB hay service ngoài | DB sự cố → mọi pod restart cùng lúc → mất dịch vụ hoàn toàn. Lỗi tốn kém nhất trong danh sách. |
| ☐ | Có PDB với minAvailable < số replica |
Bằng số replica là chặn hoàn toàn drain node và cluster upgrade. |
| Hạng mục | Vì sao | |
|---|---|---|
| ☐ | Log ra stdout dạng JSON, có trace_id |
Không có trace_id thì log của một request bị trộn giữa hàng nghìn request khác. |
| ☐ | Python có PYTHONUNBUFFERED=1 |
Thiếu là mất toàn bộ log chưa flush khi pod bị kill. |
| ☐ | Metric không có label cardinality cao | ID trong label làm Prometheus hết RAM. |
| ☐ | Java có -XX:+ExitOnOutOfMemoryError |
Thiếu là JVM OOM mà pod vẫn Ready, trả 500 cho mọi request — trạng thái tệ nhất. |
| ☐ | Heap dump/core dump trỏ vào volume riêng | Trỏ vào filesystem container là mất dump và còn gây OOMKilled lần hai. |
| ☐ | Chạy non-root, readOnlyRootFilesystem: true |
Nhớ mount emptyDir cho /tmp — JVM cần nó. |
| ☐ | drop: ["ALL"] capabilities |
App web không cần capability nào của kernel. |
| ☐ | Image được quét lỗ hổng trong CI | Chặn pipeline nếu có CVE mức HIGH/CRITICAL. Xem chặng 06. |
exec trong entrypoint → pod không nhận SIGTERMlimits.memory tính thiếu phần ngoài heap → OOMKilled sau nhiều giờ chạy ổnnproc → throttle và OOM trên node lớn-XX:+ExitOnOutOfMemoryError → pod zombie trả 500 mà không ai biết