Configuration d'Airflow pour les Language SDKs

Pour exécuter des tâches language SDK, Airflow a besoin de deux informations : quel coordinator lance le sous-processus natif, et quelle queue le route vers ce coordinator. Le mécanisme est identique pour tous les language SDKs — seuls le classpath et les kwargs de chaque coordinator diffèrent. Cette skill documente le câblage partagé une seule fois, puis les options par coordinator. C'est une approche indépendante de la plateforme : les mêmes paramètres s'appliquent sur Airflow open-source et sur les plateformes gérées comme Astro.

Expérimental. Les language SDKs sont en preview ; les clés de configuration peuvent changer.

Pour le code des tâches, voir authoring-language-sdk-tasks (et la skill d'authoring per-langage, par ex. authoring-go-sdk-tasks). Pour la construction et l'expédition de l'artefact, voir la skill de déploiement per-langage (par ex. deploying-go-sdk-bundles).

Prérequis sur le worker

• Le runtime ou l'artefact dont le SDK a besoin doit être présent sur les nœuds workers, car le coordinator lance un sous-processus natif par instance de tâche. L'exigence exacte est per-SDK — voir Options per-coordinator (le Go SDK ne nécessite aucun runtime de langage : le bundle est un exécutable natif autonome, mais il doit être construit pour l'OS/architecture du worker).
• L'ou les artefact(s) compilé(s)/natif(s) doivent être accessibles sur le worker. Voir la skill de déploiement per-langage.
• Les coordinators sont livrés avec le Airflow Task SDK (apache-airflow-task-sdk, installé avec Airflow). Aucun paquet Python supplémentaire n'est requis.

Les deux paramètres

Tous deux se trouvent dans la section de configuration [sdk] et s'appliquent à tous les language SDKs :

1. coordinators — un objet JSON mappant un nom de coordinator que vous choisissez à son implémentation (classpath) et ses kwargs de constructeur.
2. queue_to_coordinator — un objet JSON mappant une queue de tâche à un nom de coordinator.

Une tâche dont le stub définit queue="..." est confiée au coordinator nommé, qui lance le sous-processus natif. Le nom du coordinator est arbitraire — il suffit que ce soit la même chaîne dans les deux paramètres. Le nom de la queue doit correspondre au queue= défini sur la @task.stub Python.

Option A : airflow.cfg

[sdk]
coordinators = {
  "go": {
    "classpath": "airflow.sdk.coordinators.executable.ExecutableCoordinator",
    "kwargs": {"executables_root": ["/opt/airflow/executable-bundles"]}
  }
}
queue_to_coordinator = {"golang": "go"}

Option B : variables d'environnement

Chaque valeur doit être un JSON valide sur une seule ligne. Cette forme est pratique pour les conteneurs, les fichiers .env, Docker Compose et Helm.

export AIRFLOW__SDK__COORDINATORS='{"go": {"classpath": "airflow.sdk.coordinators.executable.ExecutableCoordinator", "kwargs": {"executables_root": ["/opt/airflow/executable-bundles"]}}}'
export AIRFLOW__SDK__QUEUE_TO_COORDINATOR='{"golang": "go"}'

Vous pouvez enregistrer plusieurs coordinators à la fois (par ex. un par langage) et mapper différentes queues à chacun.

Options per-coordinator

Le classpath et les kwargs sont spécifiques à chaque coordinator. Ajoutez une sous-section ici à mesure que de nouveaux language SDKs arrivent.

ExecutableCoordinator (Go et autres SDKs self-contained-executable)

• classpath: airflow.sdk.coordinators.executable.ExecutableCoordinator
• Runtime du worker: aucun au-delà du bundle lui-même. Le bundle est un exécutable natif autonome (AFBNDL01), il ne nécessite donc aucun runtime de langage, mais il doit être construit pour l'OS/architecture du worker (une incompatibilité échoue avec exec format error).

(Les futurs coordinators — pour d'autres langages — listeront leur propre classpath, runtime et kwargs ici.)

Vérification de la configuration

1. Confirmez que l'artefact est utilisable où les workers s'exécutent (pour le Go SDK : le bundle packagé existe et correspond à l'OS/architecture du worker) via astro dev bash ou docker compose exec ....
2. Confirmez que le répertoire d'artefacts référencé dans kwargs (par ex. executables_root) contient réellement votre artefact sur le système de fichiers du worker.
3. Déclenchez le DAG et ouvrez les logs de la tâche native — vous devriez voir le sous-processus démarrer et votre sortie de tâche.

Dépannage

Skills connexes

• authoring-language-sdk-tasks : Le motif de stub Python partagé et le modèle conceptuel.
• authoring-go-sdk-tasks : Code de tâche Go et stubs Python correspondants.
• deploying-go-sdk-bundles : Construire/packager le bundle Go et le placer où le coordinator scanne.
• deploying-airflow : Déploiement général d'Airflow sur Astro, Docker Compose ou Kubernetes.