Uso del HorizontalPodAutoscaler en Kubernetes

Introducción

HorizontalPodAutoscaler es una característica de Kubernetes que te permite escalar automáticamente el número de pods en una implementación (deployment) en función de la utilización de recursos. En este laboratorio, aprenderemos cómo utilizar HorizontalPodAutoscaler para escalar automáticamente nuestra implementación.

Iniciar el clúster de Minikube

Antes de crear recursos, necesitas un clúster de Kubernetes en ejecución. Minikube es un entorno ligero de Kubernetes que se ejecuta en tu máquina local.

1. Navegar a tu directorio de trabajo:

   Abre la terminal y navega hasta la carpeta de proyecto predeterminada:

   cd /home/labex/project

2. Iniciar Minikube:

   Inicia Minikube para inicializar un clúster de Kubernetes:

   minikube start

   • Este comando configura un clúster de Kubernetes de un solo nodo en tu máquina local.
   • Minikube puede tardar unos minutos en iniciar, dependiendo del rendimiento de tu sistema.

3. Verificar que Minikube esté en ejecución:

   Comprueba el estado del clúster de Minikube:

   minikube status

   • Busca componentes como kubelet y apiserver listados como Running (En ejecución).
   • Si el clúster no está en ejecución, vuelve a ejecutar minikube start.

Si encuentras problemas al iniciar Minikube, utiliza minikube delete para restablecer el entorno si es necesario.

Crear una implementación (Deployment)

Primero, necesitamos crear una implementación a la cual aplicaremos el HorizontalPodAutoscaler.

1. Crea un archivo de implementación llamado deployment.yaml con el siguiente contenido:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: hpa-demo
spec:
  replicas: 1
  selector:
    matchLabels:
      app: hpa-demo
  template:
    metadata:
      labels:
        app: hpa-demo
    spec:
      containers:
        - name: hpa-demo
          image: nginx
          resources:
            limits:
              cpu: "1"
              memory: 512Mi
            requests:
              cpu: "0.5"
              memory: 256Mi
---
apiVersion: v1
kind: Service
metadata:
  name: hpa-demo
spec:
  selector:
    app: hpa-demo
  ports:
    - name: http
      port: 80
      targetPort: 80

Esta implementación especifica una única réplica de un contenedor Nginx con límites y solicitudes de recursos para CPU y memoria.

2. Crea la implementación:

kubectl apply -f deployment.yaml

Crear un HorizontalPodAutoscaler

Ahora que tenemos una implementación (deployment), podemos crear un HorizontalPodAutoscaler para escalar automáticamente la implementación.

1. Crea un archivo de HorizontalPodAutoscaler llamado hpa.yaml con el siguiente contenido:

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

Este HorizontalPodAutoscaler especifica que queremos escalar la implementación hpa-demo para que tenga entre 1 y 10 réplicas, y que queremos alcanzar un uso promedio de CPU del 50%.

2. Crea el HorizontalPodAutoscaler:

kubectl apply -f hpa.yaml

Probar el HorizontalPodAutoscaler

Ahora que tenemos un HorizontalPodAutoscaler, podemos probarlo generando carga en la implementación (deployment).

1. Habilita el metrics-server

minikube addons enable metrics-server

2. Crea un pod de generación de carga:

kubectl run -i --tty load-generator --image=busybox /bin/sh

3. En el pod de generación de carga, ejecuta el siguiente comando para generar carga en la implementación:

while true; do wget -q -O- http://hpa-demo; done

4. Abre otra terminal y verifica el estado del HorizontalPodAutoscaler:

kubectl get hpa

Puedes ver que el número de réplicas de hpa-demo se ha extendido a 10. Puedes verificar el número de réplicas con el siguiente comando.

kubectl get pods -l app=hpa-demo

5. Detén la generación de carga escribiendo ctrl+c en el pod de generación de carga.

Resumen

En este laboratorio, aprendimos cómo usar el HorizontalPodAutoscaler para escalar automáticamente una implementación (deployment) en función del uso de recursos. Creamos una implementación, un HorizontalPodAutoscaler y lo probamos generando carga en la implementación. También vimos cómo el HorizontalPodAutoscaler escaló la implementación en respuesta al aumento de la carga.