DAG (directed acyclic graph)

Wat is een DAG?

Een DAG is de vorm waarin bijna elke datapijplijn beschreven staat: blokjes met pijlen ertussen. Elk blokje is een stap, elke pijl zegt "dit eerst, dat pas daarna". De drie letters staan voor directed acyclic graph, en die naam valt netjes uit elkaar.

Graph (graaf): een verzameling punten met verbindingen ertussen. Denk aan haltes op een metrokaart, met lijnen die ze verbinden.

Directed (gericht): de verbindingen zijn pijlen, geen gewone lijnen. Ze wijzen één kant uit. Een pijl van stap A naar stap B betekent: A moet klaar zijn voor B mag starten, en niet omgekeerd.

Acyclic (acyclisch): er zit geen lus in. Volg je de pijlen, dan kom je nooit terug bij een blokje waar je al geweest bent. Geen enkele stap kan uiteindelijk op zichzelf wachten.

Waarom een datapijplijn een DAG is

Een datapijplijn bestaat uit stappen die op elkaar wachten: eerst data ophalen, dan transformeren, dan het rapport verversen. Zet je die stappen als blokjes met pijlen neer, dan krijg je vanzelf een DAG. En dat is geen toeval, want die vorm lost drie dingen tegelijk op.

De volgorde ligt vast. Uit de pijlen leidt een machine zelf af wat eerst moet en wat pas daarna. Je hoeft nergens een vast uur in te typen en te hopen dat de vorige stap tegen dan klaar is.

Onafhankelijke stappen mogen samen draaien. Twee blokjes zonder pijl ertussen hebben niets van elkaar nodig, dus kan een orkestrator ze tegelijk uitvoeren in plaats van na elkaar.

Niets loopt vast in een cirkel. Omdat er geen lus in mag, kan stap A niet op stap B wachten terwijl B op A wacht. Zo'n cirkel zou de hele keten laten stilvallen, en de acyclische regel sluit dat op voorhand uit.

Een pijplijn van vier stappen als DAG

Neem een nachtelijke keten met vier stappen:

1. Facturen ophalen uit je boekhoudpakket.

2. Betalingen ophalen uit je bank.

3. Beide koppelen tot één overzicht van openstaande bedragen.

4. Het rapport verversen.

De pijlen: stap 1 en stap 2 wijzen allebei naar stap 3, en stap 3 wijst naar stap 4. Tussen stap 1 en stap 2 loopt geen pijl, want de facturen en de betalingen hebben niets van elkaar nodig. Ze mogen dus tegelijk draaien. Stap 3 start pas als allebei binnen zijn, stap 4 pas als de koppeling klaar is. En nergens loopt een pijl terug: stap 4 wijst niet opnieuw naar stap 1. Dat is de hele DAG.

DAG's in de tools die je kent

Je komt DAG's overal in de datawereld tegen, vaak zonder dat het woord valt.

In Apache Airflow heet je pijplijn letterlijk een DAG. Je schrijft in Python uit welke taken er zijn en welke op welke wachten, en Airflow bewaakt die graaf: het start elke taak zodra de taken ervoor klaar zijn.

Een dbt-project bouwt zijn DAG zelf op. Verwijs je in een model met ref() naar een ander model, dan weet dbt dat het ene van het andere afhangt. Uit al die verwijzingen samen leidt het de juiste uitvoeringsvolgorde af, zonder dat je die ergens apart onderhoudt.

Ook een Apache Spark-job draait als een DAG. Spark hangt je bewerkingen aan elkaar tot een graaf van stappen en voert die uit in de afgeleide volgorde. De web-interface toont die graaf zelfs letterlijk, met de bewerkingen als pijlen tussen de tussenresultaten.

Waar moet je op letten bij een DAG

De graaf is maar zo eerlijk als de pijlen die erin staan. Een stap die stilletjes op iets buiten de DAG rekent, een bestand dat een andere tool wegschrijft bijvoorbeeld, kleurt groen terwijl de data nog niet klaar is. Zet die afhankelijkheid ook echt in de graaf.

En hoe fijner je de blokjes knipt, hoe meer werk parallel kan draaien. Maar te veel piepkleine blokjes maken de graaf onleesbaar. Knip op de plekken waar een stap echt iets afrondt waar een andere op wacht.