Skip to Content
DocsFrom TemplateImplémentation Avancée

Implémentation Avancée

Voici une explication de l’implémentation avancée du CI/CD, utilisant des traitements et des outils plus détaillés. main fonctionne de la même façon que dans la version racine ; les traitements build et test proviennent du fichier advanced.mel et contiennent l’implémentation CI/CD.

Implémentation CI/CD

Les traitements build et test sont implémentés de la même façon : ils nécessitent de configurer un runner sur lequel les étapes sont distribuées. Leur implémentation de base est donnée comme exemple fonctionnel simple.

Ils prennent tous les deux le modèle CicdDispatchEngine et un signal d’entrée trigger. CicdDispatchEngine et l’entrée trigger sont utilisés pour demander un nouveau runner distribué CicdRunnerEngine via setupRunner dès que c’est utile.

treatment build[cicd: CicdDispatchEngine](repository_clone_url: string, repository_clone_ref: string) model runner: CicdRunnerEngine() input trigger: Block<void> output data: Stream<byte> { setupRunner[ dispatcher=cicd, runner=runner ]( name="build", cpu=10, memory=500, storage=1000, volumes=[|volume("build-result", 30)], containers=[|container("ubuntu", 1000, 10, 8000, |wrap<Arch>(|amd64()), [|mount("build-result", "/mounted/result")], "ubuntu:noble", _)] ) gitClone: stepOn[runner=runner]( name="git", executor_name="ubuntu", environment=|wrap<Environment>(|environment(|map([]), "/root", false, false)), commands=[ |command("apt-get", ["update"]), |command("apt-get", ["install", "-y", "git"]), |command("git", ["config", "--global", "url.https://.insteadOf", "git://"]), |command("git", ["clone", "--branch", repository_clone_ref, "--depth", "1", repository_clone_url, "project"]) ] ) makeList: stepOn[runner=runner]( name="list", executor_name="ubuntu", environment=|wrap<Environment>(|environment(|map([]), "/root/project", false, false)), commands=|raw_commands([ "sh -c \"ls -l --almost-all | tee files-list.txt\"", "mv files-list.txt /mounted/result/" ]), out_filesystem="build-result", out_file="files-list.txt" ) stopRunner[runner=runner]() Self.trigger -> setupRunner.trigger,ready -> gitClone.trigger,completed -> makeList.trigger,finished -> stopRunner.trigger makeList.data -------------> Self.data }

Configurer le runner

setupRunner prend différents paramètres, dont les principaux sont :

  • name, une chaîne avec laquelle tous les logs seront marqués ;
  • cpu, quantité de CPU (en millicores, 1000 valant un CPU entier) que le moteur Mélodium doit avoir ;
  • memory, mémoire (en mégaoctets) dédiée au moteur Mélodium ;
  • storage, espace disque (en mégaoctets) dont dispose le moteur Mélodium ;
  • volumes, tableau de volumes que le moteur Mélodium et les conteneurs peuvent partager sur le runner ;
  • containers, liste de conteneurs disponibles pour exécuter des étapes sur le runner.

Les volumes sont essentiellement des labels associés à une taille (en mégaoctets), et peuvent être montés dans les conteneurs pour partager des données avec eux. Les conteneurs sont définis comme suit :

|container(name, memory, cpu, storage, arch, mounts, image, pull_secret)
  • name étant le nom désigné avec lequel le conteneur peut être adressé comme exécuteur ;
  • memory (en mégaoctets), cpu (en millicores) et storage (en mégaoctets), dans cet ordre, ayant la même signification que pour le moteur Mélodium ;
  • arch désignant l’architecture matérielle sur laquelle le conteneur doit s’exécuter, en Option<Arch> : _ prend l’architecture du worker, |wrap<Arch>(|amd64()) en impose une ;
  • mounts étant un tableau de points de montage pour les volumes définis dans le système de fichiers du conteneur ;
  • image l’image de conteneur à utiliser comme base ;
  • pull_secret les identifiants (optionnels) du registre pour récupérer l’image de conteneur, un Secret<string> contenant une configuration Docker JSON. Le conteneur démarre avant le moteur du runner, donc le secret doit voyager avec la demande : donnez-le avec |locate et la transmission value, comme |locate<string>("env:MELODIUM_SECRET_REGISTRY", "registry", "value", false), ou reference pour un secret enregistré sur Cadence.CI, donné par son nom. Un simple localisateur reste sur la machine qui le résout, et il est refusé.

Le moteur Mélodium lui-même peut être assez économe en ressources car le travail en CI/CD est généralement effectué dans des conteneurs, ne laissant que l’orchestration et le streaming de données. Le template lui donne 10 millicores et 500 mégaoctets.

Actuellement les architectures AMD64/x86_64 |amd64() et ARM64/aarch64 |arm64() sont supportées, et tous les conteneurs d’un même runner qui en indiquent une doivent utiliser la même.

L’ensemble des volumes doit tenir dans le stockage du moteur Mélodium, et le stockage de chaque conteneur doit être au moins égal à la somme des volumes montés dedans. Alors que les valeurs de CPU et mémoire sont cumulatives entre le moteur principal et les conteneurs, l’espace de stockage correspondant aux volumes est partagé et non dupliqué entre les conteneurs.

Exécuter des étapes

Sur chaque runner, un nombre arbitraire d’étapes peut être appliqué en utilisant les traitements stepOn et stepOnWithInput. Ces traitements prennent un CicdRunnerEngine sur lequel le travail sera effectué, selon la logique suivante :

  1. réception du fichier de données en entrée (pour stepOnWithInput),
  2. traitement des commandes,
  3. émission du fichier de données en sortie.

Données en entrée

stepOnWithInput dispose de deux paramètres configurant quel fichier est écrit : in_filesystem et in_file indiquent respectivement quel volume et quel nom de fichier sont remplis avec les données provenant de l’entrée data.

Ici le fichier "list.txt" est écrit sur le volume "tested-data" et accessible au point de montage "/mounted/data/" de l’exécuteur "alpine" :

makeTest: stepOnWithInput[runner=runner]( name="test", executor_name="alpine", in_filesystem="tested-data", in_file="list.txt", commands=[ |command("test", ["-s", "/mounted/data/list.txt"]), |command("cat", ["/mounted/data/list.txt"]) ] )

Traitement des commandes

Le paramètre commands est une liste de commandes exécutées sur l’exécuteur désigné par executor_name, dans un environment optionnellement défini.

Les commandes peuvent être spécifiées de plusieurs façons :

  • fonction |command(), pour une commande détaillée avec liste d’arguments ;
  • fonction |raw_command(), pour une commande en chaîne brute ;
  • fonction |raw_commands(), pour une liste complète de commandes en chaîne.

environment peut également être fourni pour spécifier des variables d’environnement supplémentaires ou le répertoire de travail. L’environnement est appliqué à toutes les commandes d’une étape donnée.

gitClone: stepOn[runner=runner]( name="git", executor_name="ubuntu", environment=|wrap<Environment>(|environment(|map([]), "/root", false, false)), commands=[ |command("apt-get", ["update"]), |command("apt-get", ["install", "-y", "git"]), |command("git", ["config", "--global", "url.https://.insteadOf", "git://"]), |command("git", ["clone", "--branch", repository_clone_ref, "--depth", "1", repository_clone_url, "project"]) ] )

Données en sortie

Les traitements stepOn et stepOnWithInput permettent tous deux de sortir des données. out_filesystem et out_file spécifient quel volume et quel fichier sont streamés après les commandes de l’étape.

Ici le fichier "files-list.txt" est streamé depuis le volume "build-result" après l’exécution des commandes :

makeList: stepOn[runner=runner]( name="list", executor_name="ubuntu", environment=|wrap<Environment>(|environment(|map([]), "/root/project", false, false)), commands=|raw_commands([ "sh -c \"ls -l --almost-all | tee files-list.txt\"", "mv files-list.txt /mounted/result/" ]), out_filesystem="build-result", out_file="files-list.txt" )

Exécuter le CI/CD localement

Pour exécuter le programme CI/CD, invoquez Mélodium avec les paramètres du programme :

export MELODIUM_API_TOKEN=<VOTRE_JETON_D_EXECUTION> melodium run --api-report .melodium-ci/Compo.toml advanced --repository_clone_url <URL_CLONE_COMPLETE>.git --repository_clone_ref <BRANCHE_OU_TAG>

Où VOTRE_JETON_D_EXECUTION est un jeton d’exécution Cadence.CI. Cela exécute le “moteur principal” du CI/CD depuis votre ordinateur, et exécute les runners build et test sur des machines que Cadence.CI démarre dans votre compte cloud connecté. Ajoutez --work_location compose pour les exécuter plutôt en conteneurs locaux.

Tous les logs CI/CD s’affichent aussi dans le terminal.