Függőleges pod automatikus skálázása az Azure Kubernetes Service-ben (AKS)

Cikk
12/09/2023

Ez a cikk áttekintést nyújt az Azure Kubernetes Service (AKS) vertikális pod-automatikus skálázásáról (VPA), amely a Nyílt forráskód Kubernetes-verzión alapul. Ha konfigurálva van, automatikusan beállítja az erőforrás-kérelmeket és a tárolók korlátait számítási feladatonként a korábbi használat alapján. A VPA felszabadítja a processzort és a memóriát a többi pod számára, és segít hatékonyan kihasználni az AKS-fürtöt.

A függőleges pod automatikus skálázása javaslatokat tesz az erőforrás-használatra az idő függvényében. Az erőforrás-használat hirtelen növekedésének kezeléséhez használja a vízszintes pod automatikus skálázását, amely szükség szerint skálázza a podreplikák számát.

Előnyök

A függőleges pod automatikus skálázása a következő előnyöket nyújtja:

Elemzi és módosítja a processzor- és memóriaerőforrásokat az alkalmazások megfelelő méretéhez. A VPA nem csak a vertikális felskálázásért felelős, hanem az erőforrás-használatuk alapján történő leskálázásért is.
A podot a rendszer kizárja, ha módosítania kell az erőforrás-kéréseit, ha a skálázási mód automatikusan vagy újra létrehozva van.
Cpu- és memóriakorlátok beállítása az egyes tárolókhoz erőforrásházirend megadásával
Biztosítja, hogy a csomópontok megfelelő erőforrásokkal rendelkezzenek a podütemezéshez
A processzor- vagy memóriaerőforrások módosításainak konfigurálható naplózása
A fürterőforrás-kihasználtság javítása és a processzor és a memória felszabadítása más podok számára.

Korlátozások

A függőleges pod automatikus skálázása fürtönként legfeljebb 1000 podot támogat az objektumokhoz VerticalPodAutoscaler társítva.
A VPA a fürtben elérhetőnél több erőforrást javasolhat. Ennek eredményeképpen megakadályozza, hogy a pod hozzá legyen rendelve egy csomóponthoz, és fusson, mert a csomópont nem rendelkezik elegendő erőforrással. Ezt a korlátozást úgy oldhatja meg, hogy a LimitRange-t névtérenként a maximális rendelkezésre álló erőforrásra állítja , így a podok nem kérnek több erőforrást a megadottnál. Emellett a podonkénti maximális erőforrás-javaslatokat is beállíthatja egy VerticalPodAutoscaler objektumban. Vegye figyelembe, hogy a VPA nem tud teljes mértékben leküzdeni egy nem megfelelő csomóponterőforrás-problémát. A korláttartomány ki van javítva, de a csomópont erőforrás-kihasználtsága dinamikusan módosul.
Nem javasoljuk a függőleges pod automatikus skálázását vízszintes pod-automatikus skálázóval, amely ugyanazon processzor- és memóriahasználati metrikák alapján skáláz.
A VPA-ajánló legfeljebb nyolc napig tárol előzményadatokat.
A VPA nem támogatja a JVM-alapú számítási feladatokat, mivel a számítási feladat tényleges memóriahasználata korlátozott.
A VPA ezen felügyelt megvalósítása mellett nem ajánlott vagy támogatott a VPA saját implementációjának futtatása. Az extra vagy testre szabott ajánló használata támogatott.
Az AKS Windows-tárolók nem támogatottak.

Mielőtt elkezdené

Az AKS-fürt a Kubernetes 1.24-es vagy újabb verzióját futtatja.
Az Azure CLI 2.52.0-s vagy újabb verziója telepítve és konfigurálva van. A verzió azonosításához futtassa a következőt: az --version. Ha telepíteni vagy frissíteni szeretne: Az Azure CLI telepítése.
kubectl a VPA-t telepíteni kívánt fürthöz kell csatlakoztatni.

A VPA áttekintése

API-objektum

A Függőleges pod automatikus skálázása egy API-erőforrás a Kubernetes automatikus skálázási API-csoportjában. A támogatott verzió a 0.11-es és újabb verzió, és megtalálható a Kubernetes automatikus skálázási adattárában.

A VPA-objektum három összetevőből áll:

Ajánló – figyeli az aktuális és a múltbeli erőforrás-felhasználást, és ennek alapján a tárolók processzor- és memóriaigényeinek/korlátainak ajánlott értékeit biztosítja. Az ajánló figyeli a metrikaelőzményeket, az OOM-eseményeket és a VPA üzembehelyezési specifikációját, és méltányos kéréseket javasol. A megfelelő erőforrás-kérelem és a korlátok konfigurálásával a korlátok emelkednek és csökkennek.
Frissítő – ellenőrzi, hogy a felügyelt podok közül melyik rendelkezik megfelelő erőforráskészlettel, és ha nem, megöli őket, hogy a vezérlők újra létrehozhassák őket a frissített kérésekkel.
VPA belépési vezérlő – beállítja a megfelelő erőforrás-kérelmeket az új podokon (vagy a vezérlő hozta létre vagy hozza létre újra az Updater tevékenysége miatt).

VPA belépési vezérlő

A VPA belépési vezérlő egy bináris, amely regisztrálja magát egy mutációs belépési webhookként. Az egyes podok létrehozásakor lekéri a kérést az apiservertől, és kiértékeli, hogy van-e egyező VPA-konfiguráció, vagy megkeres egy megfelelőt, és az aktuális javaslattal állítja be az erőforrás-kérelmeket a podban.

Egy önálló feladat fut a VPA belépési vezérlőn kívül, az úgynevezett overlay-vpa-cert-webhook-check. Ez overlay-vpa-cert-webhook-check a tanúsítványokat a tanúsítványok létrehozásához és megújításához, valamint a VPA-belépésvezérlő regisztrálásához MutatingWebhookConfigurationhasználja.

A magas rendelkezésre állás érdekében az AKS két belépési vezérlő replikát támogat.

VPA objektumműveleti módok

A rendszer minden olyan vezérlőhöz beszúr egy függőleges pod-automatikus skálázási erőforrást, amelyet automatikusan ki szeretne számítani. Ez általában egy üzemelő példány. A VPA-k négyféleképpen működnek:

Auto - A VPA erőforrás-kérelmeket rendel hozzá a pod létrehozásakor, és frissíti a meglévő podokat az előnyben részesített frissítési mechanizmus használatával. Auto Jelenleg egyenértékű az Recreatealapértelmezett móddal, és egyben az alapértelmezett mód is. Miután elérhető a podkérelmek ingyenes ("helyben") frissítése, az a mód által előnyben részesített frissítési Auto mechanizmusként használható. Üzemmód használata Recreate esetén a VPA kiürít egy podot, ha módosítania kell az erőforrás-kérelmeket. Előfordulhat, hogy a podok egyszerre újraindulnak, ami alkalmazásbeli inkonzisztenciákat okoz. Ebben a helyzetben a PodDisruptionBudget használatával korlátozhatja az újraindításokat, és konzisztenciát tarthat fenn.
Recreate - A VPA erőforrás-kérelmeket rendel hozzá a pod létrehozása során, valamint frissíti a meglévő podokat úgy, hogy kizárja őket, ha a kért erőforrások jelentősen eltérnek az új javaslattól (a pod-megszakítási költségvetés figyelembe vételével, ha meg van adva). Ezt a módot ritkán kell használni, csak akkor, ha gondoskodnia kell arról, hogy a podok újrainduljanak, amikor az erőforrás-kérelem megváltozik. Ellenkező esetben előnyben részesíti a Auto módot, amely az újraindítás nélküli frissítések előnyeit kihasználhatja, ha már elérhetők.
Initial - A VPA csak erőforrás-kérelmeket rendel hozzá a pod létrehozásakor, és utána soha nem változik.
Off - A VPA nem módosítja automatikusan a podok erőforrás-követelményeit. A javaslatok kiszámítása és vizsgálata a VPA objektumban történik.

Üzembehelyezési minta az alkalmazásfejlesztés során

Ha nem ismeri a VPA-t, ajánlott az alábbi lépések végrehajtása az alkalmazásfejlesztés során annak egyedi erőforrás-kihasználtsági jellemzőinek azonosítása érdekében, a VPA tesztelése a megfelelő működés ellenőrzéséhez, valamint a fürt erőforrás-kihasználtságának optimalizálása érdekében a többi Kubernetes-összetevő mellett.

Állítsa be az UpdateMode = "Off" értéket az éles fürtben, és futtassa a VPA-t javaslati módban, hogy tesztelhesse és megismerhesse a VPA-t. UpdateMode = "Ki" elkerülheti a helytelen konfigurációt, amely kimaradáshoz vezethet.
Először a megfigyelhetőség megállapításához gyűjtse össze a tényleges erőforrás-kihasználtsági telemetriát egy adott időszakban. Ez segít megérteni a tároló- és poderőforrások által a rajtuk futó számítási feladatok által befolyásolt tünetek és problémák viselkedését és jeleit.
A teljesítményjellemzők megismeréséhez ismerkedjen meg a figyelési adatokkal. Ezen megállapítás alapján állítsa be a kívánt kéréseket/korlátokat ennek megfelelően, majd a következő üzembe helyezés vagy frissítés során
Állítsa be updateMode az Autoértéket a , Recreateértékre vagy Initial a követelményektől függően.

VPA üzembe helyezése, frissítése vagy letiltása egy fürtön

Ebben a szakaszban üzembe helyezheti, frissítheti vagy letilthatja a függőleges pod automatikus skálázását a fürtön.

Ha engedélyezni szeretné a VPA-t egy új fürtön, használja --enable-vpa a paramétert az az aks create paranccsal.
```
az aks create -n myAKSCluster -g myResourceGroup --enable-vpa
```
Néhány perc elteltével a parancs befejeződik, és JSON formátumú információkat ad vissza a fürtről.
Ha engedélyezni szeretné a VPA-t egy meglévő fürtön, használja a --enable-vpa [https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update] parancsot.
```
az aks update -n myAKSCluster -g myResourceGroup --enable-vpa 
```
Néhány perc elteltével a parancs befejeződik, és JSON formátumú információkat ad vissza a fürtről.
Ha le szeretné tiltani a VPA-t egy meglévő fürtön, használja a --disable-vpa [https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update] parancsot.
```
az aks update -n myAKSCluster -g myResourceGroup --disable-vpa
```
Néhány perc elteltével a parancs befejeződik, és JSON formátumú információkat ad vissza a fürtről.
Annak ellenőrzéséhez, hogy a függőleges pod automatikus méretezési podjai sikeresen létrejöttek-e, használja a kubectl get parancsot.

kubectl get pods -n kube-system

A parancs kimenete a VPA-podokra vonatkozó alábbi eredményeket tartalmazza. A podoknak futó állapotot kell mutatniuk.

NAME                                        READY   STATUS    RESTARTS   AGE
vpa-admission-controller-7867874bc5-vjfxk   1/1     Running   0          41m
vpa-recommender-5fd94767fb-ggjr2            1/1     Running   0          41m
vpa-updater-56f9bfc96f-jgq2g                1/1     Running   0          41m

A Vertical Pod Autoscaler telepítésének tesztelése

Az alábbi lépések két podot tartalmazó üzembe helyezést hoznak létre, amelyek mindegyike egyetlen tárolót futtat, amely 100 millicore-t kér le, és valamivel több mint 500 millicore-t próbál használni. Létrejön egy VPA-konfiguráció is, amely az üzembe helyezésre mutat. A VPA megfigyeli a podok viselkedését, és körülbelül öt perc elteltével egy magasabb CPU-kéréssel frissülnek.

Hozzon létre egy fájlt hamster.yaml , és másolja a függőleges pod automatikus skálázási példájának alábbi jegyzékfájlját a Kubernetes/Autoscaler GitHub-adattárból.
Telepítse a hamster.yaml függőleges pod automatikus méretezési példáját a kubectl Apply paranccsal, és adja meg a YAML-jegyzék nevét:
```
kubectl apply -f hamster.yaml
```
Néhány perc elteltével a parancs befejeződik, és JSON formátumú információkat ad vissza a fürtről.

Futtassa a következő kubectl get parancsot a podok lekéréséhez a hörcsög példaalkalmazásból:

kubectl get pods -l app=hamster

A példakimenet a következőhöz hasonló:

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

Az egyik pod kubectl leíró parancsával megtekintheti a processzor- és memóriafoglalást. Cserélje le a "exampleID" kifejezést az előző lépés kimenetében visszaadott podazonosítók egyikére.
```
kubectl describe pod hamster-exampleID
```
A példakimenet a fürtre vonatkozó információk egy részlete:
```
 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>
```
A pod 100 millicpu és 50 Mibibytes memória van fenntartva ebben a példában. Ebben a mintaalkalmazásban a pod futtatásához kevesebb mint 100 millicpu szükséges, így nincs elérhető processzorkapacitás. A podok a szükségesnél sokkal kevesebb memóriát foglalnak le. A Függőleges pod automatikus skálázási vpa-recommender üzembe helyezése elemzi a hörcsögalkalmazást üzemeltető podokat, hogy megállapítsa, megfelelőek-e a processzor- és memóriakövetelmények. Ha kiigazításra van szükség, a vpa-updater újraindítja a podokat frissített értékekkel.
Várjon, amíg a vpa-updater elindít egy új hörcsög podot, amely eltarthat néhány percig. A podokat a kubectl get paranccsal figyelheti.
```
kubectl get --watch pods -l app=hamster
```
Új hörcsög pod indításakor írja le a kubectl parancsot futtató podot, és tekintse meg a frissített CPU- és memóriafoglalásokat.
```
kubectl describe pod hamster-<exampleID>
```
A példakimenet a podot leíró információk egy részlete:
```
State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```
Az előző kimenetben látható, hogy a CPU-foglalás 587 millicpu-ra nőtt, ami az eredeti érték több mint ötszöröse. A memória 262 144 Kilobájtra nőtt, ami körülbelül 250 Mibibytes, vagyis az eredeti érték ötszöröse. Ez a pod erőforrás-alul volt, és a Függőleges pod automatikus skálázása sokkal megfelelőbb értékkel javította a becslést.
A VPA frissített ajánlásainak megtekintéséhez futtassa a kubectl leíró parancsot a hörcsög-vpa erőforrás-információk leírásához.
```
kubectl describe vpa/hamster-vpa
```
A példakimenet az erőforrás-kihasználtsággal kapcsolatos információk egy részlete:
```
 State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```

Pod automatikus skálázási kéréseinek beállítása

A függőleges pod automatikus skálázása az objektummal automatikusan beállítja az VerticalPodAutoscaler erőforrás-kérelmeket a podokon, amikor az updateMode automatikus értékre van állítva. A követelményektől és a teszteléstől függően más értéket is beállíthat. Ebben a példában az updateMode értéke Recreate.

Engedélyezze a VPA-t a fürthöz az alábbi parancs futtatásával. Cserélje le a fürt nevét myAKSCluster az AKS-fürt nevére, és cserélje le myResourceGroup annak az erőforráscsoportnak a nevét, amelyben a fürt üzemel.
```
az aks update -n myAKSCluster -g myResourceGroup --enable-vpa
```

Hozzon létre egy nevű azure-autodeploy.yamlfájlt, és másolja a következő jegyzékbe.

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"]

Ez a jegyzék egy két podot tartalmazó üzembe helyezést ír le. Minden pod egy tárolóval rendelkezik, amely 100 milliCPU-t és 50 MiB memóriát igényel.

Hozza létre a podot a kubectl create paranccsal, ahogyan az a következő példában is látható:
```
kubectl create -f azure-autodeploy.yaml
```
Néhány perc elteltével a parancs befejeződik, és JSON formátumú információkat ad vissza a fürtről.

Futtassa a következő kubectl get parancsot a podok lekéréséhez:

kubectl get pods

A kimenet a podok nevét és állapotát ábrázoló alábbi példához hasonlít:

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

Hozzon létre egy fájlt, azure-vpa-auto.yamlés másolja a következő jegyzékbe, amely leírja a következőt VerticalPodAutoscaler:
```
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"
```
Az targetRef.name érték azt határozza meg, hogy a névvel ellátott vpa-auto-deployment üzembe helyezés által szabályozott podok a következőhöz tartoznak VerticalPodAutoscaler: Az updateMode érték Recreate azt jelenti, hogy a függőleges pod automatikus skálázási vezérlője törölheti a podokat, módosíthatja a processzor- és memóriakéréseket, majd létrehozhat egy új podot.
Alkalmazza a jegyzékfájlt a fürtre a kubectl apply paranccsal:
```
kubectl create -f azure-vpa-auto.yaml
```
Várjon néhány percet, és tekintse meg újra a futó podokat a következő kubectl get parancs futtatásával:
```
kubectl get pods
```
A kimenet a következő példához hasonlít, amely azt mutatja, hogy a podok neve megváltozott, és a podok állapota módosult:
```
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
```

A Kubectl get paranccsal részletes információkat kaphat az egyik futó podról. Cserélje le podName az előző lépésben lekért podok egyikének nevét.

kubectl get pod podName --output yaml

A kimenet a következő példához hasonlít, amely azt mutatja, hogy a függőleges pod automatikus skálázási vezérlője 262144k-ra növelte a memóriakérelmet, a CPU-kérés pedig 25 milliCPU-ra.

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

A függőleges pod automatikus méretezési funkciójával és a processzorra és a memóriára vonatkozó javaslataival kapcsolatos részletes információkért használja a kubectl get parancsot:
```
kubectl get vpa vpa-auto --output yaml
```
A kimenet a következő példához hasonlít:
```
 recommendation:
  containerRecommendations:
  - containerName: mycontainer
    lowerBound:
      cpu: 25m
      memory: 262144k
    target:
      cpu: 25m
      memory: 262144k
    uncappedTarget:
      cpu: 25m
      memory: 262144k
    upperBound:
      cpu: 230m
      memory: 262144k
```
Az eredmények azt mutatják, hogy az target attribútum azt határozza meg, hogy a tároló optimális futtatásához nem kell módosítania a processzort vagy a memóriacélt. Az eredmények eltérőek lehetnek, ha a cél cpu- és memóriajavaslata magasabb.

A Függőleges pod automatikus skálázása az és upperBound az lowerBound attribútumok használatával dönti el, hogy töröl-e egy podot, és lecseréli-e egy új podra. Ha egy pod kérései kisebbek, mint az alsó vagy nagyobb, mint a felső határ, a függőleges pod automatikus skálázója törli a podot, és lecseréli egy podra, amely megfelel a célattribútumnak.

Extra ajánló a függőleges pod automatikus méretezéséhez

A VPA-ban az egyik alapvető összetevő az ajánló. Javaslatokat tesz az erőforrás-használatra a valós idejű erőforrás-használat alapján. Az AKS üzembe helyez egy ajánlót, ha egy fürt engedélyezi a VPA-t. Testre szabott ajánlót vagy további ajánlót is üzembe helyezhet az alapértelmezett képpel megegyező képpel. A testre szabott ajánló előnye, hogy testre szabhatja a javaslat logikáját. Egy további ajánlóval több ajánló számára is particionálhatja a VPA-kat, ha sok VPA-objektum van.

Az alábbi példa egy további ajánló, amelyet a meglévő AKS-fürtre alkalmaz. Ezután konfigurálja a VPA-objektumot az extra ajánló használatára.

Hozzon létre egy fájlt, extra_recommender.yaml és másolja a következő jegyzékbe:

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 # nobody 
      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

Telepítse a extra-recomender.yaml függőleges pod automatikus méretezési példáját a kubectl Apply paranccsal, és adja meg a YAML-jegyzék nevét.
```
kubectl apply -f extra-recommender.yaml 
```
Néhány perc elteltével a parancs befejeződik, és JSON formátumú információkat ad vissza a fürtről.

Hozzon létre egy fájlt, hamnster_extra_recommender.yaml és másolja a következő jegyzékbe:

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"

Ha memory nincs megadva, controlledResourcesaz ajánló nem válaszol az OOM-eseményekre. Ebben az esetben csak a CPU-t állítja be.controlledValues controlledValues Lehetővé teszi a tároló erőforrás-kéréseinek beállítás szerinti RequestsOnly frissítését, vagy az erőforrás-kérelmeket és a korlátokat is a RequestsAndLimits beállítással. Az alapértelmezett érték RequestsAndLimits. Ha ezt a lehetőséget használja, a RequestsAndLimits kérelmek kiszámítása a tényleges használat alapján történik, a korlátok pedig az aktuális pod kérési és korlátaránya alapján lesznek kiszámítva.

Ha például egy 2 CPU-t és 4 CPU-t kérő podot kezd, a VPA mindig a kérések kétszeresére állítja be a korlátot. Ugyanez az elv vonatkozik a memóriára is. Ha a RequestsAndLimits módot használja, az tervként szolgálhat az alkalmazás kezdeti erőforrás-kérelmeihez és korlátaihoz.

Leegyszerűsítheti a VPA-objektumokat az automatikus mód és a számítási javaslatok használatával a processzor és a memória számára.

Telepítse a hamster_extra-recomender.yaml példát a kubectl Apply paranccsal, és adja meg a YAML-jegyzék nevét.
```
kubectl apply -f hamster_customized_recommender.yaml
```
Várjon, amíg a vpa-updater elindít egy új hörcsög podot, amely eltarthat néhány percig. A podokat a kubectl get paranccsal figyelheti.
```
kubectl get --watch pods -l app=hamster
```

Új hörcsög pod indításakor írja le a kubectl parancsot futtató podot, és tekintse meg a frissített CPU- és memóriafoglalásokat.

kubectl describe pod hamster-<exampleID>

A példakimenet a podot leíró információk egy részlete:

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

A VPA frissített ajánlásainak megtekintéséhez futtassa a kubectl leíró parancsot a hörcsög-vpa erőforrás-információk leírásához.

kubectl describe vpa/hamster-vpa

A példakimenet az erőforrás-kihasználtsággal kapcsolatos információk egy részlete:

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

Hibaelhárítás

A VPA-telepítéssel kapcsolatos problémák diagnosztizálásához hajtsa végre az alábbi lépéseket.

Ellenőrizze, hogy az összes rendszerösszetevő fut-e a következő paranccsal:
```
kubectl --namespace=kube-system get pods|grep vpa
```

A kimenetnek három podot kell listáznia – az ajánlót, a frissítőt és a belépés-vezérlőt mind a következő állapotú állapottal Running: .

Ellenőrizze, hogy a rendszerösszetevők naplóznak-e hibákat. Az előző parancs által visszaadott podok mindegyikéhez futtassa a következő parancsot:
```
kubectl --namespace=kube-system logs [pod name] | grep -e '^E[0-9]\{4\}'
```
Ellenőrizze, hogy az egyéni erőforrásdefiníció a következő parancs futtatásával lett-e létrehozva:
```
kubectl get customresourcedefinition | grep verticalpodautoscalers
```

Következő lépések

Ez a cikk azt mutatta be, hogyan skálázhatja automatikusan a fürtcsomópontok erőforrás-kihasználtságát, például a processzort és a memóriát az alkalmazás követelményeinek megfelelően.

A vízszintes pod automatikus skálázásával automatikusan módosíthatja az alkalmazást futtató podok számát. A podok automatikus horizontális méretezésének lépéseit az alkalmazások skálázása az AKS-ben című témakörben találja.
A kapcsolódó VPA-objektumok definícióival kapcsolatos további információkért tekintse meg a függőleges podok automatikus skálázását [API-referencia].