02 eventsource

El Rol del EventSource en Argo Events

En la arquitectura de Argo Events, el componente EventSource actúa como la puerta de enlace encargada de consumir, normalizar y transmitir eventos desde el exterior o el interior del clúster de Kubernetes. Su rol se puede resumir en los siguientes puntos clave:

Consumo y Escucha: Monitorea de forma activa o pasiva diversas fuentes externas e internas (Webhooks, AWS SQS, Apache Kafka, AWS S3, Cronjobs o recursos de Kubernetes).
Normalización: Transforma los formatos heterogéneos de cada plataforma en una estructura estandarizada bajo la especificación CloudEvents.
Desacoplamiento: Su única responsabilidad tras procesar el evento es publicarlo en el EventBus (el transporte interno de Argo Events). No ejecuta acciones directas en la infraestructura.
Recurso Nativo (CRD): Se define mediante archivos YAML de Kubernetes, permitiendo configurar múltiples fuentes de eventos en un solo objeto.

El flujo arquitectónico básico es: Origen del evento ➡️ EventSource ➡️ EventBus ➡️ Sensor ➡️ Acción/Trigger.

Laboratorio Práctico: Desplegando un EventSource de tipo Webhook

En este laboratorio configuraremos un entorno mínimo de Argo Events. Crearemos un EventSource que escuche peticiones HTTP (Webhook) y un Sensor que reaccione imprimiendo un mensaje en los logs cuando reciba dicho evento.

Prerrequisitos

Un clúster de Kubernetes local (Minikube, Kind o Docker Desktop).
kubectl instalado y configurado.

Paso 1: Crear el EventSource (Webhook)

Este archivo define un EventSource que levantará un servicio interno escuchando en el puerto 12000 en la ruta /webhook.

Guarda el siguiente contenido como webhook-eventsource.yaml:

apiVersion: argoproj.io/v1alpha1
kind: EventSource
metadata:
  name: webhook-example
  namespace: argo-events
spec:
  service:
    ports:
      - port: 12000
        targetPort: 12000
  webhook:
    example-endpoint:
      port: "12000"
      endpoint: /webhook
      method: POST

Aplica el recurso:

kubectl apply -f webhook-eventsource.yaml

Paso 2: Crear el Sensor (El consumidor del evento)

Para ver el flujo completo, necesitamos un componente que escuche al EventSource a través del EventBus. Este Sensor simplemente creará un Pod de Kubernetes (un trigger) que imprimirá el contenido del evento recibido.

Guarda el siguiente contenido como webhook-sensor.yaml:

apiVersion: argoproj.io/v1alpha1
kind: Sensor
metadata:
  name: webhook-example-sensor
  namespace: argo-events
spec:
  dependencies:
    - name: test-dep
      eventSourceName: webhook-example
      eventName: example-endpoint
  triggers:
    - template:
        name: log-trigger
        k8s:
          operation: create
          source:
            resource:
              apiVersion: v1
              kind: Pod
              metadata:
                generateName: webhook-trigger-pod-
              spec:
                containers:
                  - name: echo
                    image: alpine:latest
                    command: ["sh", "-c", "echo '¡Evento recibido con éxito en Argo Events!'"]
                restartPolicy: Never

Aplica el recurso:

kubectl apply -f webhook-sensor.yaml

Paso 3: Probar el Laboratorio

Para interactuar con nuestro EventSource desde nuestra máquina local, expondremos su puerto temporalmente mediante un port-forward.

Abre una terminal y expón el servicio del EventSource:

kubectl port-forward svc/webhook-example-eventsource-svc 12000:12000 -n argo-events

En otra terminal, envía una petición POST simulando el evento externo usando curl:

curl -X POST http://localhost:12000/webhook \
  -H "Content-Type: application/json" \
  -d '{"mensaje": "Hola desde el laboratorio"}'

Verifica que el Sensor haya reaccionado creando el Pod de respuesta:
```
kubectl get pods -n argo-events | grep webhook-trigger-pod
```
Revisa los logs del Pod creado para confirmar el éxito del laboratorio:
```
kubectl logs -n argo-events -l generateName=webhook-trigger-pod-
```

Resultado esperado: Deberías ver impreso el mensaje: ¡Evento recibido con éxito en Argo Events!. Esto demuestra cómo el EventSource capturó tu HTTP POST, lo envió al EventBus y el Sensor ejecutó la acción programada.