Skip to Content
DocsFrom ScratchConstruire un pipeline CI/CD

Construire un pipeline CI/CD

Ce guide explique comment construire un pipeline CI/CD de zéro en utilisant Cadence.CI et le langage Mélodium. À la fin, vous aurez un pipeline fonctionnel qui clone un dépôt, compile un binaire et streame le résultat vers votre machine locale.

Note

Vous avez besoin de Mélodium  version 0.11.0 ou supérieure installée. Pour une introduction plus approfondie au langage Mélodium, consultez le Livre du Langage Mélodium .

Créer le projet

Commencez par créer la structure d’un nouveau programme Mélodium :

melodium new my_cicd

Ouvrez ensuite my_cicd/Compo.toml et ajoutez les dépendances suivantes :

[dependencies] std = "0.11.0" cicd = "0.11.0" fs = "0.11.0" process = "0.11.0" work = "0.11.0"

Ces packages fournissent la bibliothèque standard, les primitives de runner CI/CD, l’accès au système de fichiers, la gestion des processus et les définitions de ressources.

Définir le traitement

Un traitement en Mélodium est une unité de travail nommée avec des entrées, des sorties et des dépendances typées. Ouvrez my_cicd/lib-root.mel et déclarez le traitement buildSoftware :

use cicd/runners::CicdDispatchEngine use cicd/runners::CicdRunnerEngine treatment buildSoftware[cicd: CicdDispatchEngine]() input trigger: Block<void> output finished: Block<void> output binary: Stream<byte> model runner: CicdRunnerEngine() { }

Décomposition de la signature :

  • [cicd: CicdDispatchEngine], le modèle de dispatch qui gère le provisionnement des runners (docs ).
  • input trigger: Block<void>, un signal qui déclenche le build.
  • output finished: Block<void>, un signal émis quand le build se termine.
  • output binary: Stream<byte>, un flux d’octets typé transportant le binaire compilé.
  • model runner: CicdRunnerEngine(), le modèle de runner que ce traitement utilisera (docs ).

Définir les étapes

Dans le corps du traitement, déclarez trois étapes qui s’exécuteront séquentiellement sur le runner : l’installation des outils, le clonage du dépôt et la compilation du binaire.

use cicd/steps::stepOn use process/command::|raw_commands /* … */ install: stepOn[runner=runner]( name="install", executor_name="ubuntu", commands=|raw_commands([ "apt-get update", "apt-get install -y gcc" ]) ) clone: stepOn[runner=runner]( name="clone", executor_name="ubuntu", commands=|raw_commands([ "git clone https://github.com/niwasawa/c-hello-world.git" ]) ) build: stepOn[runner=runner]( name="build", executor_name="ubuntu", commands=|raw_commands([ "gcc c-hello-world/hello.c", "mv a.out /mnt/data/executable" ]), out_filesystem="data", out_file="executable" )

Les trois étapes s’exécutent sur l’exécuteur nommé "ubuntu" du runner. L’étape build streame également le fichier compilé via le paramètre out_file. Consultez la documentation de stepOn pour la référence complète.

Connecter les étapes

Les étapes sont connectées en déclarant des flux de données entre leurs entrées et sorties. Les étapes install et clone peuvent s’exécuter en parallèle ; build attend que les deux soient terminées avant de démarrer.

use std/flow::waitBlock /* … */ awaitPrepare: waitBlock<void>() install.success -> awaitPrepare.a clone.success ---> awaitPrepare.b awaitPrepare.awaited -> build.trigger,finished -> Self.finished build.data -------------> Self.binary

waitBlock est une primitive de synchronisation qui émet awaited seulement après que a et b ont tous les deux reçu une valeur. Une fois build terminé, finished et binary sont transmis aux propres sorties du traitement.

Provisionner le runner

Les étapes ci-dessus s’exécutent sur un runner, mais le runner lui-même doit être démarré et arrêté dans le traitement. Ajoutez les appels setupRunner et stopRunner et connectez-les au cycle de vie des étapes :

use cicd/runners::setupRunner use cicd/runners::stopRunner use std/ops/option::|wrap use work/resources/arch::Arch use work/resources/arch::|amd64 use work/resources::|container use work/resources::|mount use work/resources::|volume /* … */ setupRunner[dispatcher=cicd, runner=runner]( cpu=200, memory=100, storage=100, name="builder", volumes=[|volume("data", 30)], containers=[|container("ubuntu", 1000, 1000, 1000, |wrap<Arch>(|amd64()), [|mount("data", "/mnt/data")], "ubuntu:latest", _)] ) stopRunner[runner=runner]() Self.trigger -> setupRunner.trigger,ready -> install.trigger setupRunner.ready ---------> clone.trigger build.finished -> stopRunner.trigger

Le runner est démarré quand le traitement est déclenché, install et clone démarrent dès qu’il est prêt, et stopRunner est appelé après que build se termine. Le runner n’est jamais inactif plus longtemps que nécessaire.

Traitement complet

En assemblant tout :

use cicd/runners::CicdDispatchEngine use cicd/runners::CicdRunnerEngine use cicd/runners::setupRunner use cicd/runners::stopRunner use cicd/steps::stepOn use process/command::|raw_commands use std/flow::waitBlock use std/ops/option::|wrap use work/resources/arch::Arch use work/resources/arch::|amd64 use work/resources::|container use work/resources::|mount use work/resources::|volume treatment buildSoftware[cicd: CicdDispatchEngine]() input trigger: Block<void> output finished: Block<void> output binary: Stream<byte> model runner: CicdRunnerEngine() { setupRunner[dispatcher=cicd, runner=runner]( cpu=200, memory=100, storage=100, name="builder", volumes=[|volume("data", 30)], containers=[|container("ubuntu", 1000, 1000, 1000, |wrap<Arch>(|amd64()), [|mount("data", "/mnt/data")], "ubuntu:latest", _)] ) stopRunner[runner=runner]() Self.trigger -> setupRunner.trigger,ready -> install.trigger setupRunner.ready ---------> clone.trigger build.finished -> stopRunner.trigger install: stepOn[runner=runner]( name="install", executor_name="ubuntu", commands=|raw_commands([ "apt-get update", "apt-get install -y gcc" ]) ) clone: stepOn[runner=runner]( name="clone", executor_name="ubuntu", commands=|raw_commands([ "git clone https://github.com/niwasawa/c-hello-world.git" ]) ) build: stepOn[runner=runner]( name="build", executor_name="ubuntu", commands=|raw_commands([ "gcc c-hello-world/hello.c", "mv a.out /mnt/data/executable" ]), out_filesystem="data", out_file="executable" ) awaitPrepare: waitBlock<void>() install.success -> awaitPrepare.a clone.success ---> awaitPrepare.b awaitPrepare.awaited -> build.trigger,finished -> Self.finished build.data -------------> Self.binary }

Créer le point d’entrée

Un traitement ne peut pas être exécuté directement ; il nécessite un point d’entrée qui le connecte au monde extérieur. Ajoutez un traitement runBuild dans my_cicd/lib-root.mel :

use fs/local::writeLocal use std/engine/util::startup treatment runBuild(var output_file: string = "./executable") model cicd: CicdDispatchEngine(location="compose") { startup() buildSoftware[cicd=cicd]() writeLocal(path=output_file) startup.trigger -> buildSoftware.trigger,binary -> writeLocal.data }

Déclarez-le ensuite comme point d’entrée du programme dans my_cicd/Compo.toml :

[entrypoints] main = "my_cicd::runBuild"

Exécuter

melodium run my_cicd/Compo.toml

Un fichier nommé executable apparaîtra dans le répertoire courant une fois le pipeline terminé.

Note

Le CicdDispatchEngine est configuré avec location="compose" ici, ce qui utilise Podman Compose ou Docker Compose pour provisionner les runners localement. Pour exécuter les étapes sur des machines que Cadence.CI démarre dans votre compte cloud, retirez location="compose" ("api" est la valeur par défaut) et lancez avec --api-report, la variable d’environnement MELODIUM_API_TOKEN contenant un jeton d’exécution. Voir le Démarrage rapide et la documentation de CicdDispatchEngine.

Programme complet

Téléchargez le programme complet pour référence.