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

Artigo
12/09/2023

Este artigo fornece uma visão geral do Vertical Pod Autoscaler (VPA) no Serviço Kubernetes do Azure (AKS), que se baseia na versão de código aberto do Kubernetes . 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 a fazer uma utilização eficaz do seu cluster AKS.

O dimensionamento automático do Pod vertical fornece recomendações para o uso de recursos ao longo do tempo. Para gerenciar aumentos repentinos no uso de recursos, use o Horizontal Pod Autoscaler, que dimensiona o número de réplicas de pods conforme necessário.

Benefícios

O Vertical Pod Autoscaler oferece os seguintes benefícios:

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

Limitações

O dimensionamento automático de pods verticais suporta um máximo de 1.000 pods associados a VerticalPodAutoscaler objetos por cluster.
O VPA pode recomendar mais recursos do que os disponíveis no cluster. Como resultado, isso impede que o pod seja atribuído a um nó e executado, porque o nó não tem recursos suficientes. Você pode superar essa limitação definindo o LimitRange para 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 recomendações de recursos máximos permitidos por pod em um VerticalPodAutoscaler objeto. Esteja ciente de que o VPA não pode superar totalmente um problema de recurso de nó insuficiente. O intervalo de limite é fixo, mas o uso do recurso do nó é alterado dinamicamente.
Não recomendamos o uso do Vertical Pod Autoscaler com o Horizontal Pod Autoscaler, que é dimensionado com base nas mesmas métricas de uso de CPU e memória.
O VPA Recommender armazena apenas até oito dias de dados históricos.
O VPA não suporta cargas de trabalho baseadas em JVM devido à visibilidade limitada do uso real da memória da carga de trabalho.
Não é recomendado ou suportado executar a sua própria implementação de VPA juntamente com esta implementação gerida de VPA. Ter um recomendado extra ou personalizado é suportado.
Os contêineres do Windows AKS não são suportados.

Antes de começar

O cluster do AKS está a executar a versão 1.24 e superior do Kubernetes.
A CLI do Azure versão 2.52.0 ou posterior instalada e configurada. Executar az --version para localizar a versão. Se precisar de instalar ou atualizar, veja Install Azure CLI (Instalar o Azure CLI).
kubectl deve estar conectado ao cluster que você deseja instalar o VPA.

Visão geral do VPA

Objeto da API

O Vertical Pod Autoscaler é um recurso de API no grupo de API de dimensionamento automático do Kubernetes. A versão suportada é 0.11 e superior, e pode ser encontrada no repositório autoscaler do Kubernetes.

O objeto VPA consiste em três componentes:

Recomendador - monitora o consumo de recursos atual e passado e, com base nele, fornece valores recomendados para as solicitações/limites de CPU e memória dos contêineres. O Recommender monitora o histórico de métricas, eventos OOM (Falta de Memória) e a especificação de implantação do VPA e sugere solicitações justas. Ao fornecer uma solicitação de recurso adequada e uma configuração de limites, os limites são aumentados e reduzidos.
Updater - verifica quais dos pods gerenciados têm os recursos corretos definidos e, se não, os mata para que possam ser recriados por seus controladores com as solicitações atualizadas.
Controlador de admissão de VPA - define as solicitações de recursos corretas em novos pods (criados ou recriados por seu controlador devido à atividade do atualizador).

Controlador de admissão de VPA

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

Um trabalho independente é 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 VPA como um MutatingWebhookConfiguration.

Para alta disponibilidade, o AKS suporta duas réplicas de controladores de admissão.

Modos de operação do objeto VPA

Um recurso Vertical Pod Autoscaler é inserido para cada controlador que você deseja que os requisitos de recursos computados automaticamente. Isso é mais comumente uma implantação. Existem quatro modos de funcionamento dos APV:

Auto - VPA atribui solicitações de recursos durante a criação de pods e atualiza pods existentes usando o mecanismo de atualização preferido. Atualmente, é equivalente ao Recreate, Auto e também é o modo padrão. Uma vez que a atualização gratuita ("in-loco") de solicitações de pod esteja disponível, ela pode ser usada como o mecanismo de atualização preferido pelo Auto modo. Ao usar Recreate o modo, o VPA remove um pod se ele precisar alterar suas solicitações de recursos. Isso pode fazer com que os pods sejam reiniciados de uma só vez, causando inconsistências de aplicação. Você pode limitar as reinicializações e manter a consistência nessa situação usando um PodDisruptionBudget.
Recreate - VPA atribui solicitações de recursos durante a criação de pods, bem como atualiza pods existentes, expulsando-os quando os recursos solicitados diferem significativamente da nova recomendação (respeitando o Orçamento de Interrupção de Pod, se definido). Este modo deve ser usado raramente, apenas se você precisar garantir que os pods sejam reiniciados sempre que a solicitação de recurso for alterada. Caso contrário, o Auto modo é preferido, que pode tirar proveito de atualizações sem reinicialização assim que estiverem disponíveis.
Initial - O VPA apenas atribui solicitações de recursos durante a criação do pod e nunca muda depois.
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 VPA.

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

Um padrão de implantação comum recomendado para você se você não estiver familiarizado com o VPA é executar as seguintes etapas 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" em seu cluster de produção e execute VPA no modo de recomendação para que você possa testar e se familiarizar com VPA. UpdateMode = "Off" pode evitar a introdução de uma configuração incorreta que pode causar uma interrupção.
Estabeleça a observabilidade primeiro coletando telemetria de utilização real de recursos durante um determinado período de tempo. Isso ajuda você a entender o comportamento e os sinais de sintomas ou problemas dos recursos de contêiner e pod influenciados pelas cargas de trabalho em execução neles.
Familiarize-se com os dados de monitoramento para entender as características de desempenho. Com base nessa perceção, defina as solicitações/limites desejados de acordo e, em seguida, na próxima implantação ou atualização
Defina updateMode o valor como Auto, Recreateou Initial dependendo dos seus requisitos.

Implementar, atualizar ou desativar o VPA num cluster

Nesta seção, você implanta, atualiza ou desabilita o Vertical Pod Autoscaler em seu cluster.

Para habilitar o VPA em um novo cluster, use --enable-vpa o parâmetro com o comando az aks create .
```
az aks create \
    --name myAKSCluster \
    --resource-group myResourceGroup \
    --enable-vpa \
    --generate-ssh-keys
```
Após alguns minutos, o comando conclui e retorna informações formatadas em 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 conclui e retorna informações formatadas em JSON sobre o cluster.
Opcionalmente, para desativar 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 conclui e retorna informações formatadas em JSON sobre o cluster.
Para verificar se os pods Vertical Pod Autoscaler foram criados com êxito, use o comando kubectl get .

kubectl get pods --name kube-system

A saída do comando inclui os seguintes resultados específicos para os pods VPA. Os pods devem mostrar um status de 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 Dimensionamento 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 milinúcleos e tenta utilizar um pouco acima de 500 milinúcleos. Além disso, uma configuração de VPA é criada, apontando para a implantação. O 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 Vertical Pod Autoscaler do repositório GitHub kubernetes/autoscaler .
Implante o exemplo Vertical Pod Autoscaler usando o comando kubectl apply e especifique o hamster.yamlnome do seu manifesto YAML:
```
kubectl apply -f hamster.yaml
```
Após alguns minutos, o comando conclui e retorna informações formatadas em JSON sobre o cluster.

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

kubectl get pods -l app=hamster

A saída de exemplo é semelhante à seguinte:

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

Use o comando kubectl describe em um dos pods para visualizar sua CPU e reserva de memória. Substitua "exampleID" por um dos IDs de pod retornados na sua saída da etapa anterior.
```
kubectl describe pod hamster-exampleID
```
A saída de exemplo é um trecho 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 milicpu e 50 Mibibytes de memória reservados neste exemplo. Para este aplicativo de exemplo, o pod precisa de menos de 100 milicpu 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 vpa-recommender do Vertical Pod Autoscaler 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 reinicia os pods com valores atualizados.
Aguarde até que o vpa-updater lance um novo pod de hamster, o que deve levar alguns minutos. Você pode monitorar os pods usando o comando kubectl get .
```
kubectl get --watch pods -l app=hamster
```
Quando um novo pod de hamster for iniciado, descreva o pod que executa o comando kubectl describe e visualize as reservas atualizadas de CPU e memória.
```
kubectl describe pod hamster-<exampleID>
```
A saída de exemplo é um trecho 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 milicpu, o que é mais de cinco vezes o valor original. A memória aumentou para 262.144 Kilobytes, o que representa cerca de 250 Mibibytes, ou cinco vezes o valor original. Este pod estava com poucos recursos, e o Vertical Pod Autoscaler corrigiu a estimativa com um valor muito mais apropriado.

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

kubectl describe vpa/hamster-vpa

A saída de exemplo é um trecho 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 solicitações do Pod Autoscaler

O dimensionamento automático do pod vertical usa o objeto para definir automaticamente as solicitações de recursos em pods quando o VerticalPodAutoscaler updateMode é definido como um Auto. Você pode definir um valor diferente dependendo de seus requisitos e testes. Neste exemplo, updateMode é definido como Recreate.

Habilite o VPA para seu cluster executando o seguinte comando. Substitua o nome do cluster pelo nome do cluster AKS e substitua myResourceGroup pelo nome myAKSCluster 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.yamle copie no 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 conclui e retorna informações formatadas em JSON sobre o cluster.

Execute o seguinte comando kubectl get para obter os pods:

kubectl get pods

A saída é semelhante 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 no seguinte manifesto 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 targetRef.name valor especifica que qualquer pod controlado por uma implantação chamada vpa-auto-deployment pertence ao VerticalPodAutoscaler. O updateMode valor de significa que o controlador Vertical Pod Autoscaler pode excluir um pod, ajustar as solicitações de Recreate CPU e memória e, em seguida, criar um novo pod.
Aplique o manifesto ao cluster usando o comando kubectl apply :
```
kubectl create -f azure-vpa-auto.yaml
```

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

kubectl get pods

A saída é semelhante ao exemplo a seguir, mostrando que os nomes dos pods foram alterados e o status dos pods:

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 seus pods de corrida usando o comando Kubectl get . Substitua podName pelo nome de um dos pods recuperados na etapa anterior.

kubectl get pod podName --output yaml

A saída é semelhante ao exemplo a seguir, mostrando que o controlador Vertical Pod Autoscaler 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

Para obter informações detalhadas sobre o Vertical Pod Autoscaler e suas recomendações para CPU e memória, use o comando kubectl get :
```
kubectl get vpa vpa-auto --output yaml
```
A saída é semelhante ao seguinte exemplo:
```
 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 especifica que, para que o contêiner seja executado de forma ideal, ele não precisa alterar a CPU ou o target destino da memória. Seus resultados podem variar onde a CPU de destino e a recomendação de memória são maiores.

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

Recomendação Extra para Vertical Pod Autoscaler

No APV, um dos componentes principais é o Recomendador. Ele fornece recomendações para o uso de recursos com base no consumo de recursos em tempo real. O AKS implanta um recomendado quando um cluster habilita o VPA. Você pode implantar um recomendado personalizado ou um recomendado extra com a mesma imagem do padrão. O benefício de ter um recomendado personalizado é que você pode personalizar sua lógica de recomendação. Com um recomendado extra, você pode particionar VPAs para vários recomendadores se houver muitos objetos VPA.

O exemplo a seguir é uma recomendação extra que você aplica ao cluster AKS existente. Em seguida, configure o objeto VPA para usar o recomendado extra.

Crie um arquivo nomeado extra_recommender.yaml e copie no seguinte manifesto:

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 Vertical Pod Autoscaler usando o comando kubectl apply e especifique o extra-recomender.yamlnome do seu manifesto YAML.
```
kubectl apply -f extra-recommender.yaml 
```
Após alguns minutos, o comando conclui e retorna informações formatadas em JSON sobre o cluster.

Crie um arquivo nomeado hamnster_extra_recommender.yaml e copie no seguinte manifesto:

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 Recomendado não responderá a eventos OOM. Nesse caso, você está definindo apenas a CPU em controlledValues. controlledValues Permite que você escolha se deseja atualizar as solicitações de recursos do contêiner por RequestsOnly opção ou ambas as solicitações de recursos e limites usando a RequestsAndLimits opção. O valor predefinido é RequestsAndLimits. Se você usar a opção, as RequestsAndLimits 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 a 4 CPUs, o VPA sempre define o limite para ser o dobro das solicitações. O mesmo princípio se aplica à memória. Quando você usa o RequestsAndLimits modo, ele pode servir como um modelo para suas solicitações e limites iniciais de recursos do aplicativo.

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

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

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

kubectl describe pod hamster-<exampleID>

A saída de exemplo é um trecho 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 recomendações atualizadas do VPA, execute o comando kubectl describe para descrever as informações do recurso hamster-vpa.

kubectl describe vpa/hamster-vpa

A saída de exemplo é um trecho 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

Resolução de Problemas

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

Verifique se todos os componentes do sistema estão em execução 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. Para cada um dos 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 personalizada foi criada executando o seguinte comando:
```
kubectl get customresourcedefinition | grep verticalpodautoscalers
```

Próximos passos

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

Você também pode usar o autoscaler pod horizontal para ajustar automaticamente o número de pods que executam seu aplicativo. Para conhecer as etapas de uso do autoscaler de pod horizontal, consulte Dimensionar aplicativos no AKS.
Consulte o Vertical Pod Autoscaler [referência da API] para saber mais sobre as definições para objetos VPA relacionados.

Partilhar via