dbt sous Airflow : une tâche par modèle, pas une par projet
Un projet dbt lancé depuis un orchestrateur tient en général dans une seule tâche. Le graphe affiché ne correspond alors pas au projet, et une reprise après erreur relance tout. Ce que change le fait de confier le graphe à l’orchestrateur, et ce que cela coûte.
La façon courante de lancer dbt depuis Airflow tient en une ligne : un opérateur bash, la commande dbt run, et le projet entier dans une tâche. Cela fonctionne, mais avec trois inconvénients qui n’apparaissent qu’en cas d’incident. La reprise après erreur relance tout le projet alors qu’un seul modèle a échoué. Le graphe de dépendances que dbt connaît reste invisible pour l’orchestrateur, qui affiche un seul carré là où il y a deux cents nœuds. Et les journaux arrivent en un seul bloc, dans lequel il faut chercher.
Cosmos, publié par Astronomer, lit le projet dbt et en tire des tâches Airflow : une par modèle, avec les dépendances que dbt a déjà calculées. Ce que l’orchestrateur voit, il peut le relancer, le paralléliser et en rendre compte dans ses journaux.
Trois objets de configuration suffisent, et le DAG se déduit du projet. `ProjectConfig` indique où se trouve le projet, `ProfileConfig` comment se connecter, `ExecutionConfig` quel exécutable dbt appeler. Ce dernier est plus important qu’il n’y paraît, car dbt et Airflow ont rarement des dépendances compatibles.
from datetime import datetime
from cosmos import DbtDag, ExecutionConfig, ProfileConfig, ProjectConfig
from cosmos.profiles import AthenaAccessKeyProfileMapping
profile = ProfileConfig(
profile_name="warehouse",
target_name="prod",
# The dbt profile is built from an Airflow connection of type aws:
# no profiles.yml to deploy, no secret in the repository.
profile_mapping=AthenaAccessKeyProfileMapping(
conn_id="aws_warehouse",
profile_args={"schema": "marts"},
),
)
dag = DbtDag(
dag_id="warehouse_dbt",
project_config=ProjectConfig("/usr/local/airflow/dags/dbt/warehouse"),
profile_config=profile,
# dbt in its own virtual environment: its dependencies and Airflow's do not
# hold together, and that is the trap that costs you the day.
execution_config=ExecutionConfig(
dbt_executable_path="/usr/local/airflow/dbt_venv/bin/dbt",
),
schedule_interval="0 5 * * *",
start_date=datetime(2023, 11, 1),
catchup=False,
default_args={"retries": 2},
)Le plus souvent, le projet dbt n’est pas isolé : il suit une ingestion et précède une publication. `DbtTaskGroup` produit alors le même graphe, inséré dans un DAG existant, et les dépendances se déclarent comme entre deux tâches ordinaires.
from airflow.decorators import dag, task
from cosmos import DbtTaskGroup, ProjectConfig
@dag(schedule="0 5 * * *", start_date=datetime(2023, 11, 1), catchup=False)
def warehouse():
@task
def ingest() -> None:
...
transform = DbtTaskGroup(
group_id="transform",
project_config=ProjectConfig("/usr/local/airflow/dags/dbt/warehouse"),
profile_config=profile,
)
@task
def publish() -> None:
...
ingest() >> transform >> publish()
warehouse()Athena diffère d’une base de données classique : le calcul est assuré par AWS, les données sont dans S3, et il faut un emplacement d’écriture pour les résultats intermédiaires. Un profil dbt-athena comporte donc plus de champs qu’un profil Postgres, et deux d’entre eux, le répertoire de travail et le groupe de travail, n’ont pas d’équivalent ailleurs.
Le mapping de Cosmos lit ces champs dans le bloc `extra` d’une connexion Airflow de type `aws`, et récupère les identifiants par le mécanisme habituel du fournisseur Amazon. Un rôle IAM fonctionne donc aussi bien qu’une clé, et c’est préférable.
{
"region_name": "eu-west-1",
"database": "awsdatacatalog",
"schema": "marts",
"s3_staging_dir": "s3://warehouse-athena/results/",
"work_group": "dbt"
}Deux remarques tirées de l’usage. D’abord, donner à dbt son propre groupe de travail Athena, comme ci-dessus, isole sa consommation et permet de lui fixer une limite d’octets lus. Sans cette limite, une jointure mal écrite ne se découvre que sur la facture. Ensuite, l’adaptateur s’installe sous le nom `dbt-athena-community`, et non `dbt-athena`, une confusion qui fait perdre une demi-heure à presque tout le monde.
Le graphe doit être connu au moment où Airflow analyse le fichier, soit toutes les trente secondes par défaut. Par défaut, Cosmos appelle dbt à chaque analyse pour découvrir les modèles, et c’est la pire configuration : l’ordonnanceur ralentit à mesure que le projet grandit. La solution consiste à produire le manifeste lors de la construction de l’image et à le fournir à Cosmos, qui n’a plus à le recalculer.
Le second coût est moins visible : deux cents tâches au lieu d’une, ce sont deux cents lignes dans la base de métadonnées à chaque exécution, et un tableau de bord qu’on ne lit plus d’un coup d’œil. Sur un projet de vingt modèles, le gain est net. Au-delà de quelques centaines, il faut regrouper les tâches par dossier plutôt que par modèle, ce que Cosmos permet.
Je n’ai pas testé ce montage sur Kubernetes, où chaque tâche s’exécute dans un conteneur et où le compromis change : le graphe détaillé coûte alors un démarrage de conteneur par modèle, et l’intérêt des reprises fines peut disparaître. Je ne traite pas non plus les tests dbt exposés comme des tâches distinctes, que Cosmos permet. Je m’en méfie, car un test en échec doit arrêter la chaîne, et en faire une tâche indépendante affaiblit cette règle.
Une dernière remarque, datée. Le mapping Athena n’a qu’un mois au moment où j’écris : il est arrivé dans la version 1.2.0, le 13 octobre 2023, et cinq versions ont suivi en six semaines. Le projet évolue encore vite, et le code ci-dessus décrit un état à cette date.