Kubernetes Event-driven Autoscaling

KEDA es un Escalador Kubernetes automático basado en eventos. Con KEDA, se puede impulsar el escalado de cualquier contenedor en Kubernetes en función de la cantidad de eventos que deben procesarse.

KEDA es un componente liviano y de un solo propósito que se puede agregar a cualquier clúster de Kubernetes. KEDA funciona junto con componentes estándar de Kubernetes, como Horizontal Pod Autoscalery puede ampliar la funcionalidad sin sobrescribir ni duplicar. Con KEDA, puede asignar explícitamente las aplicaciones que desea utilizar a escala basada en eventos, mientras que otras aplicaciones continúan funcionando. Esto convierte a KEDA en una opción flexible y segura para ejecutarse junto con cualquier número de otras aplicaciones o frameworks de Kubernetes.

Cómo funciona KEDA? KEDA desempeña dos funciones clave dentro de Kubernetes:

Agente : KEDA activa y desactiva los Deployments de Kubernetes para escalar hacia y desde cero sin eventos. Esta es una de las funciones principales del keda-operator que se ejecuta cuando se instala KEDA.
Métricas : KEDA actúa como un servidor de métricas de Kubernetes que expone datos de eventos enriquecidos, como la longitud de la cola o el retraso de la transmisión, al HPA para impulsar la escalabilidad horizontal. Depende de la implementación consumir los eventos directamente desde la fuente. Esto preserva la rica integración de eventos y permite que gestos como completar o abandonar mensajes en cola funcionen de forma inmediata. El servicio de métricas es la función principal del contenedor keda-operator-metrics-apiserver que se ejecuta cuando se instala KEDA.

El siguiente diagrama muestra cómo funciona KEDA junto con Kubernetes Horizontal Pod Autoscaler, fuentes de eventos externos y el etcd de Kubernetes.

Keda

Existes deferentes tipos de Scalers (Escaladores), los escaladores de KEDA pueden detectar si un Deployment debe activarse o desactivarse y alimentar métricas personalizadas para una fuente de eventos específica.

Se pueden encontrar una lista completa de Scalers en el siguiente enlace: https://keda.sh/docs/2.8/scalers/

Laboratorio: Kubernetes Event-driven Autoscaling

La guía consiste en realizar un autoescalamiento en una hora determinada, bajo un modelo de CRON. El escalador CRON le permite definir un rango de tiempo en el que desea escalar sus cargas de trabajo hacia adentro o hacia afuera.

Cuando comience la ventana de tiempo, escalará desde la cantidad mínima de réplicas hasta la cantidad deseada de réplicas según su configuración.

Keda

Ingresar al ambiente de laboratorio en el servidor student-#-aio al cluster de usuarios de Kubernetes, exportar la variable de ambiente KUBECONFIG
```
export KUBECONFIG=~/rke-cluster-users/kube_config_cluster.yml
```
Agregar el repositorio de KEDA CORE a la instalación de HELM, HELM es un manejador de paquetes que ayuda en la instalación de Software para Kubernetes, en otro apartado del entrenamiento se revisará con mayor detalle.
```
helm repo add kedacore https://kedacore.github.io/charts
```
Puede realizar la actualización de todos los repositorios de paquetes HELM con el siguiente comando:
```
helm repo update
```
A continuación crearemos un recurso Namespace de Kubernetes llamado keda
```
kubectl create namespace keda
```

A continuación ejecutar la instalación de KEDA

helm install keda kedacore/keda --namespace keda

Verificar los Pods creados en el Namespace keda, debe esperar a que los pods se encuentren ejecutándose en su totalidad y sin ningun inconveniente
```
kubectl get pods  -n keda
```

Crear un archivo YAML con el nombre php-apache.yaml para realizar un Deployment y un recurso tipo Service llamados php-apache. Asegurarse de crear el archivo en formato YAML con el indentado correcto.

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

Al Deployment anterior se le creará un Autoescalamiento basado en Eventos, el evento será que se cumpla una franja de horario.

Llevar a cabo el Deployment y la creación del servicio utilizando una forma declarativa con el archivo creado anteriormente:
```
kubectl apply -f php-apache.yaml -n keda
```
Verificar que el Deployment haya sido creado satisfactoriamente con el siguiente comando:
```
kubectl -n keda rollout status deploy/php-apache
```
Revisar los PODS creados a partir del Deployment con el siguiente comando:
```
kubectl -n keda get pods
```

Crear un archivo YAML llamado keda-cron-example.yaml el cual contendra el Recurso ScaledObject, el cual realizará el Autoescalamiento.

apiVersion: keda.sh/v1alpha1
kind: ScaledObject
metadata:
  name: apache-scaledobject
  namespace: keda
spec:
  scaleTargetRef:
    name: php-apache
  triggers:
    - type: cron
      metadata:
      # Required
        timezone: America/Guatemala  # The acceptable values would be a value from the IANA Time Zone Database.
        start: 30 * * * *       # Every hour on the 30th minute
        end: 45 * * * *         # Every hour on the 45th minute
        desiredReplicas: "10"

Puede ajustar la zona de su país, por ejemplo para México es: America/Mexico_City Para poder verificar el Autoescalamiento con KEDA, en el atributo start y end del archivo YAML coloque un rango de tiempo próximo a cumplirse, en el ejemplo anterior al autoescalamiento se dará entre el minuto 30 y el minuto 45 de cada hora.

Crear el recurso scaledobject con el siguiente comando:

kubectl apply -f keda-cron-example.yaml -n keda

Explorar el recuso scaledobject creado anteriormente
```
kubectl get scaledobject -n keda
```
Revisar los PODS que se encuentran creados en este punto del laboratorio
```
kubectl get pods  -n keda
```
Verificar el recurso tipo HorizontalPodAutoscaler (HPA) que fue creado
```
kubectl get hpa -n keda
kubectl describe hpa -n keda
```
Abra otra terminal, ingrese con las credenciales correspondientes para verificar la cantidad de PODS que se crean al cumplirse el rango de tiempo especificado y compruebe como se produce al Autoescalamiento:
```
export KUBECONFIG=~/rke-cluster-users/kube_config_cluster.yml
```
```
watch kubectl get pods -n keda
```

Cuando se encuentre en el rango de tiempo especificado, puede regresar a la terminal uno y verificar los eventos del recurso HorizontalPodAutoscaler (HPA) que fue creado:

kubectl describe hpa -n keda

... texto omitido
Normal  SuccessfulRescale  3m33s  horizontal-pod-autoscaler  New size: 4; reason: external metric s0-cron-America-Guatemala-30xxxx-45xxxx(&LabelSelector{MatchLabels:map[string]string{scaledobject.keda.sh/name: apache-scaledobject,},MatchExpressions:[]LabelSelectorRequirement{},}) above target
  Normal  SuccessfulRescale  3m18s  horizontal-pod-autoscaler  New size: 8; reason: external metric s0-cron-America-Guatemala-30xxxx-45xxxx(&LabelSelector{MatchLabels:map[string]string{scaledobject.keda.sh/name: apache-scaledobject,},MatchExpressions:[]LabelSelectorRequirement{},}) above target
  Normal  SuccessfulRescale  3m3s   horizontal-pod-autoscaler  New size: 10; reason: external metric s0-cron-America-Guatemala-30xxxx-45xxxx(&LabelSelector{MatchLabels:map[string]string{scaledobject.keda.sh/name: apache-scaledobject,},MatchExpressions:[]LabelSelectorRequirement{},}) above target

Revisar los PODS que se encuentran creados en este punto del laboratorio

kubectl get pods  -n keda

... texto omitido
NAME                                               READY   STATUS    RESTARTS   AGE
keda-operator-6664f888bb-g97pl                     1/1     Running   0          9m16s
keda-operator-metrics-apiserver-84456bf6cf-rzv9r   1/1     Running   0          9m16s
php-apache-d4cf67d68-2bt99                         1/1     Running   0          3m43s
php-apache-d4cf67d68-dw6r8                         1/1     Running   0          3m28s
php-apache-d4cf67d68-h6rzx                         1/1     Running   0          3m58s
php-apache-d4cf67d68-jdn97                         1/1     Running   0          3m28s
php-apache-d4cf67d68-n2wgj                         1/1     Running   0          3m58s
php-apache-d4cf67d68-ndbbh                         1/1     Running   0          3m43s
php-apache-d4cf67d68-pcj7f                         1/1     Running   0          3m58s
php-apache-d4cf67d68-qsxdl                         1/1     Running   0          7m7s
php-apache-d4cf67d68-w7fcs                         1/1     Running   0          3m43s
php-apache-d4cf67d68-xztnk                         1/1     Running   0          3m43s

Cuando haya verificado el Autoescalamiento utilizando Kubernetes Event-driven Autoscaling, puede llevar a cabo la limpieza del ambiente de la siguiente manera:

kubectl delete -f  keda-cron-example.yaml -n keda

kubectl delete -f php-apache.yaml -n keda

helm uninstall keda -n keda

kubectl delete namespace keda