Editions ENI Livres | Vidéos | e-Formations
Travailler avec les registres et les environnements
Introduction
Dans le chapitre Analyser et tester son code source, nous avons vu comment utiliser GitLab pour analyser et tester notre code source, tout en rappelant brièvement la distinction entre la compilation, le build ainsi que le rôle de la conteneurisation dans ces processus.
Le présent chapitre poursuit l’exploration du cycle de développement logiciel en se concentrant sur l’empaquetage (packaging) et le déploiement du code. Pour illustrer notre propos, nous aurons recours aux registres de paquets et de conteneurs intégrés aux projets GitLab.
Comme l’objectif du développement est de rendre un logiciel accessible aux utilisateurs après l’avoir conçu et testé, nous allons présenter les concepts d’environnements et de déploiements dans le contexte de GitLab. Ces notions viendront enrichir notre compréhension des pipelines et nous aideront à mieux orchestrer la mise en production.
Enfin, nous nous intéresserons à des outils complémentaires tels que Terraform et Kubernetes et nous verrons brièvement les options offertes par GitLab pour interagir avec des fournisseurs de services cloud.
Au terme de ce chapitre, vous serez en mesure de travailler avec les registres natifs de paquets (package registry) et de conteneurs (container registry) de GitLab pour héberger vos builds. Vous découvrirez également...
Les registres intégrés de GitLab
GitLab ne se limite pas à la gestion du code source et à l’automatisation des pipelines CI/CD comme nous l’avons vu jusqu’à présent. La plateforme propose également des registres intégrés permettant de stocker, de partager et de gérer différents types d’artéfacts directement au sein des projets. Ces registres sont conçus pour simplifier le développement, le déploiement et la maintenance des applications en intégrant des solutions adaptées aux besoins des développeurs et des équipes DevOps.
1. Les registres du menu Deploiement
L’un des registres les plus utilisés est le registre de paquets. Il permet de centraliser et de distribuer des bibliothèques (libraries), des dépendances et des artéfacts logiciels en utilisant des formats adaptés aux différents écosystèmes de développement.
GitLab intègre également un registre de conteneurs (container registry), une solution clé pour le stockage et la distribution des images de conteneurs. Ce registre facilite le développement d’applications conteneurisées en offrant un espace centralisé pour héberger et gérer les images, ce qui facilite leur utilisation dans les pipelines.
Avec la montée en force...
Travailler avec le registre de paquets
Dans GitLab, le registre de paquets permet de stocker et de gérer des packages logiciels ce qui favorise leur intégration dans les pipelines CI/CD. Dans cette section, nous allons commencer par définir ce registre, nous verrons comment s’y authentifier et nous apprendrons à les utiliser.
1. Définition du registre de paquets
Un registre de paquets dans GitLab est un dépôt centralisé qui permet de stocker et de gérer divers composants logiciels tels que des bibliothèques, des packs de langage dans divers formats et plusieurs autres types de dépendances. Il simplifie la distribution de ces ressources entre différents projets et groupes GitLab, ce qui permet de garantir une cohérence dans leur utilisation. Les utilisateurs peuvent publier et récupérer ces éléments directement depuis le registre dans les jobs des pipelines.
Un pack de langage de programmation est un ensemble de fichiers et d’outils permettant d’utiliser un langage dans un environnement de développement. Il inclut généralement un compilateur ou un interpréteur, des bibliothèques standard nécessaires à l’exécution du code, ainsi qu’un gestionnaire de paquets pour installer des dépendances spécifiques. Certains packs contiennent également des outils de développement tels qu’un débogueur ou un linter.
Un registre de paquets GitLab est aussi une solution sécurisée pour le suivi des versions, car elle permet de contrôler et de documenter les modifications apportées à chaque composant. Voyons maintenant les principaux formats de packages supportés par ce registre.
2. Les formats de paquets supportés
Le registre de paquets GitLab prend en charge plusieurs formats afin de faciliter la gestion et le partage des dépendances logicielles à l’intérieur des projets. Il permet aux développeurs de stocker, versionner et distribuer leurs paquets en intégrant des gestionnaires populaires tels que npm, PyPi, Maven, NuGet et plusieurs autres.
Voici les différents formats pris en charge par le registre de paquets GitLab :
-
Debian : ces paquets sont utilisés pour distribuer et installer des logiciels sur les systèmes...
Travailler avec le registre de conteneurs
En plus du registre de paquets, GitLab propose un registre de conteneurs qui permet de stocker et gérer des images Docker. Dans la section qui suit, nous allons commencer par définir ce registre, ensuite nous verrons comment s’authentifier auprès de celui-ci et nous donnerons quelques exemples de son utilisation dans un pipeline.
1. Définition du registre de conteneurs
Le registre de conteneurs de GitLab est une solution intégrée qui permet de stocker, gérer et distribuer des images Docker directement au sein de vos projets GitLab. Il repose sur le standard Docker Registry V2, ce qui le rend compatible avec d’autres outils populaires de gestion de conteneurs, tels que Podman et Kubernetes.
Chaque projet GitLab dispose de son propre registre de conteneurs, ce qui permet aux équipes de centraliser et versionner leurs images de manière sécuritaire. L’authentification au registre peut se faire via un jeton de déploiement, un jeton de job CI/CD ou encore avec des identifiants d’utilisateur GitLab.
L’intégration avec les pipelines CI/CD permet d’automatiser les processus de build, push et pull des images. Les développeurs peuvent ainsi construire une image Docker, la pousser vers le registre, puis la récupérer pour exécuter des tests ou la déployer dans un environnement de production.
2. Les formats d’image de conteneur supportés
Le registre de conteneurs GitLab prend en charge plusieurs formats d’images standards et il s’intègre également avec d’autres solutions de gestion de conteneurs et d’orchestration. Voici les technologies qu’il prend en charge :
-
Docker V2 : format d’image basé sur la version 2 du registre Docker qui est utilisé pour stocker et gérer des images de conteneurs.
-
Open Container Initiative (OCI) : standard open source assurant l’interopérabilité des images et des runtimes de conteneurs.
-
Helm 3+ charts : paquets Helm permettant de gérer et déployer des applications Kubernetes. Bien qu’ils ne soient pas un format d’image, ils sont stockés et distribués via le registre GitLab.
-
Harbor : registre de conteneurs open source, compatible avec OCI et Docker, conçu...
Travailler avec les registres d’infrastructure
Les registres, ou plutôt l’espace de stockage des états et des modules Terraform sont des fonctionnalités permettant de gérer des composants utilisés pour les déploiements de type Infrastructure as Code (IaC). Ils permettent de suivre l’état des ressources déployées, d’assurer la collaboration entre plusieurs utilisateurs et d’organiser efficacement les configurations Terraform (ou OpenTofu, son équivalent open source). Ces registres simplifient la gestion des modules et des state files tout en sécurisant leur accès grâce à des jetons d’authentification.
Un fichier d’état (terraform.tfstate) est utilisé pour conserver une trace des ressources créées, modifiées ou supprimées lors de l’exécution de Terraform. Lorsqu’un projet est géré en équipe, stocker cet état dans un backend distant comme GitLab permet d’éviter les conflits et garantit qu’une seule instance de Terraform modifie l’infrastructure à un moment donné. GitLab prend en charge le stockage des états via une API dédiée, avec des fonctionnalités de verrouillage et de déverrouillage pour empêcher les accès concurrents non contrôlés....
Travailler avec les environnements
Jusqu’à présent, nous avons exploré la gestion et la distribution du code à travers les registres de paquets et de conteneurs et nous avons présenté les espaces de stockage dédiés à l’IaC. Il est maintenant temps de voir comment GitLab permet d’organiser et de structurer les déploiements en définissant des environnements qui représentent les différentes étapes où une application est testée et mise en production. Les environnements sont utiles pour suivre l’évolution des déploiements, effectuer des tests intermédiaires et garantir la stabilité des applications.
1. Définition d’un environnement
Dans GitLab, un environnement représente une catégorie organisationnelle pour le déploiement d’une application. Il s’agit d’une abstraction qui peut correspondre, par exemple, à un environnement de développement, test (staging) ou production.
En revanche, un environnement réel de déploiement correspond à l’infrastructure physique ou virtuelle où l’application est réellement exécutée, comme un serveur, un cluster Kubernetes ou un service cloud tel que AWS (Amazon Web Services), Microsoft Azure ou Google Cloud Platform (GCP).
Ces plateformes permettent une gestion plus flexible des environnements, souvent complétées par des outils comme Terraform dont nous avons déjà parlé ou encore Ansible, souvent utilisé pour automatiser la configuration de serveurs. Il en existe plusieurs autres comme Chef et Puppet qui servent également au provisionnement de composants d’infrastructure et à la gestion des configurations.
Chaque environnement est défini par un nom et, éventuellement, une URL permettant d’accéder à l’application déployée. Il ne contient pas une version spécifique du logiciel comme l’environnement cible réel, il sert à organiser et suivre les déploiements successifs d’une application ou des composants d’infrastructure dans le cas de l’IaC.
Les environnements sont définis dans un job de pipeline avec le mot-clé environnement. Cette directive...
Conclusion
Dans ce chapitre, nous avons exploré les différents types de registres intégrés à GitLab. Nous avons vu comment ils permettent de stocker, gérer et distribuer des artéfacts essentiels au développement et au déploiement d’applications, que ce soit sous forme de bibliothèques, d’images de conteneurs ou de configurations d’infrastructure.
Nous avons également abordé la gestion des environnements dans GitLab, en examinant leur rôle dans l’organisation et le suivi des déploiements. Ensuite, nous avons discuté de l’intégration des services cloud et de l’utilisation des variables CI/CD pour gérer les secrets de manière sécurisée.
Pour terminer, nous avons introduit brièvement l’intégration de Kubernetes dans GitLab en soulignant comment cet outil s’inscrit naturellement dans une approche de déploiement moderne et automatisée.
Dans le chapitre Sécuriser son code source : le volet DevSecOps, nous nous intéresserons aux analyses de sécurité et aux tests automatisés, selon une approche DevSecOps. Nous verrons comment GitLab permet d’intégrer des outils d’analyse statique (SAST) et dynamique (DAST) pour identifier les vulnérabilités dès les premières phases...
