pipeline ci/cd pour microservices flask avec jenkins et docker : guide pratique

Introduction

Mettre en place une pipeline CI/CD pour microservices Flask permet d’automatiser la construction, les tests et le déploiement de votre application Python. Ce guide détaille chaque étape avec des exemples concrets sous Jenkins (LTS 2.375) et Docker v26.0, pour garantir un workflow fiable, reproductible et rapide.

Étapes pour mettre en place la pipeline ci/cd

1. Préparation de l’application Flask

   Créez un Dockerfile minimal pour containeriser votre microservice :

   FROM python:3.10-slim
   WORKDIR /app
   COPY requirements.txt .
   RUN pip install --no-cache-dir -r requirements.txt
   COPY . .
   CMD ["gunicorn", "app:app", "--bind", "0.0.0.0:5000"]
   

   Vérifiez le build local : docker build -t flask-service:latest .

2. Installation et configuration de Jenkins

   Sur votre serveur Jenkins, installez les plugins « Docker Pipeline » et « Git ». Créez un Jenkinsfile à la racine du repo :

   pipeline {
     agent any
     environment {
       IMAGE = "registry.mycompany.com/flask-service:${env.BUILD_NUMBER}"
     }
     stages {
       stage('Checkout') {
         steps { git url: 'https://gitlab.com/monprojet/flask-service.git' }
       }
       stage('Build') {
         steps { 
           script {
             docker.build(IMAGE)
           }
         }
       }
       stage('Test') {
         steps {
           sh 'pytest --maxfail=1 --disable-warnings -q'
         }
       }
       stage('Push') {
         steps {
           withCredentials([usernamePassword(credentialsId: 'docker-registry', 
             usernameVariable: 'USER', passwordVariable: 'PASS')]) {
             sh 'docker login -u $USER -p $PASS registry.mycompany.com'
             sh "docker push ${IMAGE}"
           }
         }
       }
       stage('Deploy') {
         steps {
           sh "ssh deploy@prod 'docker pull ${IMAGE} && docker-compose up -d'"
         }
       }
     }
   }

   Pour en savoir plus sur Jenkins, consultez la page Jenkins.

3. Automatisation avec Docker

   L’image Docker épurée assure un démarrage rapide et un déploiement cohérent. Utilisez ces commandes dans votre Jenkinsfile ou en local :

   • docker build -t flask-service:$(date +%Y%m%d) .
   • docker run -d -p 5000:5000 flask-service:latest

   Pour approfondir la containerisation, explorez Docker.

4. Mesurer les performances et la fiabilité

   Intégrez des tests de performance basiques et mesurez le temps de build :

   Étape	Temps moyen
   Build Docker	45 s
   Tests unitaires (pytest)	30 s
   Push image	20 s

   Objectif : réduire le Time to Deploy sous 2 minutes.

Bonnes pratiques

• Versionnez votre Jenkinsfile dans Git pour auditabilité.
• Utilisez un registre privé et des credentials sécurisés (plugins Credentials Binding).
• Coupez les conteneurs inutiles après chaque déploiement pour libérer des ressources.
• Intégrez des tests de sécurité comme bandit pour le code Python.
• Surveillez vos builds avec des métriques Jenkins intégrées ou via un plugin Prometheus.

Conclusion

En centralisant build, tests et déploiement via Jenkins et Docker, vous gagnez en vitesse et en fiabilité. Cette pipeline CI/CD standardisée s’adapte à d’autres microservices et facilite l’échelle. Pour aller plus loin sur Python, consultez notre page Python.

Besoin d’aide pour mettre en place votre pipeline CI/CD ? Contactez-nous pour une audit et un accompagnement sur-mesure.