Compartilhar via

Usar o dimensionador automático de pod vertical no AKS (Serviço de Kubernetes do Azure)

  • Artigo

Este artigo mostra como usar o VPA (Dimensionador Automático de Pod Vertical) no cluster do AKS (Serviço de Kubernetes do Azure). O VPA ajusta automaticamente as solicitações de CPU e memória para seus pods para corresponder aos padrões de uso de suas cargas de trabalho. Esse recurso ajuda a otimizar o desempenho de seus aplicativos e reduzir o custo de execução de suas cargas de trabalho no AKS.

Para obter mais informações, consulte a Visão geral do Vertical Pod Autoscaler.

Antes de começar

  • Se você tiver um cluster do AKS existente, verifique se ele está executando o Kubernetes versão 1.24 ou superior.

  • Você precisa da CLI do Azure versão 2.52.0 ou posterior instalada e configurada. Execute az --version para encontrar a versão. Se você precisa instalar ou atualizar, consulte Instalar a CLI do Azure.

  • Se estiver habilitando o VPA em um cluster existente, verifique se kubectl está instalado e configurado para se conectar ao cluster do AKS usando o comando az aks get-credentials.

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

Implantar o Vertical Pod Autoscaler em um novo cluster

  • Crie um novo cluster do AKS com o VPA habilitado usando o comando az aks create com o sinalizador --enable-vpa.

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

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Atualizar um cluster existente para usar o Vertical Pod Autoscaler

  • Atualize um cluster existente para usar o VPA usando o comando az aks update com o sinalizador --enable-vpa.

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

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Desabilitar o Vertical Pod Autoscaler em um cluster existente

  • Desabilite o VPA em um cluster existente usando o comando az aks update com o sinalizador --disable-vpa.

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

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Testar a instalação do Vertical Pod Autoscaler

No exemplo a seguir, criamos uma implantação com dois pods, cada um executando um único contêiner que solicita 100 milicore e tenta utilizar um pouco acima de 500 millicores. Também criamos uma configuração de VPA apontando para a implantação. O VPA observa o comportamento dos pods e, após cerca de cinco minutos, atualiza os pods para solicitar 500 milicores.

  1. Crie um arquivo chamado hamster.yaml e copie o seguinte manifesto do exemplo do Vertical Pod Autoscaler do repositório 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. Implante o exemplo do hamster.yaml Vertical Pod Autoscaler usando o comando kubectl apply.

    kubectl apply -f hamster.yaml

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

  3. Exiba os pods em execução usando o comando kubectl get.

    kubectl get pods -l app=hamster

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

  4. Exiba as reservas de CPU e memória em um dos pods usando o comando kubectl describe. Certifique-se de substituir <example-pod> por uma das IDs de pod retornadas na saída da etapa anterior.

    kubectl describe pod hamster-<example-pod>

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

     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>

    O pod tem 100 milicpu e 50 Mibibytes de memória reservados neste exemplo. Para este aplicativo de exemplo, o pod precisa de menos de 100 milliCPU para ser executado, portanto, não há capacidade de CPU disponível. Os pods também reservam menos memória do que o necessário. A implantação do Vertical Pod Autoscaler vpa-recommender analisa os pods que hospedam o aplicativo hamster para ver se os requisitos de CPU e memória são apropriados. Se forem necessários ajustes, o vpa-updater relança os pods com valores atualizados.

  5. Monitore os pods usando o comando kubectl get.

    kubectl get --watch pods -l app=hamster

  6. Quando o novo pod de hamster for iniciado, você poderá exibir as reservas de CPU e memória atualizadas usando o comando kubectl describe. Certifique-se de substituir <example-pod> por uma das IDs de pod retornadas na saída da etapa anterior.

    kubectl describe pod hamster-<example-pod>

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

    Na saída anterior, você pode ver que a reserva de CPU aumentou para 587 milliCPU, que é mais de cinco vezes o valor original. A memória aumentou para 262.144 Kilobytes, o que equivale a cerca de 250 Mibibytes, ou cinco vezes o valor original. Esse pod estava sem recursos e o Dimensionador Automático do Pod Vertical corrigiu a estimativa com um valor muito mais apropriado.

  7. Exiba recomendações atualizadas do VPA usando o comando kubectl describe para descrever as informações do recurso hamster-vpa.

    kubectl describe vpa/hamster-vpa

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

Definir solicitações do Vertical Pod Autoscaler

O objeto VerticalPodAutoscaler define automaticamente solicitações de recursos em pods com um updateMode de Auto. Você pode definir um valor diferente dependendo dos seus requisitos e testes. Neste exemplo, criamos e testamos um manifesto de implantação com dois pods, cada um executando um contêiner que solicita 100 miliCPUs e 50 MiB de memória e define o updateMode como Recreate.

  1. Crie um arquivo chamado azure-autodeploy.yaml e copie-o para o manifesto a seguir:

    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. Crie o pod usando o comando kubectl create.

    kubectl create -f azure-autodeploy.yaml

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

  3. Exiba os pods em execução usando o comando kubectl get.

    kubectl get pods

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    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. Crie um arquivo chamado azure-vpa-auto.yaml e copie-o para o manifesto a seguir:

    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"

    O valor targetRef.name especifica que qualquer pod controlado por uma implantação chamada vpa-auto-deployment pertence a VerticalPodAutoscaler. O valor updateMode de Recreate significa que o controlador Vertical Pod Autoscaler pode excluir um pod, ajustar as solicitações de CPU e Memória e, em seguida, criar um novo pod.

  5. Aplique o manifesto ao cluster usando o comando kubectl apply.

    kubectl create -f azure-vpa-auto.yaml

  6. Aguarde alguns minutos e exiba os pods em execução usando o comando kubectl get.

    kubectl get pods

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    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. Obtenha informações detalhadas sobre um dos pods em execução usando o comando kubectl get. Certifique-se de substituir <pod-name> pelo nome de um dos pods da saída anterior.

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

    Sua saída deve ser semelhante à saída de exemplo a seguir, que mostra que o controlador VPA aumentou a solicitação de memória para 262144k e a solicitação de CPU para 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. Obtenha informações detalhadas sobre o Vertical Pod Autoscaler e suas recomendações para CPU e Memória usando o comando kubectl get.

    kubectl get vpa vpa-auto --output yaml

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

    Neste exemplo, os resultados no atributo target especificam que ele não precisa alterar a CPU ou o destino de memória para que o contêiner seja executado de maneira ideal. No entanto, os resultados podem variar dependendo do aplicativo e de sua utilização de recursos.

    O Dimensionador Automático Vertical de Pod usa os atributos lowerBound e upperBound para decidir se quer excluir um pod e substituí-lo por um novo pod. Se um pod tiver solicitações menores que o limite inferior ou maior que o limite superior, o Dimensionador Automático Vertical de Pod excluirá o pod e o substituirá por um pod que atenda ao atributo de destino.

Recomendador Adicional para o Dimensionador Automático Vertical de Pod

O Recomendador fornece recomendações para o uso de recursos com base no consumo de recursos em tempo real. O AKS implanta um Recomendador quando um cluster habilita o VPA. Você pode implantar um Recomendador personalizado ou um Recomendador extra com a mesma imagem que o padrão. O benefício de ter um Recomendador personalizado é que você pode personalizar sua lógica de recomendação. Com um Recomendador extra, você pode particionar VPAs para usar Recomendador diferentes.

No exemplo a seguir, criamos um Recomendador extra, aplicamos a um clust AKS existente e configuramos o objeto VPA para usar o Recomendador extra.

  1. Crie um arquivo chamado extra_recommender.yaml e copie-o para o manifesto a seguir:

    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. Implante o exemplo do extra-recomender.yamlVertical Pod Autoscaler usando o comando kubectl apply.

    kubectl apply -f extra-recommender.yaml

    Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

  3. Crie um arquivo chamado hamster-extra-recommender.yaml e copie-o para o manifesto a seguir:

    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 não for especificado no controlledResources, o Recomendador não responderá aos eventos OOM. Neste exemplo, definimos apenas CPU em controlledValues. controlledValues permite que você escolha se deseja atualizar as solicitações de recursos do contêiner usando a opção RequestsOnly ou por solicitações de recursos e limites usando a opção RequestsAndLimits. O valor padrão é RequestsAndLimits. Se você usar a opção RequestsAndLimits, as solicitações serão calculadas com base no uso real e os limites serão calculados com base na taxa de solicitação e limite do pod atual.

    Por exemplo, se você começar com um pod que solicita 2 CPUs e limita 4 CPUs, o VPA sempre define o limite como o dobro das solicitações. O mesmo princípio se aplica à Memória. Quando você usa o modo RequestsAndLimits, ele pode servir como um blueprint para suas solicitações e limites de recursos de aplicativo iniciais.

    Você pode simplificar o objeto VPA usando o modo Auto e as recomendações de computação para CPU e memória.

  4. Implante o exemplo hamster-extra-recomender.yaml usando o comando kubectl apply.

    kubectl apply -f hamster-extra-recommender.yaml

  5. Monitore seus pods usando o comando [kubectl get]kubectl-get.

    kubectl get --watch pods -l app=hamster

  6. Quando o novo pod de hamster for iniciado, exiba as reservas de CPU e memória atualizadas usando o comando kubectl describe. Certifique-se de substituir <example-pod> por um dos IDs do pod.

    kubectl describe pod hamster-<example-pod>

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

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

  7. Exiba as recomendações atualizadas do VPA usando o comando kubectl describe.

    kubectl describe vpa/hamster-vpa

    Seu resultado deve ser semelhante ao seguinte exemplo de saída:

    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

Solucionar problemas do Vertical Pod Autoscaler

Se você encontrar problemas com o Vertical Pod Autoscaler, poderá solucionar problemas dos componentes do sistema e da definição de recursos personalizados para identificar o problema.

  1. Verifique se todos os componentes do sistema estão em execução usando o seguinte comando:

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

    Sua saída deve listar três pods: recommender, updater e admission-controller, todos com um status de Running.

  2. Para cada um dos pods retornados na saída anterior, verifique se os componentes do sistema estão registrando erros usando o seguinte comando:

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

  3. Verifique se a definição de recurso customizado foi criada usando o seguinte comando:

    kubectl get customresourcedefinition | grep verticalpodautoscalers

Próximas etapas

Para saber mais sobre o objeto VPA, consulte a Referência da API do Vertical Pod Autoscaler.