Como escalonar 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 código 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

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 o kubectl scale, você altera rapidamente o número de réplicas do aplicativo que pretende executar.

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 por 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

kubectl apply

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

Para fazer o escalonamento com kubectl apply, o arquivo de configuração que você fornecer 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 cria um objeto HorizontalPodAutoscaler (ou HPA) que tem como alvo 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 da CPU que você especifica.

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.

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

A partir do GKE versão 1.9, é possível escalonar as implantações com base em métricas personalizadas exportadas do Stackdriver Monitoring.

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

Próximas etapas

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

Enviar comentários sobre…

Documentação do Kubernetes Engine