Les tâches récurrentes peuvent vivre dans les entrées d'un planificateur système tant qu'il y en a cinq et qu'aucune ne dépend d'une autre. Avec cinquante tâches, dont l'une doit attendre trois autres, et où une panne oblige à savoir quelles données sont maintenant périmées, il faut un autre mécanisme.
Airflow décrit un pipeline comme un graphe de dépendances : des tâches, un ordre et des conditions. La plateforme suit ce qui s'est exécuté, ce qui a échoué et ce qui attend, et l'interface le montre sous une forme lisible pendant une panne.
La version trois, sortie en avril 2025, a apporté des changements qui modifient votre façon de travailler plus que le numéro ne le laisse penser.
Votre premier pipeline
from airflow.sdk import dag, task
from datetime import datetime
@dag(schedule="0 6 * * *", start_date=datetime(2026, 1, 1), catchup=False)
def daily_report():
@task
def fetch_orders() -> list[dict]:
return db.orders_from_yesterday()
@task
def compute_metrics(orders: list[dict]) -> dict:
return {"count": len(orders), "value": sum(o["amount"] for o in orders)}
@task
def send_report(metrics: dict) -> None:
mail.send("board@company.com", metrics)
send_report(compute_metrics(fetch_orders()))
daily_report()Les dépendances découlent du passage des résultats d'une tâche à l'autre, elles n'ont donc pas besoin de déclaration séparée. La dernière ligne décrit tout le graphe : fetch, compute, send, dans cet ordre.
Le namespace utilisé dans l'import est nouveau dans la version trois. Avant, on importait depuis divers endroits internes, ce qui provoquait des changements incompatibles à chaque mise à jour. Il existe désormais un ensemble d'interfaces stables pour écrire les pipelines, séparé des composants internes de la plateforme.
Le rattrapage (catchup) est désactivé par défaut dans la version trois, car catchup_by_default vaut maintenant false. L'exemple le précise quand même explicitement, pour que l'intention soit visible dans le code plutôt que cachée dans la configuration d'une installation. Si vous l'activez volontairement, ou si vous reprenez une configuration de la version deux où il était activé par défaut, un pipeline dont la date de début remonte à un an déclenche trois cent soixante-cinq exécutions d'un coup.
Le versioning des pipelines
C'est le changement le plus important de la version trois, et la réponse à un problème qui causait auparavant le plus de confusion.
Dans les versions précédentes, relancer une ancienne exécution la faisait tourner avec le code actuel. Une exécution d'il y a un mois, reprise après une modification de la logique, donnait un résultat différent de l'original, et personne ne savait lequel était correct.
Maintenant, la plateforme suit la version du code avec laquelle une exécution a démarré et la reprend par défaut avec la même. Un paramètre permet de choisir le comportement, mais la valeur par défaut est la bonne : une exécution de mars est rejouée comme elle l'était en mars.
Cela change la façon de corriger les données historiques, avec une exception facile à oublier. Les backfills ont gardé l'ancien comportement et s'exécutent par défaut avec le code le plus récent. Le paramètre rerun_with_latest_version en décide : false pour vider et relancer, true pour les backfills, avec une possibilité de le modifier par requête ou par pipeline.
L'interface montre avec quelle version chaque exécution a tourné. Quand on diagnostique un écart dans les données, c'est la première chose à vérifier, alors qu'il fallait auparavant la chercher dans l'historique du dépôt.
Les assets et les déclencheurs par événements
Le deuxième grand changement concerne ce qui démarre un pipeline. Une planification horaire est simple et porte un défaut : une tâche à sept heures suppose que les données de l'étape précédente sont prêtes, et si elles ne le sont pas, elle traite des données périmées.
Le modèle basé sur les assets inverse cette logique. Un pipeline déclare ce qu'il produit et ce qu'il consomme, et la plateforme l'exécute dès que les données nécessaires apparaissent.
from airflow.sdk import asset
@asset(schedule="@daily")
def raw_orders() -> None:
db.load_from_source()
@asset(schedule=raw_orders)
def clean_orders() -> None:
db.transform()Le deuxième pipeline n'a pas d'horaire propre. Il s'exécute dès que le premier se termine et met à jour son asset, donc il n'y a aucun intervalle à deviner ni aucune marge de sécurité à ajouter.
La version trois a étendu cela avec des déclencheurs issus d'événements extérieurs à la plateforme. Un message dans une file, un fichier dans un stockage d'objets ou un événement d'un système externe peuvent démarrer un pipeline, ce qui supprime le contournement le plus courant : interroger une source toutes les cinq minutes.
Des tâches dans d'autres langages
La version trois a ajouté une couche qui permet d'écrire certaines tâches dans d'autres langages que Python, tandis que la description du pipeline reste en Python.
Cela répond à une situation récurrente dans les équipes data : la logique de traitement existe déjà dans un autre langage, et la seule raison de la réécrire en Python était une limite de l'outil. Maintenant, une tâche peut s'exécuter là où elle vit, la plateforme se chargeant de l'ordre, des nouvelles tentatives et de la visibilité.
La conclusion pratique : si vous avez déjà du code dans un autre langage, vérifiez cette voie avant de prévoir une migration. Réécrire du code qui fonctionne uniquement pour l'adapter à un outil est rarement un bon investissement. La couche de coordination et les SDK Java et Go sont marqués comme expérimentaux depuis la version 3.3, considérez-les donc comme une piste à évaluer plutôt que comme une base de production.
Nouvelles tentatives et gestion des erreurs
Un pipeline de données échoue régulièrement : les sources tombent en panne et les données arrivent incomplètes. La façon de traiter ces situations distingue un pipeline de production d'un script.
@task(retries=3, retry_delay=timedelta(minutes=5), retry_exponential_backoff=True)
def fetch_from_api() -> list[dict]:
return client.fetch_data()Les nouvelles tentatives avec un délai croissant gèrent les erreurs passagères, c'est-à-dire l'indisponibilité d'un service et les limites de débit. Cela couvre la plupart des échecs qui se réparent d'eux-mêmes.
Une autre question est de savoir quoi faire quand les tentatives sont épuisées. Par défaut, la tâche est marquée comme échouée et les tâches dépendantes attendent. Dans un pipeline où une étape en échec ne doit pas bloquer le reste, on peut définir une autre règle de déclenchement pour la tâche suivante.
Distinguez aussi un échec d'une absence de données. Une tâche qui n'a rien trouvé à traiter n'est pas un échec, et il vaut mieux la marquer comme ignorée (skipped) plutôt que comme échouée, sinon les alertes deviennent du bruit.
Le dernier point est la notification. Un pipeline en échec sans notification n'est remarqué que lorsque quelqu'un demande où est passé un rapport. Un callback d'échec qui envoie un message dans un canal d'équipe coûte quelques lignes et ramène le délai de réaction de plusieurs jours à quelques minutes.
Tester les pipelines
Un pipeline est du code, les mêmes règles s'appliquent donc que partout ailleurs, et pourtant c'est la partie la moins testée.
Le geste le plus simple et le plus efficace est d'extraire la logique de traitement en dehors de la définition de la tâche. Une fonction qui prend des données et renvoie un résultat se teste avec un simple test unitaire, sans rien exécuter.
def compute_metrics(orders: list[dict]) -> dict:
return {"count": len(orders), "value": sum(o["amount"] for o in orders)}
@task
def metrics_task(orders: list[dict]) -> dict:
return compute_metrics(orders)La tâche devient une fine enveloppe et toute la logique vit dans un endroit vérifiable en quelques millisecondes. Ce seul changement apporte le plus et ne demande aucun outil au-delà de ce que l'équipe utilise déjà.
Le deuxième niveau vérifie les définitions de pipelines elles-mêmes : si elles sont toutes analysées sans erreur, si le graphe ne contient aucun cycle, si les identifiants sont uniques. Un tel test dans le pipeline de build attrape les fautes de frappe avant qu'elles n'arrivent en production.
Le troisième consiste à exécuter une seule tâche avec des données de test. Cela aide pour les tâches qui touchent des systèmes externes, là où un test unitaire ne suffit pas et où exécuter tout le graphe coûte trop cher.
Il est utile de savoir d'où vient cette gymnastique. La définition du pipeline est ici un graphe séparé, donc exécuter quoi que ce soit dans un test demande un scheduler et une base de métadonnées, c'est pourquoi la logique est d'abord sortie de la tâche. Les outils qui assemblent un flux à partir de décorateurs sur des fonctions ordinaires, comme Prefect, n'ont pas ce problème, puisque le flux s'appelle dans un test comme n'importe quelle autre fonction. Le prix se paie dans l'autre sens : la structure du graphe n'y est connue que pendant l'exécution, et non avant le démarrage.
L'exploiter et le maintenir
La plateforme se compose de plusieurs éléments : un scheduler qui décide quoi exécuter, un serveur d'interface, une base de métadonnées et des workers. C'est nettement plus qu'un seul service, et il vaut mieux le savoir avant de se décider.
L'auto-hébergement signifie maintenir ces éléments, sauvegarder la base de métadonnées et s'assurer que les workers disposent de ressources suffisantes. Pour une équipe, cela représente quelques heures par mois ; pour une installation plus grande, c'est un poste à part entière.
L'alternative, ce sont les services managés, proposés par les grands fournisseurs de cloud et par des entreprises spécialisées dans cette plateforme. Vous payez alors la maintenance et vous gagnez du temps, en perdant une partie du contrôle sur la version et la configuration.
La troisième voie consiste à se passer de la plateforme pour les besoins simples. Cinq tâches indépendantes ne demandent rien de plus qu'un planificateur, et déployer cette plateforme pour un tel ensemble est disproportionné.
Migrer depuis la version deux
Passer à la version trois est faisable et ne se résume pas à changer un numéro dans les dépendances.
Le plus gros changement concerne les imports. Les définitions de pipelines qui puisent directement dans les composants internes de la plateforme doivent passer au nouveau namespace. Pour une douzaine de pipelines, c'est une heure de travail ; pour deux cents, cela vaut la peine d'écrire un script pour les motifs les plus courants.
Le deuxième est un renommage. Le concept de dataset a été remplacé par les assets, en gardant le même mécanisme d'inlet et d'outlet. Le code qui utilise l'ancien nom doit être corrigé, bien que le comportement reste proche.
Le troisième est le comportement des relances. La version précédente utilisait toujours le code actuel ; la version actuelle revient par défaut à la version d'origine. C'est généralement une amélioration, mais si votre processus de correction des données reposait sur l'ancien comportement, réglez-le explicitement.
L'ordre pratique : d'abord lancer une installation de test sur la nouvelle version et y faire passer une copie de vos pipelines, puis corriger ce qui ne s'analyse pas, et enfin planifier le basculement en production. La version trois a conservé la rétrocompatibilité pour la plupart des définitions, la liste des corrections est donc souvent plus courte que ne le suggère un changement de version majeure.
Airflow face aux alternatives
| Outil | Point fort | Point faible | À choisir quand |
|---|---|---|---|
| Airflow | Maturité, vaste ensemble d'intégrations, versioning | Lourd à maintenir, demande de l'infrastructure | Grands pipelines de données, nombreuses dépendances |
| Dagster | Modèle basé sur les assets dès l'origine, testabilité | Écosystème plus petit | Équipe qui part de zéro avec un focus data |
| Temporal | Exécution durable, processus de durée arbitraire | Autre objectif, pas pour les données | Processus métier plutôt que pipelines analytiques |
| n8n ou Make | Visuel, rapide à déployer | Faible sur de gros volumes de données | Automatisations qui relient des services |
La troisième ligne appartient à une autre catégorie, même si on les confond. Cette plateforme planifie des traitements de données répétés à heures fixes ou après des événements. Une solution d'exécution durable gère des processus métier qui tournent une fois par commande et durent des semaines. Le recouvrement est faible.
Le choix entre les deux premières lignes dépend du fait que vous partiez de zéro ou non. Avec une installation existante et des centaines de pipelines, changer coûte cher et se justifie rarement. Sur un nouveau projet, comparez les deux, car les modèles conceptuels diffèrent considérablement.
L'argument qui tranche généralement en faveur de cette plateforme est le nombre d'intégrations prêtes à l'emploi. Une connexion aux bases de données, aux entrepôts de données, aux services cloud et aux systèmes de files existe généralement et est utilisée par de nombreuses équipes, ce qui veut dire que quelqu'un d'autre a déjà trouvé les cas limites. Avec des outils moins populaires, ce travail vous revient.
Le deuxième argument est la disponibilité des personnes. L'expérience de cette plateforme est répandue, donc une nouvelle personne dans l'équipe en connaît généralement les bases. Cela ressemble à un argument mou, et sur plusieurs années de maintenance d'une installation il pèse concrètement.
Erreurs courantes
La première est un catchup activé à la main ou hérité d'une configuration de la version deux. Un pipeline dont la date de début remonte à un an génère des centaines d'exécutions d'un coup et bloque tout le reste, même si la version trois demande un effort délibéré pour en arriver là, puisque la valeur par défaut est désactivée.
La deuxième est la logique de traitement placée dans le fichier de définition du pipeline. Le scheduler analyse ce fichier de nombreuses fois par minute, donc du code qui interroge une base de données à l'import ralentit toute l'installation.
La troisième est l'absence de timeouts sur les tâches. Une tâche qui se bloque indéfiniment occupe un slot et en bloque d'autres sans rien signaler.
La quatrième est le passage de gros volumes de données entre les tâches. Les résultats transitent par la base de métadonnées, donc passer une table plutôt qu'un chemin vers elle encombre la base et ralentit tout.
La cinquième est un seul pipeline pour tout un processus. Trente tâches dans un même graphe rendent difficile la relance d'un fragment et obligent, en cas d'échec à la fin, à tout recommencer.
La sixième est de ne pas tester. Un pipeline est du code : extrayez la logique de traitement dans des fonctions testées plutôt que de la vérifier uniquement en exécutant tout le graphe.
FAQ
À quoi sert Airflow ?
À planifier et exécuter des pipelines de traitement de données avec des dépendances entre les étapes. La plateforme gère l'ordre, les nouvelles tentatives et la visibilité de l'état, et vous décrivez un pipeline en code Python sous forme de graphe de tâches.
Qu'a apporté la version trois ?
Trois choses changent votre façon de travailler : le versioning des pipelines, pour qu'une ancienne exécution soit rejouée avec le code de son époque ; un modèle basé sur les assets avec des déclencheurs par événements plutôt que de simples horaires ; et un namespace stable pour écrire les pipelines, séparé des composants internes de la plateforme.
Airflow convient-il aux petits projets ?
Rarement. La plateforme demande une base de métadonnées, un scheduler, un serveur d'interface et des workers, donc avec cinq tâches indépendantes le coût de maintenance dépasse le bénéfice. Elle commence à avoir du sens avec des dépendances entre tâches et un besoin de visibilité, en général à partir d'une douzaine de pipelines.
En quoi diffère-t-il de Temporal ?
L'objectif est différent, malgré des descriptions qui se ressemblent. Airflow planifie des traitements de données répétés, exécutés selon un cycle ou après un événement. Temporal exécute des processus métier lancés individuellement, qui peuvent durer des semaines et doivent résister à une panne en cours de route.
Les tâches doivent-elles être en Python ?
La description du pipeline, oui, mais la version trois autorise certaines tâches dans d'autres langages. C'est utile quand la logique de traitement existe déjà et que la réécrire serait du travail fait uniquement pour s'adapter à un outil.
La documentation se trouve sur le site du projet, et les changements de la version trois apparaissent dans l'annonce de la sortie.