Como dimensionar um aplicativo

Nesta página, explicamos como 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

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 ID do projeto padrão:

  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 a gcloud para a versão mais recente:

  gcloud components update

Observação: é possível modificar essas configurações padrão nos comandos gcloud usando as sinalizações operacionais --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 kubectl get [CONTROLLER]. Substitua [CONTROLLER] por deployments, statefulsets ou outro tipo de objeto de 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 alcançar 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, com apenas uma réplica, visto que seu estado pretendido é uma réplica. Você define o estado pretendido no momento da criação, mas pode alterá-lo a qualquer momento escalonando o aplicativo.

Como inspecionar StatefulSets

Antes de escalonar um StatefulSet, é preciso inspecioná-lo executando 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 pode apresentar falha.

Se um StatefulSet parecer não íntegro, execute kubectl get pods para ver quais réplicas estão com o problema. Em seguida, execute kubectl delete [POD], em que [POD] é o nome do pod não íntegro.

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

Como escalonar um aplicativo

Nas seções a seguir, descrevemos cada método que você pode usar para escalonar um aplicativo. O método kubectl scale é o caminho mais rápido para escalonar. No entanto, você pode preferir outro método em algumas situações, como ao atualizar arquivos de configuração ou ao executar modificações no local.

kubectl scale

Com a kubectl scale (em inglês), você altera rapidamente o número de réplicas do que você quer para executar o aplicativo.

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

kubectl scale [CONTROLLER] my-app --replicas 4

Se o comando for bem-sucedido, a saída 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 dimensionamento pode levar vários minutos.

kubectl apply

Use kubectl apply (em inglês) para aplicar um novo arquivo de configuração a um objeto controlador atual. 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 fazer o dimensionamento com kubectl apply, o arquivo de configuração que você fornece precisa incluir um novo número de réplicas no campo replicas da especificação do objeto.

Você encontra abaixo uma versão atualizada do arquivo de configuração do objeto my-app de exemplo: O exemplo mostra uma Implantação, portanto, se você usar outro tipo de controlador, como StatefulSet, altere o kind também. 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 esse arquivo de configuração é aplicado, o objeto my-app escala para três réplicas.

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

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 Platform, execute as seguintes etapas:

1. Acesse o menu "Cargas de trabalho" do Google Kubernetes Engine no console do GCP.

   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 escalonamento automático das implantações com base na utilização da CPU de pods usando kubectl autoscale ou a partir do menu “Cargas de trabalho” do GKE no console do GCP.

kubectl autoscale

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

Observação: o modelo de pod do seu objeto pode incluir um campo resources que especifica uma solicitação de utilização da 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.

Ao usar kubectl autoscale, você especifica o máximo e o mínimo de réplicas para o aplicativo, bem como a 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

Nesse comando, a sinalização --max é obrigatória. A sinalização --cpu-percent é a meta de utilização da 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 visa 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 consultar um objeto HorizontalPodAutoscaler específico no seu cluster, execute:

kubectl get hpa [HPA_NAME]

Para consultar 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, o campo targetCPUUtilizationPercentage contém o valor de porcentagem de 50 passado do exemplo kubectl autoscale.

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

kubectl describe hpa [HPA_NAME]

Você pode modificar o HorizontalPodAutoscaler aplicando um novo arquivo de configuração com kubectl apply usando kubectl edit, ou usando 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 GCP.

   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 um estado de pré-lançamento e pode ser alterado ou ter suporte limitado. Para mais informações, consulte Estágios de lançamento do produto.

É possível escalonar suas implantações com base em métricas personalizadas (em inglês) exportadas a partir do [Stackdriver 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 Stackdriver Monitoring é um serviço do Google Cloud Platform separado do GKE. Para usar o dimensionamento com base em métricas personalizadas, você precisa ter uma conta de serviço paga do Stackdriver associada ao seu projeto do Console do GCP. Para mais informações, consulte a documentação do Stackdriver Kubernetes Engine Monitoring.

A seguir

• Saiba mais sobre como exibir o aplicativo externamente.