Kiedy należy używać narzędzia Horizontal Pod Autoscaling (HPA) na platformie Kubernetes?

Krótka odpowiedź: Użyj HPA, gdy Twoja aplikacja może działać w wielu identycznych replikach, a zapotrzebowanie się waha — skaluj na podstawie użycia CPU/pamięci, metryk aplikacji (RPS/latencji) lub zewnętrznych metryk kolejki/zaległości. Nie stosuj HPA w przypadku usług stanowych z jedną repliką ani wtedy, gdy rzeczywistym wąskim gardłem jest wydajność węzła lub ograniczenia po stronie systemów zależnych (połączenia z bazą danych, limity liczby żądań usług zewnętrznych).

TL;DR:

  • Używaj HPA w przypadku obciążeń, które można skalować poziomo, gdy metryki dla poszczególnych zasobników lub metryki zewnętrzne odzwierciedlają obciążenie.
  • Użyj metryk zasobów/niestandardowych/zewnętrznych (CPU, RPS, długość kolejki); połącz z Cluster Autoscaler, aby skalować pojemność węzłów.
  • Użyj KEDA do skalowania do zera sterowanego zdarzeniami lub z zewnętrznymi skalerami; użyj VPA w trybie rekomendacji do doboru wartości requests.

Lista kontrolna szybkiej decyzji (Tak/Nie):

  • Czy obciążenie jest bezstanowe lub możliwe do partycjonowania w wielu replikach? (Tak → kandydata HPA)
  • Czy można obserwować obciążenie jako metrykę dla każdego poda lub metrykę zewnętrzną (CPU, żądania/s, głębokość kolejki)? (Tak → odpowiednie dla HPA)
  • Czy klaster może zaplanować więcej zasobników (skalowanie automatyczne klastra lub pojemność zapasową)? (Tak → kontynuować; jeśli nie, włącz skalowanie automatyczne węzłów)
  • Czy usługi podrzędne (pule baz danych, interfejsy API innych firm) ograniczają współbieżność? (Tak → dodać ograniczanie przepustowości/buforowanie połączeń lub preferować skalowanie w pionie)

Macierz decyzyjna (obciążenie → najlepsza metryka → zalecany skaler):

Typ obciążenia Najlepsza metryka docelowa Zalecany skaler
Web/API (bezstanowe) CPU lub RPS na pod HPA (+zalecenie dotyczące VPA + Cluster Autoscaler)
Proces obsługi kolejki w tle Długość kolejki lub komunikaty na sekundę HPA za pośrednictwem metryk zewnętrznych lub KEDA (KEDA obsługuje skalowanie do zera)
Baza danych z jedną instancją lub aplikacja stanowa Nie dotyczy (nie można partycjonować poziomo) VPA lub skalowanie ręczne
Procesy robocze zdarzeń wsadowych/efemerycznych Zaległości zdarzeń KEDA lub HPA z metrykami zewnętrznymi

Jak działa hpa (prosta pętla sterowania i ważne pola)

  • Składniki: kontroler HPA (płaszczyzna sterowania) + dostawcy metryk (metrics-server dla metryk zasobów, API metryk niestandardowych/zewnętrznych za pośrednictwem adapterów lub KEDA).
  • Pętla sterowania (ogólny schemat): kontroler HPA odpytuje interfejs API metryk → oblicza `desiredReplicas` na podstawie każdej skonfigurowanej metryki → wybiera największą obliczoną wartość `desiredReplicas` → stosuje wartości minimalne/maksymalne oraz reguły działania (polityki/stabilizacja) → aktualizuje `spec.replicas` w zasobie docelowym → powtarza. Szczegółowe informacje można znaleźć w dokumentacji rozwiązania Kubernetes HPA .
  • Formuła (w jaki sposób obliczana jest docelowa liczba replik): desiredReplicas = ceil(current_total / target_per_pod). Kontroler oblicza żądaną liczbę replik dla każdej skonfigurowanej metryki, a następnie wybiera największą wartość przed zastosowaniem ograniczeń minimum/maksimum oraz reguł zachowania (ta zasada pierwszeństwa metryk jest udokumentowana w dokumentacji HPA).
  • Ważne pola autoscaling/v2: minReplicas, maxReplicas, metrics (Resource, Pods, Object, External), behavior (zasady scaleUp/scaleDown i stabilizationWindowSeconds).
  • Użyj parametru behavior, aby ograniczyć szybkość zmian i uniknąć oscylacji; parametr stabilizationWindowSeconds jest kluczowy dla wygładzania skalowania w dół.

Przykładowy fragment kodu zachowania (autoskalowanie/wersja 2)

behavior:
  scaleUp:
    stabilizationWindowSeconds: 0
    policies:
      - type: Percent
        value: 100
        periodSeconds: 60
  scaleDown:
    stabilizationWindowSeconds: 300
    policies:
      - type: Pods
        value: 1
        periodSeconds: 60

Kiedy używać HPA (według typu metryk / typowe przypadki użycia)

  1. Procesor/pamięć (metryki zasobów)
    • Użyj HPA, gdy wykorzystanie CPU lub pamięci dla każdego poda jest skorelowane z zapotrzebowaniem na zasoby, a pody mają poprawnie zdefiniowane żądania zasobów. Typowe dla internetowych API i bezstanowych mikrousług.
    • Praktyczny punkt wyjścia: ustaw docelowe średnie wykorzystanie CPU w zakresie 60–80% i dostosuj je na podstawie testów obciążeniowych. HPA oblicza wykorzystanie na podstawie żądań podów, więc należy ustawić żądania.
  2. Niestandardowe metryki wewnątrz klastra (Prometheus / metryki niestandardowe)
    • Używaj funkcji HPA, gdy sygnały na poziomie aplikacji (żądania/s, opóźnienie, odbiorcy kolejki/zasobnik) lepiej reprezentują obciążenie niż procesor CPU.
    • Udostępniaj metryki za pomocą Prometheus + prometheus-adapter (custom.metrics.k8s.io) lub innego dostawcy metryk niestandardowych i wykorzystuj te metryki jako cele w HPA.
  3. Metryki zewnętrzne (kolejki, zaległości w chmurze)
    • Użyj HPA (za pośrednictwem interfejsu API metryk zewnętrznych) lub KEDA, gdy skalowanie powinno odbywać się na podstawie sygnałów zewnętrznych, takich jak długość kolejki (RabbitMQ, Azure Service Bus), Event Hubs lub metryki monitorowania w chmurze.
    • Jeśli potrzebujesz zachowania opartego na zdarzeniach skalowalnego do zera lub ścisłego, preferuj KEDA — natywnie integruje zewnętrzne moduły skalowania i obsługuje skalowanie do zera (dokumentacja KEDA).

Kiedy NIE należy używać HPA

  • Usługi stanowe z jedną repliką (bazy danych, stan unikatowy w zasobniku): HPA nie jest odpowiednia, chyba że można bezpiecznie podzielić na fragmenty/partycje.
  • Gdy wąskie gardło występuje na poziomie węzła (GPU, operacje we/wy dysku, CPU węzła), a nie na poziomie pojedynczego poda, należy preferować automatyczne skalowanie puli węzłów lub skalowanie w pionie.
  • Gdy systemy podrzędne (pule połączeń bazy danych, pamięci podręczne, interfejsy API innych firm) mają ścisłe limity współbieżności: skalowanie zasobników bez zwiększania pojemności podrzędnej może pogorszyć awarie — zobacz sekcję "Zagadnienia podrzędne i operacyjne" poniżej.
  • Jeśli potrzebujesz skalowania do zera, samo HPA tego nie zapewni; użyj KEDA lub zewnętrznego kontrolera.

Wiele metryk, pierwszeństwa i przykład

  • Jeśli skonfigurujesz wiele metryk, kontroler HPA oblicza wartość desiredReplicas dla każdej metryki niezależnie, a następnie wybiera największą wartość desiredReplicas jako podstawę skalowania. Następnie są stosowane zasady minReplicas/maxReplicas i zachowania (źródło: Dokumentacja rozwiązania Kubernetes HPA).
  • Przykład: wartość docelowa użycia CPU daje 5 replik, a wartość docelowa żądań/s daje 12 replik → HPA wybierze 12 (następnie limity min/max i zasady skalowania mogą zmodyfikować ostatecznie zastosowaną zmianę).
  • Aby uniknąć gwałtownego przeskalowania, połącz politykę scaleUp opartą na wartości procentowej z rozsądnym parametrem scaleDown stabilizationWindowSeconds (zobacz fragment konfiguracji behavior powyżej).

HPA vs VPA vs Cluster Autoscaler vs KEDA (krótkie wskazówki)

  • HPA: skaluje repliki w poziomie na podstawie metryk. Najlepsze do obciążeń podlegających partycjonowaniu.
  • VPA: dostosowuje żądania/limity zasobów zasobnika (w pionie). Najlepsze do obciążeń, których nie da się zrównoleglić, lub do ustawienia sensownych wartości domyślnych.
  • Cluster Autoscaler (lub Karpenter): skaluje węzły, aby spełnić żądania harmonogramowania (pojemność na poziomie węzła). Użyj, gdy zasobniki pozostają w stanie Pending z powodu braku węzłów.
  • KEDA: autoskaler sterowany zdarzeniami, integrujący zewnętrzne wyzwalacze i obsługujący skalowanie do zera dla obciążeń opartych na zdarzeniach.

Typowy wzorzec: użyj VPA w trybie rekomendacji do ustalenia bazowych wartości żądań zasobów, HPA do skalowania liczby replik, a Cluster Autoscaler (lub Karpenter) do zapewnienia pojemności węzłów. Użyj KEDA, jeśli potrzebujesz skalowania do zera lub bezpośredniej integracji z zewnętrznymi źródłami zdarzeń.

Uwaga: zarządzane oferty platformy Kubernetes (AKS/GKE/EKS) mogą wstępnie instalować dostawców metryk lub udostępniać zintegrowane funkcje skalowania automatycznego. Dokumentacja narzędzia do automatycznego skalowania klastra usługi AKS


Dalsze kwestie i aspekty operacyjne (typowe pułapki)

  • Pule połączeń bazy danych: zwiększanie liczby replik zwiększa jednoczesne połączenia. Można temu zaradzić za pomocą pulowania połączeń (np. PgBouncer), ograniczenia współbieżności dla każdego zasobnika lub zwiększenia rozmiaru puli połączeń do bazy danych przed skalowaniem zasobników.
  • Limity szybkości API i limity usług zewnętrznych: upewnij się, że systemy zależne są w stanie obsłużyć wolumen żądań generowany przez skalowane pody; rozważ ograniczanie tempa żądań po stronie klienta.
  • PodDisruptionBudgets (PDB): pliki PDB nie uniemożliwiają skalowania hpa w górę, ale mogą mieć wpływ na operacje konserwacji i zachowanie opróżniania; upewnij się, że zasady skalowania są zgodne z plikami PDB.
  • Efekty uruchamiania i rozgrzewania: initContainers, wstępne wypełnianie pamięci podręcznej lub długie zimne starty mogą zniekształcać metryki i powodować oscylacje — użyj sond gotowości i startowych oraz okien stabilizacji.
  • Zalecane podejście operacyjne: ustawić konserwatywne współczynniki skalowania, dostosować wartości requests/limits i sondy, przetestować w środowisku nieprodukcyjnym oraz dodać ograniczanie przepustowości uwzględniające cele SLO, jeśli systemy zależne są wąskim gardłem.

Lista kontrolna konfiguracji i bezpieczne kroki wdrażania

Zapewnij metryki i RBAC:

  • Wdróż serwer metryk dla metryk zasobów (lub użyj dostawcy zarządzanego).
  • W razie potrzeby wdroż Prometheus + prometheus-adapter do obsługi metryk niestandardowych (custom.metrics.k8s.io).
  • W przypadku zewnętrznych skalerów lub skalerów zdarzeń rozważ użycie KEDA.

Zapisywanie obliczeń HPA (skalowanie automatyczne/wersja 2) przy użyciu:

  • minReplicas i maxReplicas,
  • jawne metryki i zachowanie (zasady scaleUp/scaleDown),
  • sondy gotowości i startowe na podach,
  • rozsądne żądania zasobów, dzięki czemu metryki zasobów są istotne.

Lista kontrolna bezpiecznego testowania (jak bezpiecznie przetestować aplikację HPA):

  1. Przetestuj w nieprodukcyjnej przestrzeni nazw lub klastrze o podobnych rozmiarach węzłów i z włączonym autoskalowaniem.
  2. Zacznij od konserwatywnej minimalnej i maksymalnej liczby replik oraz łagodnych zasad skalowania w górę (np. wzrost o maksymalnie 100% na minutę).
  3. Przeprowadzaj stopniowe testy obciążeniowe, monitoruj parametry desiredReplicas oraz currentReplicas, a także pody w stanie Pending.
  4. Iterowanie żądań/limitów, sond gotowości i zasad zachowania przed zwiększeniem agresywności.

Uwagi dotyczące usługi AKS i automatycznego skalowania węzłów:

  • AKS i inne oferty chmurowe mogą mieć preinstalowany komponent metrics-server lub oferować integrację z zarządzanym automatycznym skalowaniem. Przykładowy interfejs wiersza polecenia usługi AKS umożliwiający automatyczne skalowanie klastra: az aks nodepool update --resource-group myRG --cluster-name myAKS --name node-pool1 --enable-cluster-autoscaler --min-count 1 --max-count 5

Uwaga dotycząca Karpenter: Karpenter jest alternatywnym sposobem automatycznego skalowania węzłów, ukierunkowanym na szybkie prowizjonowanie; warto rozważyć to rozwiązanie, gdy wymagane jest szybkie prowizjonowanie węzłów.


Działające przykłady YAML

HpA oparte na procesorze CPU (skalowanie automatyczne/wersja 2):

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: webapi-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: webapi
  minReplicas: 3
  maxReplicas: 12
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 60
  behavior:
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Pods
          value: 1
          periodSeconds: 60

HPA korzystająca z niestandardowej metryki udostępnianej przez Prometheus (za pośrednictwem prometheus-adapter):

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: api-requests-hpa
  namespace: production
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: api
  minReplicas: 2
  maxReplicas: 20
  metrics:
    - type: Pods
      pods:
        metric:
          name: http_requests_per_second
        target:
          type: AverageValue
          averageValue: "100"

Zobacz dokumentację prometheus-adapter , aby uzyskać informacje o zapytaniach mapowania

KEDA ScaledObject (Azure Service Bus) — obsługuje skalowanie do zera:

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: sb-queue-scaledobject
  namespace: workers
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: event-worker
  minReplicaCount: 0
  maxReplicaCount: 20
  pollingInterval: 30
  cooldownPeriod: 300
  triggers:
    - type: azure-servicebus
      metadata:
        queueName: orders-queue
        queueLength: "50"
      authenticationRef:
        name: keda-azure-credentials

Dokumentacja usługi KEDA


Obserwowalność, alerty i przykłady SRE

Sugerowane alerty (przykłady z możliwością kopiowania rozwiązania Prometheus — dostosowywanie nazw metryk do konfiguracji eksportu):

  1. Alert, gdy docelowa wartość HPA > bieżąca przez > 5 min (problem z pojemnością harmonogramowania)

    alert: HPAUnschedulable
    expr: (kube_hpa_status_desired_replicas - kube_hpa_status_current_replicas) > 0
    for: 5m
    labels:
      severity: page
    annotations:
      summary: "HPA desired replicas exceed current replicas for >5m (possible scheduling issue)"
    
  2. Alert dotyczący oczekujących zasobników w przestrzeni nazw

    alert: PodsPendingHigh
    expr: sum(kube_pod_status_phase{phase="Pending", namespace="production"}) > 3
    for: 2m
    labels:
      severity: ticket
    annotations:
      summary: "High number of Pending pods in production"
    
  3. Alert dotyczący częstego skalowania (flapping)

    alert: HPAFlapping
    expr: increase(kube_hpa_status_replicas_last_transition_count[10m]) > 5
    for: 0m
    labels:
      severity: warning
    annotations:
      summary: "Frequent HPA scaling events detected"
    

Tablice przyrządów pokazujące:

  • HPA: currentReplicas, desiredReplicas, lastScaleTime, wartości metryk używane przez HPA
  • Stan zasobników: zasobniki w stanie oczekiwania, zdarzenia FailedScheduling, liczba restartów zasobników
  • Usługi podrzędne: wykorzystanie połączeń z bazą danych, współczynniki błędów, współczynniki błędów zewnętrznego interfejsu API / odpowiedzi 429

Polecenia operacyjne i debugowania (krótki przewodnik)

  • Wyświetl HPAs: kubectl get hpa -n
  • Opisz HPA (sprawdź bieżące/aktualne metryki, desiredReplicas, lastScaleTime, events): kubectl describe hpa -n
  • Pola do sprawdzenia w danych wyjściowych polecenia describe: currentReplicas, desiredReplicas, metryki (bieżące/docelowe wartości), lastScaleTime, zdarzenia (błędy od dostawcy metryk lub niepowodzenia skalowania)
  • Wyświetlanie użycia zasobów (wymaga metryk serwera): kubectl top pods -n
  • Sprawdź oczekujące zasobniki i błędy planowania: kubectl get pods -n | grep Pending, kubectl describe pod -n (poszukaj elementu FailedScheduling)
  • Sprawdź dzienniki dostawcy metryk: kubectl logs -n kube-system deploy/metrics-server, kubectl logs -n deploy/prometheus-adapter
  • Zastosuj manifest HPA: kubectl apply -f hpa.yaml

Porady dotyczące szybkiego rozwiązywania problemów:

  • HPA zgłasza desiredReplicas > currentReplicas, a pody pozostają w stanie Pending → prawdopodobnie niewystarczające zasoby węzłów; włącz Cluster Autoscaler lub zwiększ pulę węzłów.
  • HPA pokazuje w zdarzeniach błędy związane z metrykami → sprawdź RBAC/konfigurację adaptera oraz dzienniki dostawcy metryk.
  • Skalowanie HPA jest zbyt szybkie/wolne → dostroić polityki zachowania (limity procentowe/liczby zasobników) oraz okna stabilizacji.

  • Docelowy poziom wykorzystania CPU: zacznij od około 60% średniego wykorzystania (typowy zakres 60–80%) i dostosuj w zależności od obciążenia.
  • minReplicas: co najmniej 1 w celu zapewnienia dostępności; użyj KEDA, jeśli potrzebujesz minReplicas: 0.
  • maxReplicas: ustaw na podstawie planowania pojemności i kosztów; upewnij się, że limity skalowania automatycznego klastra zezwalają na dodawanie węzłów do wymaganej pojemności.
  • stabilizationWindowSeconds: scaleDown ≈ 300 s (5 min) to częsty punkt wyjścia, aby uniknąć zbyt szybkiego skalowania w dół; dostosuj w zależności od obciążenia.
  • zasady skalowania: ogranicz procentowy wzrost w danym okresie (np. maksymalnie 100% wzrostu na minutę), aby uniknąć przeciążenia systemów podrzędnych.
  • Sondy gotowości i uruchamiania: zawsze je definiuj, aby pody nie otrzymywały ruchu, dopóki nie będą w pełni gotowe.

Uwaga: określone wartości domyślne chronometrażu kontrolera i dokładne zachowanie mogą się różnić w różnych wersjach i dystrybucjach platformy Kubernetes — sprawdź dokumenty HPA dotyczące wersji klastra


Typowe pułapki i lista kontrolna przed włączeniem HPA

  • Brak żądań zasobów dla Poda lub ich nieprawidłowa konfiguracja → cele HPA oparte na zasobach będą mylące.
  • Brak dostawcy metryk (metrics-server/prometheus-adapter/KEDA) → HPA nie może odczytać metryk.
  • Klaster nie ma dostępnych zasobów węzłów, a Cluster Autoscaler nie jest włączony → pody pozostaną w stanie Pending.
  • Łączenie HPA i VPA: unikaj sytuacji, w której oba kontrolery aktywnie zmieniają żądania zasobów — uruchom VPA w trybie rekomendacji, a skalowanie liczby replik pozostaw HPA.
  • Piki obciążenia podczas uruchamiania (initContainers, niezagrzane pamięci podręczne) przy braku sond → należy dostosować okna stabilizacji lub ręcznie rozgrzać instancje.
  • Nieprawidłowa konfiguracja RBAC: upewnij się, że adaptery metryk i kontroler HPA mają wymagane uprawnienia do odczytu metryk.

Szybkie często zadawane pytania

Pyt.: Jakie są zalety hpa? A: Automatycznie dostosuj liczbę replik do zmieniającego się obciążenia, popraw wykorzystanie zasobów i obniż koszty oraz utrzymuj docelowe opóźnienia przy użyciu odpowiednich metryk i autoskalowania węzłów.

P: W jaki sposób HPA oblicza liczbę żądanych replik? O: Odczytuje skonfigurowane metryki, oblicza desiredReplicas = ceil(current_total / target_per_pod) dla każdej metryki, przyjmuje największą obliczoną wartość, a następnie stosuje zasady min/maksimum i zachowania (źródło: dokumentacja HPA).

Pyt.: Czy HPA może skalować się do zera? A: Nie — zwykła HPA nie może skalować się do zera. Użyj KEDA do skalowania do zera (dokumentacja KEDA).

P: Jak skalować na podstawie długości kolejki lub RPS? A: Udostępnij długość kolejki/RPS jako metrykę zewnętrzną lub niestandardową (adapter Prometheus lub interfejs API metryk zewnętrznych) albo użyj KEDA do skalowania sterowanego zdarzeniami.


References