Débuter avec Dagger

Mise à jour :

Les pipelines CI/CD, c’est un peu comme les autoroutes du développement moderne : ils
permettent d’aller vite, mais quand ça bouchonne, c’est la panique. Entre les scripts YAML
imbriquées, les erreurs incompréhensibles et les limitations des outils traditionnels, on peut vite
perdre patience. Et si je vous disais qu’il existe une solution plus flexible et – soyons honnêtes –
bien plus agréable à utiliser ?
Dagger est là pour révolutionner la manière dont on construit et exécute les pipelines CI/CD. Imaginé
par les créateurs de Docker, cet outil moderne et programmable mise sur les conteneurs pour offrir une
expérience fluide et portable. Fini les configurations rigides : avec Dagger, vous codez vos pipelines
comme n’importe quelle autre application. Python, Go, TypeScript… choisissez votre arme.
Dans ce guide, je vous propose de découvrir comment créer votre premier pipeline CI/CD avec Dagger
et Python. On part de zéro, on installe l’outil, on écrit un pipeline simple pour construire et tester une
application et on termine par un aperçu des fonctionnalités avancées. Pas à pas, vous verrez à quel
point il est facile et agréable de personnaliser vos workflows avec Dagger.
Prêt à transformer vos pipelines ? Alors, c’est parti ! 🚀
Historique rapide de Dagger
Pour bien comprendre ce qu’apporte Dagger, il faut jeter un œil à son histoire. L’outil n’est pas arrivé
par hasard : il est né d’un besoin pressant dans le monde DevOps, celui de simplifier les pipelines
CI/CD, souvent devenus des monstres de complexité.
Dagger a été lancé en 2022 par une équipe bien connue dans le monde du développement : le fondateur
de Docker, Solomon Hykes rien que ça ! Son objectif ? Faire pour les pipelines ce que Docker a fait
pour les conteneurs : unifier, standardiser et rendre les workflows accessibles à tous, même aux
équipes les plus hétérogènes.
Dagger repose sur BuildKit, le moteur de construction qui propulse déjà Docker. BuildKit est connu
pour ses performances et sa flexibilité : il est capable de gérer des caches intelligents, d’exécuter des
étapes en parallèle et de fonctionner sur différents environnements, de votre laptop jusqu’à un cluster
Kubernetes.
Avant Dagger, les pipelines CI/CD dépendaient souvent de solutions comme Jenkins, GitLab CI/CD
ou CircleCI. Bien que puissants, ces outils sont souvent :
• Rigides : les configurations se font en YAML, un format pratique mais vite limité pour des cas
d’usage complexes.
• Fragmentés : chaque outil a ses propres spécificités, rendant les pipelines difficiles à migrer ou
à partager.
• Dépendants des plateformes : bon courage si vous voulez utiliser un outil sur plusieurs
environnements.
Avec Dagger, tout change. Les pipelines deviennent des programmes que vous écrivez dans le langage
de votre choix (Python, Go, TypeScript). Et surtout, ils fonctionnent partout où les conteneurs sont
pris en charge.
Dagger, c’est l’idée que vos pipelines CI/CD doivent être aussi portables et modulaires que vos
applications. À mon avis, c’est cette philosophie qui va convaincre de nombreuses équipes DevOps
d’adopter cet outil. On ne parle plus de configuration, mais de programmation. Un vrai plaisir pour
ceux qui aiment garder un contrôle total sur leurs outils.

Fonctionnalités de Dagger
Dagger n’est pas juste un autre outil de pipelines CI/CD dans une longue liste. Il se distingue par ses
fonctionnalités uniques, conçues pour enrichir vos pipelines, tout en vous laissant un contrôle total.
Voici ce qui rend Dagger incontournable.
1. Programmabilité : vos pipelines en Python (ou un autre langage !) : Fini les fichiers
YAML ! Avec Dagger, vos pipelines sont écrits dans un langage de programmation que vous
connaissez et appréciez : Python, Go ou TypeScript. Cela signifie :
• Plus de flexibilité : vous pouvez écrire des boucles, des conditions, importer des
librairies, bref, tout ce qu’un programme classique permet.
• Une réutilisabilité accrue : organisez vos pipelines en fonctions, modules et classes.
2. Portabilité : des pipelines qui fonctionnent partout : Dagger repose sur les conteneurs
(Docker, Podman, ou tout moteur conforme OCI). Cela garantit que vos pipelines tournent :
• Sur votre ordinateur local.
• Dans un environnement de CI/CD comme GitHub Actions.
• Sur des serveurs de production.
3. Caching intelligent : la rapidité avant tout : Dagger exploite un système de cache intégré
pour éviter les exécutions inutiles :
• Si une étape n’a pas changé, elle est simplement récupérée depuis le cache.
• Les étapes parallélisables sont exécutées en même temps.
 4. Compatibilité avec les outils DevOps populaires : Dagger ne cherche pas à remplacer tout
votre écosystème ; il s’y intègre parfaitement. Vous pouvez connecter Dagger à vos outils
préférés :
• Analyse de sécurité avec Trivy.
• Déploiements sur Kubernetes , AWS Lambda ou autres.
• Intégrations avec des services comme GitHub Actions ou GitLab CI…
5. Open Source et communauté active : Dagger est un projet open source avec une
communauté en pleine croissance. Vous bénéficiez d’un outil gratuit, robuste et enrichi en
continu grâce aux contributions des utilisateurs.

L’Architecture de Dagger
L’architecture de Dagger repose sur une combinaison de composants modulaires et interconnectés.
Voici un aperçu de la structure de l’application :
Dagger Engine
Le Dagger Engine est le cœur du système. Il orchestre toutes les étapes d’un pipeline, des builds aux
tests, en passant par le déploiement. Voici ses principales caractéristiques :
• Basé sur BuildKit : Le moteur utilise BuildKit, une technologie éprouvée utilisée par Docker,
pour exécuter les étapes du pipeline de manière efficace, avec un cache intelligent et une
exécution parallèle.
• Portabilité : Grâce à sa conception conteneurisée, le moteur fonctionne sur n’importe quel
environnement compatible Docker ou OCI, comme Podman.
• Définition programmable : Toutes les étapes d’un pipeline sont décrites via un code
exécutable dans des SDK comme Python, Go ou TypeScript, ce qui remplace les fichiers YAML
traditionnels.

Les SDK Dagger

Les SDK Dagger sont les outils qui permettent aux développeurs de coder leurs pipelines.
Contrairement aux solutions traditionnelles, où les workflows sont définis dans des fichiers YAML ou
JSON, Dagger permet de les programmer dans des langages modernes :
• SDK Python : Idéal pour les développeurs qui préfèrent la simplicité et la lisibilité de Python.
• SDK Go : Conçu pour des performances élevées et une intégration profonde avec les outils
cloud-native.
• SDK TypeScript : Parfait pour les développeurs orientés web et ceux travaillant déjà avec
[Link].
Ces SDK permettent de :
• Écrire des pipelines dynamiques avec des boucles, des conditions et des fonctions.
• Réutiliser des bibliothèques ou des modules pour éviter la duplication de code.
• Tirer parti des outils et des librairies de l’écosystème du langage choisi.

Dagger Verse
Le DaggerVerse est l’écosystème de modules qui enrichit l’expérience Dagger. Pensez-y comme à une
boîte à outils extensible pour vos pipelines :
1. Modules préconstruits par Dagger : Dagger fournit des modules prêts à l’emploi pour des
tâches courantes, comme la gestion de conteneurs ou l’analyse de sécurité.
2. Modules de l’écosystème : Une collection de modules partagés par la communauté et les
partenaires de Dagger. Cela inclut des intégrations avec des outils populaires comme
Kubernetes, Terraform, ou Trivy.
3. Modules utilisateurs : Créez et partagez vos propres modules réutilisables pour standardiser
vos pipelines au sein de votre équipe.
Dagger Cloud
Le Dagger Cloud est un service optionnel qui complète l’infrastructure locale de Dagger. Il apporte
plusieurs avantages clés :
• Collaboration : Partagez vos pipelines, modules et configurations avec votre équipe
directement depuis le cloud.
• Gestion centralisée : Accédez à vos workflows depuis n’importe où, avec une gestion unifiée
des ressources.
• Performances optimisées : Exécutez vos pipelines dans des environnements scalables gérés
par Dagger Cloud, en minimisant les limitations locales.
• Sécurité : Toutes les communications entre le Dagger Engine et le Dagger Cloud sont
chiffrées.

Installation de Dagger
Maintenant que vous savez pourquoi Dagger est si révolutionnaire, il est temps de mettre les mains
dans le cambouis !

Pré-requis
Avant d’installer la CLI Dagger, assurez-vous d’avoir les éléments suivants :
• Docker ou Podman installé sur votre machine.
• Python 3.7 ou une version ultérieure si vous souhaitez utiliser le SDK Python.
Si vous utilisez Podman, pensez à activer son socket de compatibilité Docker :
Terminal window
systemctl --user start [Link]

Télécharger et installer Dagger

• Pour Linux :

↗
Plutôt que d’installer Dagger avec le script shell disponible en ligne, je préfère utiliser une
méthode plus manuelle. Allez sur la page des releases du projet Dagger et téléchargez le
binaire correspondant à votre système.
Décompressez l’archive et déplacez le binaire dans le répertoire /usr/bin/local :

Terminal window
cd /tmp
wget -O dagger_v0.14.0_linux_amd64.[Link]
[Link]
ux_amd64.[Link]
tar xvfz dagger_v0.14.0_linux_amd64.[Link]
sudo mv dagger /usr/local/bin/
 • Sur MacOS :
Installer si ce n’est pas déjà fait HomeBrew, exécutez la commande suivante :
Terminal window
brew install dagger/tap/dagger

Vérifier l’installation
Une fois la CLI Dagger installé, vérifiez que tout fonctionne correctement en exécutant :
Terminal window
dagger version

Vous devriez voir quelque chose comme :

dagger v0.14.0 ([Link]/engine:v0.14.0) linux/amd64

Installation de l’auto-complétion
Pour ajouter l’autocomplétion, il suffit de suivre ces étapes.
• Pour Zsh :
Terminal window
mkdir -p ~/.zsh/completions
dagger completion zsh > ~/.zsh/completions/_dagger
echo "fpath=(~/.zsh/completions \$fpath)" >> ~/.zshrc

• Pour Bash :
Terminal window
mkdir -p ~/.bash/completions
dagger completion bash > ~/.bash/completions/_dagger
echo "source ~/.bash/completions/_dagger" >> ~/.bashrc

Quittez votre shell et relancez-le pour que les modifications soient prises en compte.

Initialisation de votre premier pipeline Dagger

Il nous faut un projet pour commencer. Je vais créer un projet Python le plus basique possible avec
cette arborescence :
• Répertoire
minimal-test/
•
• [Link]
 • Répertoiresrc/
• Répertoire
• minimal/
• init .py
• [Link]
[Link]
[[Link]]
name = "minimal"
version = "0.1.0"
description = "Minimal Dagger test"
authors = ["Your Name <[Link]@[Link]>"]
packages = [
{ include = "minimal", from = "src" }
]

[[Link]]
python = ">=3.10"

src/minimal/[Link]
def main():
print("Hello, Dagger!")

On peut lancer l’installation du package :

Terminal window
poetry install
Installing dependencies from lock file

Installing the current project: minimal (0.1.0)

Placez-vous dans le répertoire du projet et exécutez :

Terminal window

✔✔
dagger init --sdk=python --source=./pipeline
connect 0.2s

✔✔cache request: mkfile /[Link] 0.0s

load cache: mkfile /[Link] 0.0s
cache request:

✔
blob://sha256:6a6fb10b7c4d93bd179b72ce9c9ebc2b28933e95a8b320547a900498bc0a0fbd 0.0s
load cache:

✔✔
blob://sha256:6a6fb10b7c4d93bd179b72ce9c9ebc2b28933e95a8b320547a900498bc0a0fbd 0.0s
moduleSource(refString: "."): ModuleSource! 0.0s

✔✔
[Link]: ModuleSourceKind! 0.0s
[Link]: String! 0.0s

✔✔
[Link](name: "test-dagger-python"): ModuleSource! 0.0s
[Link](sdk: "python"): ModuleSource! 0.0s

✔✔
[Link]: ModuleSource! 0.0s
[Link](path: "pipeline"): ModuleSource! 0.0s

✔✔
[Link]: ModuleSource! 0.2s
[Link](engineVersion: "latest"): Module! 2.7s
[Link]: Directory! 0.0s
✔ [Link](path: "/home/bob/Projets/test-dagger-python"): String! 0.8s
10:29:20 WRN no LICENSE file found; generating one for you, feel free to change or
remove license=Apache-2.0
Initialized module test-dagger-python in .

Cela génère une structure de projet de base :

• Répertoire
pipeline/
•
• LICENSE
• [Link]
• [Link]
• Répertoire
• sdk/
• Répertoiresrc/
• Répertoire
my_first_dagger_pipeline/
•
• init .py
• [Link]
• [Link]
• Un fichier [Link] : votre point d’entrée ou sera décrit notre pipeline.
• Un fichier [Link] pour gérer les dépendances Python de dagger.

Ouvrons le fichier [Link] :

import dagger
from dagger import dag, function, object_type

@object_type
class TestDaggerPython:
@function
def container_echo(self, string_arg: str) -> [Link]:
"""Returns a container that echoes whatever string argument is provided"""
return [Link]().from_("alpine:latest").with_exec(["echo",
string_arg])

@function
async def grep_dir(self, directory_arg: [Link], pattern: str) -> str:
"""Returns lines that match a pattern in the files of the provided
Directory"""
return await (
[Link]()
.from_("alpine:latest")
 .with_mounted_directory("/mnt", directory_arg)
.with_workdir("/mnt")
.with_exec(["grep", "-R", pattern, "."])
.stdout()
)

Quelques explications :
• TestDaggerPython est une classe qui regroupe plusieurs fonctions liées au pipeline.
• @object_type : Transforme la classe en un type reconnu par Dagger, permettant d’appeler
ses méthodes comme étapes du pipeline.
Ce pipeline contient deux fonctions :
• container_echo qui exécute un conteneur qui affiche une chaîne de texte passée en
argument.
• grep_dir qui exécute un conteneur qui recherche un motif dans les fichiers d’un répertoire.

Exécution d’une étape du pipeline

Nous allons lancer une des fonctions pour le moment. Pour le moment vons ne connaissez que la
commande dagger init. Voyons la commande dagger call qui permet de lancer des étapes ne
notre futur pipeline :
Terminal window

✔✔
dagger call --help
connect 0.2s

✔ loading module 1.9s

parsing command line arguments 0.0s

Setup tracing at [Link] To hide: export STOPIT=1

Call one or more functions, interconnected into a pipeline

USAGE
dagger call [options] <function>

FUNCTIONS
container-echo Returns a container that echoes whatever string argument is
provided
grep-dir Returns lines that match a pattern in the files of the provided
Directory

OPTIONS
-j, --json Present result as JSON
-m, --mod string Path to the module directory. Either local path or a remote
git repo
-o, --output string Save the result to a local file or directory

INHERITED OPTIONS
-d, --debug Show debug logs and full verbosity
-i, --interactive Spawn a terminal on container exec failure
--interactive-command string Change the default command for interactive
mode (default "/bin/sh")
-E, --no-exit Leave the TUI running after completion
 --progress string Progress output format (auto, plain, tty)
(default "auto")
-q, --quiet count Reduce verbosity (show progress, but clean up
at the end)
-s, --silent Do not show progress at all
-v, --verbose count Increase verbosity (use -vv or -vvv for more)
-w, --web Open trace URL in a web browser

Use "dagger call [command] --help" for more information about a command.

On voit que nos deux fonctions sont listées. On peut obtenir de l’aide sur la seconde fonction :
Terminal window
dagger call grep-dir --help

✔✔ connect 0.2s

✔ parsing command line arguments 0.0s

loading module 0.7s

Setup tracing at [Link] To hide: export SHUTUP=1

Returns lines that match a pattern in the files of the provided Directory

USAGE
dagger call grep-dir [arguments]

ARGUMENTS
--directory-arg Directory A directory. [required]
--pattern string [required]

On voit qu’elle peut prendre deux arguments :

• directory-arg qui est un répertoire.
• pattern qui est un motif.

Nous allons donc lancer notre fonction avec un répertoire et un motif :

Terminal window

✔✔
dagger call grep-dir --directory-arg src --pattern Hello
connect 0.2s

✔✔loading module 2.0s

parsing command line arguments 0.0s

✔testDaggerPython: TestDaggerPython! 0.9s

✔
[Link](
directoryArg: [Link](path: "src"):
Directory! 0.0s
pattern: "Hello"
): String! 1.3s

Setup tracing at [Link] To hide: export NOTHANKS=1

./minimal/[Link]: print("Hello, Dagger!")

Cette fonction nous indique que le fichier ./minimal/[Link] contient le motif Hello.
Maintenant que Dagger est installé et prêt à l’emploi, nous verrons dans le prochain guide pour
construire un pipeline de CI/CD étape par étape.

Conclusion
Je sais, vous allez me dire “Outch, mais c’est complexe !”. Et oui, ça l’est. Mais c’est aussi le futur.
C’est pour cette raison que je vous invite à vous former à au moins un langage de programmation
comme Python ou Go. Dans un monde où l’automatisation et l’infrastructure as code deviennent la
norme, il ne faut pas se le cacher : petit à petit, on vous demande de savoir écrire du code. Ce n’est
plus seulement un “plus”, c’est une compétence indispensable.
Mais malgré cette complexité apparente, j’adore le concept de Dagger. Il réussit là où de nombreux
outils CI/CD échouent : offrir une flexibilité totale tout en restant accessible, pour peu qu’on prenne le
temps de l’apprivoiser.
Cela me donne envie de continuer à développer des contenus pour vous aider à plonger dans le
développement. Je dois compléter la section Python avec de sujets essentiels comme :
• La programmation orientée objet (POO) pour structurer votre code.
• Les décorateurs pour étendre les fonctionnalités de vos pipelines sans tout réécrire.
• Poetry, l’outil parfait pour gérer vos dépendances Python et packager vos projets comme des
pros et qui est un pré-requis pour Dagger.
Alors, prêt à monter en compétence ? La route est peut-être longue, mais elle est passionnante et je suis
là pour vous accompagner pas à pas.