WorkflowTemplate

Un WorkflowTemplate es exactamente lo que su nombre indica: una plantilla reutilizable de un flujo de trabajo.

Si tienes una secuencia de pasos que vas a ejecutar frecuentemente (por ejemplo, "construir imagen Docker" -> "correr tests" -> "enviar alerta por Slack"), no querrás escribir todo ese código YAML cada vez que necesites ejecutarlo.

• Un Workflow normal se ejecuta una vez y su definición vive y muere con esa ejecución.
• Un WorkflowTemplate se guarda en el clúster de Kubernetes como una definición estática (como si fuera una "función" en programación). Luego, puedes crear múltiples Workflows mucho más cortos que simplemente "llaman" a esa plantilla, pasándole diferentes parámetros.

---

💻 Laboratorio: Creando y usando un WorkflowTemplate

Paso 1: Crear el WorkflowTemplate

Vamos a crear una plantilla que hace algo sencillo: recibir un mensaje como parámetro y hacer que una ballena (usando la imagen docker/whalesay) lo imprima en pantalla.

Crea un archivo llamado workflow-template.yaml:

apiVersion: argoproj.io/v1alpha1
kind: WorkflowTemplate
metadata:
  name: whalesay-template
  namespace: argocd
spec:
  # Definimos qué plantilla se ejecutará por defecto si llamamos a este template
  entrypoint: whalesay-logic

  # Declaramos que esta plantilla acepta parámetros (con un valor por defecto)
  arguments:
    parameters:
    - name: mensaje
      value: "Hola desde el template por defecto"

  templates:
  - name: whalesay-logic
    inputs:
      parameters:
      - name: mensaje
    container:
      image: docker/whalesay:latest
      command: [cowsay]
      args: ["{{inputs.parameters.mensaje}}"]

Aplica este archivo en tu clúster:

kubectl apply -f workflow-template.yaml

Nota: Este comando solo guarda la plantilla en el clúster, no ejecuta ningún Pod todavía.

Paso 2: Ejecutar un Workflow usando la Plantilla

Ahora vamos a "instanciar" o llamar a esa plantilla creando un Workflow real. Observa lo corto que es este archivo, ya que toda la lógica de los contenedores reside en el WorkflowTemplate.

Crea un archivo llamado mi-ejecucion.yaml:

apiVersion: argoproj.io/v1alpha1
kind: Workflow
metadata:
  name: ejecucion-ballena-1
  namespace: argocd
spec:
  # Hacemos referencia al template que creamos en el Paso 2
  workflowTemplateRef:
    name: whalesay-template
  # Le pasamos el parámetro que queremos en esta ejecución específica
  arguments:
    parameters:
    - name: mensaje
      value: "¡Argo Workflows es increíble!"

Aplica el archivo para iniciar la ejecución:

kubectl apply -f mi-ejecucion.yaml

Paso 3: Observar los resultados

Una vez aplicado el Workflow, Argo Workflows creará un Pod para ejecutar la tarea. Puedes revisar el estado de tu Workflow ejecutando:

kubectl get workflows -n argo

Para ver el resultado de lo que hizo la ballena (los logs del contenedor), busca el nombre del Pod que se creó (tendrá el prefijo ejecucion-ballena-1) y mira sus logs:

# Ver los pods creados en el namespace argo
kubectl get pods -n argo

# Ver los logs del pod (sustituye el nombre exacto de tu pod)
kubectl logs ejecucion-ballena-1-xxxxx -n argo -c main

Resultado esperado en los logs:

 _____________________________ 
< ¡Argo Workflows es increíble! >
 ----------------------------- 
    \
     \
      \     
                    ##        .            
              ## ## ##       ==            
           ## ## ## ##      ===            
       /""""""""""""""""___/ ===        
  ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~   
       \______ o          __/            
        \    \        __/             
          \____\______/