Dimensionamento Automático Vertical de Pod no AKS (Serviço de Kubernetes do Azure)

Artigo
12/22/2023

Este artigo oferece uma visão geral do VPA (Dimensionador Automático Vertical de Pod) do AKS (Serviço de Kubernetes do Azure), que se baseia na versão do Kubernetes de código aberto. Quando configurado, ele define automaticamente solicitações de recursos e limites em contêineres por carga de trabalho com base no uso anterior. O VPA libera CPU e Memória para os outros pods e ajuda no uso eficaz do seu cluster do AKS.

O Dimensionamento Automático Vertical de Pod fornece recomendações para o uso dos recursos ao longo do tempo. Para gerenciar os aumentos repentinos no uso de recursos, use o Dimensionador Automático Horizontal de Pod, que dimensiona o número de réplicas de pod conforme for necessário.

Benefícios

O Dimensionador Automático do Pod Vertical oferece os seguintes benefícios:

Ele analisa e ajusta os recursos de processador e memória para dimensionar corretamente seus aplicativos. A VPA não é responsável apenas pela expansão, mas também redução com base no uso de recursos ao longo do tempo.
Um pod será removido se ele precisar alterar suas solicitações de recurso se o modo de dimensionamento for definido como automático ou recriar.
Definir restrições de CPU e memória para contêineres individuais especificando uma política de recurso
Garante que os nós tenham recursos corretos para agendamento de pod
Registro em log configurável de quaisquer ajustes feitos em recursos do processador ou da memória
Aprimore a utilização de recursos do cluster e libere a CPU e a memória para outros pods.

Limitações

O Dimensionamento Automático Vertical de Pod dá suporte a um máximo de 1.000 pods associados a VerticalPodAutoscaler objetos por cluster.
O VPA pode recomendar mais recursos do que o disponível no cluster. Como resultado, isso impede que o pod seja atribuído a um nó e executado, pois o nó não tem recursos suficientes. Você pode superar essa limitação definindo LimitRange como o máximo de recursos disponíveis por namespace, o que garante que os pods não solicitem mais recursos do que o especificado. Além disso, você pode definir o máximo permitido de recomendações de recursos por pod em um objeto VerticalPodAutoscaler. Lembre-se de que o VPA não pode superar totalmente um problema de recurso de nó insuficiente. O intervalo de limite é fixo, mas o uso de recursos do nó é alterado dinamicamente.
Não recomendamos usar o Dimensionador Automático Vertical de Pod com o Dimensionador Automático Horizontal de Pod, que é dimensionado com base nas mesmas métricas de uso de CPU e memória.
O Recomendador VPA armazena apenas até oito dias de dados históricos.
O VPA não dá suporte a cargas de trabalho baseadas em JVM devido à visibilidade limitada do uso real de memória da carga de trabalho.
Não é recomendável ou compatível executar sua própria implementação do VPA junto com essa implementação gerenciada do VPA. Há suporte para ter um recomendador adicional ou personalizado.
Não há suporte para contêineres do Windows no AKS.

Antes de começar

O cluster do AKS está executando o Kubernetes versão 1.24 e superior.
A 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.
kubectl deve estar conectado ao cluster que você deseja instalar a VPA.

Visão geral do VPA

Objeto da API

O Dimensionador Automático do Pod Vertical é um recurso de API no grupo de API de dimensionamento automático do Kubernetes. A versão com suporte é 0.11 e posterior e pode ser encontrada no repositório de dimensionamento automático do Kubernetes.

O objeto VPA consiste de três componentes:

Recomendador: ele monitora o consumo de recursos atual e anterior e, com base nele, fornece valores recomendados para as solicitações/limites de CPU e memória dos contêineres. O Recomendador monitora o histórico de métricas, os eventos de OOM (Memória Insuficiente), a especificação de implantação do VPA e sugere solicitações consideráveis. Ao fornecer uma solicitação de recurso adequada e uma configuração de limites, os limites são elevados e reduzidos.
Atualizador: ele verifica quais dos pods gerenciados têm os recursos corretos definidos e, caso contrário, os elimina para que possam ser recriados por seus controladores com as solicitações atualizadas.
Controlador de Admissão do VPA: ele define as solicitações de recurso corretas nos novos pods (criados ou recriados pelo controlador devido à atividade do Atualizador).

Controladores de admissão do VPA

O controlador de admissão do VPA é um binário que se registra como um Webhook de Admissão de Mutação. Com os pods criados, ele recebe uma solicitação de apiserver e avalia se há uma configuração do VPA compatível ou encontra uma correspondente e usa a recomendação atual para definir as solicitações de recursos no pod.

Um trabalho autônomo é executado fora do controlador de admissão do VPA, chamado overlay-vpa-cert-webhook-check. O overlay-vpa-cert-webhook-check é usado para criar e renovar os certificados e registrar o controlador de admissão do VPA como um MutatingWebhookConfiguration.

Na alta disponibilidade, o AKS dá suporte a duas réplicas do controlador de admissão.

Modos de operação do objeto do VPA

Um recurso do Dimensionador Automático Vertical de Pod é inserido nos controladores que você quer que tenha requisitos de recursos computados automaticamente. Normalmente, essa é uma implantação. Há quatro modos em que os VPAs operam:

Auto: o VPA atribui solicitações de recurso durante a criação do pod e atualiza os pods existentes usando o mecanismo de atualização preferencial. Atualmente, o Auto é equivalente ao Recreate e também é o modo padrão. Depois que a atualização ("in-loco") sem reinicialização das solicitações de pod estiver disponível, ela poderá ser usada como o mecanismo de atualização preferencial pelo modo Auto. Ao usar o modo Recreate, o VPA removerá um pod se precisar alterar suas solicitações de recurso. Isso pode fazer com que os pods sejam reiniciados de uma só vez, causando inconsistências no aplicativo. Você pode limitar as reinicializações e manter a consistência nessa situação usando um PodDisruptionBudget.
Recreate: o VPA atribui solicitações de recurso durante a criação do pod, bem como atualiza os pods existentes removendo-os quando os recursos solicitados diferem significativamente da nova recomendação (respeitando o Orçamento de Interrupção de Pod, se definido). Esse modo deve ser usado raramente, somente se você precisar garantir que os pods sejam reiniciados sempre que a solicitação de recurso for alterada. Caso contrário, o modo Auto é preferido, o que pode aproveitar as atualizações sem reinicialização quando estiverem disponíveis.
Initial: o VPA atribui apenas solicitações de recurso durante a criação do pod e nunca é alterada posteriormente.
Off: o VPA não altera automaticamente os requisitos de recursos dos pods. As recomendações são calculadas e podem ser inspecionadas no objeto do VPA.

Padrão de implantação durante o desenvolvimento dos aplicativos

Um padrão de implantação comum recomendado para você, se não estiver familiarizado com o VPA, é executar as etapas a seguir durante o desenvolvimento do aplicativo para identificar suas características exclusivas de utilização de recursos, testar o VPA para verificar se ele está funcionando corretamente e testar junto com outros componentes do Kubernetes para otimizar a utilização de recursos do cluster.

Defina UpdateMode = "Off" no seu cluster de produção e execute o VPA no modo de recomendação para que você possa testar e se familiarizar com o VPA. UpdateMode = "Off" pode evitar a introdução de uma configuração incorreta que pode causar uma interrupção.
Estabeleça primeiro a observabilidade coletando a telemetria real da utilização de recursos durante um determinado período de tempo. Isso ajuda você a compreender o comportamento e os sinais de sintomas ou problemas dos recursos de contêineres e dos pods influenciados pelas cargas de trabalho sendo executadas neles.
Familiarize-se com os dados de monitoramento para entender as características de desempenho. Com base neste insight, defina as solicitações/limites desejados adequadamente e depois na próxima implantação ou atualização
Defina o valor updateMode como Auto, Recreate ou Initial, dependendo dos seus requisitos.

Implantar, atualizar ou desabilitar a VPA em um cluster

Nesta seção, você implantará, atualizará ou desabilitará o Dimensionador Automático do Pod Vertical em seu cluster.

Para habilitar a VPA em um novo cluster, use o parâmetro --enable-vpa com o comando de criação do az aks.
```
az aks create ---name myAKSCluster --resource-group myResourceGroup --enable-vpa
```
Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.
Opcionalmente, para habilitar o VPA em um cluster existente, use o --enable-vpa comando with the [https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update].
```
az aks update --name myAKSCluster --resource-group myResourceGroup --enable-vpa 
```
Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.
Opcionalmente, para desabilitar o VPA em um cluster existente, use o --disable-vpa comando with the [https://learn.microsoft.com/en-us/cli/azure/aks?view=azure-cli-latest#az-aks-update].
```
az aks update --name myAKSCluster --resource-group myResourceGroup --disable-vpa
```
Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.
Para verificar se os pods do Dimensionador Automático do Pod Vertical foram criados com êxito, use o comando de obter do kubectl.

kubectl get pods --name kube-system

A saída do comando inclui os seguintes resultados específicos para os pods da VPA. Os pods devem mostrar um status em execução.

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

Testar a instalação do Dimensionador Automático do Pod Vertical

As etapas a seguir criam uma implantação com dois pods, cada um executando um único contêiner que solicita 100 millicores e tenta utilizar um pouco acima de 500 millicores. Uma configuração do VPA também é criada, apontando para a implantação. A VPA observa o comportamento dos pods e, após cerca de cinco minutos, eles são atualizados com uma solicitação de CPU mais alta.

Crie um arquivo nomeado hamster.yaml e copie no manifesto a seguir do exemplo do Dimensionador Automático do Pod Vertical do repositório GitHub do kubernetes/dimensionador automático.
Implante o exemplo hamster.yaml do Dimensionador Automático do Pod Vertical usando o comando de aplicar do kubectl e especifique o nome do manifesto YAML:
```
kubectl apply -f hamster.yaml
```
Após alguns minutos, o comando será concluído e retornará informações no formato JSON sobre o cluster.

Execute o seguinte comando de obter do kubectl para obter os pods do aplicativo de exemplo hamster:

kubectl get pods -l app=hamster

A saída de exemplo é semelhante ao seguinte:

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

Use o comando de descrever do kubectl em um dos pods para exibir sua CPU e reserva de memória. Substitua "exampleID" por uma das IDs do pod retornadas na saída da etapa anterior.
```
kubectl describe pod hamster-exampleID
```
A saída de exemplo é um snippet das informações sobre o cluster:
```
 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 milliCPU 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 muito menos memória do que o necessário. A implantação do vpa-recommender do Dimensionador Automático do Pod Vertical 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.
Aguarde até que o vpa-updater inicie um novo pod de hamster, o que deve levar alguns minutos. Você pode monitorar os pods usando o comando de obter do kubectl.
```
kubectl get --watch pods -l app=hamster
```
Quando um novo pod hamster for iniciado, descreva o pod que executa o comando descrever do kubectl e exiba as reservas de CPU e memória atualizadas.
```
kubectl describe pod hamster-<exampleID>
```
A saída de exemplo é um snippet das informações que descrevem o pod:
```
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 Quilobytes, que é em torno 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.
Para exibir as recomendações atualizadas da VPA, execute o comando de descrever do kubectl para descrever as informações do recurso hamster-vpa.
```
kubectl describe vpa/hamster-vpa
```
A saída de exemplo é um snippet das informações sobre a utilização do recurso:
```
 State:          Running
  Started:      Wed, 28 Sep 2022 15:09:51 -0400
Ready:          True
Restart Count:  0
Requests:
  cpu:        587m
  memory:     262144k
Environment:  <none>
```

Definir as solicitações do Dimensionador Automático de Pod

O Dimensionamento Automático Vertical de Pod usa o objeto VerticalPodAutoscaler para definir automaticamente solicitações de recurso em pods quando o updateMode estiver definido como Automático. Você pode definir um valor diferente dependendo dos seus requisitos e testes. Neste exemplo, o updateMode é definido como Recreate.

Habilite a VPA para seu cluster executando o seguinte comando. Substitua o nome myAKSCluster do cluster pelo nome do cluster do AKS e substitua myResourceGroup pelo nome do grupo de recursos no qual o cluster está hospedado.
```
az aks update --name myAKSCluster --resource-group myResourceGroup --enable-vpa
```

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

Este manifesto descreve uma implantação que tem dois pods. Cada pod tem um contêiner que solicita 100 miliCPU e 50 MiB de memória.

Crie o pod com o comando kubectl create, conforme mostrado no exemplo a seguir:
```
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.

Execute o seguinte comando de obter do kubectl para obter os pods:

kubectl get pods

A saída se assemelha ao exemplo a seguir mostrando o nome e o status dos pods:

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

Crie um arquivo chamado azure-vpa-auto.yaml e copie-o para o manifesto a seguir que descreve um 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"
```
O valor targetRef.name especifica que qualquer pod controlado por uma implantação nomeada vpa-auto-deployment pertence a VerticalPodAutoscaler. O valor updateMode de Recreate significa que o controlador do Dimensionador Automático Vertical de Pod pode excluir um pod, ajustar as solicitações de CPU e memória e depois criar um novo pod.
Aplique o manifesto ao cluster usando o comando de aplicar do kubectl:
```
kubectl create -f azure-vpa-auto.yaml
```

Aguarde alguns minutos e veja os pods em execução novamente executando o seguinte comando kubectl get:

kubectl get pods

A saída se assemelha ao exemplo a seguir, mostrando os nomes e o status dos pods alterados:

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

Obtenha informações detalhadas sobre um dos pods em execução usando o comando Kubectl get. Substitua podName pelo nome de um dos seus pods recuperados na etapa anterior.

kubectl get pod podName --output yaml

A saída se assemelha ao exemplo a seguir, mostrando que o controlador do Dimensionador Automático do Pod Vertical aumentou a solicitação de memória para 262144k e a solicitação de CPU para 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

Para obter informações detalhadas sobre o Dimensionador Automático do Pod Vertical e suas recomendações para CPU e memória, use o comando de obter do kubectl:
```
kubectl get vpa vpa-auto --output yaml
```
A saída é semelhante ao exemplo a seguir:
```
 recommendation:
  containerRecommendations:
  - containerName: mycontainer
    lowerBound:
      cpu: 25m
      memory: 262144k
    target:
      cpu: 25m
      memory: 262144k
    uncappedTarget:
      cpu: 25m
      memory: 262144k
    upperBound:
      cpu: 230m
      memory: 262144k
```
Os resultados mostram que o atributo target especifica que, para que o contêiner seja executado de forma ideal, ele não precisa alterar a CPU ou o destino de memória. Seus resultados podem variar onde a CPU de destino e a recomendação de memória são maiores.

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

No VPA, um dos componentes principais é o Recomendador. Ele fornece recomendações para o uso dos recursos com base no consumo dos 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 a padrão. O benefício de ter um recomendador personalizado é que você pode personalizar sua lógica de recomendação. Com um recomendador adicional, você pode particionar os VPAs em vários recomendadores se houver muitos objetos do VPA.

O exemplo a seguir é um recomendador adicional que você aplica ao cluster do AKS existente. Em seguida, configure o objeto VPA para usar o recomendador adicional.

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 # nobody 
      containers: 
      - name: recommender 
        image: registry.k8s.io/autoscaling/vpa-recommender:0.13.0 
        imagePullPolicy: Always 
        args: 
          - --recommender--nameame=extra-recommender 
        resources: 
          limits: 
            cpu: 200m 
            memory: 1000Mi 
          requests: 
            cpu: 50m 
            memory: 500Mi 
        ports: 
        - name: prometheus 
          containerPort: 8942

Implante o exemplo extra-recomender.yaml do Dimensionador Automático Vertical de Pod usando o comando kubectl apply e especifique o nome do seu manifesto YAML.
```
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.

Crie um arquivo chamado hamnster_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 de OOM. Neste caso, você só está definindo a CPU em controlledValues. controlledValues permite que você escolha se quer atualizar as solicitações de recurso do contêiner pela opção RequestsOnly ou pelas solicitações de recurso e limites usando a opção RequestsAndLimits. O valor padrão é RequestsAndLimits. Se você usar a opção RequestsAndLimits, as solicitações serão computadas 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 do VPA usando o modo Automático e as recomendações de computação para CPU e Memória.

Implante o exemplo hamster_extra-recomender.yaml usando o comando kubectl apply e especifique o nome do manifesto YAML.
```
kubectl apply -f hamster_customized_recommender.yaml
```
Aguarde até que o vpa-updater inicie um novo pod de hamster, o que deve levar alguns minutos. Você pode monitorar os pods usando o comando de obter do kubectl.
```
kubectl get --watch pods -l app=hamster
```

Quando um novo pod hamster for iniciado, descreva o pod que executa o comando descrever do kubectl e exiba as reservas de CPU e memória atualizadas.

kubectl describe pod hamster-<exampleID>

A saída de exemplo é um snippet das informações que descrevem o pod:

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

Para exibir as recomendações atualizadas da VPA, execute o comando de descrever do kubectl para descrever as informações do recurso hamster-vpa.

kubectl describe vpa/hamster-vpa

A saída de exemplo é um snippet das informações sobre a utilização do recurso:

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

Solução de problemas

Para diagnosticar os problemas com uma instalação do VPA, execute as etapas a seguir.

Verifique se todos os componentes do sistema estão sendo executados usando o seguinte comando:
```
kubectl ---namespace=kube-system get pods|grep vpa
```

A saída deve listar três pods: recomendador, atualizador e controlador de admissão, todos com o estado mostrando um status de Running.

Confirme se os componentes do sistema registram erros. Quanto aos pods retornados pelo comando anterior, execute o seguinte comando:
```
kubectl ---namespace=kube-system logs [pod name] | grep -e '^E[0-9]\{4\}'
```
Confirme se a definição de recurso personalizado foi criada executando o seguinte comando:
```
kubectl get customresourcedefinition | grep verticalpodautoscalers
```

Próximas etapas

Este artigo mostrou como dimensionar automaticamente a utilização de recursos, como CPU e memória, de nós de cluster para corresponder aos requisitos do aplicativo.

Você também pode usar o dimensionador automático de pod horizontal para ajustar automaticamente o número de pods que executam o aplicativo. Para obter as etapas de como usar o dimensionador automático de pod horizontal, confira Dimensionar aplicativos no AKS.
Consulte o Dimensionador Automático Vertical de Pod [referência de API] para saber mais sobre as definições dos objetos do VPA relacionados.

Share via