Como escalonar um aplicativo

Nesta página, você aprende a escalonar um aplicativo implantado no Google Kubernetes Engine.

Visão geral

Ao implantar um aplicativo no GKE, você define quantas réplicas do aplicativo pretende executar. Ao escalonar um aplicativo, você aumenta ou diminui o número de réplicas.

Cada réplica do aplicativo representa um pod do Kubernetes que encapsula os contêineres desse aplicativo.

Antes de começar

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

• Verifique se você ativou a API do Google Kubernetes Engine.
Ativar a API Google Kubernetes Engine
• Verifique se o SDK do Cloud está instalado.

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

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

Como usar o gcloud init

Se você receber o erro One of [--zone, --region] must be supplied: Please specify location, conclua esta seção.

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

   gcloud init

   Se você estiver usando 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.

Observação: para modificar essas configurações padrão nos comandos gcloud, use as sinalizações --project, --zone e --region.

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: para modificar essas configurações padrão nos comandos gcloud, use as sinalizações --project, --zone e --region.

Como inspecionar um aplicativo

Antes de escalonar o aplicativo, é preciso inspecioná-lo para garantir que esteja íntegro.

Para ver todos os aplicativos implantados no cluster, execute o comando a seguir:

kubectl get controller

Substitua controller por deployments, statefulsets ou outro tipo de objeto controlador.

Por exemplo, se você executar kubectl get deployments e tiver criado apenas uma implantação, a saída do comando será semelhante a esta:

NAME                  DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
my-app                1         1         1            1           10m

A saída desse comando é semelhante para todos os objetos, mas pode parecer um pouco diferente. Nas implantações, a saída tem seis colunas:

• NAME lista os nomes das implantações no cluster.
• DESIRED exibe o número pretendido de réplicas ou o estado pretendido do aplicativo, que você define ao criar a implantação.
• CURRENT mostra quantas réplicas estão em execução atualmente.
• UP-TO-DATE exibe o número de réplicas que foram atualizadas para atingir o estado desejado.
• AVAILABLE exibe quantas réplicas do aplicativo estão disponíveis para os usuários.
• AGE exibe o tempo de execução do aplicativo no cluster.

Neste exemplo, há apenas uma implantação, my-app, que tem apenas uma réplica porque seu estado desejado é uma réplica. Você define o estado pretendido no momento da criação, mas pode alterá-lo a qualquer momento dimensionando o aplicativo.

Como inspecionar StatefulSets

Antes de escalonar um StatefulSet, é preciso inspecioná-lo executando o seguinte comando:

kubectl describe statefulset my-app

Na saída desse comando, verifique o campo Status dos pods. Se o valor Failed for maior que 0, o escalonamento poderá falhar.

Se um StatefulSet parecer não íntegro, execute estas etapas:

1. Receba uma lista de pods e veja quais deles não são íntegros:

   kubectl get pods
   

2. Remova o pod não íntegro:

   kubectl delete pod-name
   

Tentar escalonar um StatefulSet enquanto ele estiver não íntegro pode torná-lo indisponível.

Como escalonar um aplicativo

Nas seções a seguir, você verá cada método que é possível usar para escalonar um aplicativo. O método kubectl scale é a maneira mais rápida de escalonar. No entanto, talvez você prefira outro método em algumas situações, como ao atualizar arquivos de configuração ou ao executar modificações no local.

kubectl scale

O comando kubectl scale permite alterar instantaneamente o número de réplicas que você quer executar no aplicativo.

Para usar kubectl scale, especifique o novo número de réplicas definindo a sinalização --replicas. Por exemplo, para escalonar my-app para quatro réplicas, execute o comando a seguir, substituindo controller por deployment, statefulset ou outro tipo de objeto controlador:

kubectl scale controller my-app --replicas 4

Se for bem-sucedida, a saída desse comando será semelhante a deployment "my-app" scaled.

Em seguida, execute:

kubectl get controller my-app

A saída será semelhante a:

NAME                  DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
my-app                4         4         4            4           15m

Observação: a conclusão do escalonamento pode levar vários minutos.

kubectl apply

É possível usar kubectl apply para aplicar um novo arquivo de configuração a um objeto controlador existente. kubectl apply é útil para fazer várias alterações para um recurso e pode ser útil para usuários que preferem gerenciar recursos em arquivos de configuração.

Para escalonar usando kubectl apply, o arquivo de configuração fornecido precisa incluir um novo número de réplicas no campo replicas da especificação do objeto.

Veja a seguir uma versão atualizada do arquivo de configuração para o objeto my-app de exemplo. O exemplo mostra uma implantação, portanto, se você usar outro tipo de controlador, como StatefulSet, altere kind proporcionalmente. Esse exemplo funciona melhor em um cluster com pelo menos três nós.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: app
  template:
    metadata:
      labels:
        app: app
    spec:
      containers:
      - name: my-container
        image: gcr.io/google-samples/hello-app:2.0

Neste arquivo, o valor do campo replicas é 3. Quando este arquivo de configuração é aplicado, o objeto my-app é dimensionado para três réplicas.

Para aplicar um arquivo de configuração atualizado, execute o comando a seguir:

kubectl apply -f config.yaml

Em seguida, execute:

kubectl get controller my-app

A saída será semelhante a:

NAME                  DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
my-app                3         3         3            3           15m

Console

Para escalonar uma carga de trabalho no Console do Google Cloud, execute as seguintes etapas:

1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

   Acessar o menu “Cargas de trabalho”

2. Selecione a carga de trabalho desejada no menu.

3. Clique em Ações e depois em Escalonar.

4. No campo Réplicas, insira o número desejado de réplicas.

5. Clique em Escalonar.

Como fazer escalonamento automático de implantações

É possível fazer o escalonamento automático de implantações com base na utilização de CPU dos pods usando kubectl autoscale ou no menu Cargas de trabalho do GKE no Console do Cloud.

kubectl autoscale

kubectl autoscale cria um objeto HorizontalPodAutoscaler (ou HPA) que segmenta um recurso especificado (chamado de meta de escalonamento) e o dimensiona conforme necessário. O HPA ajusta periodicamente o número de réplicas da meta de escalonamento para corresponder à utilização média de CPU que você especifica.

Observação: o modelo de pod do objeto pode incluir um campo resources que especifica uma solicitação de utilização de CPU para cada pod. Para saber mais sobre como fazer solicitações de recursos para pods e contêineres, consulte Como gerenciar recursos de computação para contêineres

Quando você usa kubectl autoscale, especifica um número máximo e mínimo de réplicas para o aplicativo, bem como uma meta de utilização da CPU. Por exemplo, para definir o número máximo de réplicas como seis e o mínimo como quatro, com uma meta de utilização da CPU de 50%, execute o comando abaixo:

kubectl autoscale deployment my-app --max 6 --min 4 --cpu-percent 50

Neste comando, a sinalização --max é obrigatória. A sinalização --cpu-percent é a meta de utilização de CPU em todos os pods. Este comando não escalona imediatamente a implantação para seis réplicas, a menos que já exista uma demanda sistêmica.

Depois de executar kubectl autoscale, o objeto HorizontalPodAutoscaler é criado e segmenta o aplicativo. Quando há alteração na carga, o objeto aumenta ou diminui as réplicas do aplicativo.

Observação: o número máximo de réplicas é limitado pelos recursos do cluster. Se o cluster tiver um número estático de nodes disponíveis, ele pode ficar sem recursos e impedir a execução de alguns pods replicados. Para saber sobre o escalonamento do cluster, consulte Como redimensionar um cluster e Escalonamento automático de cluster.

Para ver uma lista dos objetos HorizontalPodAutoscaler no cluster, execute:

kubectl get hpa

Para ver um objeto HorizontalPodAutoscaler específico no cluster, execute:

kubectl get hpa hpa-name

Em que hpa-name é o nome do objeto HorizontalPodAutoscaler.

Para ver a configuração HorizontalPodAutoscaler:

kubectl get hpa hpa-name -o yaml

A saída deste comando é semelhante a:

apiVersion: v1
items:
- apiVersion: autoscaling/v1
  kind: HorizontalPodAutoscaler
  metadata:
    creationTimestamp: ...
    name: hpa-name
    namespace: default
    resourceVersion: "664"
    selfLink: ...
    uid: ...
  spec:
    maxReplicas: 10
    minReplicas: 1
    scaleTargetRef:
      apiVersion: apps/v1
      kind: Deployment
      name: hpa-name
    targetCPUUtilizationPercentage: 50
  status:
    currentReplicas: 0
    desiredReplicas: 0
kind: List
metadata: {}
resourceVersion: ""
selfLink: ""

Neste exemplo de saída, o campo targetCPUUtilizationPercentage contém o valor de porcentagem 50 transmitido do exemplo kubectl autoscale.

Para ver uma descrição detalhada de um objeto HorizontalPodAutoscaler específico no cluster:

kubectl describe hpa hpa-name

Modifique o HorizontalPodAutoscaler aplicando um novo arquivo de configuração com kubectl apply, usando kubectl edit ou kubectl patch.

Para excluir um objeto HorizontalPodAutoscaler:

kubectl delete hpa hpa-name

Console

Para autenticar uma implantação, execute as etapas abaixo:

1. Acesse o menu Cargas de trabalho do Google Kubernetes Engine no Console do Cloud.

   Acessar o menu “Cargas de trabalho”

2. Selecione a carga de trabalho desejada no menu.

3. Clique em Ações e depois em Escalonamento automático.

4. Preencha o campo Número máximo de pods com o número máximo desejado de pods.

5. Opcionalmente, preencha os campos Número mínimo de pods e Meta de uso da CPU em porcentagem com os valores desejados.

6. Clique em Escalonamento automático.

Como fazer escalonamento automático com métricas personalizadas

Beta

Este produto ou recurso está em estado de pré-lançamento, podendo ser alterado ou ter suporte limitado. Para mais informações, consulte as etapas de lançamento do produto .

É possível escalonar suas implantações com base em métricas personalizadas (em inglês) exportadas pelo Kubernetes Engine Monitoring.

Para saber como usar métricas personalizadas para fazer o escalonamento automático de implementações, consulte este tutorial.

Observação: o Kubernetes Engine Monitoring é um serviço do Google Cloud separado do GKE. Para usar o escalonamento com base em métricas personalizadas, é preciso associar uma conta de serviço paga do pacote de operações do Google Cloud ao projeto do Console do Cloud. Para mais informações, consulte a documentação do Kubernetes Engine Monitoring.

A seguir

• Saiba mais sobre como exibir o aplicativo externamente.