Escalar y equilibrar la carga de aplicaciones

Introducción

En este laboratorio, iniciará un clúster local de Kubernetes utilizando Minikube, desplegará una aplicación de muestra de NGINX y luego la escalará para satisfacer demandas variables. Observará el equilibrio de carga entre múltiples pods, monitoreará los eventos del clúster y obtendrá una breve introducción al Horizontal Pod Autoscaler (HPA) para la automatización de escalado en el futuro. Este laboratorio tiene como objetivo proporcionar una experiencia práctica integral para comprender el escalado y el equilibrio de carga en Kubernetes.

Iniciar el clúster de Kubernetes

En este paso, aprenderá cómo iniciar y verificar un clúster local de Kubernetes utilizando Minikube. Este es un paso esencial para desplegar y gestionar aplicaciones contenerizadas en un entorno de Kubernetes.

Primero, inicie el clúster de Minikube:

minikube start

Ejemplo de salida:

😄  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 el estado del clúster utilizando varios comandos:

minikube status
kubectl get nodes

Ejemplo de salida para minikube status:

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

Ejemplo de salida para kubectl get nodes:

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

Estos comandos confirman que:

Minikube se está ejecutando correctamente.
Se ha creado un clúster local de Kubernetes.
El clúster está listo para usar.
Tiene un clúster de un solo nodo con capacidades de plano de control.

Desplegar una aplicación de muestra

En este paso, aprenderá cómo desplegar una aplicación web simple utilizando un Despliegue (Deployment) de Kubernetes con una única réplica. Crearemos un manifiesto YAML para un servidor web NGINX y lo aplicaremos al clúster de Minikube. Comprender cómo desplegar una aplicación es fundamental para utilizar Kubernetes.

Primero, cree un directorio para sus manifiestos de Kubernetes:

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

Cree un nuevo archivo YAML para el despliegue:

nano nginx-deployment.yaml

Agregue la siguiente configuración de despliegue:

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

Guarde el archivo (Ctrl+X, luego Y, luego Enter).

Explicación de la configuración YAML:

apiVersion: apps/v1: Especifica la versión de la API para los Despliegues (Deployments).
kind: Deployment: Indica que este es un objeto Despliegue (Deployment), utilizado para gestionar aplicaciones replicadas.
metadata: Contiene metadatos sobre el Despliegue.
- name: nginx-deployment: El nombre del despliegue.
- labels: app: nginx: Una etiqueta utilizada para identificar este despliegue.
spec: Contiene la especificación del despliegue.
- replicas: 1: El número deseado de instancias de pods (réplicas). En este despliegue inicial, tenemos solo una réplica.
- selector: Define cómo el despliegue seleccionará los pods para gestionarlos.
  - matchLabels: app: nginx: Los pods con la etiqueta app: nginx serán gestionados por este despliegue.
- template: La plantilla del pod. Especifica la configuración para los pods que crea el despliegue.
  - metadata.labels: app: nginx: Etiqueta que se aplica a los pods gestionados por este despliegue.
  - spec.containers: Define los contenedores en el pod.
    - name: nginx: El nombre del contenedor.
    - image: nginx:latest: La imagen Docker para el contenedor (utilizando la última imagen de NGINX).
    - ports: containerPort: 80: Expone el puerto 80 en el contenedor.

Aplique el despliegue al clúster de Kubernetes:

kubectl apply -f nginx-deployment.yaml

Ejemplo de salida:

deployment.apps/nginx-deployment created

Verifique el estado del despliegue:

kubectl get deployments
kubectl get pods

Ejemplo de salida para kubectl get deployments:

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

Ejemplo de salida para kubectl get pods:

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

Puntos clave sobre este despliegue:

Creamos un Despliegue con una única réplica.
El despliegue utiliza la última imagen de NGINX.
El contenedor expone el puerto 80.
El despliegue tiene una etiqueta app: nginx para identificación.

Inspeccione los detalles del despliegue:

kubectl describe deployment nginx-deployment

La salida de ejemplo mostrará la configuración del despliegue, los eventos y el estado actual.

Escalar despliegues para manejar una carga aumentada

En este paso, aprenderá cómo escalar su aplicación para manejar más tráfico. En el mundo real, a medida que su aplicación se vuelve más popular, una sola réplica puede no ser suficiente para manejar la carga. Para abordar esto, Kubernetes le permite escalar fácilmente su aplicación aumentando el número de instancias de pods (réplicas).

Antes de escalar, discutamos brevemente por qué son necesarias múltiples réplicas. Una sola réplica de una aplicación solo puede manejar una cierta cantidad de solicitudes concurrentes. Si el tráfico aumenta más allá de esa capacidad, la aplicación puede volverse lenta o no responder. Al tener múltiples réplicas, la carga se puede distribuir entre diferentes instancias de pods, asegurando que la aplicación siga respondiendo y esté disponible. Este concepto es esencial para crear aplicaciones escalables.

Ahora aprenderá cómo escalar su despliegue de Kubernetes modificando el campo replicas en el manifiesto YAML y también utilizando el comando kubectl scale.

Abra el manifiesto de despliegue creado previamente:

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

Modifique el campo replicas de 1 a 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

Guarde el archivo (Ctrl+X, luego Y, luego Enter).

Aplique el despliegue actualizado:

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

Ejemplo de salida:

deployment.apps/nginx-deployment configured

Verifique el despliegue escalado:

kubectl get deployments
kubectl get pods

Ejemplo de salida para kubectl get deployments:

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

Ejemplo de salida 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 escalado utilizando kubectl scale:

kubectl scale deployment nginx-deployment --replicas=4

Ejemplo de salida:

deployment.apps/nginx-deployment scaled

Verifique el nuevo número de réplicas:

kubectl get deployments
kubectl get pods

Puntos clave sobre el escalado:

Modifique replicas en el archivo YAML o utilice el comando kubectl scale.
Utilice kubectl apply para actualizar el despliegue cuando realice cambios en el archivo YAML.
Kubernetes asegura que se estén ejecutando el número deseado de réplicas.
Puede escalar hacia arriba (aumentar réplicas) o hacia abajo (disminuir réplicas).

Verificar el equilibrio de carga comprobando las respuestas de múltiples pods

En este paso, aprenderá cómo verificar el equilibrio de carga en Kubernetes creando un Servicio y comprobando las respuestas de múltiples pods. El equilibrio de carga es crucial para distribuir el tráfico entre múltiples réplicas, asegurando que ningún solo pod se vea abrumado. Los Servicios de Kubernetes manejan este proceso automáticamente.

Cree un servicio para exponer el despliegue:

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

Agregue la siguiente configuración de servicio:

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

Guarde el archivo (Ctrl+X, luego Y, luego Enter).

Explicación de la configuración YAML:

apiVersion: v1: Especifica la versión de la API para los Servicios.
kind: Service: Indica que este es un objeto Servicio.
metadata: Contiene metadatos sobre el Servicio.
- name: nginx-service: El nombre del Servicio.
spec: Contiene la especificación del servicio.
- selector: Define a qué pods este servicio enrutará el tráfico.
  - app: nginx: Selecciona los pods con la etiqueta app: nginx, que coincide con los pods creados en el paso anterior.
- type: ClusterIP: Crea un servicio interno con una dirección IP de clúster, utilizado para la comunicación interna. Este tipo de servicio solo es accesible dentro del clúster de Kubernetes.
- ports: Define cómo el servicio mapeará el tráfico.
  - port: 80: El puerto que el servicio expone.
  - targetPort: 80: El puerto en el que la aplicación dentro del contenedor está escuchando.

Aplique el servicio:

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

Ejemplo de salida:

service/nginx-service created

Verifique el servicio:

kubectl get services

Ejemplo de salida:

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

Ahora, para verificar realmente el equilibrio de carga, creará un pod temporal y enviará múltiples solicitudes al servicio. Esto le permite ver que las solicitudes se están distribuyendo entre diferentes pods de NGINX.

Cree un pod temporal para probar el equilibrio de carga:

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

Este comando hace lo siguiente:

kubectl run curl-test: Crea un nuevo pod llamado curl-test.
--image=curlimages/curl: Utiliza una imagen Docker con curl instalado.
--rm: Elimina automáticamente el pod cuando haya terminado.
-it: Asigna una pseudo-TTY y mantiene la entrada estándar abierta.
-- sh: Inicia una sesión de shell en el pod.

Dentro del pod temporal, ejecute múltiples solicitudes:

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

Este bucle enviará 10 solicitudes al nginx-service. Cada solicitud debe enrutarse a uno de los pods de NGINX disponibles. La salida imprimirá Welcome to nginx - Request $i para cada solicitud exitosa.

Ejemplo de salida:

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

Salga del pod temporal:

exit

Puntos clave sobre el equilibrio de carga:

Los Servicios distribuyen el tráfico entre todos los pods coincidentes.
Cada solicitud puede llegar a un pod diferente.
Kubernetes utiliza un enfoque de round-robin por defecto.
El tipo de servicio ClusterIP proporciona equilibrio de carga interno.
La prueba con curl muestra que la carga se está distribuyendo entre múltiples instancias de NGINX.

Ajustar dinámicamente la escala del despliegue para satisfacer la demanda

En este paso, practicarás ajustar dinámicamente la escala de tu despliegue de Kubernetes para satisfacer las cambiantes demandas de la aplicación utilizando el comando kubectl scale. Este paso enfatiza el aspecto práctico de ajustar el número de réplicas en ejecución sin modificar directamente el archivo YAML, lo cual puede ser útil para realizar ajustes rápidos en respuesta a picos de tráfico.

Primero, verifica el estado actual del despliegue:

kubectl get deployments

Ejemplo de salida:

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

Escala el despliegue utilizando el comando kubectl:

kubectl scale deployment nginx-deployment --replicas=5

Ejemplo de salida:

deployment.apps/nginx-deployment scaled

Verifica el nuevo número de réplicas:

kubectl get deployments
kubectl get pods

Ejemplo de salida para los despliegues:

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

Ejemplo de salida para los 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

Ahora, actualiza el archivo YAML del despliegue para una escala persistente:

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

Modifica el 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

Aplica la configuración actualizada:

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

Ejemplo de salida:

deployment.apps/nginx-deployment configured

Simula una reducción de escala para una demanda menor:

kubectl scale deployment nginx-deployment --replicas=2

Ejemplo de salida:

deployment.apps/nginx-deployment scaled

Verifica el número reducido de réplicas:

kubectl get deployments
kubectl get pods

Puntos clave sobre la escala:

Utiliza kubectl scale para una escala rápida y temporal.
Actualiza el archivo YAML para una configuración persistente.
Kubernetes asegura una escala fluida con la mínima interrupción.
Puedes escalar hacia arriba o hacia abajo según las necesidades de la aplicación utilizando tanto el comando como la configuración.

Monitorear los eventos de despliegue y pods en busca de cambios

En este paso, aprenderás cómo monitorear los despliegues y pods de Kubernetes utilizando varios comandos de kubectl para seguir los cambios, solucionar problemas y entender el ciclo de vida de tus aplicaciones. La observabilidad es crucial para garantizar la salud y el rendimiento de tus aplicaciones.

Describe el despliegue actual para obtener información detallada:

kubectl describe deployment nginx-deployment

Ejemplo de salida:

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>

Obtén información detallada sobre pods individuales:

kubectl describe pods -l app=nginx

La salida de ejemplo mostrará detalles para cada pod, incluyendo:

Estado actual
Información del contenedor
Eventos
Direcciones IP
Información del nodo

Visualiza los eventos a nivel de clúster:

kubectl get events

Ejemplo de salida:

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

Filtra los eventos para recursos específicos:

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

La salida de ejemplo mostrará solo los eventos relacionados con el despliegue.

Simula un evento eliminando un 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

Observa los eventos y la recreación del pod:

kubectl get events
kubectl get pods

Puntos clave sobre el monitoreo:

kubectl describe proporciona información detallada sobre los recursos.
kubectl get events muestra los eventos a nivel de clúster.
Kubernetes reemplaza automáticamente los pods eliminados.
Los eventos ayudan a solucionar problemas de despliegue.
Utiliza describe para obtener información detallada sobre un objeto y events para seguir las acciones.

Introducción breve al Horizontal Pod Autoscaler (HPA) para un aprendizaje futuro

En este paso, obtendrás una introducción al Horizontal Pod Autoscaler (HPA), una poderosa característica de Kubernetes que escala automáticamente las aplicaciones en función de la utilización de recursos. El HPA te permite definir reglas de escalado basadas en métricas como la utilización de CPU, el uso de memoria o incluso métricas personalizadas.

Comprensión del HPA:

El HPA ajusta automáticamente el número de réplicas de pods en ejecución en un Deployment, ReplicaSet o StatefulSet en función de la utilización de CPU o memoria observada, o en función de métricas personalizadas proporcionadas por tus aplicaciones. Esto garantiza que tu aplicación pueda escalar automáticamente para manejar cargas de tráfico cambiantes, mejorando el rendimiento y la disponibilidad.

Habilita el complemento metrics server en Minikube:

minikube addons enable metrics-server

Ejemplo de salida:

* The 'metrics-server' addon is enabled

El metrics server proporciona a Kubernetes datos de utilización de tus recursos y es esencial para que funcione el HPA.

Crea un despliegue con solicitudes de recursos:

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

Agrega el siguiente contenido:

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

Aplica el despliegue:

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

Explicación de la configuración YAML:

Este archivo YAML define un Deployment para una aplicación PHP y el servicio correspondiente.
La configuración del Deployment es muy similar a la de NGINX, con la excepción de:
- name: php-apache: El nombre del despliegue y del contenedor del pod.
- image: k8s.gcr.io/hpa-example: La imagen Docker del contenedor.
- resources: Esta sección especifica los requisitos de recursos para el contenedor.
  - limits.cpu: 500m: La CPU máxima permitida para el contenedor.
  - requests.cpu: 200m: La cantidad de CPU garantizada asignada al contenedor.
El servicio es una configuración de servicio estándar que expone el despliegue internamente.

Crea una configuración de HPA:

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

Agrega el siguiente manifiesto de 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

Aplica la configuración de HPA:

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

Explicación de la configuración YAML:

apiVersion: autoscaling/v2: Especifica la versión de la API para HorizontalPodAutoscaler.
kind: HorizontalPodAutoscaler: Indica que este es un objeto HPA.
metadata: Contiene metadatos sobre el HPA.
- name: php-apache: El nombre del HPA.
spec: Contiene la especificación del HPA.
- scaleTargetRef: Define el Deployment objetivo que se escalará.
  - apiVersion: apps/v1: La versión de la API del recurso objetivo.
  - kind: Deployment: El tipo de recurso objetivo, que es un Deployment.
  - name: php-apache: El nombre del Deployment objetivo a escalar.
- minReplicas: 1: El número mínimo de réplicas a mantener en ejecución.
- maxReplicas: 10: El número máximo de réplicas a las que se puede escalar.
- metrics: Define cómo determinar las métricas de escalado.
  - type: Resource: Escala en función de una métrica de recurso.
  - resource.name: cpu: Escala en función del uso de CPU.
  - resource.target.type: Utilization: Escala en función de un porcentaje de la CPU solicitada por el pod.
  - resource.target.averageUtilization: 50: Escala cuando el uso promedio de CPU en todos los pods supera el 50% de las solicitudes.

Verifica la configuración de HPA:

kubectl get hpa

Ejemplo de salida:

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

Simular carga y observar el escalado automático en tiempo real

Para simular una carga alta y activar el escalador automático, ejecutarás un generador de carga en una terminal y monitorearás la actividad de escalado en una terminal separada.

Primero, abre una terminal para el generador 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"

NO CIERRES la terminal con el generador de carga. ABRE OTRA TERMINAL para monitorear la actividad de escalado.

En la segunda terminal, puedes usar varios comandos para observar el escalado automático en tiempo real:

Monitorea el estado del HPA (se actualiza cada pocos segundos):

kubectl get hpa -w

Observa cómo se crean los pods a medida que el HPA escala hacia arriba:

kubectl get pods -w

Realiza un seguimiento de los eventos relacionados con la actividad de escalado:

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

Puedes ejecutar cualquiera de estos comandos para observar diferentes aspectos del proceso de escalado automático. Por ejemplo, observar los pods con la bandera -w te muestra cómo se crean los pods en tiempo real a medida que el sistema escala:

Ejemplo de salida 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

Verás que el HPA responde a la carga aumentada escalando hacia arriba el número de pods. La actualización de las métricas puede tardar un minuto o más en reflejar los cambios:

Ejemplo de salida 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

Cuando hayas terminado de observar, presiona Ctrl+C para detener el comando de monitoreo y vuelve a la primera terminal y presiona Ctrl+C para detener el generador de carga.

Puntos clave sobre el HPA:

Escala automáticamente los pods en función de la utilización de recursos, lo que mejora la resiliencia de la aplicación.
Puede escalar en función de la CPU, la memoria o métricas personalizadas.
Define los recuentos mínimos y máximos de réplicas, garantizando un escalado equilibrado y eficiente.
El HPA es un componente crucial para mantener el rendimiento y la disponibilidad de la aplicación bajo diferentes cargas.
Usar la bandera -w (watch) con los comandos de kubectl proporciona un monitoreo en tiempo real de los cambios en el clúster.

Resumen

En este laboratorio, has adquirido experiencia práctica en escalado y equilibrio de carga en Kubernetes. Comenzaste creando un clúster local de Kubernetes con Minikube y desplegando una aplicación web básica de NGINX. Luego, exploraste diferentes métodos de escalado, incluyendo la modificación de archivos YAML de despliegue y el uso de kubectl scale para ajustar el número de réplicas de pods. Aprendiste cómo verificar el equilibrio de carga utilizando Servicios de Kubernetes y un pod de prueba temporal.

Además, aprendiste cómo monitorear despliegues y pods a través de los comandos kubectl describe y kubectl get events. Finalmente, adquiriste una comprensión básica del Horizontal Pod Autoscaler (HPA), incluyendo cómo puede escalar automáticamente tu aplicación en función de la utilización de recursos, utilizando un ejemplo basado en una imagen php-apache. Este laboratorio proporciona una introducción integral a las técnicas de escalado, equilibrio de carga, monitoreo y escalado automático en Kubernetes, y establece la base para la gestión de aplicaciones más complejas en Kubernetes.