Kestra est une plateforme d'orchestration de workflows où la définition d'un flow est un document YAML et où les tâches s'exécutent dans n'importe quel langage. La série de versions actuelle est la 1.3, ouverte en mars 2026, et le moteur est sous licence Apache 2.0.
Cette décision de conception unique le distingue des outils où un flow est du code dans un langage particulier, et elle commande toutes les autres différences. Il vaut la peine de la comprendre avant de comparer quoi que ce soit d'autre.
Un flow comme document plutôt que comme code
Dans les outils bâtis autour d'un seul langage, un flow est une fonction ou une classe, donc le lire exige de connaître ce langage. Ici, un flow est une description de structure, et le code se trouve à l'intérieur des tâches.
id: daily-import
namespace: data.production
tasks:
- id: fetch
type: io.kestra.plugin.scripts.python.Script
script: |
import requests
data = requests.get("https://api.example.com/orders").json()
print(len(data))
- id: transform
type: io.kestra.plugin.jdbc.postgresql.Query
sql: INSERT INTO report SELECT * FROM staging WHERE day = CURRENT_DATE
triggers:
- id: daily
type: io.kestra.plugin.core.trigger.Schedule
cron: "0 3 * * *"La structure est visible immédiatement : ce qui suit quoi, ce qui démarre l'ensemble, où passe la frontière entre les étapes. La première tâche exécute du Python, la deuxième une requête de base de données, et personne n'a besoin de connaître les deux pour comprendre le flow.
Deux conséquences en découlent, toutes deux réelles.
La première est organisationnelle. Un flow peut être lu par quelqu'un qui ne programme pas dans le langage de la tâche : un analyste, un administrateur, une personne qui valide le travail. Dans des équipes mixtes, cela compte parfois plus que l'élégance du code.
La seconde est technique et moins agréable. La logique exprimée dans un document est plus pauvre que celle d'un langage de programmation. On peut écrire une condition ou une boucle, mais une logique de contrôle élaborée en YAML devient illisible plus vite que le nombre de lignes ne le laisse penser.
Plusieurs langages au cœur du système
Puisque le code se trouve à l'intérieur des tâches, le langage cesse d'être un choix au niveau de l'outil entier.
Un même flow peut exécuter un script Python, une requête de base de données, une commande shell, un conteneur avec une image prête et un appel à une interface externe. Ce ne sont pas des contournements mais des types de tâches ordinaires.
Le gain se voit dans les organisations où les données passent par plusieurs équipes. Les analystes écrivent des requêtes, les ingénieurs des scripts, l'équipe plateforme gère des conteneurs, et tout tient dans un seul flow plutôt que dans trois systèmes enchaînés par des appels.
Il existe bien plus d'un millier de plugins, un chiffre à retenir car il détermine ce que vous obtenez tout fait. Se connecter à une base de données typique, à un stockage de fichiers dans le cloud ou à un système de files d'attente revient généralement à une entrée dans le document plutôt qu'à du code à écrire.
Rappelez-vous toutefois qu'un plugin est une dépendance comme une autre. Pour ceux qui sont rarement utilisés, il vaut la peine de vérifier la date de leur dernière mise à jour, car un catalogue de cette taille n'est pas uniforme dans la qualité de son entretien.
Événements et triggers
Un flow peut être démarré par un planning, et c'est la variante évidente. Les autres sont plus intéressantes.
Un trigger d'événement réagit à l'apparition d'un fichier dans le stockage, à un message dans une file, à un changement dans une base de données ou à un appel d'interface. Ainsi, un flow démarre quand il y a quelque chose à faire plutôt que quand une échéance arrive.
Un trigger fondé sur la fin d'un autre flow permet de construire des chaînes sans délais artificiels. C'est ce que l'on résout avec un ordonnanceur système en réglant la deuxième tâche quinze minutes plus tard en espérant que la première a fini.
Il faut connaître à part le trigger par polling, car il a une propriété qui surprend quand on chiffre la charge. Il interroge une source à intervalles fixes, que quelque chose ait changé ou non, donc avec plusieurs flows de ce type, le système travaille en permanence alors que rien ne se passe.
À la conception, commencez par la question de ce qui doit vraiment démarrer le flow. La réponse « tous les jours à trois heures » est souvent une simplification de quelque chose qui veut vraiment dire « une fois que les données d'hier sont arrivées », et les deux se comportent différemment quand les données sont en retard.
Éditions open source et commerciale
La séparation est nette ici et mérite d'être connue avant un déploiement en entreprise.
La version ouverte sous Apache 2.0 couvre le moteur, l'interface et la plupart des plugins, c'est-à-dire tout ce qu'il faut pour exécuter des flows. Ce n'est pas une version amputée pour la démonstration mais un outil fonctionnel. Le catalogue de plugins se scinde toutefois en deux, et une poignée d'entrées marquées enterprise exigent l'édition commerciale, donc vérifiez cela avant de vous engager sur une intégration inhabituelle.
La version commerciale ajoute ce dont une organisation a besoin plutôt qu'une équipe : la connexion via un système d'identité d'entreprise, des permissions fondées sur les rôles, un support avec des délais de réponse garantis et des mécanismes pour gérer plusieurs équipes sur une seule installation.
La séparation n'est pourtant pas à deux voies, car à côté de l'installation auto-hébergée, le fournisseur propose aussi une variante managée. Kestra Cloud est la même plateforme exploitée côté fournisseur, avec les plugins enterprise inclus et une facturation qui croît avec l'usage, tandis que l'accès est accordé sur demande, ce n'est donc pas un service auquel on s'inscrit en cinq minutes.
La conclusion pratique est simple. Une équipe qui exécute des flows pour elle-même se débrouille avec la version ouverte et ne perd rien d'important. Une organisation où cinq équipes aux permissions différentes partagent une installation a besoin d'un contrôle d'accès, et celui-ci se trouve du côté commercial.
Vérifiez cette frontière sur votre propre cas avant de décider, car la liste des fonctions attribuées à chaque édition change d'une version à l'autre.
Passer des données entre les tâches
C'est là que l'approche par document diffère le plus du code, et cela mérite d'être compris, car la plupart des erreurs naissent ici.
Dans du code, le résultat d'une fonction est transmis comme valeur. Ici, les tâches sont isolées les unes des autres, donc la sortie de l'une va dans le stockage et la suivante s'y réfère par une expression qui nomme l'identifiant de la tâche et le nom de la sortie.
L'effet pratique joue dans les deux sens. Les tâches peuvent s'exécuter dans différents langages et sur différentes machines, puisqu'elles ne partagent aucune mémoire. Et : transmettre des données a un coût, puisqu'elles passent par le stockage plutôt que par une variable.
Il en découle une règle à adopter dès le départ. Transmettez des identifiants et des chemins plutôt que des contenus. Une tâche qui récupère un million d'enregistrements doit les écrire dans une base de données ou un fichier et transmettre une référence plutôt que le tableau entier. Passer de grandes structures par le stockage fonctionne, puis cesse de fonctionner à une échelle que personne n'attend.
La deuxième chose, ce sont les variables et les expressions. Le document gère des templates qui permettent d'atteindre la date d'exécution, les paramètres d'entrée et les sorties des tâches précédentes. C'est commode et tentant d'en abuser : une expression avec trois conditions imbriquées dans un champ texte, c'est du code écrit au pire endroit possible.
La frontière pratique : une expression qui sélectionne une valeur ou compose un chemin convient, tandis qu'une expression qui prend une décision métier a sa place dans une tâche avec un script que l'on peut lire et tester.
Gestion des erreurs et nouvelles tentatives
Il vaut la peine de décrire ce que l'on obtient tout fait, car c'est la principale raison de choisir un orchestrateur plutôt qu'un ordonnanceur système.
Les nouvelles tentatives se déclarent sur une tâche : nombre d'essais, intervalle et progression. Une tâche qui atteint une interface externe parfois indisponible reçoit trois essais, et c'est quelques lignes dans le document plutôt qu'une boucle dans le code.
Les tâches de gestion d'erreur s'exécutent quand quelque chose s'est mal passé et permettent de nettoyer ou de prévenir la bonne personne. C'est différent d'une situation où un flow s'arrête simplement et où l'information atterrit dans un log que personne n'ouvre.
Les limites de concurrence fonctionnent au niveau du flow et au niveau de la tâche. Un flow planifié toutes les cinq minutes qui prend parfois sept minutes aura, sans cette limite, deux exécutions simultanées, et quand les deux écrivent dans la même table, ce n'est généralement pas ce qui était voulu.
Le dernier point est la gestion des délais et des pauses. Une tâche peut attendre une durée fixée, peut suspendre le flow jusqu'à ce qu'une condition soit remplie et, dans les processus impliquant des personnes, peut attendre une approbation. L'attente ne consomme entre-temps aucune ressource d'exécution, ce qui, dans une solution maison, exigerait un état durable et un mécanisme de reprise.
Kestra face aux alternatives
| Option | Description du flow | Langages des tâches | À choisir quand |
|---|---|---|---|
| Kestra | Un document YAML | N'importe lequel | Équipes mixtes, nombreuses technologies |
| Prefect | Une fonction Python | Python | Une équipe Python, tests des flows |
| Airflow | Un graphe Python | Python plus des opérateurs | Une grande équipe, pratiques établies |
| Temporal | Du code avec garanties de durabilité | Plusieurs langages | Longs processus métier |
La comparaison avec la deuxième ligne est la plus instructive ici, car les deux outils résolvent le même problème par des moyens opposés.
Là, un flow est une fonction, donc on peut l'appeler dans un test et toute la puissance du langage est disponible. Ici, un flow est un document, donc tout le monde le lit et les tâches peuvent être en n'importe quoi. Le choix se réduit à savoir si votre contrainte est la complexité de la logique ou la diversité des technologies et des personnes.
Conseil pratique : pour une équipe Python qui construit des pipelines de données, la deuxième ligne l'emporte généralement par la commodité. Pour une organisation où un flow touche une base de données, un conteneur, un script shell et trois équipes, la première l'emporte par la lisibilité.
La quatrième ligne résout un problème différent, et les confondre est fréquent. Là, il s'agit de processus qui durent des jours avec la garantie de survivre aux pannes ; ici, il s'agit d'un traitement répétable avec visibilité et nouvelles tentatives.
Exécution et maintenance
L'exécution demande le serveur lui-même plus une base de données pour l'état, généralement PostgreSQL. À plus grande échelle, une file d'attente et des processus workers séparés s'y ajoutent.
Un déploiement démarre généralement à partir d'un seul conteneur avec une base de données embarquée, ce qui suffit pour évaluer l'outil en une heure. Pour la production, il vaut la peine de mettre en place tout de suite une base de données externe, car migrer l'état plus tard est un travail que personne ne prévoit.
Gardez les flows dans un dépôt et déployez-les automatiquement plutôt que de les modifier dans l'interface. L'éditeur intégré est pratique pour les expériences et tentant en production, alors qu'un changement fait via l'interface ne passe aucune relecture et n'apparaît dans aucun historique de projet.
Réglez aussi tôt la répartition des namespaces. À vingt flows, tout semble bien aller quelle que soit la structure, et à deux cents, l'absence de zones rend la liste inutilisable.
Le dernier point est le stockage des sorties de tâches. La sortie d'une tâche va dans le stockage et reste disponible pour les étapes suivantes, ce qui est commode et grossit avec le temps. Une politique de suppression des anciennes exécutions est ici obligatoire plutôt qu'optionnelle.
Erreurs courantes
La première est d'exprimer une logique de contrôle compliquée dans le document. Les conditions et les boucles fonctionnent, mais une logique élaborée en YAML devient illisible, et le bon endroit est alors un script à l'intérieur d'une tâche.
La deuxième est de modifier les flows de production dans l'interface. Le changement prend effet immédiatement, ne passe aucune relecture et ne laisse aucune trace dans l'historique du projet.
La troisième est un planning là où il faudrait un événement. Un flow lancé à heure fixe traite des données qui ne sont peut-être pas encore arrivées, et l'échec paraît aléatoire.
La quatrième est de multiplier les triggers par polling. Le système travaille en permanence alors que rien ne se passe, et la charge croît linéairement avec le nombre de ces flows.
La cinquième est l'absence de politique de suppression des anciennes exécutions et sorties. Le stockage grossit à un rythme dicté par la taille des données plutôt que par le nombre de tâches.
La sixième est une installation de production sur la base de données embarquée. Cela fonctionne jusqu'au premier redémarrage sous charge, et déplacer l'état plus tard est un projet à part entière.
La septième est de passer de grands jeux de données entre les tâches au lieu d'identifiants. Tout transite par le stockage, donc une solution qui fonctionne à mille enregistrements cesse de fonctionner à un million, sans seuil d'alerte clair.
FAQ
En quoi Kestra diffère-t-il de Prefect ?
Par la façon de décrire un flow. Ici, un flow est un document YAML et les tâches peuvent être dans n'importe quel langage, donc quelqu'un qui ne programme pas peut aussi le lire. Dans Prefect, un flow est une fonction Python, ce qui donne toute la puissance du langage et la possibilité de tester en l'appelant.
La version ouverte suffit-elle pour la production ?
Oui, elle couvre le moteur, l'interface et la plupart des plugins sous Apache 2.0. La version commerciale ajoute la connexion par identité d'entreprise, des permissions fondées sur les rôles, des plugins réservés à l'édition enterprise et un support avec des délais de réponse garantis, c'est-à-dire ce dont une organisation a besoin plutôt qu'une seule équipe. Une variante managée par le fournisseur, Kestra Cloud, existe à part.
Dans quels langages écrire les tâches ?
Dans n'importe lesquels, puisque le code se trouve à l'intérieur d'une tâche. Un même flow peut exécuter un script Python, une requête de base de données, une commande shell et un conteneur, et il existe bien plus d'un millier de plugins pour les systèmes typiques.
Peut-on versionner cela comme du code ?
Oui, et il le faut. Gardez les flows dans un dépôt et déployez-les automatiquement, car modifier dans l'interface contourne la relecture et ne laisse aucune trace dans l'historique du projet. L'éditeur intégré convient aux expériences plutôt qu'à la production.
De quoi ai-je besoin pour l'exécuter ?
D'un serveur et d'une base de données pour l'état, en pratique PostgreSQL. Pour l'évaluation, un seul conteneur avec une base embarquée suffit, tandis que pour la production il vaut la peine de mettre en place tout de suite une base externe, car déplacer l'état plus tard est une tâche à part.
La documentation se trouve sur le site du projet, et les versions dans le dépôt GitHub.