Module d'onboarding — Kestra

Contenu pédagogique produit par Bill (QA). Destiné à onboarding.fastodata.com.
Public : ingénieur data. Format : théorie d'abord → exercices → quiz corrigé.
Contexte équipe : orchestrateur utilisé sur la plateforme data (déclaratif YAML). Complémentaire au module Airflow.
Durée estimée : ~2-3 h.

Objectifs pédagogiques

À la fin, l'apprenant sait :

1. Expliquer le modèle Kestra (flows déclaratifs en YAML) et le situer vs Airflow.
2. Écrire un flow : id, namespace, tasks, triggers.
3. Enchaîner des tâches, passer des variables (Pebble), gérer les erreurs.
4. Utiliser les plugins (BigQuery, GCS, Soda…) et les triggers (schedule, flow).
5. Lire l'UI, débugger une exécution.

Module 1 — Modèle mental Kestra

Kestra orchestre des workflows déclaratifs : un flow = un fichier YAML (pas du code Python comme Airflow). Même rôle qu'Airflow (quoi/quand/ordre/erreurs) mais l'approche est config-first, versionnable et lisible par des non-développeurs.

Briques :

• flow : identifié par id + namespace.
• tasks : étapes exécutées dans l'ordre (séquentiel par défaut).
• triggers : ce qui déclenche le flow (planning, autre flow, webhook).
• inputs / variables / outputs : paramètres et passage de données entre tâches.

Différence clé avec Airflow : Airflow = DAG en Python (impératif) ; Kestra = flow en YAML (déclaratif). Mêmes concepts d'orchestration, ergonomie différente.

Module 2 — Un flow minimal

id: pipeline_ventes
namespace: data.ventes

tasks:
  - id: extract
    type: io.kestra.plugin.core.log.Log
    message: "Extraction des ventes"

  - id: transform
    type: io.kestra.plugin.core.log.Log
    message: "Transformation"

triggers:
  - id: daily
    type: io.kestra.plugin.core.trigger.Schedule
    cron: "0 6 * * *"

• Les tâches s'exécutent dans l'ordre déclaré.
• type = le plugin/opérateur (chaque tâche est typée).
• Le trigger Schedule planifie via cron.

Module 3 — Variables, templating (Pebble), erreurs

• Templating Pebble (moteur de Kestra) : {{ ... }} pour injecter variables/outputs.
  • {{ trigger.date }}, {{ outputs.extract.uri }}, {{ inputs.jour }}.
• Passage de données : une tâche expose des outputs réutilisables par les suivantes.
• Gestion d'erreurs : errors: (tâches exécutées en cas d'échec), retry: par tâche (type, max attempts, interval), allowFailure.
• Flowable tasks : Sequential, Parallel, EachSequential/EachParallel (boucles), If (conditions), Switch.

Migration / pièges : éviter les types dépréciés, Handlebars remplacé par Pebble, valider les paramètres de tâche. (cf. skill kestra-migration.)

Module 4 — Plugins & triggers

• Plugins : la force de Kestra. BigQuery (Query, Load), GCS (Upload, Download), Soda (qualité données), notifications (Slack/email), scripts (Bash/Python), dbt.
• Triggers :
  • Schedule (cron),
  • Flow (un flow en déclenche un autre),
  • Webhook (déclenchement externe),
  • triggers de plugin (ex. nouveau fichier sur GCS).
• Intégration data typique : Schedule → Load GCS→BQ → transform (dbt/Query) → Soda (qualité) → notif.

Module 5 — UI & debug

• Topology : voir le graphe du flow.
• Executions : état de chaque run/tâche (success/failed/running), avec logs par tâche.
• Replay / Restart : rejouer une exécution depuis une tâche.
• Editor intégré : éditer le YAML + validation en direct.
• Réflexe debug : ouvrir l'exécution en échec → tâche rouge → logs → corriger le YAML → relancer.

Exercices

1. Écris un flow id: charge_orders, namespace data.ventes, avec une tâche de log et un trigger cron quotidien à 7h.
2. Ajoute un retry (3 tentatives, 5 min d'intervalle) sur une tâche fragile.
3. Tu veux qu'une tâche de notification s'exécute si le flow échoue. Quelle section utilises-tu ?
4. Comment passes-tu l'URI de sortie d'une tâche extract à une tâche load ? (syntaxe Pebble)
5. Cite l'enchaînement de plugins d'un pipeline data typique (ingestion → qualité → notif).

Quiz final corrigé

Q1. Différence fondamentale Kestra vs Airflow ?
→ Kestra = flows déclaratifs en YAML (config-first). Airflow = DAGs en Python (impératif). Même rôle d'orchestration.

Q2. Quels sont les 3 grands blocs d'un flow ?
→ tasks (étapes), triggers (déclencheurs), + l'identité id/namespace (et inputs/variables/outputs).

Q3. Quel moteur de templating, et exemple ?
→ Pebble, ex. {{ outputs.extract.uri }} ou {{ trigger.date }}.

Q4. Comment gérer un échec de tâche ?
→ retry (tentatives/intervalle) par tâche, section errors: pour des tâches de récupération, allowFailure si l'échec est tolérable.

Q5. À quoi sert un trigger Flow ?
→ Déclencher un flow depuis un autre flow (chaînage d'orchestrations).

Pour aller plus loin

• Skills équipe : kestra, kestra-plugins-reference, kestra-soda-integration, kestra-migration.
• Comparer avec le module Airflow (mêmes concepts, ergonomie différente).
• Doc officielle Kestra (plugins, Pebble, flowable tasks).