Condividi tramite

Usare la Scalabilità automatica verticale dei pod nel servizio Azure Kubernetes

  • Articolo

Questo articolo illustra come usare la Scalabilità automatica verticale dei pod (VPA) nel cluster del servizio Azure Kubernetes. VPA regola automaticamente le richieste di CPU e memoria per i pod in modo che corrispondano ai modelli di utilizzo dei carichi di lavoro. Questa funzionalità consente di ottimizzare le prestazioni delle applicazioni e di ridurre i costi di esecuzione dei carichi di lavoro nel servizio Azure Kubernetes.

Per altre informazioni, vedere Panoramica della Scalabilità automatica verticale dei pod.

Operazioni preliminari

  • Se si dispone di un cluster del servizio Azure Kubernetes esistente, assicurarsi che sia in esecuzione Kubernetes versione 1.24 o successiva.

  • È necessario che sia installata e configurata l'interfaccia della riga di comando di Azure 2.52.0 o versione successiva. Eseguire az --version per trovare la versione. Se è necessario eseguire l'installazione o l'aggiornamento, vedere Installare l'interfaccia della riga di comando di Azure.

  • Se si abilita VPA in un cluster esistente, assicurarsi che kubectl sia installato e configurato per connettersi al cluster del servizio Azure Kubernetes tramite il comando az aks get-credentials.

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

Distribuire la Scalabilità automatica verticale dei pod in un nuovo cluster

  • Creare un nuovo cluster del servizio Azure Kubernetes con VPA abilitato tramite il comando az aks create con il flag --enable-vpa.

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

    Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

Aggiornare un cluster esistente per usare la Scalabilità automatica verticale dei pod

  • Aggiornare un cluster esistente per usare VPA tramite il comando az aks update con il flag --enable-vpa.

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

    Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

Disabilitare la Scalabilità automatica verticale dei pod in un cluster esistente

  • Disabilitare VPA in un cluster esistente tramite il comando az aks updatecon il flag --disable-vpa.

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

    Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

Testare l'installazione di Scalabilità automatica verticale dei pod

Nell'esempio seguente, viene creata una distribuzione con due pod, ognuno dei quali esegue un singolo contenitore che richiede 100 millicore e tenta di usare un numero di millicore leggermente superiore a 500. Viene anche creata una configurazione di VPA che punta alla distribuzione. VPA osserva il comportamento dei pod e, dopo circa cinque minuti, aggiorna i pod per richiedere 500 millicores.

  1. Creare un file denominato hamster.yaml e copiare il seguente manifesto dell'esempio di Scalabilità automatica verticale dei pod dal repository 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. Distribuire l'esempio di Scalabilità automatica verticale dei pod hamster.yaml tramite il comando kubectl apply.

    kubectl apply -f hamster.yaml

    Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

  3. Visualizzare i pod in esecuzione usando il comando kubectl get.

    kubectl get pods -l app=hamster

    L'output dovrebbe essere simile all'esempio di output seguente:

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

  4. Visualizzare le prenotazioni di CPU e memoria in uno dei pod usando il comando kubectl describe. Assicurarsi di sostituire <example-pod> con uno degli ID pod restituiti nell'output del passaggio precedente.

    kubectl describe pod hamster-<example-pod>

    L'output dovrebbe essere simile all'esempio di output seguente:

     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>

    In questo esempio, il pod dispone di 100 millicpu e 50 Mibibyte di memoria riservati. Per questa applicazione di esempio, il pod richiede meno di 100 millicpu per l'esecuzione, quindi non è disponibile alcuna capacità di CPU. I pod, inoltre, riservano una quantità di memoria inferiore a quella necessaria. La distribuzione di Scalabilità automatica verticale dei pod vpa-recommender di VPA analizza i pod che ospitano l'applicazione hamster per verificare se i requisiti di CPU e memoria sono appropriati. Se sono necessarie modifiche, vpa-updater riavvia i pod con valori aggiornati.

  5. Monitorare i pod tramite il comando kubectl get.

    kubectl get --watch pods -l app=hamster

  6. All'avvio del nuovo pod di hamster, è possibile visualizzare le prenotazioni di CPU e Memoria aggiornate tramite il comando kubectl describe. Assicurarsi di sostituire <example-pod> con uno degli ID pod restituiti nell'output del passaggio precedente.

    kubectl describe pod hamster-<example-pod>

    L'output dovrebbe essere simile all'esempio di output seguente:

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

    Nell'output precedente è possibile notare che la prenotazione di CPU ha raggiunto 587 millicpu, ovvero più di cinque volte il valore originale. Memoria ha raggiunto 262.144 kilobyte, ovvero circa 250 Mibibyte o cinque volte il valore originale. Questo pod non aveva risorse sufficienti e il Vertical Pod Autoscaler ha corretto la stima con un valore molto più appropriato.

  7. Visualizzare le raccomandazioni aggiornate da VPA tramite il comando kubectl describeper descrivere le informazioni sulla risorsa hamster-vpa.

    kubectl describe vpa/hamster-vpa

    L'output dovrebbe essere simile all'esempio di output seguente:

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

Impostare richieste di Scalabilità automatica verticale dei pod

L'oggetto VerticalPodAutoscaler imposta automaticamente le richieste della risorsa nei pod con un updateMode di Auto. È possibile impostare un valore diverso a seconda dei requisiti e dei test. In questo esempio viene creato e testato un manifesto della distribuzione con due pod, ognuno dei quali esegue un contenitore che richiede 100 milliCPU e 50 MiB di memoria e imposta il updateMode su Recreate.

  1. Creare un file denominato azure-autodeploy.yaml e copiarlo nel manifesto seguente:

    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. Creare il pod usando il comando kubectl create.

    kubectl create -f azure-autodeploy.yaml

    Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

  3. Visualizzare i pod in esecuzione usando il comando kubectl get.

    kubectl get pods

    L'output dovrebbe essere simile all'esempio di output seguente:

    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. Creare un file denominato azure-vpa-auto.yaml e copiarlo nel manifesto seguente:

    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"

    Il valore targetRef.name specifica che qualsiasi pod controllato da una distribuzione denominata vpa-auto-deployment appartiene a VerticalPodAutoscaler. Il valore updateMode di Recreate indica che il controller di Scalabilità automatica verticale dei pod può eliminare un pod, regolare le richieste di CPU e Memoria e quindi creare un nuovo pod.

  5. Applicare il manifesto al cluster tramite il comando kubectl apply.

    kubectl create -f azure-vpa-auto.yaml

  6. Attendere alcuni minuti e quindi visualizzare i pod in esecuzione tramite il comandokubectl get.

    kubectl get pods

    L'output dovrebbe essere simile all'esempio di output seguente:

    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. Ottenere informazioni dettagliate su uno dei pod in esecuzione tramite il comando kubectl get. Assicurarsi di sostituire <pod-name> con il nome di uno dei pod dell'output precedente.

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

    L'output dovrebbe essere simile a quello dell'esempio seguente, che mostra un aumento della richiesta di memoria da parte del controller VPA a 262144k e della richiesta di CPU a 25 milliCPU:

    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. Per ottenere informazioni dettagliate sulla Scalabilità automatica verticale dei pod e le relative raccomandazioni per CPU e Memoria, usare il comando kubectl get.

    kubectl get vpa vpa-auto --output yaml

    L'output dovrebbe essere simile all'esempio di output seguente:

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

    In questo esempio, i risultati nell'attributo target specificano che non è necessario modificare la CPU o la destinazione di Memoria per un’esecuzione ottimale del contenitore. Tuttavia, i risultati possono variare a seconda dell'applicazione e del relativo utilizzo delle risorse.

    Vertical Pod Autoscaler usa gli attributi lowerBound e upperBound per decidere se eliminare un pod e sostituirlo con un nuovo pod. Se un pod ha richieste minori del limite inferiore o maggiori del limite superiore, Vertical Pod Autoscaler elimina il pod e lo sostituisce con un pod che soddisfa l'attributo di destinazione.

Modulo di raccomandazione aggiuntivo per Vertical Pod Autoscaler

Il Sistema di raccomandazione fornisce consigli per l'utilizzo delle risorse in base al loro consumo in tempo reale. Il servizio Azure Kubernetes distribuisce un Sistema di raccomandazione quando un cluster abilita VPA. È possibile distribuire un Sistema di raccomandazione personalizzato o un Sistema di raccomandazione aggiuntivo con la stessa immagine di quello predefinito. Il vantaggio di disporre di un Sistema di raccomandazione personalizzato consiste nella possibilità di personalizzare la logica di raccomandazione. Con un Sistema di raccomandazione aggiuntivo, è possibile partizionare le VPA per l'uso di sistemi di raccomandazione diversi.

Nell'esempio seguente, viene creato un Sistema di raccomandazione aggiuntivo, che si applica a un cluster del servizio Azure Container esistente, e quindi configurato l'oggetto VPA per consentirne l’uso.

  1. Creare un file denominato extra_recommender.yaml e copiarlo nel manifesto seguente:

    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. Distribuire l'esempio di Scalabilità automatica verticale dei pod extra-recomender.yaml tramite il comando kubectl apply.

    kubectl apply -f extra-recommender.yaml

    Il comando viene completato dopo pochi minuti e vengono restituite informazioni in formato JSON sul cluster.

  3. Creare un file denominato hamster-extra-recommender.yaml e copiarlo nel manifesto seguente:

    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"

    Se memory non è specificato in controlledResources, il Sistema di raccomandazione non risponde agli eventi OOM. In questo esempio viene impostata solo la CPU in controlledValues. controlledValues consente di scegliere se aggiornare le richieste di risorse del contenitore tramite l’opzione RequestsOnly, oppure sia le richieste di risorse che i limiti tramite l’opzione RequestsAndLimits. Il valore predefinito è RequestsAndLimits. Se si usa l'opzione RequestsAndLimits, le richieste vengono calcolate in base all'uso effettivo e i limiti in base al rapporto tra richieste e limiti del pod corrente.

    Ad esempio, se si inizia con un pod che richiede 2 CPU e ha un limite di 4 CPU, VPA imposta sempre il limite in modo che sia il doppio delle richieste. Lo stesso principio si applica a Memoria. Quando si usa la modalità RequestsAndLimits, questa può servire come modello per le richieste e i limiti iniziali delle risorse dell'applicazione.

    È possibile semplificare l'oggetto di VPA usando la modalità Auto e le raccomandazioni di calcolo per CPU e Memoria.

  4. Distribuire l'esempio hamster-extra-recomender.yaml tramite il comando kubectl apply.

    kubectl apply -f hamster-extra-recommender.yaml

  5. Monitorare i pod tramite il comando [kubectl get]kubectl-get.

    kubectl get --watch pods -l app=hamster

  6. All'avvio del nuovo pod di hamster, visualizzare le prenotazioni di CPU e Memoria aggiornate tramite il comando kubectl describe. Assicurarsi di sostituire <example-pod> con uno degli ID pod.

    kubectl describe pod hamster-<example-pod>

    L'output dovrebbe essere simile all'esempio di output seguente:

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

  7. Visualizzare le raccomandazioni aggiornate da VPA tramite il comando kubectl describe.

    kubectl describe vpa/hamster-vpa

    L'output dovrebbe essere simile all'esempio di output seguente:

    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

Risolvere i problemi di Scalabilità automatica verticale dei pod

Se si verificano errori con Scalabilità automatica verticale dei pod, è possibile risolvere i problemi relativi ai componenti del sistema e alla definizione delle risorse personalizzate per identificarne la causa.

  1. Verificare che tutti i componenti del sistema siano in funzione tramite il comando seguente:

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

    L'output dovrebbe elencare tre pod: sistema di raccomandazione, strumento di aggiornamento e controller di ammissione, tutti con lo stato di Running.

  2. Per ognuno dei pod restituiti nell'output precedente, verificare che i componenti del sistema registrino eventuali errori usando il comando seguente:

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

  3. Verificare che la definizione della risorsa personalizzata sia stata creata tramite il comando seguente:

    kubectl get customresourcedefinition | grep verticalpodautoscalers

Passaggi successivi

Per altre informazioni sull'oggetto VPA, vedere il riferimento API di Scalabilità automatica verticale dei pod.