Débuter avec Dagger

Mise à jour : 08/12/2024

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.

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.
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.
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.
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…
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 Node.js.

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 :

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é.
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.
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 :

systemctl --user start podman.socket

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.tar.gz https://github.com/dagger/dagger/releases/download/v0.14.0/dagger_v0.14.0_linux_amd64.tar.gz
tar xvfz dagger_v0.14.0_linux_amd64.tar.gz
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 :

dagger version

Vous devriez voir quelque chose comme :

dagger v0.14.0 (registry.dagger.io/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 :

mkdir -p ~/.zsh/completions
dagger completion zsh > ~/.zsh/completions/_dagger
echo "fpath=(~/.zsh/completions \$fpath)" >> ~/.zshrc

Pour Bash :

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épertoireminimal-test/
- pyproject.toml
- Répertoiresrc/
  - Répertoireminimal/
    …
  - init .py
  - main.py

[tool.poetry]
name = "minimal"
version = "0.1.0"
description = "Minimal Dagger test"
authors = ["Your Name <robert.stephane@example.com>"]
packages = [
    { include = "minimal", from = "src" }
]

[tool.poetry.dependencies]
python = ">=3.10"

def main():
    print("Hello, Dagger!")

On peut lancer l’installation du package :

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 :

dagger init --sdk=python --source=./pipeline
✔ connect 0.2s
✔ cache request: mkfile /schema.json 0.0s
✔ load cache: mkfile /schema.json 0.0s
✔ cache request: blob://sha256:6a6fb10b7c4d93bd179b72ce9c9ebc2b28933e95a8b320547a900498bc0a0fbd 0.0s
✔ load cache: blob://sha256:6a6fb10b7c4d93bd179b72ce9c9ebc2b28933e95a8b320547a900498bc0a0fbd 0.0s
✔ moduleSource(refString: "."): ModuleSource! 0.0s
✔ ModuleSource.kind: ModuleSourceKind! 0.0s
✔ ModuleSource.resolveContextPathFromCaller: String! 0.0s
✔ ModuleSource.withName(name: "test-dagger-python"): ModuleSource! 0.0s
✔ ModuleSource.withSDK(sdk: "python"): ModuleSource! 0.0s
✔ ModuleSource.withInit: ModuleSource! 0.0s
✔ ModuleSource.withSourceSubpath(path: "pipeline"): ModuleSource! 0.0s
✔ ModuleSource.resolveFromCaller: ModuleSource! 0.2s
✔ ModuleSource.asModule(engineVersion: "latest"): Module! 2.7s
✔ Module.generatedContextDiff: Directory! 0.0s
✔ Directory.export(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épertoirepipeline/
- LICENSE
- dagger.json
- pyproject.toml
- Répertoiresdk/
  - …
- Répertoiresrc/
  - Répertoiremy_first_dagger_pipeline/
    init .py
    main.py
- uv.lock

Un fichier main.py : votre point d’entrée ou sera décrit notre pipeline.
Un fichier pyproject.toml pour gérer les dépendances Python de dagger.

Ouvrons le fichier main.py :

import dagger
from dagger import dag, function, object_type


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

    @function
    async def grep_dir(self, directory_arg: dagger.Directory, pattern: str) -> str:
        """Returns lines that match a pattern in the files of the provided Directory"""
        return await (
            dag.container()
            .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 :

dagger call --help
✔ connect 0.2s
✔ loading module 1.9s
✔ parsing command line arguments 0.0s

Setup tracing at https://dagger.cloud/traces/setup. 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 :

dagger call grep-dir --help

✔ connect 0.2s
✔ loading module 0.7s
✔ parsing command line arguments 0.0s

Setup tracing at https://dagger.cloud/traces/setup. 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 :

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
✔ TestDaggerPython.grepDir(
    directoryArg: ✔ ModuleSource.resolveDirectoryFromCaller(path: "src"): Directory! 0.0s
    pattern: "Hello"
  ): String! 1.3s

Setup tracing at https://dagger.cloud/traces/setup. To hide: export NOTHANKS=1

./minimal/main.py:    print("Hello, Dagger!")

Cette fonction nous indique que le fichier ./minimal/main.py 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. 🚀