Como configurar o escalonamento automático vertical de pods

Nesta página, explicamos como configurar o escalonamento automático de pods verticais em um cluster do Google Kubernetes Engine. O dimensionamento de pods verticais envolve 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 e de memória dos contêineres. Configure um VerticalPodAutoscaler para fazer recomendações para solicitações de CPU e memória ou para fazer alterações automáticas nessas solicitações.

Antes de começar

Prepare-se para a tarefa tomando as seguintes medidas:

  • Verifique se você ativou a API Google Kubernetes Engine.
  • Ativar a API Google Kubernetes Engine
  • Verifique se o SDK do Cloud está instalado.
  • Defina o código padrão do projeto:
    gcloud config set project [PROJECT_ID]
  • Se você estiver trabalhando com clusters zonais, defina a zona de computação padrão:
    gcloud config set compute/zone [COMPUTE_ZONE]
  • Se você estiver trabalhando com clusters regionais, defina a região de computação padrão:
    gcloud config set compute/region [COMPUTE_REGION]
  • Atualize o gcloud para a versão mais recente:
    gcloud components update

Observação sobre as versões da API

Para seguir este guia, você precisa ter a versão v1beta2 da API Vertical Pod Autoscaler instalada no cluster do Google Kubernetes Engine. Ela está disponível a partir da versão 1.11.8.

É recomendada a utilização dessa API. Para instruções sobre como migrar a partir de versões mais antigas da API, consulte o guia de migração.

Como ativar o escalonamento automático vertical de pods em um cluster

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

gcloud beta container clusters create [CLUSTER_NAME] --enable-vertical-pod-autoscaling

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:

cloud beta 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 um updateMode em "Off". Em seguida, cria uma implantação 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 em seu campo status. O VerticalPodAutoscaler não executa qualquer ação para atualizar as solicitações de recursos para os contêineres em execução.

Aqui está um manifesto para o VerticalPodAutoscaler:

apiVersion: autoscaling.k8s.io/v1beta2
kind: VerticalPodAutoscaler
metadata:
  name: my-rec-vpa
spec:
  targetRef:
    apiVersion: "extensions/v1beta1"
    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 de uma implantação:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-rec-deployment
spec:
  replicas: 2
  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 na implantação pertencem ao VerticalPodAutoscaler porque ele aponta para o destino de kind: Deployment e name: my-rec-deployment.

Copie o manifesto para um arquivo denominado my-rec-deployment.yaml e crie a implantação:

kubectl create -f my-rec-deployment.yaml

Aguarde um minuto e visualize o VerticalPodAutoscaler:

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

A saída 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, pode optar por excluir a implantação, adicionar solicitações de CPU e memória ao manifesto de implantação e reiniciar sua implantação.

Como atualizar solicitações de recursos automaticamente

Neste exercício, você cria uma implantação com dois pods. Cada pod tem um contêiner que solicita 100 milliCPU e 50 mebibytes de memória. Em seguida, cria um VerticalPodAutoscaler que ajusta automaticamente as solicitações de CPU e memória.

Veja aqui um manifesto de uma implantação:

apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  name: my-auto-deployment
spec:
  replicas: 2
  template:
    metadata:
      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 para um arquivo denominado my-deployment.yaml e crie a implantação:

kubectl create -f my-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-deployment-cbcdd49fb-d6bf9   1/1       Running            0          8s
my-deployment-cbcdd49fb-th288   1/1       Running            0          8s

Anote os nomes dos pods para uso posterior.

As solicitações de CPU e memória para a implantação são muito pequenas. Portanto, é provável que a implantação se beneficie de um aumento nos recursos.

Veja um manifesto de um VerticalPodAutoscaler:

apiVersion: autoscaling.k8s.io/v1beta2
kind: VerticalPodAutoscaler
metadata:
  name: my-vpa
spec:
  targetRef:
    apiVersion: "extensions/v1beta1"
    kind:       Deployment
    name:       my-deployment
  updatePolicy:
    updateMode: "Auto"

No manifesto, o campo targetRef informa que qualquer pod controlado por uma implantação denominada my-deployment pertence a este VerticalPodAutoscaler.

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

Copie o manifesto para um arquivo denominado 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 para 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 funcionará de maneira ideal se solicitar 587 milliCPU 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

Esta página foi útil? Conte sua opinião sobre:

Enviar comentários sobre…

Documentação do Kubernetes Engine