Sdílet prostřednictvím

Použití vertikálního automatického škálování podů ve službě Azure Kubernetes Service (AKS)

  • Článek

V tomto článku se dozvíte, jak používat vertikální automatické škálování podů (VPA) v clusteru Azure Kubernetes Service (AKS). VPA automaticky upraví požadavky na procesor a paměť pro vaše pody tak, aby odpovídaly vzorcům využití vašich úloh. Tato funkce pomáhá optimalizovat výkon aplikací a snížit náklady na provoz úloh v AKS.

Další informace najdete v přehledu vertikálního automatického škálování podů.

Než začnete

  • Pokud máte existující cluster AKS, ujistěte se, že používá Kubernetes verze 1.24 nebo vyšší.

  • Potřebujete nainstalovanou a nakonfigurovanou verzi Azure CLI 2.52.0 nebo novější. Verzi zjistíte spuštěním příkazu az --version. Pokud potřebujete instalaci nebo upgrade, přečtěte si téma Instalace Azure CLI.

  • Pokud povolíte VPA v existujícím clusteru, ujistěte se, že kubectl je nainstalovaný a nakonfigurovaný pro připojení ke clusteru AKS pomocí az aks get-credentials příkazu.

    az aks get-credentials --name <cluster-name> --resource-group <resource-group-name>

Nasazení vertikálního automatického škálování podů do nového clusteru

  • Pomocí příkazu s --enable-vpa příznakem vytvořte nový cluster AKS s povoleným az aks create analyzátorem VPA.

    az aks create --name <cluster-name> --resource-group <resource-group-name> --enable-vpa --generate-ssh-keys

    Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

Aktualizace existujícího clusteru tak, aby používal vertikální automatické škálování podů

  • Aktualizujte existující cluster tak, aby používal virtuálnípa pomocí az aks update příkazu s příznakem --enable-vpa .

    az aks update --name <cluster-name> --resource-group <resource-group-name> --enable-vpa

    Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

Zakázání vertikálního automatického škálování podů v existujícím clusteru

  • Pomocí příkazu s příznakem az aks update zakažte VPA v existujícím clusteru --disable-vpa .

    az aks update --name <cluster-name> --resource-group <resource-group-name> --disable-vpa

    Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

Testování instalace automatického škálování svislého podu

V následujícím příkladu vytvoříme nasazení se dvěma pody, z nichž každý spustí jeden kontejner, který požaduje 100 milicore a pokusí se využít mírně nad 500 milicores. Vytvoříme také konfiguraci VPA odkazující na nasazení. VPA sleduje chování podů a po přibližně pěti minutách aktualizuje pody tak, aby požadovaly 500 milicores.

  1. Vytvořte soubor s názvem hamster.yaml a zkopírujte v následujícím manifestu příkladu vertikálního automatického škálování podů z úložiště GitHub kubernetes/autoscaler :

    apiVersion: "autoscaling.k8s.io/v1"
kind: VerticalPodAutoscaler
metadata:
  name: hamster-vpa
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind: Deployment
    name: hamster
  resourcePolicy:
    containerPolicies:
      - containerName: '*'
        minAllowed:
          cpu: 100m
          memory: 50Mi
        maxAllowed:
          cpu: 1
          memory: 500Mi
        controlledResources: ["cpu", "memory"]
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: hamster
spec:
  selector:
    matchLabels:
      app: hamster
  replicas: 2
  template:
    metadata:
      labels:
        app: hamster
    spec:
      securityContext:
        runAsNonRoot: true
        runAsUser: 65534
      containers:
        - name: hamster
          image: registry.k8s.io/ubuntu-slim:0.1
          resources:
            requests:
              cpu: 100m
              memory: 50Mi
          command: ["/bin/sh"]
          args:
            - "-c"
            - "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"

  2. Pomocí příkazu nasaďte příklad vertikálního hamster.yaml automatického škálování podů kubectl apply .

    kubectl apply -f hamster.yaml

    Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

  3. Pomocí příkazu zobrazte spuštěné pody kubectl get .

    kubectl get pods -l app=hamster

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    hamster-78f9dcdd4c-hf7gk   1/1     Running   0          24s
hamster-78f9dcdd4c-j9mc7   1/1     Running   0          24s

  4. Pomocí příkazu zobrazte rezervace procesoru a paměti na jednom z podů kubectl describe . Nezapomeňte nahradit <example-pod> jedním z ID podů vrácených ve výstupu z předchozího kroku.

    kubectl describe pod hamster-<example-pod>

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

     hamster:
    Container ID:  containerd://
    Image:         k8s.gcr.io/ubuntu-slim:0.1
    Image ID:      sha256:
    Port:          <none>
    Host Port:     <none>
    Command:
      /bin/sh
    Args:
      -c
      while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    State:          Running
      Started:      Wed, 28 Sep 2022 15:06:14 -0400
    Ready:          True
    Restart Count:  0
    Requests:
      cpu:        100m
      memory:     50Mi
    Environment:  <none>

    Pod má v tomto příkladu rezervovaných 100 milicpu a 50 Mibibajtů paměti. Pro tuto ukázkovou aplikaci potřebuje pod ke spuštění méně než 100 milicpu, takže není k dispozici žádná kapacita procesoru. Pody také vyhradí méně paměti, než je potřeba. Nasazení vertikálního automatického škálování podů vpa-recommender analyzuje pody hostující aplikaci hamster a zjistí, jestli jsou vhodné požadavky na procesor a paměť. Pokud jsou potřeba úpravy, nástroj vpa-updater znovu zobrazí pody s aktualizovanými hodnotami.

  5. Monitorujte pody pomocí kubectl get příkazu.

    kubectl get --watch pods -l app=hamster

  6. Když se spustí nový pod hamster, můžete pomocí příkazu zobrazit aktualizované rezervace kubectl describe procesoru a paměti. Nezapomeňte nahradit <example-pod> jedním z ID podů vrácených ve výstupu z předchozího kroku.

    kubectl describe pod hamster-<example-pod>

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>

    V předchozím výstupu vidíte, že se rezervace procesoru zvýšila na 587 milicpu, což je více než pětkrát původní hodnota. Paměť se zvýšila na 262 144 kilobajtů, což je přibližně 250 Mibibajtů nebo pětkrát původní hodnota. Tento pod byl nedostatečně prostředků a vertikální automatické škálování podů opravilo odhad s mnohem vhodnější hodnotou.

  7. Pokud chcete popsat informace o prostředku hamster-vpa, zobrazte aktualizovaná doporučení z VPA pomocí kubectl describe příkazu.

    kubectl describe vpa/hamster-vpa

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

     State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>

Nastavení požadavků automatického škálování svislých podů

Objekt VerticalPodAutoscaler automaticky nastaví požadavky na prostředky na pody s příponou AutoupdateMode . V závislosti na vašich požadavcích a testování můžete nastavit jinou hodnotu. V tomto příkladu vytvoříme a otestujeme manifest nasazení se dvěma pody, každý spustí kontejner, který požaduje 100 miliCPU a 50 MiB paměti a nastaví updateMode na Recreate.

  1. Vytvořte soubor s názvem azure-autodeploy.yaml a zkopírujte ho v následujícím manifestu:

    apiVersion: apps/v1
kind: Deployment
metadata:
  name: vpa-auto-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: vpa-auto-deployment
  template:
    metadata:
      labels:
        app: vpa-auto-deployment
    spec:
      containers:
      - name: mycontainer
        image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
        resources:
          requests:
            cpu: 100m
            memory: 50Mi
        command: ["/bin/sh"]
        args: ["-c", "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"]

  2. Vytvořte pod pomocí kubectl create příkazu.

    kubectl create -f azure-autodeploy.yaml

    Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

  3. Pomocí příkazu zobrazte spuštěné pody kubectl get .

    kubectl get pods

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    NAME                                   READY   STATUS    RESTARTS   AGE
vpa-auto-deployment-54465fb978-kchc5   1/1     Running   0          52s
vpa-auto-deployment-54465fb978-nhtmj   1/1     Running   0          52s

  4. Vytvořte soubor s názvem azure-vpa-auto.yaml a zkopírujte ho v následujícím manifestu:

    apiVersion: autoscaling.k8s.io/v1
kind: VerticalPodAutoscaler
metadata:
  name: vpa-auto
spec:
  targetRef:
    apiVersion: "apps/v1"
    kind:       Deployment
    name:       vpa-auto-deployment
  updatePolicy:
    updateMode: "Recreate"

    Hodnota targetRef.name určuje, že libovolný pod řízený nasazením, do kterého VerticalPodAutoscalerpatří vpa-auto-deployment . Hodnota updateMode znamená, že kontroler vertikálního automatického Recreate škálování podů může odstranit pod, upravit požadavky na procesor a paměť a pak vytvořit nový pod.

  5. Použijte manifest v clusteru kubectl apply pomocí příkazu.

    kubectl create -f azure-vpa-auto.yaml

  6. Počkejte několik minut a pak pomocí příkazu zobrazte spuštěné pody kubectl get .

    kubectl get pods

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    NAME                                   READY   STATUS    RESTARTS   AGE
vpa-auto-deployment-54465fb978-qbhc4   1/1     Running   0          2m49s
vpa-auto-deployment-54465fb978-vbj68   1/1     Running   0          109s

  7. Pomocí příkazu získejte podrobné informace o jednom ze spuštěných podů kubectl get . Nezapomeňte nahradit <pod-name> názvem jednoho z podů z předchozího výstupu.

    kubectl get pod <pod-name> --output yaml

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu, který ukazuje, že kontroler VPA zvýšil požadavek na paměť na 262144k a požadavek procesoru na 25 miliCPU:

    apiVersion: v1
kind: Pod
metadata:
  annotations:
    vpaObservedContainers: mycontainer
    vpaUpdates: 'Pod resources updated by vpa-auto: container 0: cpu request, memory
      request'
  creationTimestamp: "2022-09-29T16:44:37Z"
  generateName: vpa-auto-deployment-54465fb978-
  labels:
    app: vpa-auto-deployment

spec:
  containers:
  - args:
    - -c
    - while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done
    command:
    - /bin/sh
    image: mcr.microsoft.com/oss/nginx/nginx:1.15.5-alpine
    imagePullPolicy: IfNotPresent
    name: mycontainer
    resources:
      requests:
        cpu: 25m
        memory: 262144k

  8. Získejte podrobné informace o vertikálním automatickém škálování podů a jeho doporučení pro procesor a paměť pomocí kubectl get příkazu.

    kubectl get vpa vpa-auto --output yaml

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

     recommendation:
  containerRecommendations:
  - containerName: mycontainer
    lowerBound:
      cpu: 25m
      memory: 262144k
    target:
      cpu: 25m
      memory: 262144k
    uncappedTarget:
      cpu: 25m
      memory: 262144k
    upperBound:
      cpu: 230m
      memory: 262144k

    V tomto příkladu je výsledkem atributu target , že nemusí měnit procesor nebo cíl paměti, aby kontejner běžel optimálně. Výsledky se ale můžou lišit v závislosti na aplikaci a jejím využití prostředků.

    Vertikální automatické škálování podů používá lowerBound atributy a upperBound určuje, jestli se má pod odstranit a nahradit ho novým podem. Pokud má pod požadavky menší než dolní mez nebo větší než horní mez, vertikální automatické škálování podů odstraní pod a nahradí ho podem, který splňuje cílový atribut.

Další doporučení pro vertikální automatické škálování podů

Doporučovací služba poskytuje doporučení pro využití prostředků na základě spotřeby prostředků v reálném čase. AKS nasadí doporučovací nástroj, když cluster povolí funkci VPA. Můžete nasadit přizpůsobený doporučovač nebo další doporučovač se stejnou imagí jako výchozí. Výhodou přizpůsobeného doporučovacího modulu je, že můžete přizpůsobit logiku doporučení. Pomocí dalšího doporučovacího nástroje můžete rozdělit vpady tak, aby používaly různé doporučovací nástroje.

V následujícím příkladu vytvoříme další doporučovací nástroj, použijeme ho u existujícího clusteru AKS a nakonfigurujeme objekt VPA tak, aby používal extra Recommender.

  1. Vytvořte soubor s názvem extra_recommender.yaml a zkopírujte ho v následujícím manifestu:

    apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: extra-recommender 
  namespace: kube-system 
spec: 
  replicas: 1 
  selector: 
    matchLabels: 
      app: extra-recommender 
  template: 
    metadata: 
      labels: 
        app: extra-recommender 
    spec: 
      serviceAccountName: vpa-recommender 
      securityContext: 
        runAsNonRoot: true 
        runAsUser: 65534
      containers: 
      - name: recommender 
        image: registry.k8s.io/autoscaling/vpa-recommender:0.13.0 
        imagePullPolicy: Always 
        args: 
          - --recommender-name=extra-recommender 
        resources: 
          limits: 
            cpu: 200m 
            memory: 1000Mi 
          requests: 
            cpu: 50m 
            memory: 500Mi 
        ports: 
        - name: prometheus 
          containerPort: 8942

  2. Pomocí příkazu nasaďte příklad vertikálního extra-recomender.yaml automatického škálování podů kubectl apply .

    kubectl apply -f extra-recommender.yaml

    Po několika minutách se příkaz dokončí a vrátí informace o clusteru ve formátu JSON.

  3. Vytvořte soubor s názvem hamster-extra-recommender.yaml a zkopírujte ho v následujícím manifestu:

    apiVersion: "autoscaling.k8s.io/v1" 
kind: VerticalPodAutoscaler 
metadata: 
  name: hamster-vpa 
spec: 
  recommenders:  
    - name: 'extra-recommender' 
  targetRef: 
    apiVersion: "apps/v1" 
    kind: Deployment 
    name: hamster 
  updatePolicy: 
    updateMode: "Auto" 
  resourcePolicy: 
    containerPolicies: 
      - containerName: '*' 
        minAllowed: 
          cpu: 100m 
          memory: 50Mi 
        maxAllowed: 
          cpu: 1 
          memory: 500Mi 
        controlledResources: ["cpu", "memory"] 
--- 
apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: hamster 
spec: 
  selector: 
    matchLabels: 
      app: hamster 
  replicas: 2 
  template: 
    metadata: 
      labels: 
        app: hamster 
    spec: 
      securityContext: 
        runAsNonRoot: true 
        runAsUser: 65534 # nobody 
      containers: 
        - name: hamster 
          image: k8s.gcr.io/ubuntu-slim:0.1 
          resources: 
            requests: 
              cpu: 100m 
              memory: 50Mi 
          command: ["/bin/sh"] 
          args: 
            - "-c" 
            - "while true; do timeout 0.5s yes >/dev/null; sleep 0.5s; done"

    Pokud memory není zadaný, controlledResourcesdoporučovací nástroj nereaguje na události OOM. V tomto příkladu nastavíme pouze procesor v controlledValues. controlledValues umožňuje zvolit, jestli chcete aktualizovat požadavky na prostředky kontejneruRequestsOnly pomocí této možnosti, nebo podle požadavků na prostředky i omezení pomocí této RequestsAndLimits možnosti. Výchozí hodnota je RequestsAndLimits. Pokud tuto možnost použijete RequestsAndLimits , požadavky se počítají na základě skutečného využití a limity se počítají na základě požadavku a limitu aktuálního podu.

    Pokud například začínáte s podem, který požaduje 2 procesory a omezení na 4 procesory, VPA vždy nastaví limit na dvojnásobek požadavků. Stejný princip platí pro paměť. Když použijete RequestsAndLimits režim, může sloužit jako podrobný plán pro počáteční požadavky a limity prostředků aplikace.

    Objekt VPA můžete zjednodušit pomocí Auto doporučení režimu a výpočtů pro procesor i paměť.

  4. Nasaďte příklad hamster-extra-recomender.yaml pomocí kubectl apply příkazu.

    kubectl apply -f hamster-extra-recommender.yaml

  5. Monitorujte pody pomocí [kubectl getpříkazu ]kubectl-get .

    kubectl get --watch pods -l app=hamster

  6. Po spuštění nového podu hamster si pomocí příkazu prohlédněte aktualizované rezervace procesoru kubectl describe a paměti. Nezapomeňte nahradit <example-pod> jedním z ID podů.

    kubectl describe pod hamster-<example-pod>

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>

  7. Pomocí příkazu zobrazte aktualizovaná doporučení z VPA kubectl describe .

    kubectl describe vpa/hamster-vpa

    Výstup by měl vypadat podobně jako v následujícím příkladu výstupu:

    State:          Running
 Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
Spec:
  recommenders:
    Name: customized-recommender

Řešení potíží s vertikálním automatickým škálováním podů

Pokud narazíte na problémy s vertikálním automatickým škálováním podů, můžete vyřešit potíže se systémovými komponentami a vlastní definicí prostředků a identifikovat problém.

  1. Pomocí následujícího příkazu ověřte, že jsou spuštěné všechny systémové komponenty:

    kubectl --namespace=kube-system get pods|grep vpa

    Výstup by měl obsahovat tři pody: doporučovač, aktualizátor a kontroler přístupu, a to vše se stavem Running.

  2. Pro každý z podů vrácených v předchozím výstupu ověřte, že systémové komponenty protokolují případné chyby pomocí následujícího příkazu:

    kubectl --namespace=kube-system logs [pod name] | grep -e '^E[0-9]\{4\}'

  3. Pomocí následujícího příkazu ověřte, že byla vytvořena definice vlastního prostředku:

    kubectl get customresourcedefinition | grep verticalpodautoscalers

Další kroky

Další informace o objektu VPA najdete v referenčních informacích k rozhraní API vertikálního automatického škálování podů.