Como configurar o escalonamento automático do pod vertical

Nesta página, você aprende a configurar o escalonamento automático do pod vertical em um cluster do Google Kubernetes Engine. Esse escalonamento inclui o ajuste de solicitações de CPU e memória de um pod.

Visão geral

É possível usar o recurso personalizado VerticalPodAutoscaler para analisar e ajustar solicitações de CPU (em inglês) e de memória (em inglês) dos contêineres. Configure um VerticalPodAutoscaler para fazer recomendações de solicitações de CPU e memória ou para realizar alterações automáticas nessas solicitações.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

Defina configurações gcloud padrão usando um dos métodos a seguir:

  • Use gcloud init se você quer orientações para definir os padrões.
  • Use gcloud config para definir separadamente a região, a zona e o ID do projeto.

Como usar o gcloud init

  1. Execute gcloud init e siga as instruções:

    gcloud init

    Se você usa o SSH em um servidor remoto, utilize a sinalização --console-only para impedir que o comando inicie um navegador:

    gcloud init --console-only
  2. Siga as instruções para autorizar a gcloud a usar sua conta do Google Cloud.
  3. Crie uma nova configuração ou selecione uma atual.
  4. Escolha um projeto do Google Cloud.
  5. Escolha uma zona padrão do Compute Engine.

Como usar o gcloud config

  • Defina o ID do projeto padrão:
    gcloud config set project project-id
  • Se você estiver trabalhando com clusters zonais, defina a zona do Compute padrão:
    gcloud config set compute/zone compute-zone
  • Se você estiver trabalhando com clusters regionais, defina a região do Compute padrão:
    gcloud config set compute/region compute-region
  • Atualize gcloud para a versão mais recente:
    gcloud components update

Observação sobre as versões da API

Como pré-requisito deste guia, você precisa ter a versão v1 da API Vertical Pod Autoscaler instalada no cluster do Google Kubernetes Engine. Ela está disponível na versão 1.14.7-gke.10 ou superior e 1.15.4-gke.15 ou superior.

A utilização dessa API é bastante recomendada. Para instruções sobre como migrar de versões mais antigas da API, consulte o guia relacionado.

Como ativar o escalonamento automático do pod vertical em um cluster

Para criar um novo cluster com o escalonamento automático do pod vertical ativado, insira este comando:

    gcloud container clusters create [CLUSTER_NAME] --enable-vertical-pod-autoscaling --cluster-version=1.14.7
    

em que [CLUSTER_NAME] é o nome que você escolhe para o cluster.

Para ativar o escalonamento automático de pods verticais para um cluster atual, digite este comando:

    gcloud container clusters update [CLUSTER-NAME] --enable-vertical-pod-autoscaling
    

em que [CLUSTER_NAME] é o nome do cluster.

Como receber recomendações de recursos

Neste exercício, você cria um VerticalPodAutoscaler com o valor "Off" em updateMode. Em seguida, você cria um Deployment que tem dois pods, cada um com um contêiner. Quando os pods são criados, o VerticalPodAutoscaler analisa as necessidades de CPU e memória dos contêineres e registra essas recomendações no campo status. O VerticalPodAutoscaler não executa qualquer ação para atualizar as solicitações de recursos dos contêineres em execução.

Veja aqui um manifesto do VerticalPodAutoscaler:

    apiVersion: autoscaling.k8s.io/v1
    kind: VerticalPodAutoscaler
    metadata:
      name: my-rec-vpa
    spec:
      targetRef:
        apiVersion: "apps/v1"
        kind:       Deployment
        name:       my-rec-deployment
      updatePolicy:
        updateMode: "Off"
    

Salve o manifesto em um arquivo chamado my-rec-vpa.yaml e crie o VerticalPodAutoscaler:

    kubectl create -f my-rec-vpa.yaml
    

Veja aqui um manifesto do Deployment:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-rec-deployment
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: my-rec-deployment
      template:
        metadata:
          labels:
            app: my-rec-deployment
        spec:
          containers:
          - name: my-rec-container
            image: nginx
    

No manifesto, você vê que não há solicitações de CPU ou memória. Também é possível ver que os pods no Deployment pertencem ao VerticalPodAutoscaler, porque ele aponta para o destino de kind: Deployment e name: my-rec-deployment.

Copie o manifesto em um arquivo chamado my-rec-deployment.yaml e crie o Deployment:

    kubectl create -f my-rec-deployment.yaml
    

Aguarde um minuto e visualize o VerticalPodAutoscaler:

    kubectl get vpa my-rec-vpa --output yaml
    

O resultado mostra recomendações para solicitações de CPU e memória:

    ...
      recommendation:
        containerRecommendations:
        - containerName: my-rec-container
          lowerBound:
            cpu: 25m
            memory: 262144k
          target:
            cpu: 25m
            memory: 262144k
          upperBound:
            cpu: 7931m
            memory: 8291500k
    ...
    

Agora que você tem as solicitações de CPU e memória recomendadas, exclua o Deployment, adicione essas solicitações ao manifesto de Deployment ou reinicie o Deployment.

Como desativar contêineres específicos

Neste exercício, você cria um VerticalPodAutoscaler com um contêiner específico desativado. Em seguida, você cria um Deployment com um pod que tem dois contêineres. Quando o pod é criado, o VerticalPodAutoscaler gera e aplica uma recomendação apenas de um contêiner, ignorando o que foi desativado.

Veja aqui um manifesto do VerticalPodAutoscaler:

    apiVersion: autoscaling.k8s.io/v1
    kind: VerticalPodAutoscaler
    metadata:
      name: my-opt-vpa
    spec:
      targetRef:
        apiVersion: "apps/v1"
        kind:       Deployment
        name:       my-opt-deployment
      updatePolicy:
        updateMode: "Auto"
      resourcePolicy:
        containerPolicies:
        - containerName: my-opt-sidecar
          mode: "Off"
    

O VerticalPodAutoscaler tem mais informações na seção resourcePolicy. mode "Off" desativa as recomendações de um contêiner com um nome especificado. Neste caso, my-opt-sidecar.

Salve o manifesto em um arquivo chamado my-opt-vpa.yaml e crie o VerticalPodAutoscaler:

    kubectl create -f my-opt-vpa.yaml
    

Veja aqui um manifesto do Deployment:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-opt-deployment
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: my-opt-deployment
      template:
        metadata:
          labels:
            app: my-opt-deployment
        spec:
          containers:
          - name: my-opt-container
            image: nginx
          - name: my-opt-sidecar
            image: busybox
            command: ["sh","-c","while true; do echo Doing sidecar stuff!; sleep 60; done"]
    

Copie o manifesto em um arquivo chamado my-opt-deployment.yaml e crie o Deployment:

    kubectl create -f my-opt-deployment.yaml
    

Aguarde um minuto e visualize o VerticalPodAutoscaler:

    kubectl get vpa my-opt-vpa --output yaml
    

O resultado mostra recomendações para solicitações de CPU e memória:

    ...
      recommendation:
        containerRecommendations:
        - containerName: my-opt-container
    ...
    

Observe que há recomendações apenas para um contêiner. Não há recomendações de my-opt-sidecar devido à desativação do contêiner.

O VerticalPodAutoscaler nunca atualiza recursos em contêineres desativados. Depois de alguns minutos, o Pod é recriado, mas apenas um contêiner tem as solicitações de recurso atualizadas.

Como atualizar solicitações de recursos automaticamente

Neste exercício, você cria um Deployment com dois pods. Cada pod tem um contêiner que solicita 100 mili-CPUs e 50 mebibytes de memória. Em seguida, é criado um VerticalPodAutoscaler que ajusta automaticamente as solicitações de CPU e memória.

Veja aqui um manifesto do Deployment:

    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: my-auto-deployment
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: my-auto-deployment
      template:
        metadata:
          labels:
            app: my-auto-deployment
        spec:
          containers:
          - name: my-container
            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"]
    

Copie o manifesto em um arquivo chamado my-auto-deployment.yaml e crie o Deployment:

    kubectl create -f my-auto-deployment.yaml
    

Liste os pods em execução:

    kubectl get pods
    

A saída mostra os nomes dos pods em my-deployment:

    NAME                            READY     STATUS             RESTARTS   AGE
    my-auto-deployment-cbcdd49fb-d6bf9   1/1       Running            0          8s
    my-auto-deployment-cbcdd49fb-th288   1/1       Running            0          8s
    

Anote os nomes dos pods para uso posterior.

As solicitações de CPU e memória do Deployment são muito pequenas. Portanto, é provável que um aumento nos recursos seja bom para o Deployment.

Veja um manifesto de um VerticalPodAutoscaler:

    apiVersion: autoscaling.k8s.io/v1
    kind: VerticalPodAutoscaler
    metadata:
      name: my-vpa
    spec:
      targetRef:
        apiVersion: "apps/v1"
        kind:       Deployment
        name:       my-auto-deployment
      updatePolicy:
        updateMode: "Auto"
    

No manifesto, o campo targetRef informa que os pods controlados por um Deployment chamado my-deployment pertencem a esse VerticalPodAutoscaler.

O campo updateMode tem um valor Auto, o que significa que o VerticalPodAutoscaler pode atualizar solicitações de CPU e memória durante o ciclo de vida de um pod. Em outras palavras, o VerticalPodAutoscaler pode excluir um pod, ajustar as solicitações de CPU e memória e iniciar um novo pod.

Copie o manifesto em um arquivo chamado my-vpa.yaml e crie o VerticalPodAutoscaler:

    kubectl create -f my-vpa.yaml
    

Aguarde alguns minutos e veja os pods em execução novamente:

    kubectl get pods
    

Observe que os nomes do pod foram alterados. Se os nomes do pod ainda não tiverem mudado, aguarde mais um pouco e liste os pods em execução novamente.

Receba informações detalhadas sobre um dos seus pods em execução:

    kubectl get pod [POD_NAME] --output yaml
    

em que [POD_NAME] é o nome de um dos seus pods.

Na saída, veja que o VerticalPodAutoscaler aumentou as solicitações de memória e de CPU. Também é possível ver uma anotação que documenta a atualização:

    apiVersion: v1
    kind: Pod
    metadata:
      annotations:
        vpaUpdates: 'Pod resources updated by my-vpa: container 0: cpu capped to node
          capacity, memory capped to node capacity, cpu request, memory request'
    ...
    spec:
      containers:
      ...
        resources:
          requests:
            cpu: 510m
            memory: 262144k
        ...
    

Receba informações detalhadas sobre o VerticalPodAutoscaler:

    kubectl get vpa my-vpa --output yaml
    

A saída mostra três conjuntos de recomendações de solicitações de CPU e de memória: limite inferior, destino e limite superior:

    ...
      recommendation:
        containerRecommendations:
        - containerName: my-container
          lowerBound:
            cpu: 536m
            memory: 262144k
          target:
            cpu: 587m
            memory: 262144k
          upperBound:
            cpu: 27854m
            memory: "545693548"
    

A recomendação target informa que o contêiner terá a melhor execução se solicitar 587 mili-CPUs e 262.144 kilobytes de memória.

O VerticalPodAutoscaler usa as recomendações lowerBound e upperBound para decidir se exclui um pod e o substitui por um novo. Se um pod tiver solicitações abaixo do limite inferior ou acima do superior, o VerticalPodAutoscaler excluirá o pod e o substituirá por um que tenha a recomendação de destino.

A seguir