Introducción

Integrar Apache Airflow con .NET 10 no significa portar el orquestador, reescribir DAGs en C# ni ejecutar el runtime de Python dentro de la aplicación. La solución correcta es mantener a Airflow como responsable de crear, programar y monitorear workflows y hacer que el servicio .NET consuma su API REST pública. El servicio se autentica, dispara un DAG Run con parámetros, guarda el identificador devuelto y consulta el estado hasta recibir success, failed o canceled. Esta separación preserva el papel de cada tecnología y crea un contrato claro entre la aplicación transaccional y la plataforma de datos.

En esta guía, voy a implementar este flujo de punta a punta usando .NET 10, HttpClient, autenticación JWT y la API /api/v2 de Apache Airflow 3.3. El ejemplo no se limita a un POST: genera un dag_run_id rastreable, serializa conf correctamente, reutiliza el token hasta cerca de su expiración, renueva la credencial tras una respuesta 401, aplica timeout al monitoreo y propaga la cancelación. También voy a exponer la integración mediante una Minimal API, para que otro sistema pueda iniciar el proceso sin conocer los detalles de Airflow.

El nombre actual de la plataforma de Microsoft es .NET 10, y no “.NET Core 10”. La marca “.NET Core” se usó hasta la versión 3.1; desde .NET 5, el producto unificado pasó a llamarse solo .NET. Esta diferencia no altera el código, pero evita confusiones al buscar documentación, imágenes de contenedor y paquetes compatibles.

El escenario práctico será un servicio de pedidos que solicita la ejecución del DAG etl_vendas. La configuración enviada contiene la fecha de referencia y un identificador de correlación. Airflow sigue ejecutando tareas Python, SQL, contenedores o jobs distribuidos; C# solo controla el ciclo de vida de la ejecución a través de la frontera HTTP.

ℹ️ Información: en Airflow 3, los endpoints públicos estables están bajo /api/v2. Las rutas internas de la UI no son un contrato de integración y pueden cambiar junto con el frontend.

Requisitos previos

Para seguir el ejemplo, necesitas el .NET 10 SDK, Docker Compose 2.14 o superior y al menos 4 GB de memoria disponibles para Docker. El repositorio incluye una instancia de Apache Airflow 3.3.0, PostgreSQL 16 y el DAG etl_vendas, por lo que no es necesario instalar Airflow ni Python directamente en la máquina. La autenticación usa un JWT obtenido mediante POST /auth/token.

El ejemplo fue escrito para la API pública v2. Si tu empresa todavía usa Airflow 2, la API estable normalmente aparece bajo /api/v1, con contratos y mecanismos de autenticación que pueden variar. No cambies solo el número en la URL: valida el OpenAPI de la versión instalada, porque los nombres de campos, estados y recursos disponibles no son necesariamente idénticos.

También debes confirmar estos puntos antes de programar:

  • El servicio .NET puede resolver el DNS y abrir una conexión TLS con el endpoint de Airflow.
  • El usuario técnico tiene solo los permisos necesarios para disparar y leer el DAG elegido.
  • El proxy inverso acepta los verbos POST y GET, el header Authorization y el tamaño máximo previsto para conf.
  • El DAG es idempotente o recibe una clave de negocio que impide el procesamiento duplicado.
  • El timeout del servicio es compatible con la duración esperada del workflow.

En producción, almacena la contraseña en un vault, un secret de contenedor o una variable de entorno. La clave jerárquica de .NET será Airflow__Senha; los dos guiones bajos representan el separador de configuración. Nunca publiques la credencial en appsettings.json, en una imagen Docker, en un log ni en la telemetría.

Levantando Airflow 3 con datos persistentes en Docker

El ejemplo usa un stack más pequeño que el quick-start oficial porque el objetivo es probar la integración REST, no demostrar el CeleryExecutor. El LocalExecutor ejecuta las tareas en el mismo entorno que el scheduler y elimina Redis y los workers de Celery. Se mantienen los componentes necesarios de Airflow 3: API server, scheduler, DAG processor, triggerer, inicializador y PostgreSQL.

Todos los datos relevantes usan bind mounts, es decir, directorios explícitos del repositorio montados en los contenedores. Los DAGs quedan en dags/, los logs en logs/, la configuración en config/, los plugins en plugins/ y el clúster PostgreSQL en data/postgres/. Los directorios generados están en .gitignore; solo el DAG, el Compose y los archivos .gitkeep se versionan. Ejecutar docker compose down puede destruir contenedores y red sin borrar la base de datos, los usuarios, el historial ni los logs.

En Airflow 3, el executor también necesita comunicarse con la Execution API. Por eso, todos los servicios reciben AIRFLOW__CORE__EXECUTION_API_SERVER_URL=http://airflow-api-server:8080/execution/. Usar localhost en esta variable haría que el scheduler buscara la API dentro de su propio contenedor y las tasks fallarían con Connection refused, incluso con el healthcheck externo saludable.

El fragmento siguiente muestra los mounts. El archivo completo también define healthchecks y dependencias de inicialización:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
services:
  postgres:
    image: postgres:16-alpine
    volumes:
      # Los metadatos y el historial sobreviven a la recreación del contenedor.
      - ./data/postgres:/var/lib/postgresql/data

  airflow-api-server:
    image: apache/airflow:3.3.0
    command: api-server
    ports:
      # El puerto 8081 evita conflictos con otros servicios locales.
      - "8081:8080"
    volumes:
      - ./dags:/opt/airflow/dags
      - ./logs:/opt/airflow/logs
      - ./config:/opt/airflow/config
      - ./plugins:/opt/airflow/plugins

📂 Código Fuente: El stack, el DAG y las instrucciones completas están disponibles en el repositorio de ejemplos: BlogSamples/Orchestration/Airflow/

Inicializa la base de datos y crea el usuario en la primera ejecución. El comando up -d --wait solo retorna cuando los healthchecks terminan:

1
2
3
4
# Ejecuta desde la carpeta Orchestration/Airflow del ejemplo.
Copy-Item .env.example .env
docker compose up airflow-init
docker compose up -d --wait

La interfaz web y la API pública estarán en http://localhost:8081. Las credenciales por defecto del ejemplo son el usuario dotnet-service y la contraseña airflow; cámbialas en .env en cualquier entorno compartido. Para configurar el cliente .NET sin grabar la contraseña en un archivo, usa una variable de entorno:

1
2
3
# Los dos guiones bajos representan Airflow:Senha en la configuración de .NET.
$env:Airflow__Senha = "airflow"
dotnet run --project src/BlogSamples

⚠️ Atención: este stack está destinado a desarrollo y demostración. Las credenciales por defecto, el LocalExecutor y una API HTTP sin TLS no cumplen los requisitos de producción.

Cómo Apache Airflow divide las responsabilidades

Apache Airflow representa los workflows mediante DAGs, grafos acíclicos dirigidos que describen tareas y dependencias. Un DAG es la definición; un DAG Run es una ejecución concreta de esa definición en un contexto determinado. Varios DAG Runs del mismo DAG pueden coexistir, y cada uno tiene su propio dag_run_id, estado, fechas y configuración. Esta distinción es esencial para que el cliente .NET no confunda el pipeline con una de sus ejecuciones.

El scheduler evalúa programaciones y dependencias. El executor envía las tareas al entorno de ejecución, que puede usar procesos locales, Celery o Kubernetes, según la implementación. Los workers ejecutan las tareas. La interfaz web presenta grids, grafos, logs e historial. La API pública ofrece una frontera programática sobre estos recursos. Por lo tanto, el servicio .NET no necesita conocer colas internas, la base de metadatos ni detalles de los workers.

Esta arquitectura funciona bien en pipelines de ETL, entrenamiento de modelos, generación de informes y automatizaciones con muchas etapas. Un checkout en .NET puede publicar un evento y responder rápidamente, mientras Airflow coordina un procesamiento posterior. En otro escenario, una API administrativa puede disparar el DAG y esperar el resultado porque el operador necesita una confirmación síncrona. La elección entre esperar y desacoplar depende de la duración y del impacto en el usuario, no de la capacidad técnica de la API.

El estado del DAG Run se deriva de las tareas hoja. Según la documentación oficial, los estados finales normales de un DAG Run son success y failed; el endpoint experimental de espera también considera canceled. Estados como queued y running indican que la ejecución todavía puede cambiar. Un cliente no debe interpretar HTTP 200 en el disparo como una conclusión exitosa: esa respuesta confirma la creación del DAG Run, no el resultado del workflow.

API REST v2, JWT y contrato de autenticación

El flujo de autenticación documentado para Airflow 3 comienza en POST /auth/token. El cuerpo contiene username y password, y la respuesta contiene access_token. Las llamadas siguientes envían Authorization: Bearer <token>. Como el endpoint de token lo proporciona el auth manager, una implementación corporativa puede usar otro mecanismo o añadir requisitos. Consulta la configuración del entorno antes de asumir que las credenciales locales estarán habilitadas.

Después de la autenticación, el disparo usa POST /api/v2/dags/{dag_id}/dagRuns. En Airflow 3.3, el cuerpo exige dag_run_id, conf y logical_date; envía logical_date: null cuando quieras que el servidor determine la fecha lógica. La configuración es un objeto JSON entregado al contexto del DAG. La consulta usa GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}. El identificador debe escaparse en la URL, incluso cuando los nombres actuales parecen contener solo letras y guiones bajos.

En C#, mapeo los nombres en snake case explícitamente. Esto es importante porque JsonSerializerDefaults.Web produce camel case, no dag_run_id. El fragmento siguiente muestra los contratos principales:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
public sealed record DispararDagRequest(
    [property: JsonPropertyName("dag_run_id")] string DagRunId,
    [property: JsonPropertyName("conf")]
  IReadOnlyDictionary<string, object?> Configuracao,
  // El campo es obligatorio en la API 3.3, pero puede ser nulo.
  [property: JsonPropertyName("logical_date")]
  DateTimeOffset? DataLogica = null);

public sealed record DagRunResponse(
    [property: JsonPropertyName("dag_run_id")] string DagRunId,
    [property: JsonPropertyName("dag_id")] string DagId,
    [property: JsonPropertyName("state")] string Estado,
    [property: JsonPropertyName("start_date")] DateTimeOffset? Inicio,
    [property: JsonPropertyName("end_date")] DateTimeOffset? Fim);

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/Orchestration/Airflow/

Un cliente robusto no solicita un nuevo token en cada polling. Lee el claim exp del JWT y reutiliza la credencial mientras haya margen de validez. Un SemaphoreSlim impide que varias solicitudes concurrentes renueven el token al mismo tiempo. Si el servidor responde 401 o 403 tras una rotación de la clave JWT, el cliente invalida la caché, se autentica de nuevo y repite la llamada una única vez. Un permiso realmente insuficiente seguirá devolviendo 403 en el segundo intento. Las repeticiones ilimitadas ocultarían credenciales incorrectas y podrían presionar el endpoint de autenticación.

Identidad de la ejecución, parámetros e idempotencia

El dag_run_id es el puente de trazabilidad entre las dos plataformas. En el ejemplo, sigue el formato dotnet__<timestamp UTC>__<guid>. El timestamp ayuda durante una investigación manual, mientras que el GUID evita colisiones entre instancias del servicio. Registro este identificador junto con el dag_id, el estado y el correlation ID de la solicitud de origen. Así, una búsqueda en el log de .NET lleva al DAG Run correspondiente en la interfaz de Airflow.

Para procesos de negocio, la aleatoriedad no basta. Imagina que el cliente envía el mismo pedido dos veces tras un timeout de red. El primer POST puede haber creado la ejecución, aunque la respuesta no haya llegado. Repetir automáticamente el disparo con otro GUID produciría dos workflows. Una estrategia más sólida deriva el identificador de una clave idempotente, como pedido__8f32..., y trata 409 Conflict consultando la ejecución ya existente. Otra alternativa persiste una outbox antes de la integración y deja que un worker controle los intentos.

El objeto conf debe contener referencias pequeñas e inmutables, no archivos ni grandes lotes de registros. Envía pedido_id, data_referencia, la URI de un objeto o un correlation ID. El DAG usa estas referencias para obtener los datos en la fuente autorizada. La propia documentación advierte que los payloads muy grandes pueden afectar la estabilidad del webserver y recomienda límites en el proxy.

⚠️ Atención: no apliques una política genérica de retry al POST de disparo sin una clave idempotente. Un fallo de transporte no prueba que Airflow haya dejado de crear el DAG Run.

Evita también colocar secretos en conf. La configuración aparece en los metadatos del DAG Run y puede quedar visible para operadores autorizados. Pasa solo identificadores; recupera las credenciales en un secrets backend de Airflow, como HashiCorp Vault, AWS Secrets Manager u otro provider compatible con tu infraestructura.

Arquitectura del disparo y del monitoreo

El flujo síncrono tiene tres fases. Primero, el servicio .NET obtiene o reutiliza un JWT. Después, crea el DAG Run y recibe el estado inicial, generalmente queued. Por último, consulta la misma ejecución en intervalos controlados hasta un estado terminal. La cancelación de la solicitud y un timeout propio deben interrumpir el bucle para no mantener conexiones y tareas indefinidamente.

Flujo de la API REST entre un servicio .NET 10 y Apache Airflow para disparar y monitorear un DAG

Prefiero un polling explícito con GET en el ejemplo principal porque los endpoints usados son estables. Airflow 3 también ofrece GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id}/wait, que transmite actualizaciones en NDJSON, pero la documentación lo clasifica como experimental. Puede ser útil en automatizaciones controladas, pero no es la mejor base para un contrato de larga duración sin encapsulamiento y pruebas de compatibilidad.

El intervalo de polling debe equilibrar latencia y carga. Consultar cada 100 milisegundos no acelera el DAG y multiplica las solicitudes al webserver. Para workflows de minutos, cinco o diez segundos suelen ser un punto de partida razonable. Añade jitter cuando muchas instancias puedan iniciar juntas, evitando que todas consulten en el mismo instante. Para miles de workflows simultáneos, prefiere un worker central, callbacks o eventos en lugar de mantener una solicitud HTTP por ejecución.

El timeout del HttpClient limita una llamada individual; no limita todo el monitoreo. Por eso, el ejemplo usa un CancellationTokenSource vinculado al token recibido y llama a CancelAfter con el tiempo máximo del workflow. Esta distinción evita un error común: configurar 30 segundos en el cliente HTTP y creer que todo el bucle terminará en ese plazo.

Ejemplo Práctico

El núcleo del ejemplo es un cliente tipado registrado con IHttpClientFactory. El BaseAddress viene de la configuración, y cada llamada crea su propio HttpRequestMessage. El header Bearer queda en el mensaje, no en DefaultRequestHeaders, lo que evita disputas cuando solicitudes concurrentes usan tokens diferentes durante una renovación.

El método siguiente crea un identificador, arma conf y dispara la ejecución:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
public async Task<DagRunResponse> DispararAsync(
    string dagId,
    IReadOnlyDictionary<string, object?>? configuracao = null,
    CancellationToken cancellationToken = default)
{
    // El ID único permite correlacionar los logs de .NET y de Airflow.
    var dagRunId = $"dotnet__{DateTimeOffset.UtcNow:yyyyMMddTHHmmssfff}__{Guid.NewGuid():N}";
    var payload = new DispararDagRequest(
        dagRunId,
        configuracao ?? new Dictionary<string, object?>());

    var caminho = $"api/v2/dags/{Uri.EscapeDataString(dagId)}/dagRuns";
    return await EnviarAutenticadoAsync<DagRunResponse>(
        () => new HttpRequestMessage(HttpMethod.Post, caminho)
        {
            Content = JsonContent.Create(payload)
        },
        cancellationToken);
}

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/Orchestration/Airflow/

El monitor usa la respuesta del disparo y solo vuelve a consultar mientras el estado no sea terminal:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
public async Task<DagRunResponse> DispararEMonitorarAsync(
    string dagId,
    IReadOnlyDictionary<string, object?>? configuracao,
    CancellationToken cancellationToken)
{
    var execucao = await DispararAsync(dagId, configuracao, cancellationToken);
    using var timeout = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
    timeout.CancelAfter(TimeSpan.FromMinutes(10));

    while (!EstadosFinais.Contains(execucao.Estado))
    {
        // Un polling moderado evita sobrecargar el webserver de Airflow.
        await Task.Delay(TimeSpan.FromSeconds(5), timeout.Token);
        execucao = await ObterExecucaoAsync(dagId, execucao.DagRunId, timeout.Token);
    }

    return execucao;
}

📂 Código Fuente: El ejemplo completo está disponible en el repositorio de ejemplos del blog: BlogSamples/Orchestration/Airflow/

La aplicación registra el cliente y llama a una Minimal API con el siguiente cuerpo:

1
2
3
4
5
6
7
8
9
{
  // Parámetros pequeños y no confidenciales entregados al DAG.
  "configuracao": {
    "data_referencia": "2026-07-21",
    "correlation_id": "pedido-8f328ba9"
  },
  // El endpoint permanece abierto hasta success, failed o canceled.
  "aguardarConclusao": true
}
1
2
3
4
# Dispara el DAG y espera un estado terminal.
curl -X POST "https://localhost:7063/api/airflow/dags/etl_vendas/runs" \
  -H "Content-Type: application/json" \
  -d '{"configuracao":{"data_referencia":"2026-07-21","correlation_id":"pedido-8f328ba9"},"aguardarConclusao":true}'

Una respuesta concluida preserva los nombres JSON del contrato de Airflow, lo que facilita la correlación con su API e interfaz web:

1
2
3
4
5
6
7
8
{
  // Usa este ID para correlacionar la ejecución en las dos plataformas.
  "dag_run_id": "dotnet__20260721T130000000__8f328ba9...",
  "dag_id": "etl_vendas",
  "state": "success",
  "start_date": "2026-07-21T13:00:01Z",
  "end_date": "2026-07-21T13:02:44Z"
}

Fallos, observabilidad y seguridad en producción

Una integración robusta exige separar los fallos de autenticación, autorización, validación, disponibilidad y ejecución. Un 401 normalmente pide renovar el token; un 403 indica que la identidad no tiene permiso; un 404 puede significar un DAG o DAG Run incorrecto; un 409 puede indicar un conflicto de identidad; 429 y las respuestas 5xx sugieren presión o indisponibilidad temporal. El cliente debe registrar el status, el endpoint lógico y el correlation ID, pero nunca el token, la contraseña ni el contenido sensible de conf.

El ejemplo incluye una única repetición tras un 401. Para GET, los retries exponenciales con jitter son seguros porque la operación no altera el estado. Para POST, la política depende de la idempotencia. Una biblioteca de resiliencia puede automatizar timeout, circuit breaker y retries, pero la regla de negocio todavía necesita decidir si repetir el disparo es válido. Ninguna biblioteca puede inferirlo solo a partir del verbo HTTP.

Crea métricas para el tiempo de autenticación, la latencia del disparo, la duración total, la cantidad de DAG Runs por estado y los timeouts. Registra dag_id, dag_run_id y el correlation ID como propiedades estructuradas. Traza la llamada HTTP con OpenTelemetry y propaga un identificador en conf para que las tareas del DAG también lo incluyan en los logs. De esta forma, una investigación recorre la API, Airflow y los sistemas de datos sin depender de búsquedas textuales frágiles.

En seguridad, usa HTTPS con validación normal de certificados, una cuenta técnica de mínimo privilegio y rotación de credenciales. No desactives la validación TLS en producción. Restringe la API de Airflow por red, firewall o gateway; la existencia de JWT no hace deseable exponer el webserver públicamente. Si el servicio se ejecuta en Kubernetes, inyecta la contraseña mediante un Secret o integra un vault. En entornos con auth manager corporativo, prefiere identidades de workload y tokens de corta duración cuando haya soporte.

Cuándo usar API, mensajería o ejecución en contenedores

La API REST es adecuada cuando el servicio necesita iniciar un workflow específico, proporcionar parámetros y acompañar una ejecución identificable. Ofrece feedback inmediato, un contrato HTTP claro y buena trazabilidad. El costo es el acoplamiento temporal: Airflow debe estar accesible en el disparo, y esperar la conclusión retiene recursos del llamador. Para operaciones administrativas y bajo volumen, este compromiso suele ser aceptable.

La mensajería es mejor cuando el productor debe seguir funcionando durante indisponibilidades del orquestador o cuando el volumen es alto. .NET publica en Azure Service Bus, RabbitMQ o Kafka, y un componente consumidor transforma los mensajes en DAG Runs o activa pipelines orientados a eventos. La cola ofrece buffering y entrega controlada, pero introduce semántica de duplicidad, dead-letter, ordenamiento y observabilidad adicional. Airflow no debe sustituir a un broker en un flujo transaccional de baja latencia.

Los contenedores y Kubernetes resuelven otro problema: dónde ejecutar la carga. Un DAG puede iniciar un job que use la misma imagen de una herramienta .NET, o llamar a un servicio C# por HTTP. Esto no exige que Airflow entienda la implementación interna. La imagen debe exponer una operación determinista, devolver el exit code correcto y grabar la salida en un almacenamiento durable. Los logs locales del pod no son una integración de datos.

En muchos sistemas, las tres estrategias coexisten. La API .NET graba una transacción y una outbox; un worker publica un evento; Airflow inicia un DAG; una tarea de Kubernetes ejecuta una utilidad .NET. El diseño debe seguir los requisitos de consistencia, latencia y recuperación. Elegir API, cola o contenedor solo porque el equipo ya conoce la tecnología tiende a ocultar el verdadero contrato operativo.

Consejos y Buenas Prácticas

  • Usa una identidad técnica de mínimo privilegio. Autoriza solo los DAGs y las operaciones que el servicio requiere. Separa la cuenta de la integración de las cuentas humanas para facilitar la auditoría y la rotación.

  • Haz que el disparo sea idempotente. Deriva el dag_run_id de una clave de negocio o persiste la asociación antes de la llamada. Trata las respuestas ambiguas consultando la ejecución existente, en lugar de crear otra silenciosamente.

  • Mantén conf pequeño y sin secretos. Envía IDs, fechas y URIs hacia datos durables. Los payloads voluminosos presionan el webserver y la información sensible puede aparecer en los metadatos de la ejecución.

  • Diferencia el timeout de la llamada del timeout del workflow. Usa un límite corto para cada solicitud HTTP y otro para el ciclo completo de polling. Propaga el CancellationToken en la autenticación, el disparo, la espera y la consulta.

  • Aplica retry según la semántica. Repetir un GET tras un fallo transitorio es predecible; repetir un POST puede duplicar el procesamiento. Combina backoff exponencial, jitter y circuit breaker solo después de definir la idempotencia.

  • Registra identificadores, no credenciales. Incluye dag_id, dag_run_id, correlation ID, estado y duración en logs estructurados. Nunca registres el JWT, la contraseña ni la configuración sensible.

  • Prueba los contratos sin depender del Airflow real. Un HttpMessageHandler falso valida URLs, headers, JSON, la renovación tras un 401 y las transiciones de estado. Mantén también una prueba de integración contra una versión soportada antes del deploy.

Resumen Objetivo

  • Apache Airflow 3 — expone una API pública estable bajo /api/v2; los endpoints internos de la interfaz web no deben usarse como contrato de integración.
  • .NET 10 — se integra con Airflow por HTTP y no ejecuta DAGs en C#; Airflow sigue siendo responsable de la programación, las dependencias, los workers y el estado.
  • Autenticación JWT — la documentación estándar usa POST /auth/token y envía el token en Authorization: Bearer; el cliente renueva la credencial una vez tras un 401 o 403 causado por un token inválido.
  • DAG Run — es una ejecución concreta de un DAG y debe rastrearse por dag_id y dag_run_id; HTTP 200 en el disparo no significa que el workflow haya terminado con éxito.
  • Monitoreo — consulta GET /api/v2/dags/{dag_id}/dagRuns/{dag_run_id} hasta success, failed o canceled, con un intervalo moderado, timeout total y cancelación propagada.
  • Idempotencia — los retries automáticos de POST pueden duplicar workflows; una clave de negocio en el dag_run_id permite reconocer una ejecución ya creada.
  • Configuración del DAG — en Airflow 3.3, el payload incluye dag_run_id, conf y logical_date; este último puede ser null, mientras que conf debe llevar referencias pequeñas y no confidenciales.

Lee También

Referencias