Juan Manuel Hoyos

Posted on Jul 28

🚀 Escala tus Pods en Kubernetes usando KEDA

#kubernetes #devops #programming

¿Te has preguntado cómo escalar automáticamente tus aplicaciones en Kubernetes según eventos reales, como una cola con tareas pendientes?

En este artículo te mostraré cómo usar KEDA (Kubernetes-based Event Driven Autoscaler) para escalar dinámicamente un worker en Python en función de los mensajes en una cola Redis.

✅ Ideal si usas colas de trabajo, microservicios, workers o tareas en background.

🧠 ¿Qué es KEDA?

KEDA es un componente liviano que se conecta a tu clúster de Kubernetes y escala tus pods basado en eventos, no solo en métricas de CPU o memoria. Esto permite que escales cuando hay:

Mensajes en una cola
Eventos en Kafka
Entradas en una base de datos
Y muchos otros eventos

📦 Componentes del proyecto

Redis: Almacena tareas en una lista
Worker Python: Procesa tareas de la cola
KEDA: Motor de escalado automático
Kustomize: Gestión de manifiestos Kubernetes

🔧 Requisitos

Cluster Kubernetes (Minikube o en la nube)
kubectl y helm instalados
Docker (opcional, para construir imágenes personalizadas)
KEDA instalado

📂 Archivos del proyecto

Dockerfile (opcional)

FROM python:3.11-slim
WORKDIR /app
RUN pip install redis
COPY worker.py .
CMD ["python", "worker.py"]

worker.py

import redis
import time
import os

redis_host = os.getenv("REDIS_HOST", "localhost")
redis_queue = os.getenv("REDIS_QUEUE", "myqueue")

r = redis.Redis(host=redis_host, port=6379)

print(f"Worker started. Listening on queue: {redis_queue}", flush=True)
while True:
    task = r.blpop(redis_queue, timeout=0)
    if task:
        print(f"Processing task: {task[1].decode('utf-8')}", flush=True)
    time.sleep(1)

keda-scaledobject.yaml

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: redis-scaledobject
spec:
  scaleTargetRef:
    name: redis-worker
  pollingInterval: 5
  cooldownPeriod: 30
  minReplicaCount: 0
  maxReplicaCount: 5
  triggers:
  - type: redis
    metadata:
      address: redis.default:6379
      listName: myqueue
      listLength: "5"

redis-worker.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis-worker
spec:
  replicas: 0
  selector:
    matchLabels:
      app: redis-worker
  template:
    metadata:
      labels:
        app: redis-worker
    spec:
      containers:
      - name: worker
        image: juanhoyos/redis-worker:latest
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        env:
        - name: REDIS_HOST
          value: "redis"
        - name: REDIS_QUEUE
          value: "myqueue"

redis.yaml

# redis-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: redis
spec:
  replicas: 1
  selector:
    matchLabels:
      app: redis
  template:
    metadata:
      labels:
        app: redis
    spec:
      containers:
      - name: redis
        image: redis:7
        resources:
          requests:
            memory: "128Mi"
            cpu: "100m"
          limits:
            memory: "256Mi"
            cpu: "500m"
        ports:
        - containerPort: 6379
---
apiVersion: v1
kind: Service
metadata:
  name: redis
spec:
  ports:
  - port: 6379
  selector:
    app: redis

namespaces.yaml

apiVersion: v1
kind: Namespace
metadata:
  name: keda
  labels:
    name: keda

kustomization.yaml

apiVersion: kustomize.config.k8s.io/v1beta1
kind: Kustomization

resources:
  - namespaces.yaml
  - redis.yaml
  - redis-worker.yaml
  - keda-scaledobject.yaml

🛠️ Instalación paso a paso

1. Instalar KEDA con Helm

helm repo add kedacore https://kedacore.github.io/charts
helm repo update
helm install keda kedacore/keda \
  --version 2.17.2 \
  --namespace keda \
  --create-namespace

2. Construir imagen personalizada (opcional)

docker build -t <tu-usuario>/redis-worker:latest .
docker push <tu-usuario>/redis-worker:latest

💡 También puedes usar la imagen preconstruida: juanhoyos/redis-worker:latest

3. Desplegar la solución

kubectl apply -k .

🧠 ¿Cómo funciona?

El worker Python se conecta a Redis y monitorea la lista myqueue
KEDA mide la longitud de la cola
Si hay más de 5 mensajes, escala hasta 5 pods
Cuando la cola está vacía, reduce a 0 pods

🧪 Probar el autoscaling

1. Acceder al pod de Redis

kubectl exec -it deploy/redis -- sh

2. Generar tareas de prueba

i=1; while true; do
  echo "Enviando tareas del $i al $((i+39))"
  for j in $(seq $i $((i+39))); do
    redis-cli -h redis rpush myqueue "task$j"
  done
  i=$((i+40))
  sleep 10
done

3. Monitorear los pods

kubectl get pods -w

🏁 Conclusión

KEDA permite construir sistemas eficientes que escalan según la demanda real. Es perfecto para:

Workers en background
Sistemas basados en colas
Procesamiento de datos
Automatización de tareas

¿Interesado en ver ejemplos con Kafka o RabbitMQ? ¡Déjalo en los comentarios! 🚀

DEV Community