Global Info Tom

Changer le thème

Tutoriel : Déploiement de Jenkins via Docker Compose avec pipeline .NET Core

Ce tutoriel présente la mise en place d'une instance Jenkins dans un conteneur Docker, construite via Docker Compose, et la configuration d'un pipeline Jenkins qui exécute des builds .NET Core dans des conteneurs Docker éphémères. La bonne pratique utilisée ici consiste à organiser les Dockerfiles dans des sous-répertoires pour une meilleure isolation des contextes de build.

1. Prérequis

2. Organisation du projet

Nous recommandons la structure suivante pour gérer plusieurs Dockerfiles et outils :

project-root/
├── jenkins/
│   └── Dockerfile         # Dockerfile pour l'image Jenkins personnalisée
├── Jenkinsfile            # Pipeline Jenkins pour l'application .NET Core
└── docker-compose.yml     # Fichier Docker Compose pour builder et déployer Jenkins

3. Création de l'image Jenkins personnalisée

Dans le répertoire jenkins/, créez le fichier Dockerfile suivant :

# jenkins/Dockerfile

# Utilisation de l'image officielle Jenkins LTS
FROM jenkins/jenkins:lts

# Passage en mode root pour installer des packages
USER root

# Installation des paquets nécessaires et configuration du dépôt Docker
RUN apt-get update && \
    apt-get install -y ca-certificates curl gnupg2 lsb-release apt-transport-https software-properties-common && \
    install -m 0755 -d /etc/apt/keyrings && \
    curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc && \
    chmod a+r /etc/apt/keyrings/docker.asc && \
    . /etc/os-release && \
    echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/debian $VERSION_CODENAME stable" \
      | tee /etc/apt/sources.list.d/docker.list > /dev/null && \
    apt-get update && \
    apt-get install -y docker-ce-cli && \
    rm -rf /var/lib/apt/lists/*

# Ajout du groupe Docker et ajout de l'utilisateur Jenkins à ce groupe.
# Remplacez 999 par le GID obtenu via : stat -c '%g' /var/run/docker.sock sur votre hôte.
ARG DOCKER_GID=999
RUN groupadd -for -g ${DOCKER_GID} docker && usermod -aG docker jenkins

# Retour à l'utilisateur Jenkins
USER jenkins

Explications techniques :

4. Déploiement via Docker Compose

Créez à la racine du projet un fichier docker-compose.yml avec la configuration suivante :

version: '3.8'

services:
  jenkins:
    build:
      context: ./jenkins
      dockerfile: Dockerfile
      args:
        DOCKER_GID: 999  # Remplacez 999 par le GID obtenu sur votre système
    container_name: jenkins-master
    ports:
      - "8080:8080"
      - "50000:50000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - jenkins_home:/var/jenkins_home

volumes:
  jenkins_home:

Note :
Aucune directive group_add n'est nécessaire dans le fichier Compose, puisque la configuration se fait dans l'image via le Dockerfile.

Lancez Jenkins avec la commande suivante :

docker-compose up -d

Explications techniques :

5. Configuration du plugin Docker Pipeline dans Jenkins

  1. Accédez à l'interface Jenkins via http://localhost:8080.
  2. Récupérez le mot de passe initial dans le conteneur (dans le fichier /var/jenkins_home/secrets/initialAdminPassword ou via les logs).
  3. Installez le plugin Docker Pipeline via Manage Jenkins → Manage Plugins.

6. Création d’un pipeline Jenkins pour une application .NET Core

Créez à la racine du projet un fichier Jenkinsfile avec le contenu suivant :

pipeline {
    agent none
    stages {
        stage('Restore') {
            agent {
                docker {
                    image 'mcr.microsoft.com/dotnet/sdk:6.0'
                    // Chaque étape démarre dans un conteneur neuf pour garantir un environnement propre
                    reuseNode false
                }
            }
            steps {
                // Restauration des packages NuGet
                sh 'dotnet restore'
            }
        }
        stage('Build') {
            agent {
                docker {
                    image 'mcr.microsoft.com/dotnet/sdk:6.0'
                    reuseNode false
                }
            }
            steps {
                // Compilation en configuration Release
                sh 'dotnet build --configuration Release'
            }
        }
        stage('Test') {
            agent {
                docker {
                    image 'mcr.microsoft.com/dotnet/sdk:6.0'
                    reuseNode false
                }
            }
            steps {
                // Exécution des tests unitaires sans recompilation
                sh 'dotnet test --no-build --verbosity normal'
            }
        }
    }
}

Détails techniques :

7. Déploiement et validation du pipeline

  1. Création du job Pipeline :

    • Dans Jenkins, créez un nouveau job de type Pipeline.
    • Configurez-le pour pointer vers votre dépôt Git contenant le Jenkinsfile ou copiez directement le script dans l'éditeur du pipeline.

  2. Exécution et vérification :

    • Lancez le pipeline.
    • Vérifiez dans la console du job que chaque étape (restore, build, test) s'exécute dans un conteneur Docker distinct et que les commandes .NET s'exécutent correctement.

8. Références techniques