Dimensionar e Balancear Carga em Aplicações

Introdução

Neste laboratório, você iniciará um cluster Kubernetes local usando o Minikube, implantará uma aplicação NGINX de exemplo e, em seguida, a escalará para atender às demandas variáveis. Você observará o balanceamento de carga em vários pods, monitorará eventos do cluster e obterá uma breve introdução ao Horizontal Pod Autoscaler (HPA) para automação de escalonamento futuro. Este laboratório visa fornecer uma experiência prática e abrangente para entender o escalonamento e o balanceamento de carga do Kubernetes.

Iniciar o Cluster Kubernetes

Nesta etapa, você aprenderá como iniciar e verificar um cluster Kubernetes local usando o Minikube. Este é um primeiro passo essencial para implantar e gerenciar aplicações em contêineres em um ambiente Kubernetes.

Primeiro, inicie o cluster Minikube:

minikube start

Exemplo de saída:

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🚀  Launching Kubernetes ...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Verifique o status do cluster usando múltiplos comandos:

minikube status
kubectl get nodes

Exemplo de saída para minikube status:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

Exemplo de saída para kubectl get nodes:

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Esses comandos confirmam que:

1. Minikube está rodando com sucesso.
2. Um cluster Kubernetes local foi criado.
3. O cluster está pronto para uso.
4. Você tem um cluster de nó único com capacidades de plano de controle.

Implantar uma Aplicação de Exemplo

Nesta etapa, você aprenderá como implantar uma aplicação web simples usando um Deployment Kubernetes com uma única réplica. Criaremos um manifesto YAML para um servidor web NGINX e o aplicaremos ao cluster Minikube. Entender como implantar uma aplicação é fundamental para usar o Kubernetes.

Primeiro, crie um diretório para seus manifestos Kubernetes:

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Crie um novo arquivo YAML para o deployment:

nano nginx-deployment.yaml

Adicione a seguinte configuração de deployment:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 1
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Salve o arquivo (Ctrl+X, depois Y, depois Enter).

Explicação da configuração YAML:

• apiVersion: apps/v1: Especifica a versão da API para Deployments.
• kind: Deployment: Indica que este é um objeto Deployment, usado para gerenciar aplicações replicadas.
• metadata: Contém metadados sobre o Deployment.
  • name: nginx-deployment: O nome do deployment.
  • labels: app: nginx: Um rótulo usado para identificar este deployment.
• spec: Contém a especificação do deployment.
  • replicas: 1: O número desejado de instâncias de pod (réplicas). Neste deployment inicial, temos apenas uma réplica.
  • selector: Define como o deployment selecionará os pods para gerenciar.
    • matchLabels: app: nginx: Pods com o rótulo app: nginx serão gerenciados por este deployment.
  • template: O template do pod. Ele especifica a configuração para os pods que o deployment cria.
    • metadata.labels: app: nginx: Rótulo que se aplica aos pods gerenciados por este deployment
    • spec.containers: Define os contêineres no pod
      • name: nginx: O nome do contêiner.
      • image: nginx:latest: A imagem Docker para o contêiner (usando a imagem NGINX mais recente).
      • ports: containerPort: 80: Expõe a porta 80 no contêiner.

Aplique o deployment ao cluster Kubernetes:

kubectl apply -f nginx-deployment.yaml

Exemplo de saída:

deployment.apps/nginx-deployment created

Verifique o status do deployment:

kubectl get deployments
kubectl get pods

Exemplo de saída para kubectl get deployments:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   1/1     1            1           30s

Exemplo de saída para kubectl get pods:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          30s

Pontos-chave sobre este deployment:

1. Criamos um Deployment com uma única réplica.
2. O deployment usa a imagem NGINX mais recente.
3. O contêiner expõe a porta 80.
4. O deployment tem um rótulo app: nginx para identificação.

Inspecione os detalhes do deployment:

kubectl describe deployment nginx-deployment

O exemplo de saída mostrará a configuração do deployment, eventos e o estado atual.

Escalar Deployments para Lidar com Carga Aumentada

Nesta etapa, você aprenderá como dimensionar sua aplicação para lidar com mais tráfego. No mundo real, à medida que sua aplicação se torna mais popular, uma réplica pode não ser suficiente para lidar com a carga. Para resolver isso, o Kubernetes permite que você dimensione facilmente sua aplicação, aumentando o número de instâncias de pod (réplicas).

Antes de dimensionar, vamos discutir brevemente por que múltiplas réplicas são necessárias. Uma única réplica de uma aplicação pode lidar apenas com uma certa quantidade de requisições concorrentes. Se o tráfego aumentar além dessa capacidade, a aplicação pode ficar lenta ou não responder. Ao ter múltiplas réplicas, a carga pode ser distribuída entre diferentes instâncias de pod, garantindo que a aplicação permaneça responsiva e disponível. Este conceito é essencial para criar aplicações escaláveis.

Você aprenderá agora como dimensionar seu deployment Kubernetes modificando o campo replicas no manifesto YAML e também usando o comando kubectl scale.

Abra o manifesto de deployment criado anteriormente:

nano ~/project/k8s-manifests/nginx-deployment.yaml

Modifique o campo replicas de 1 para 3:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 3 ## Changed from 1 to 3
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Salve o arquivo (Ctrl+X, depois Y, depois Enter).

Aplique o deployment atualizado:

kubectl apply -f ~/project/k8s-manifests/nginx-deployment.yaml

Exemplo de saída:

deployment.apps/nginx-deployment configured

Verifique o deployment dimensionado:

kubectl get deployments
kubectl get pods

Exemplo de saída para kubectl get deployments:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   3/3     3            3           5m

Exemplo de saída para kubectl get pods:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          5m
nginx-deployment-xxx-zzz            1/1     Running   0          30s
nginx-deployment-xxx-www            1/1     Running   0          30s

Método alternativo de dimensionamento usando kubectl scale:

kubectl scale deployment nginx-deployment --replicas=4

Exemplo de saída:

deployment.apps/nginx-deployment scaled

Verifique o novo número de réplicas:

kubectl get deployments
kubectl get pods

Pontos-chave sobre dimensionamento:

1. Modifique replicas no arquivo YAML ou use o comando kubectl scale.
2. Use kubectl apply para atualizar o deployment ao fazer alterações no arquivo YAML.
3. O Kubernetes garante que o número desejado de réplicas esteja rodando.
4. Você pode dimensionar tanto para cima (aumentar réplicas) quanto para baixo (diminuir réplicas).

Verificar o Balanceamento de Carga Verificando Múltiplas Respostas de Pods

Nesta etapa, você aprenderá como verificar o balanceamento de carga no Kubernetes criando um Service e verificando as respostas de múltiplos pods. O balanceamento de carga é crucial para distribuir o tráfego entre múltiplas réplicas, garantindo que nenhum pod seja sobrecarregado. Os Services Kubernetes lidam com este processo automaticamente.

Crie um service para expor o deployment:

nano ~/project/k8s-manifests/nginx-service.yaml

Adicione a seguinte configuração de service:

apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  type: ClusterIP
  ports:
    - port: 80
      targetPort: 80

Salve o arquivo (Ctrl+X, depois Y, depois Enter).

Explicação da configuração YAML:

• apiVersion: v1: Especifica a versão da API para Services.
• kind: Service: Indica que este é um objeto Service.
• metadata: Contém metadados sobre o Service.
  • name: nginx-service: O nome do Service.
• spec: Contém a especificação do service.
  • selector: Define para quais pods este service roteará o tráfego.
    • app: nginx: Seleciona pods com o rótulo app: nginx, que corresponde aos pods criados na etapa anterior.
  • type: ClusterIP: Cria um service interno com um endereço IP do cluster, usado para comunicação interna. Este tipo de service só é acessível dentro do cluster Kubernetes.
  • ports: Define como o service mapeará o tráfego.
    • port: 80: A porta que o service expõe.
    • targetPort: 80: A porta em que a aplicação dentro do contêiner está ouvindo.

Aplique o service:

kubectl apply -f ~/project/k8s-manifests/nginx-service.yaml

Exemplo de saída:

service/nginx-service created

Verifique o service:

kubectl get services

Exemplo de saída:

NAME            TYPE        CLUSTER-IP      EXTERNAL-IP   PORT(S)   AGE
kubernetes      ClusterIP   10.96.0.1       <none>        443/TCP   30m
nginx-service   ClusterIP   10.96.xxx.xxx   <none>        80/TCP    30s

Agora, para realmente verificar o balanceamento de carga, você criará um pod temporário e enviará múltiplas requisições ao service. Isso permite que você veja que as requisições estão sendo distribuídas entre diferentes pods NGINX.

Crie um pod temporário para testar o balanceamento de carga:

kubectl run curl-test --image=curlimages/curl --rm -it -- sh

Este comando faz o seguinte:

• kubectl run curl-test: Cria um novo pod chamado curl-test.
• --image=curlimages/curl: Usa uma imagem Docker com curl instalado.
• --rm: Remove automaticamente o pod quando ele é finalizado.
• -it: Aloca um pseudo-TTY e mantém o stdin aberto.
• -- sh: Inicia uma sessão de shell no pod.

Dentro do pod temporário, execute múltiplas requisições:

for i in $(seq 1 10); do curl -s nginx-service | grep -q "Welcome to nginx!" && echo "Welcome to nginx - Request $i"; done

Este loop enviará 10 requisições ao nginx-service. Cada requisição deve ser roteada para um dos pods NGINX disponíveis. A saída imprimirá Welcome to nginx - Request $i para cada requisição bem-sucedida.

Exemplo de saída:

Welcome to nginx - Request 1
Welcome to nginx - Request 2
Welcome to nginx - Request 3
...

Saia do pod temporário:

exit

Pontos-chave sobre balanceamento de carga:

1. Services distribuem o tráfego entre todos os pods correspondentes.
2. Cada requisição pode potencialmente atingir um pod diferente.
3. O Kubernetes usa uma abordagem round-robin por padrão.
4. O tipo de service ClusterIP fornece balanceamento de carga interno.
5. O teste curl mostra a carga sendo distribuída entre múltiplas instâncias NGINX.

Ajustar Dinamicamente a Escala do Deployment para Atender à Demanda

Nesta etapa, você praticará o ajuste dinâmico da escala do seu deployment Kubernetes para atender às mudanças nas demandas da aplicação usando o comando kubectl scale. Esta etapa enfatiza o aspecto prático de ajustar o número de réplicas em execução sem modificar diretamente o arquivo YAML, o que pode ser útil para ajustes rápidos em resposta a picos de tráfego.

Primeiro, verifique o status atual do deployment:

kubectl get deployments

Exemplo de saída:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   4/4     4            4           45m

Escale o deployment usando o comando kubectl:

kubectl scale deployment nginx-deployment --replicas=5

Exemplo de saída:

deployment.apps/nginx-deployment scaled

Verifique o novo número de réplicas:

kubectl get deployments
kubectl get pods

Exemplo de saída para deployments:

NAME               READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment   5/5     5            5           46m

Exemplo de saída para pods:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m
nginx-deployment-xxx-aaa            1/1     Running   0          1m
nginx-deployment-xxx-bbb            1/1     Running   0          1m

Agora, atualize o YAML do deployment para dimensionamento persistente:

nano ~/project/k8s-manifests/nginx-deployment.yaml

Modifique o campo replicas:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
  labels:
    app: nginx
spec:
  replicas: 5 ## Updated from previous value
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          ports:
            - containerPort: 80

Aplique a configuração atualizada:

kubectl apply -f ~/project/k8s-manifests/nginx-deployment.yaml

Exemplo de saída:

deployment.apps/nginx-deployment configured

Simule a redução da escala para demanda reduzida:

kubectl scale deployment nginx-deployment --replicas=2

Exemplo de saída:

deployment.apps/nginx-deployment scaled

Verifique o número reduzido de réplicas:

kubectl get deployments
kubectl get pods

Pontos-chave sobre dimensionamento:

1. Use kubectl scale para dimensionamento rápido e temporário.
2. Atualize o YAML para configuração persistente.
3. O Kubernetes garante um dimensionamento suave com interrupção mínima.
4. Você pode aumentar ou diminuir a escala com base nas necessidades da aplicação usando tanto o comando quanto a configuração.

Monitorar Eventos de Deployment e Pods para Mudanças

Nesta etapa, você aprenderá como monitorar deployments e pods Kubernetes usando vários comandos kubectl para rastrear mudanças, solucionar problemas e entender o ciclo de vida de suas aplicações. A observabilidade é crucial para garantir a saúde e o desempenho de suas aplicações.

Descreva o deployment atual para obter informações detalhadas:

kubectl describe deployment nginx-deployment

Exemplo de saída:

Name:                   nginx-deployment
Namespace:              default
CreationTimestamp:      [timestamp]
Labels:                 app=nginx
Replicas:               2 desired | 2 updated | 2 total | 2 available | 0 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Pod Template:
  Labels:  app=nginx
  Containers:
   nginx:
    Image:        nginx:latest
    Port:         80/TCP
    Host Port:    0/TCP
    Environment:  <none>
    Mounts:       <none>
Conditions:
  Type           Status  Reason
  ----           ------  ------
  Available      True    MinimumReplicasAvailable
  Progressing    True    NewReplicaSetAvailable
OldReplicaSets:  <none>
NewReplicaSet:   nginx-deployment-xxx (2/2 replicas created)
Events:          <some deployment events>

Obtenha informações detalhadas sobre pods individuais:

kubectl describe pods -l app=nginx

O exemplo de saída mostrará detalhes para cada pod, incluindo:

• Status atual
• Informações do contêiner
• Eventos
• Endereços IP
• Informações do nó

Visualize eventos em todo o cluster:

kubectl get events

Exemplo de saída:

LAST SEEN   TYPE      REASON              OBJECT                           MESSAGE
5m          Normal    Scheduled           pod/nginx-deployment-xxx-yyy    Successfully assigned default/nginx-deployment-xxx-yyy to minikube
5m          Normal    Pulled              pod/nginx-deployment-xxx-yyy    Container image "nginx:latest" already present on machine
5m          Normal    Created             pod/nginx-deployment-xxx-yyy    Created container nginx
5m          Normal    Started             pod/nginx-deployment-xxx-yyy    Started container nginx

Filtre eventos para recursos específicos:

kubectl get events --field-selector involvedObject.kind=Deployment

O exemplo de saída mostrará apenas eventos relacionados ao deployment.

Simule um evento excluindo um pod:

## Get a pod name
POD_NAME=$(kubectl get pods -l app=nginx -o jsonpath='{.items[0].metadata.name}')

## Delete the pod
kubectl delete pod $POD_NAME

Observe os eventos e a recriação do pod:

kubectl get events
kubectl get pods

Pontos-chave sobre monitoramento:

1. kubectl describe fornece informações detalhadas sobre os recursos.
2. kubectl get events mostra eventos em todo o cluster.
3. O Kubernetes substitui automaticamente os pods excluídos.
4. Os eventos ajudam a solucionar problemas de deployment.
5. Use describe para informações detalhadas sobre objetos e events para rastrear ações.

Breve Introdução ao Horizontal Pod Autoscaler (HPA) para Aprendizado Futuro

Nesta etapa, você terá uma introdução ao Horizontal Pod Autoscaler (HPA), um recurso Kubernetes poderoso que dimensiona automaticamente as aplicações com base na utilização de recursos. O HPA permite que você defina regras de dimensionamento com base em métricas como utilização da CPU, uso da memória ou até mesmo métricas personalizadas.

Entendendo o HPA:

O HPA ajusta automaticamente o número de réplicas de pod em execução em um Deployment, ReplicaSet ou StatefulSet com base no uso observado da CPU ou memória, ou com base em métricas personalizadas fornecidas por suas aplicações. Isso garante que sua aplicação possa escalar automaticamente para lidar com as mudanças nas cargas de tráfego, melhorando o desempenho e a disponibilidade.

Habilite o addon do servidor de métricas no Minikube:

minikube addons enable metrics-server

Exemplo de saída:

* The 'metrics-server' addon is enabled

O servidor de métricas fornece ao Kubernetes dados de uso sobre seus recursos e é essencial para o funcionamento do HPA.

Crie um deployment com solicitações de recursos:

nano ~/project/k8s-manifests/hpa-example.yaml

Adicione o seguinte conteúdo:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: php-apache
spec:
  selector:
    matchLabels:
      run: php-apache
  replicas: 1
  template:
    metadata:
      labels:
        run: php-apache
    spec:
      containers:
        - name: php-apache
          image: k8s.gcr.io/hpa-example
          ports:
            - containerPort: 80
          resources:
            limits:
              cpu: 500m
            requests:
              cpu: 200m
---
apiVersion: v1
kind: Service
metadata:
  name: php-apache
  labels:
    run: php-apache
spec:
  ports:
    - port: 80
  selector:
    run: php-apache

Aplique o deployment:

kubectl apply -f ~/project/k8s-manifests/hpa-example.yaml

Explicação da configuração YAML:

• Este arquivo YAML define um Deployment para uma aplicação PHP e o Service correspondente.
• A configuração do Deployment é muito semelhante à do NGINX, com a exceção de:
  • name: php-apache: O nome do deployment e do contêiner do pod.
  • image: k8s.gcr.io/hpa-example: A imagem Docker para o contêiner.
  • resources: Esta seção especifica os requisitos de recursos para o contêiner.
    • limits.cpu: 500m: A CPU máxima permitida para uso pelo contêiner.
    • requests.cpu: 200m: A quantidade garantida de CPU atribuída ao contêiner.
• O service é uma configuração de serviço padrão, expondo o deployment internamente.

Crie uma configuração HPA:

nano ~/project/k8s-manifests/php-apache-hpa.yaml

Adicione o seguinte manifesto HPA:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: php-apache
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: php-apache
  minReplicas: 1
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 50

Aplique a configuração HPA:

kubectl apply -f ~/project/k8s-manifests/php-apache-hpa.yaml

Explicação da configuração YAML:

• apiVersion: autoscaling/v2: Especifica a versão da API para HorizontalPodAutoscaler.
• kind: HorizontalPodAutoscaler: Indica que este é um objeto HPA.
• metadata: Contém metadados sobre o HPA.
  • name: php-apache: O nome do HPA.
• spec: Contém a especificação do HPA.
  • scaleTargetRef: Define o Deployment de destino que será dimensionado.
    • apiVersion: apps/v1: A versão da API do recurso de destino.
    • kind: Deployment: O tipo de recurso de destino, que é um Deployment.
    • name: php-apache: O nome do Deployment de destino a ser dimensionado.
  • minReplicas: 1: O número mínimo de réplicas a serem mantidas em execução.
  • maxReplicas: 10: O número máximo de réplicas para dimensionar.
  • metrics: Define como determinar as métricas de dimensionamento.
    • type: Resource: Dimensiona com base em uma métrica de recurso.
    • resource.name: cpu: Dimensiona com base no uso da CPU.
    • resource.target.type: Utilization: Dimensiona com base em uma porcentagem da CPU solicitada pelo pod
    • resource.target.averageUtilization: 50: Dimensiona quando o uso médio da CPU em todos os pods excede 50% das solicitações.

Verifique a configuração do HPA:

kubectl get hpa

Exemplo de saída:

NAME         REFERENCE              TARGETS         MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache  0%/50%          1         10        1          30s

Simule a Carga e Observe o Autoscaling em Tempo Real

Para simular alta carga e acionar o autoscaler, você executará um gerador de carga em um terminal e monitorará a atividade de dimensionamento em um terminal separado.

Primeiro, abra um terminal para o gerador de carga:

kubectl run -i --tty load-generator --rm --image=busybox --restart=Never -- /bin/sh -c "while sleep 0.01; do wget -q -O- http://php-apache; done"

NÃO FECHE o terminal com o gerador de carga. ABRA OUTRO TERMINAL para monitorar a atividade de dimensionamento.

No segundo terminal, você pode usar vários comandos para observar o autoscaling em tempo real:

1. Monitore o status do HPA (atualizações a cada poucos segundos):

kubectl get hpa -w

2. Observe os pods sendo criados à medida que o HPA escala:

kubectl get pods -w

3. Acompanhe os eventos relacionados à atividade de dimensionamento:

kubectl get events --sort-by='.lastTimestamp' -w

Você pode executar qualquer um desses comandos para observar diferentes aspectos do processo de autoscaling. Por exemplo, observar pods com a flag -w mostra os pods sendo criados em tempo real à medida que o sistema escala:

Exemplo de saída para kubectl get pods -w:

NAME                         READY   STATUS    RESTARTS   AGE
php-apache-xxxxxxxxx-xxxxx   1/1     Running   0          2m
load-generator               1/1     Running   0          30s
php-apache-xxxxxxxxx-yyyyy   0/1     Pending   0          0s
php-apache-xxxxxxxxx-yyyyy   0/1     ContainerCreating   0          0s
php-apache-xxxxxxxxx-yyyyy   1/1     Running   0          3s
php-apache-xxxxxxxxx-zzzzz   0/1     Pending   0          0s
php-apache-xxxxxxxxx-zzzzz   0/1     ContainerCreating   0          0s
php-apache-xxxxxxxxx-zzzzz   1/1     Running   0          2s

Você verá o HPA respondendo ao aumento da carga, dimensionando o número de pods. A atualização das métricas pode levar um minuto ou mais para refletir as mudanças:

Exemplo de saída para kubectl get hpa -w:

NAME         REFERENCE               TARGETS   MINPODS   MAXPODS   REPLICAS   AGE
php-apache   Deployment/php-apache   0%/50%    1         10        1          30s
php-apache   Deployment/php-apache   68%/50%   1         10        1          90s
php-apache   Deployment/php-apache   68%/50%   1         10        2          90s
php-apache   Deployment/php-apache   79%/50%   1         10        2          2m
php-apache   Deployment/php-apache   79%/50%   1         10        4          2m15s

Quando terminar de observar, pressione Ctrl+C para parar o comando de monitoramento e volte para o primeiro terminal e pressione Ctrl+C para parar o gerador de carga.

Pontos-chave sobre o HPA:

1. Dimensiona automaticamente os pods com base na utilização de recursos, o que melhora a resiliência da aplicação.
2. Pode dimensionar com base na CPU, memória ou métricas personalizadas.
3. Define contagens mínimas e máximas de réplicas, garantindo um dimensionamento equilibrado e eficiente.
4. O HPA é um componente crucial para manter o desempenho e a disponibilidade da aplicação sob carga variável.
5. Usar a flag -w (watch) com os comandos kubectl fornece monitoramento em tempo real das mudanças no cluster.

Resumo

Neste laboratório, você adquiriu experiência prática com dimensionamento e balanceamento de carga no Kubernetes. Você começou criando um cluster Kubernetes local com Minikube e implantando uma aplicação web NGINX básica. Em seguida, você explorou diferentes métodos de dimensionamento, incluindo a modificação de arquivos YAML de deployment e o uso de kubectl scale para ajustar o número de réplicas de pod. Você aprendeu como verificar o balanceamento de carga usando Kubernetes Services e um pod de teste temporário.

Além disso, você aprendeu como monitorar deployments e pods por meio dos comandos kubectl describe e kubectl get events. Por fim, você obteve uma compreensão básica do Horizontal Pod Autoscaler (HPA), incluindo como ele pode dimensionar automaticamente sua aplicação com base na utilização de recursos, usando um exemplo baseado em uma imagem php-apache. Este laboratório fornece uma introdução abrangente às técnicas de dimensionamento, balanceamento de carga, monitoramento e autoscaling do Kubernetes, e estabelece a base para gerenciar aplicações mais complexas no Kubernetes.