1. Introduction — The Hidden Problem Behind Kubernetes Load Balancing

Trong kiến trúc microservices, Load Balancing là một trong những cơ chế quan trọng giúp phân phối traffic giữa các backend instances, cải thiện khả năng mở rộng (Scalability) và duy trì tính sẵn sàng (Availability) của hệ thống.

Khi triển khai ứng dụng trên Kubernetes, chúng ta thường mong đợi rằng việc tăng số lượng Pods sẽ giúp phân phối workload tốt hơn. Đặc biệt, khi kết hợp với Horizontal Pod Autoscaler (HPA), hệ thống có thể tự động bổ sung tài nguyên khi nhu cầu xử lý tăng cao.

Tuy nhiên, trong tình huống thực tế:

Một ứng dụng ban đầu chạy trên 3 Pods. Khi lượng request tăng mạnh, P99 latency bắt đầu tăng và một số request gặp timeout. Kubernetes HPA phát hiện mức sử dụng CPU vượt ngưỡng và tự động scale Deployment từ 3 lên 10 Pods.

Sau khi scaling hoàn thành:

  • Tất cả 10 Pods đều ở trạng thái Running và Ready.
  • Kubernetes Service nhận diện đầy đủ các backend endpoints.
  • Cluster vẫn còn tài nguyên CPU và Memory.
  • Một số Pods tiếp tục hoạt động gần ngưỡng CPU tối đa.
  • Phần lớn các Pods mới gần như không nhận traffic.
  • P99 latency và timeout rate không cải thiện đáng kể.

Tại sao hệ thống đã có thêm tài nguyên nhưng vẫn không giải quyết được tình trạng quá tải?

Vấn đề đặt ra là liệu việc Load Balancing ở network layer có thực sự đồng nghĩa với việc phân phối đều các application requests hay không.

Khi các microservices giao tiếp thông qua gRPC và HTTP/2, mối quan hệ giữa TCP connections, RPC calls và cách Kubernetes Service lựa chọn backend trở thành yếu tố quan trọng ảnh hưởng đến quá trình phân phối traffic.

Trong bài viết này, tôi sẽ phân tích một sự cố production giả lập, nơi HPA đã scale thành công nhưng hiệu năng hệ thống vẫn không cải thiện. Từ các dấu hiệu ban đầu, bài viết sẽ đi qua quá trình troubleshooting, tìm hiểu cơ chế Load Balancing trong Kubernetes, xác định root cause và đề xuất giải pháp khắc phục.

2. System Architecture & Initial Conditions — Kiến trúc hệ thống và điều kiện ban đầu

2.1. System Overview

Giả sử chúng ta đang vận hành một hệ thống thương mại điện tử được xây dựng theo kiến trúc microservices và triển khai trên Kubernetes.

Hệ thống bao gồm ba thành phần chính:

API Gateway

Là điểm tiếp nhận HTTP requests từ phía người dùng. Gateway thực hiện xác thực, kiểm tra request và chuyển các lời gọi nghiệp vụ tới những backend services.

Order Service

Chịu trách nhiệm xử lý đơn hàng. Service này cung cấp các RPC methods như CreateOrder, GetOrder và ValidateOrder.

Kubernetes Infrastructure

Quản lý các Pods của Order Service, cung cấp service discovery, networking và cơ chế autoscaling thông qua HPA.

Trong tình huống này, API Gateway giao tiếp với Order Service bằng gRPC trên HTTP/2, thông qua một Kubernetes Service có kiểu ClusterIP.

Kiến trúc logic:

 Client Applications | | HTTPS v API Gateway (2 Pods) | | gRPC / HTTP/2 v Kubernetes ClusterIP order-service | +------------+------------+ | | | v v v Order Pod A Order Pod B Order Pod C | | | +------------+------------+ | Database 

Trong kiến trúc trên, API Gateway đóng vai trò là gRPC client, còn các Order Service Pods đóng vai trò là gRPC servers.

2.2. Kubernetes Deployment & Autoscaling Configuration

Hệ thống được thiết kế với các thông số sau:

Component Configuration
Container Orchestration Kubernetes
Worker Nodes 3 Nodes
API Gateway 2 Pods
Order Service 3 Pods ban đầu
Maximum Replicas 10 Pods
Autoscaling Horizontal Pod Autoscaler
HPA Target CPU utilization 60%
Service Type ClusterIP
Service Port TCP 50051
Communication Protocol gRPC / HTTP/2
Load Balancing Layer Layer 4 tại Kubernetes Service
Service Proxy kube-proxy (iptables mode)

HPA được cấu hình để tăng số lượng Order Service Pods khi CPU utilization vượt mục tiêu đã thiết lập.

Mục tiêu kiến trúc là cho phép Order Service mở rộng linh hoạt trong những khoảng thời gian có traffic cao, mà không yêu cầu người vận hành thao tác bằng tay.

2.3. gRPC Connection Behavior

Một đặc điểm quan trọng trong kiến trúc này là cách API Gateway quản lý kết nối tới Order Service.

Thay vì thiết lập TCP connection mới cho mỗi RPC, Gateway sử dụng các gRPC channels được tái sử dụng trong suốt vòng đời của ứng dụng.

Trong kịch bản mô phỏng này, mỗi Gateway Pod duy trì một số lượng nhỏ HTTP/2 connections tới địa chỉ ClusterIP của Order Service.

Nhờ HTTP/2 multiplexing, nhiều RPC calls có thể được truyền đồng thời trên cùng một TCP connection.

Ngoài ra, để giới hạn phạm vi phân tích, chúng ta giả định:

  • Gateway không có cơ chế client-side load balancing nhận diện trực tiếp danh sách Order Service Pods.
  • Không có L7 proxy trung gian thực hiện load balancing theo từng RPC.
  • Các TCP connections có thể tồn tại trong thời gian dài.
  • Kubernetes Service sử dụng cơ chế chuyển tiếp Layer 4 thông thường.
  • Các Pods có cùng resource requests, limits và cấu hình ứng dụng.
  • Database không phải bottleneck chính trong kịch bản này.

Những điều kiện trên rất quan trọng vì chúng ảnh hưởng trực tiếp đến cách một gRPC call được định tuyến từ Gateway đến backend Pod.

2.4. Expected Behavior

Trong trạng thái hoạt động bình thường, Order Service xử lý trung bình khoảng 1.200 RPC requests/giây.

P99 latency duy trì quanh mức 150–180 ms và không có tình trạng timeout đáng kể.

Khi traffic tăng, chúng ta mong đợi HPA sẽ bổ sung replicas để nâng tổng năng lực xử lý.

Ví dụ, với 5.000 RPC requests/giây và 10 Pods, nếu traffic được phân phối lý tưởng theo từng request, mỗi Pod sẽ nhận trung bình:

5.000 / 10 = 500 RPS

Tuy nhiên, đây chỉ là mức phân phối lý tưởng dùng để so sánh. Kubernetes không mặc định bảo đảm các Pods sẽ nhận số lượng RPC bằng nhau.

Liệu hệ thống thực tế có hoạt động đúng với mong đợi này?

3. Production Incident — Dấu hiệu và Quá trình xảy ra sự cố

Lưu ý: Các metrics, thời điểm và thông số trong phần này là dữ liệu giả lập nhằm mô phỏng một failure scenario có cơ sở kỹ thuật, không phải số liệu từ một production incident thực tế.

3.1. Incident Overview

Vào khoảng 10:00, hệ thống bắt đầu ghi nhận lượng traffic tăng nhanh do một chiến dịch khuyến mãi.

Số lượng gRPC calls đến Order Service tăng từ khoảng 1.200 lên 5.000 RPS.

Ban đầu, HPA hoạt động đúng như thiết kế: phát hiện mức CPU utilization tăng cao và bắt đầu tạo thêm Order Service Pods.

Tuy nhiên, sau khi Deployment mở rộng lên 10 replicas, các cảnh báo liên quan đến latency và request timeouts vẫn tiếp tục xuất hiện.

Trong khi đó, Kubernetes Dashboard cho thấy toàn bộ Pods đều đang hoạt động bình thường.

3.2. Incident Timeline

Time Event
09:55 Hệ thống ổn định với 3 Order Service Pods
10:00 Traffic bắt đầu tăng mạnh
10:02 P99 latency vượt ngưỡng cảnh báo
10:03 Xuất hiện gRPC DEADLINE_EXCEEDED
10:04 HPA bắt đầu bổ sung replicas
10:08 Deployment đạt 10/10 Ready Pods
10:10 P99 latency vẫn trên 2 giây
10:12 Phát hiện traffic phân phối không đều giữa các Pods

3.3. Observed Metrics

Tại thời điểm sự cố, các chỉ số được ghi nhận như sau:

Metric Normal Incident
Incoming RPC Rate 1.200 RPS 5.000 RPS
Order Service Replicas 3 10
Ready Pods 3/3 10/10
P99 Latency 160 ms 2.600 ms
RPC Deadline Exceeded Rate Gần 0% 4,1%
Highest Pod CPU 55% 96%

Một điều bất thường xuất hiện khi phân tích metrics theo từng Pod.

Mặc dù Order Service đã có 10 replicas, phần lớn traffic vẫn tập trung vào những Pods tồn tại trước quá trình scaling.

Ví dụ về phân phối 5.000 RPC/s tại một thời điểm:

Pod Group Incoming RPC/s
Pod A 3.400
Pod B 1.300
Pod C 260
7 Pods mới (tổng cộng) 40
Total 5.000

Pod A nhận gần 68% tổng số RPC, trong khi bảy Pods mới cộng lại chỉ nhận khoảng 0,8%.

Điều này dẫn đến tình trạng một số Pods phải xử lý lượng workload rất lớn, trong khi các Pods còn lại vẫn có nhiều tài nguyên chưa được sử dụng.

3.4. Initial Observations

Nhóm vận hành bắt đầu kiểm tra những thành phần thường gây ra lỗi khi một Kubernetes application có latency cao.

Kết quả kiểm tra ban đầu:

Deployment Status

NAME READY UP-TO-DATE AVAILABLE order-service 10/10 10 10 

Không có Pods bị CrashLoopBackOff, OOMKilled hoặc liên tục restart.

Kubernetes Service

Service vẫn tồn tại và EndpointSlices chứa đầy đủ 10 backend endpoints đủ điều kiện phục vụ traffic.

Cluster Resources

Các worker Nodes vẫn còn CPU và Memory còn trống. Không ghi nhận tình trạng Node resource exhaustion ở cấp cluster.

Application Logs

Không phát hiện lỗi ứng dụng phổ biến như database connection failure, unhandled exception hoặc process crash.

Tuy nhiên, API Gateway tiếp tục ghi nhận các RPC calls kết thúc với trạng thái DEADLINE_EXCEEDED.

3.5. The Unexpected Behavior

Kết quả kiểm tra ban đầu cho thấy một điều bất thường:

Kubernetes đã mở rộng thành công số lượng Pods, nhưng traffic vẫn không được phân phối tương ứng với tài nguyên mới.

Một số câu hỏi quan trọng xuất hiện:

  1. Tại sao các Pods mới đã Ready nhưng hầu như không nhận request?
  2. Tại sao HPA tăng số replicas mà P99 latency vẫn cao?
  3. Liệu có vấn đề trong Kubernetes Service, EndpointSlice hoặc kube-proxy?
  4. Có phải một số TCP connections đang tiếp tục sử dụng những backend Pods cũ?
  5. Cơ chế HTTP/2 multiplexing của gRPC có liên quan đến hiện tượng này không?

Tại thời điểm này, chưa có đủ bằng chứng để kết luận root cause.

Để tìm ra nguyên nhân thực sự, chúng ta cần tiếp tục kiểm tra từ application metrics xuống network layer, đặc biệt là cách các gRPC channels, HTTP/2 connections và Kubernetes Service tương tác với nhau.

4. Investigation & Troubleshooting — Quá trình điều tra sự cố

Sau khi HPA mở rộng Order Service từ 3 lên 10 Pods, hệ thống vẫn ghi nhận P99 latency cao và nhiều gRPC calls bị timeout.

Điều đáng chú ý là các thành phần Kubernetes đều có vẻ hoạt động bình thường. Không có Pod nào bị crash, tài nguyên cluster vẫn còn trống và Deployment đã đạt trạng thái mong muốn.

Vì vậy, thay vì tiếp tục tăng số lượng replicas, chúng ta cần kiểm tra từng thành phần để xác định chính xác traffic đang bị ảnh hưởng ở đâu.

4.1. Kiểm tra HPA và trạng thái Deployment

Giả thuyết đầu tiên là HPA không scale đúng thời điểm hoặc các Pods mới chưa sẵn sàng xử lý request.

Kiểm tra Deployment và HPA:

kubectl get deployment order-service kubectl get pods -l app=order-service -o wide kubectl describe hpa order-service 

Kết quả mô phỏng:

NAME READY UP-TO-DATE AVAILABLE order-service 10/10 10 10 NAME REFERENCE TARGETS MINPODS MAXPODS REPLICAS order-service Deployment/order-service 43%/60% 3 10 10 

HPA đã tăng số lượng replicas thành công. CPU utilization trung bình tại thời điểm kiểm tra cũng đã giảm xuống dưới target 60%.

Tuy nhiên, latency vẫn cao và một số Pods vẫn gần như không nhận request.

Điều này cho thấy việc tăng số lượng Pods đã hoàn thành, nhưng không đồng nghĩa workload được phân phối hiệu quả đến các Pods mới.

4.2. Kiểm tra Service và EndpointSlice

Giả thuyết tiếp theo là Kubernetes Service chưa cập nhật đầy đủ danh sách backend endpoints sau khi scaling.

Kiểm tra Service:

kubectl get svc order-service -o yaml 

Sau đó kiểm tra EndpointSlices:

kubectl get endpointslices \ -l kubernetes.io/service-name=order-service \ -o yaml 

Trong kịch bản mô phỏng, kết quả cho thấy cả 10 Pod IP đều xuất hiện trong các EndpointSlices, với trạng thái ready: true.

Điều đó có nghĩa Kubernetes control plane đã nhận diện những Pods mới là các backend đủ điều kiện nhận traffic.

Tuy nhiên, EndpointSlice chỉ phản ánh danh sách backend và trạng thái của chúng. Nó không cho biết lượng traffic thực tế đang được chuyển đến mỗi endpoint, cũng không chứng minh toàn bộ network dataplane hoạt động chính xác.

Chúng ta cần tiếp tục kiểm tra ở application layer.

4.3. Phân tích Resource Utilization và Request Distribution

Từ các chỉ số ban đầu, chúng ta biết rằng Pod A đang nhận khoảng 3.400 RPS, trong khi bảy Pods mới cộng lại chỉ nhận khoảng 40 RPS.

Để kiểm tra mức độ chênh lệch, có thể sử dụng:

kubectl top pods -l app=order-service 

Kết hợp với Prometheus và Grafana, chúng ta cần theo dõi ít nhất ba nhóm metrics:

  • RPC Rate per Pod: Số RPC thực sự được xử lý bởi từng Pod.
  • CPU Utilization per Pod: Mức sử dụng CPU tương ứng với workload.
  • RPC Latency & Error Rate: Phân phối thời gian phản hồi và tỷ lệ DEADLINE_EXCEEDED.

Một ví dụ PromQL, với điều kiện ứng dụng đã instrument metric grpc_server_started_total và có label pod:

sum by (pod) ( rate(grpc_server_started_total{ job="order-service" }[2m]) ) 

Kết quả quan sát cho thấy những Pods có tỷ lệ RPC cao cũng có CPU utilization và latency cao hơn đáng kể.

Trong khi đó, các Pods mới vẫn có mức sử dụng tài nguyên rất thấp.

Điều này giúp thu hẹp phạm vi điều tra: vấn đề không chỉ nằm ở tổng tài nguyên cluster mà còn liên quan đến sự phân phối workload giữa các backend Pods.

4.4. Loại trừ các nguyên nhân từ Application và Database

Một khả năng khác là Order Service đang gặp bottleneck ở database hoặc một dependency bên ngoài.

Các vấn đề như slow queries, connection pool exhaustion hoặc lock contention đều có thể khiến latency tăng dù Kubernetes vẫn hoạt động bình thường.

Vì vậy, chúng ta tiếp tục kiểm tra:

  • Database query latency và số lượng active connections.
  • Application errors và thời gian xử lý RPC.
  • CPU throttling và memory pressure.
  • Số lượng requests đang xử lý đồng thời trên từng Pod.

Trong kịch bản này, không phát hiện database bottleneck hoặc lỗi ứng dụng chung có thể giải thích sự chênh lệch traffic giữa các Pods.

Tuy nhiên, điều đáng chú ý là các requests chậm chủ yếu xuất hiện trên những Pods đang nhận lượng traffic lớn.

Điều này đặt ra một giả thuyết mới: có thể vấn đề không xuất phát từ khả năng mở rộng của Kubernetes, mà từ cách các request được định tuyến đến backend Pods.

4.5. Kiểm tra gRPC Connections

Chúng ta quay lại kiến trúc ban đầu.

API Gateway giao tiếp với Order Service thông qua gRPC trên HTTP/2 và sử dụng long-lived connections để tránh phải thiết lập kết nối mới cho mỗi RPC.

Ở bước này, cần kiểm tra số lượng TCP connections thực tế từ Gateway đến Order Service.

Trong network namespace của Gateway Pod, có thể sử dụng công cụ như:

ss -tn | grep ':50051' 

Lệnh này giúp quan sát các TCP connections đang tồn tại tới port 50051. Nếu container không có công cụ ss, có thể sử dụng một debugging container phù hợp.

Một điểm cần lưu ý: khi kết nối qua ClusterIP, thông tin destination mà ứng dụng nhìn thấy có thể chỉ là Service IP. Vì vậy, để xác định chính xác backend Pod được lựa chọn, cần đối chiếu thêm thông tin connection ở phía server hoặc NAT/conntrack trên Node.

Ở bước này, giả sử chúng ta ghi nhận:

  • Gateway duy trì một số ít TCP connections có thời gian tồn tại dài.
  • Lượng RPC trên mỗi connection không đồng đều.
  • Phần lớn RPC được xử lý bởi một vài Pods đã tồn tại trước khi scaling.
  • Những Pods mới chỉ nhận traffic từ một số kết nối mới được thiết lập sau đó.

Các quan sát trên làm xuất hiện một hướng điều tra đáng chú ý:

Liệu Kubernetes Service đang phân phối TCP connections, trong khi gRPC lại truyền hàng nghìn RPC calls trên chính những connections đó?

Nếu đúng, việc bổ sung Pods có thể không tác động đến các connections đang tồn tại.

Để hiểu rõ giả thuyết này, chúng ta cần phân tích cách gRPC, HTTP/2 và Kubernetes Service xử lý traffic ở những network layers khác nhau.

5. Technical Deep Dive — Understanding the Hidden Load Balancing Behavior

Qua quá trình troubleshooting, chúng ta đã xác định được một điểm bất thường: Kubernetes đã scale Order Service từ 3 lên 10 Pods, tất cả endpoints đều ở trạng thái Ready, nhưng phần lớn traffic vẫn tập trung vào những Pods cũ.

Nếu tài nguyên đã được bổ sung và Service cũng nhận diện đầy đủ các backend, tại sao những Pods mới gần như không được sử dụng?

Để hiểu điều này, chúng ta cần nhìn lại cách một gRPC call di chuyển từ API Gateway đến Order Service, đặc biệt là mối quan hệ giữa HTTP/2 connections và cơ chế Load Balancing của Kubernetes.

5.1. gRPC và HTTP/2: Khi nhiều Requests chia sẻ một Connection

Trong kiến trúc đang xét, API Gateway giao tiếp với Order Service thông qua gRPC trên HTTP/2.

Một đặc điểm quan trọng của HTTP/2 là multiplexing, cho phép nhiều requests được truyền đồng thời qua những streams riêng biệt trên cùng một TCP connection.

Thay vì thiết lập connection mới cho mỗi RPC, gRPC client thường tái sử dụng các channels và những transport connections bên dưới nhằm giảm chi phí thiết lập kết nối, đồng thời cải thiện hiệu năng giao tiếp giữa các services.

Ví dụ, ba lời gọi RPC độc lập có thể cùng sử dụng một TCP connection:

 API Gateway | gRPC Channel | TCP Connection | +----------+----------+ | | | HTTP/2 HTTP/2 HTTP/2 Stream 1 Stream 2 Stream 3 | | | RPC A RPC B RPC C 

Mặc dù RPC A, B và C là những lời gọi độc lập ở application layer, chúng vẫn chia sẻ cùng một kết nối TCP ở transport layer.

Một gRPC channel có thể quản lý một hoặc nhiều HTTP/2 connections tùy implementation và cấu hình. Tuy nhiên, trong kịch bản này, API Gateway duy trì một số ít long-lived connections đến Order Service.

Điều đó có nghĩa hàng nghìn RPC mỗi giây có thể được truyền qua một số lượng TCP connections tương đối nhỏ.

Về mặt hiệu năng, connection reuse là một cơ chế hữu ích. Nhưng vấn đề bắt đầu xuất hiện khi những connections này được chuyển tiếp qua Kubernetes Service ở Layer 4.

Nếu Kubernetes lựa chọn backend dựa trên TCP connection, liệu hàng nghìn RPC nằm bên trong cùng connection có được phân phối đến những Pods khác nhau?

Để trả lời, chúng ta cần xem Kubernetes Service thực sự xử lý traffic như thế nào.

5.2. Kubernetes Service: Backend được lựa chọn ở đâu?

Trong hệ thống này, API Gateway truy cập Order Service thông qua một Kubernetes Service loại ClusterIP.

Service cung cấp một địa chỉ IP ổn định, trong khi các backend Pods có những địa chỉ IP riêng.

Ví dụ:

Kubernetes Service: 10.96.0.50:50051 Backend Pods: Pod A: 10.244.1.10:50051 Pod B: 10.244.2.20:50051 Pod C: 10.244.3.30:50051 

Khi API Gateway thiết lập một TCP connection đến 10.96.0.50:50051, traffic được xử lý bởi networking dataplane của Kubernetes.

Với kube-proxy ở chế độ iptables như trong kịch bản này, kube-proxy cấu hình các quy tắc Netfilter để lựa chọn backend và chuyển đổi địa chỉ đích thông qua Destination Network Address Translation (DNAT).

Giả sử connection đầu tiên được lựa chọn chuyển đến Pod A:

 API Gateway | TCP Connection | v 10.96.0.50:50051 (ClusterIP) | Backend Selection | DNAT | v 10.244.1.10:50051 (Pod A) 

Ở chế độ iptables thông thường, nếu không có chính sách đặc biệt như session affinity, backend có thể được lựa chọn ngẫu nhiên trong số những endpoints đủ điều kiện.

Sau khi connection được thiết lập, Linux conntrack duy trì thông tin NAT mapping để những packets tiếp theo thuộc cùng connection tiếp tục được chuyển đến backend đã chọn.

Vấn đề nằm ở đây: Kubernetes Service không phân tích nội dung HTTP/2 để lựa chọn lại backend cho từng gRPC call.

Một khi TCP connection đã được ánh xạ đến Pod A, các HTTP/2 streams truyền trên connection đó cũng tiếp tục đi đến Pod A.

Chúng ta có thể phân biệt hai cơ chế:

  • Connection-level Load Balancing (Layer 4): Backend được lựa chọn dựa trên network connection hoặc flow.
  • Request-level Load Balancing (Layer 7): Một proxy có khả năng hiểu giao thức ứng dụng có thể lựa chọn backend cho từng HTTP request hoặc RPC mới.

Trong trường hợp này, Kubernetes ClusterIP Service đang thực hiện connection-level Load Balancing.

Vì vậy, việc phân phối TCP connections không đồng nghĩa với phân phối đều gRPC calls.

Đây chính là điểm liên kết giữa hành vi HTTP/2 multiplexing ở phía ứng dụng và sự mất cân bằng traffic mà chúng ta quan sát được.

5.3. Tại sao Scaling không phân phối lại Workload?

Quay lại sự cố ban đầu.

Trước khi scaling, Order Service có 3 Pods. API Gateway đã thiết lập một số long-lived TCP connections đến Service và những connections đó được ánh xạ tới các backend hiện có.

Ví dụ:

Before Scaling API Gateway | +---- Connection 1 ----> Pod A | +---- Connection 2 ----> Pod A | +---- Connection 3 ----> Pod B | +---- Connection 4 ----> Pod C 

Khi traffic tăng, HPA bắt đầu mở rộng Deployment từ 3 lên 10 Pods.

Các Pods mới lần lượt được khởi tạo, vượt qua readiness checks và được bổ sung vào EndpointSlices. Lúc này, Kubernetes đã nhận diện thêm 7 backend đủ điều kiện nhận traffic.

Tuy nhiên, việc cập nhật danh sách endpoints không làm thay đổi NAT mappings của những TCP connections đang hoạt động.

Nếu API Gateway tiếp tục tái sử dụng các connections cũ, phần lớn RPC vẫn được chuyển đến những backend đã được lựa chọn trước khi scaling.

After Scaling API Gateway | +---- Connection 1 ----> Pod A | +---- Connection 2 ----> Pod A | +---- Connection 3 ----> Pod B | +---- Connection 4 ----> Pod C New Available Backends: Pod D Pod E Pod F Pod G Pod H Pod I Pod J Ready, but not used by existing connections 

Những Pods mới có thể được lựa chọn khi các TCP connections mới được thiết lập. Tuy nhiên, nếu số lượng connections mới không đáng kể so với traffic đang chạy trên các connections cũ, sự mất cân bằng có thể tiếp tục tồn tại.

Để hiểu rõ hơn, chúng ta cần phân biệt số lượng connections và lượng RPC được truyền trên mỗi connection.

Giả sử mỗi connection có một RPC rate riêng. Tổng RPC rate của Pod i có thể biểu diễn bằng:

RPSi​=c∈Ci​∑​λc​

Trong đó:

  • RPS_i: Tổng số RPC/giây đến Pod i.
  • C_i: Tập hợp TCP connections được ánh xạ đến Pod i.
  • λ_c: Số RPC/giây được truyền trên connection c.

Công thức này cho thấy lượng traffic mà một Pod nhận được phụ thuộc vào cả số connections và lượng RPC trên từng connection.

Example: RPC Distribution after Scaling

Giả sử sau khi Deployment scale từ 3 lên 10 Pods, API Gateway đang duy trì 5 TCP connections với lượng RPC trên mỗi connection như sau:

TCP Connection Backend RPC/s
Connection 1 Pod A 1.800
Connection 2 Pod A 1.600
Connection 3 Pod B 1.300
Connection 4 Pod C 260
Connection 5 (mới) Pod D 40
Total 5.000

Tổng RPC rate của Pod i được tính bằng:

RPSi​=c∈Ci​∑​λc​

Áp dụng công thức cho Pod A:

RPSA​=λ1​+λ2​
RPSA​=1800+1600=3400

Trong khi đó, nếu 5.000 RPC/giây được phân phối đồng đều giữa 10 Pods, lượng traffic lý tưởng trên mỗi Pod sẽ là:

RPSideal​=105000​=500

Mức độ chênh lệch giữa traffic thực tế của Pod A và mức phân phối lý tưởng:

RPSideal​RPSA​​=5003400​=6.8

Như vậy, mặc dù Deployment đã có 10 Pods, Pod A vẫn nhận lượng RPC cao gấp 6,8 lần mức phân phối lý tưởng, trong khi 7 Pods mới cộng lại chỉ nhận 0,8% tổng traffic.

Điều này có thể xảy ra vì hai TCP connections đang được ánh xạ đến Pod A mang phần lớn RPC traffic của hệ thống.

Các con số này phù hợp với giả thuyết rằng phần lớn RPC vẫn đang sử dụng những long-lived connections được thiết lập trước khi scaling.

Equal Connections ≠ Equal Requests ≠ Equal Workload.

Điều quan trọng là Kubernetes không cố tình ưu tiên những Pods cũ. Các connections hiện tại đơn giản là vẫn sử dụng backend đã được lựa chọn từ trước.

Kubernetes đã tạo thêm Pods, nhưng các connections cũ vẫn tiếp tục gửi RPC đến những backend ban đầu.

5.4. HPA đã Scale thành công, vậy tại sao vấn đề vẫn tồn tại?

Đến đây, chúng ta đã hiểu tại sao traffic có thể tiếp tục tập trung vào một số backend. Nhưng điều gì khiến HPA không thể tự giải quyết tình trạng này?

Horizontal Pod Autoscaler chịu trách nhiệm điều chỉnh số lượng replicas dựa trên những metrics được cấu hình, chẳng hạn CPU utilization.

Với CPU utilization target, công thức cơ bản của HPA là:

DesiredReplicas=⌈CurrentReplicas×TargetUtilizationCurrentUtilization​⌉

Nói một cách đơn giản, HPA so sánh mức sử dụng tài nguyên hiện tại với mục tiêu, từ đó tính toán số replicas mong muốn.

Example: HPA Scaling Calculation

Quay lại thời điểm trước khi Order Service được scale từ 3 lên 10 Pods.

Giả sử tại thời điểm traffic tăng cao, hệ thống có các thông số sau:

Parameter Value
Current Replicas 3
CPU Request per Pod 200m
Average CPU Usage per Pod 400m
Target CPU Utilization 60%
Minimum Replicas 3
Maximum Replicas 10

Đầu tiên, HPA xác định CPU utilization hiện tại dựa trên tỷ lệ giữa CPU usage và CPU request:

CPUutilization​=200400​×100=200%

Lưu ý rằng CPU utilization đạt 200% không có nghĩa Pod sử dụng 200% CPU vật lý. Đây là mức sử dụng CPU tương đối so với CPU request đã được cấu hình.

Sau đó, HPA sử dụng công thức cơ bản để tính số replicas mong muốn:

Related posts