SmartTask est une application web de gestion de tâches développée selon une architecture microservices et entièrement conteneurisée avec Docker.
Le projet met en œuvre une chaîne DevOps complète intégrant la conteneurisation, l'orchestration, le versionnement Git/GitHub et l'automatisation CI/CD avec Jenkins.
SmartTask repose sur une architecture microservices composée de trois services principaux :
- Frontend : application React/Vite servie par Nginx
- Backend : API REST développée avec Node.js et Express
- Database : base de données MySQL 8.0
flowchart TB
Client["Poste client<br/>Navigateur Web"]
Frontend["Frontend<br/>React + Nginx<br/>Port 8081"]
Backend["Backend API<br/>Node.js + Express<br/>Port 5000"]
Database["Database<br/>MySQL 8.0<br/>Port 3306"]
Network["smarttask_network<br/>Réseau Docker privé"]
Client -->|HTTP : 8081| Frontend
Frontend -->|HTTP : 5000| Backend
Backend -->|MySQL : 3306| Database
Frontend -.-> Network
Backend -.-> Network
Database -.-> Network
Poste client
|
| HTTP : 8081
v
Frontend React / Nginx
|
| HTTP : 5000
v
Backend Node.js / Express
|
| MySQL : 3306
v
Base de données MySQL
La communication entre les composants repose sur un réseau Docker privé nommé :
smarttask_network
Les trois conteneurs sont connectés à ce réseau.
Le Backend communique avec MySQL à travers le réseau Docker interne.
Le serveur MySQL est accessible par son nom de service Docker :
db
La variable d'environnement utilisée par le Backend est :
DB_HOST=dbLa communication Backend → MySQL utilise le port interne :
3306
Aucune adresse IP statique de conteneur n'est nécessaire grâce à la résolution DNS intégrée à Docker Compose.
Le navigateur du poste client accède au Frontend via le port 8081 de la machine hôte :
http://<IP_SERVEUR>:8081
Le port 8081 de l'hôte est redirigé vers le port 80 du conteneur Nginx.
Le code JavaScript exécuté dans le navigateur consomme l'API Backend via le port 5000 exposé par le serveur :
http://<IP_SERVEUR>:5000/api/tasks
Le Backend communique ensuite avec MySQL via le réseau Docker interne.
| Composant | Technologie |
|---|---|
| Frontend | React / Vite |
| Serveur Web | Nginx |
| Backend | Node.js / Express |
| Base de données | MySQL 8.0 |
| Conteneurisation | Docker |
| Orchestration | Docker Compose |
| Versionnement | Git |
| Hébergement du dépôt | GitHub |
| CI/CD | Jenkins |
| Runtime JavaScript | Node.js 20 LTS |
| Java | OpenJDK 21 |
L'objectif global de SmartTask DevOps est de concevoir, conteneuriser, automatiser et déployer une application web microservices complète en appliquant les principes et bonnes pratiques DevOps.
| Objectif | Description |
|---|---|
| Isolation | Isoler le Frontend, le Backend et la base de données dans des conteneurs indépendants |
| Standardisation | Garantir un environnement reproductible entre les différentes machines |
| Orchestration | Permettre le démarrage de toute la stack avec Docker Compose |
| Persistance | Conserver les données MySQL grâce à un volume Docker |
Le projet utilise Git et GitHub pour :
- centraliser le code source ;
- suivre les modifications ;
- gérer les différentes versions ;
- séparer les environnements de développement et de production.
Jenkins est utilisé pour automatiser la chaîne d'intégration et de déploiement continu.
Le pipeline est organisé autour des étapes suivantes :
Checkout
↓
Build
↓
Tests
↓
Construction des images
↓
Déploiement
.
├── backend/ # Service API Node.js / Express
│ ├── Dockerfile # Image Docker du Backend
│ ├── package.json # Dépendances Node.js
│ └── server.js # Code source et endpoints REST
│
├── database/ # Service MySQL
│ └── Dockerfile # Image MySQL
│
├── frontend/ # Interface React / Vite
│ ├── Dockerfile # Image Docker Frontend
│ ├── index.html # Point d'entrée HTML
│ ├── nginx.conf # Configuration Nginx
│ ├── package.json # Dépendances Node.js
│ ├── src/
│ │ ├── api/ # Communication avec l'API Backend
│ │ ├── components/ # Composants React
│ │ ├── App.jsx # Composant principal
│ │ ├── main.jsx # Point d'entrée React
│ │ └── index.css # Styles globaux
│ └── vite.config.js # Configuration Vite
│
├── .env.example # Modèle des variables d'environnement
├── .gitignore # Fichiers exclus de Git
├── docker-compose.yml # Orchestration des services
├── build-images.sh # Script de construction des images
├── Jenkinsfile # Pipeline CI/CD Jenkins
├── setup.sh # Script d'installation de l'environnement
└── README.md # Documentation du projet
L'environnement recommandé est un serveur Linux Ubuntu disposant d'un accès Internet et d'un compte utilisateur avec des privilèges sudo.
- Linux / Ubuntu recommandé
- Architecture x86_64 / amd64
- Accès Internet
- Compte utilisateur avec privilèges
sudo - Git 2.x ou supérieur
Le script setup.sh automatise l'installation et la configuration de :
- Docker Engine
- Docker Compose
- Git
- Node.js 20 LTS
- npm
- OpenJDK 21
- Jenkins
Le script configure également :
- l'utilisateur courant dans le groupe
docker; - l'utilisateur
jenkinsdans le groupedocker; - le démarrage automatique de Jenkins.
Jenkins est nécessaire pour la partie CI/CD. Il n'est pas indispensable pour effectuer un déploiement manuel avec Docker Compose.
Le script setup.sh, présent à la racine du dépôt, permet de préparer automatiquement l'environnement nécessaire au projet.
Depuis le serveur de déploiement :
git clone https://github.com/kaman2803/smarttask-devops.git
cd smarttask-devopsLa branche Dev étant la branche par défaut du dépôt, Git la sélectionne automatiquement lors du clonage.
Le script est versionné avec ses permissions d'exécution :
ls -l setup.shIl doit notamment apparaître avec le droit x :
-rwxrwxr-x
Il n'est donc pas nécessaire d'exécuter chmod +x setup.sh après le clonage.
./setup.shLe script installe et configure automatiquement :
Git
Docker Engine
Docker Compose
Node.js 20 LTS
npm
OpenJDK 21
Jenkins
Il configure également :
Utilisateur courant → groupe docker
Jenkins → groupe docker
Jenkins → démarrage automatique
Lorsque l'installation est réalisée depuis une session SSH déjà ouverte, l'ajout au groupe docker n'est pas immédiatement disponible dans la session courante.
Exécuter :
newgrp dockerOu fermer la session SSH puis se reconnecter.
Vérifier ensuite :
groupsPuis tester Docker sans sudo :
docker ps
newgrp dockerest uniquement nécessaire lorsque la session courante n'a pas encore pris en compte l'ajout de l'utilisateur au groupedocker.
Vérifier les versions installées :
docker --version
docker compose version
git --version
node -v
npm -v
java -versionVérifier Jenkins :
sudo systemctl status jenkins --no-pagerVérifier l'appartenance de Jenkins au groupe Docker :
groups jenkinsLe résultat doit notamment contenir :
jenkins docker
La branche Dev est la branche par défaut du dépôt et est utilisée pour le développement et les tests.
La branche Prod contient la version stable destinée à la production.
Le fichier .env n'est pas versionné dans Git afin d'éviter de publier les informations sensibles.
Créer le fichier à partir du modèle :
cp .env.example .envModifier ensuite les valeurs :
nano .envExemple :
MYSQL_ROOT_PASSWORD=<mot_de_passe_root>
MYSQL_DATABASE=smarttask_db
MYSQL_USER=smarttask_user
MYSQL_PASSWORD=<mot_de_passe_user>
DB_HOST=db
PORT=5000
PORT_FRONTEND=8081
PORT_BACKEND=5000
PORT_DB=3306Le fichier
.envest exclu du dépôt grâce au fichier.gitignore. Il ne doit jamais être versionné.
Avant de démarrer les services :
docker compose configCette commande permet de vérifier notamment :
- les variables d'environnement ;
- les services ;
- les ports ;
- le réseau Docker ;
- le volume MySQL ;
- les dépendances entre les services.
docker compose up -d --buildCette commande :
- construit les trois images Docker ;
- crée le réseau
smarttask_network; - crée le volume
smarttask_db_data; - démarre MySQL ;
- attend que MySQL soit disponible ;
- démarre le Backend ;
- démarre le Frontend.
docker compose psRésultat attendu :
| Conteneur | Service | État attendu | Port |
|---|---|---|---|
smarttask_frontend |
Frontend | Up / Healthy | 8081 → 80 |
smarttask_backend |
Backend | Up | 5000 → 5000 |
smarttask_db |
MySQL | Up / Healthy | 3306 → 3306 |
Vérifier également les conteneurs actifs :
docker psAfficher les logs de l'ensemble de la stack :
docker compose logsSuivre les logs en temps réel :
docker compose logs -fConsulter les logs d'un service particulier :
docker compose logs backend
docker compose logs db
docker compose logs frontendTester la route principale :
curl http://localhost:5000/Réponse attendue :
{
"message": "API SmartTask opérationnelle et connectée à la base de données !"
}Les logs Backend doivent également indiquer :
Backend SmartTask démarré sur le port 5000
Table "tasks" vérifiée / créée avec succès dans MySQL.
curl http://localhost:5000/api/healthRéponse attendue :
{
"status": "OK",
"timestamp": "..."
}Tester la récupération des tâches :
curl http://localhost:5000/api/tasksLorsque la base est vide :
[]Vérifier que Nginx sert correctement l'application React :
curl -I http://localhost:8081Une réponse HTTP 200 OK confirme que le Frontend est accessible.
Exemple :
HTTP/1.1 200 OK
Server: nginx/1.31.3
Content-Type: text/html
Depuis un poste client du réseau :
http://<IP_SERVEUR>:8081
Exemple :
http://192.168.120.3:8081
Le fonctionnement de l'API est vérifié à travers les quatre opérations CRUD :
Create
Read
Update
Delete
curl -X POST http://localhost:5000/api/tasks \
-H "Content-Type: application/json" \
-d '{
"title": "Test Docker",
"description": "Test de déploiement SmartTask",
"status": "À faire",
"priority": "high"
}'Réponse attendue :
{
"id": 1,
"title": "Test Docker",
"description": "Test de déploiement SmartTask",
"status": "À faire",
"priority": "high"
}curl http://localhost:5000/api/tasksLa tâche créée doit apparaître dans la réponse.
curl -X PUT http://localhost:5000/api/tasks/1 \
-H "Content-Type: application/json" \
-d '{
"title": "Test Docker modifié",
"description": "Test CRUD SmartTask",
"status": "En cours",
"priority": "medium"
}'Vérifier la modification :
curl http://localhost:5000/api/taskscurl -X DELETE http://localhost:5000/api/tasks/1Réponse attendue :
{
"message": "Tâche supprimée avec succès"
}Vérification finale :
curl http://localhost:5000/api/tasksRésultat attendu :
[]Les tests réalisés sur l'environnement de déploiement ont confirmé le bon fonctionnement de la stack.
| Élément vérifié | Résultat |
|---|---|
| Image MySQL | ✅ Construite |
| Conteneur MySQL | ✅ Healthy |
| Image Backend | ✅ Construite |
| Conteneur Backend | ✅ Opérationnel |
| Image Frontend | ✅ Construite |
| Conteneur Frontend | ✅ Healthy |
| Réseau Docker | ✅ Créé |
| Volume MySQL | ✅ Créé |
| Backend → MySQL | ✅ Validé |
| API principale | ✅ Validée |
| API Healthcheck | ✅ Validée |
| API GET | ✅ Validée |
| API POST | ✅ Validée |
| API PUT | ✅ Validée |
| API DELETE | ✅ Validée |
| Frontend / Nginx | ✅ HTTP 200 |
| CRUD complet | ✅ Validé |
| Composant | Service Docker | Port hôte | Port conteneur | Accès |
|---|---|---|---|---|
| Frontend | smarttask_frontend |
8081 |
80 |
http://<IP_SERVEUR>:8081 |
| Backend API | smarttask_backend |
5000 |
5000 |
http://<IP_SERVEUR>:5000 |
| MySQL | smarttask_db |
3306 |
3306 |
<IP_SERVEUR>:3306 |
| Méthode | Endpoint | Description |
|---|---|---|
GET |
/ |
Vérification de l'API |
GET |
/api/health |
Healthcheck de l'API |
GET |
/api/tasks |
Récupération des tâches |
POST |
/api/tasks |
Création d'une tâche |
PUT |
/api/tasks/:id |
Modification d'une tâche |
DELETE |
/api/tasks/:id |
Suppression d'une tâche |
Pour arrêter la stack sans supprimer les données :
docker compose downLe volume MySQL est conservé.
docker compose up -ddocker compose down -v
⚠️ L'option-vsupprime le volume MySQL et entraîne donc la suppression des données persistantes de la base de données.
Le projet utilise deux branches principales.
La branche Dev est la branche par défaut du dépôt.
Elle est utilisée pour :
- le développement ;
- l'intégration des nouvelles fonctionnalités ;
- les corrections ;
- les tests ;
- l'intégration continue.
La branche Prod contient la version stable destinée à la production.
Pour travailler explicitement sur la branche Prod :
git switch ProdPour vérifier la branche courante :
git branch --show-currentPour consulter l'état du dépôt :
git statusLe projet met en œuvre une chaîne CI/CD automatisée avec Jenkins afin de construire, versionner et publier les images Docker de l'application SmartTask.
L'architecture CI/CD repose sur :
- Jenkins
- Jenkins Multibranch Pipeline
- GitHub comme gestionnaire du code source
- Un agent Docker personnalisé
- Docker Engine
- Docker Hub comme registre d'images
- Deux branches principales :
DevetProd
GitHub
│
│ Push / Commit
▼
Jenkins Multibranch
│
Détection des branches
│
┌────────┴────────┐
│ │
Dev Prod
│ │
└────────┬────────┘
▼
Agent Docker Jenkins
│
▼
Checkout du code
│
▼
Build des images Docker
│
▼
Tag des images
│
▼
Docker Hub Login
│
▼
Push vers Docker Hub
│
┌───────┼───────┐
▼ ▼ ▼
Frontend Backend Database
Le projet utilise un Jenkins Multibranch Pipeline connecté au dépôt GitHub :
https://github.com/kaman2803/smarttask-devops
Le pipeline détecte automatiquement les branches du dépôt.
Les branches utilisées sont :
Dev
Prod
Chaque branche possède son propre contexte d'exécution Jenkins.
Le fichier :
Jenkinsfile
est récupéré directement depuis la branche concernée.
Pour permettre à Jenkins d'exécuter les commandes Docker, un agent Docker personnalisé a été créé.
Le fichier utilisé est :
jenkins-agent/Dockerfile
Contenu :
FROM jenkins/inbound-agent:latest
USER root
RUN apt-get update \
&& apt-get install -y docker.io \
&& apt-get clean \
&& rm -rf /var/lib/apt/lists/*
USER jenkinsCet agent ajoute la CLI Docker à l'image officielle Jenkins.
L'image a été construite localement avec :
docker build -t smarttask-jenkins-agent:latest ./jenkins-agentVérification :
docker images | grep smarttask-jenkins-agentRésultat obtenu :
smarttask-jenkins-agent:latest
La présence de la CLI Docker dans l'agent a été validée avec :
docker run --rm \
--entrypoint docker \
smarttask-jenkins-agent:latest \
--versionRésultat :
Docker version 26.1.5+dfsg1, build a72d7cd
L'agent Jenkins utilise également le socket Docker de l'hôte :
/var/run/docker.sock
Ce montage permet aux commandes Docker exécutées depuis le conteneur Jenkins de communiquer avec le démon Docker de la machine hôte.
Jenkins est connecté à GitHub avec des informations d'authentification permettant d'accéder au dépôt du projet.
Lors de l'exécution du pipeline, Jenkins récupère automatiquement le fichier :
Jenkinsfile
depuis le commit correspondant.
Exemple observé dans les journaux Jenkins :
Connecting to https://api.github.com
Obtained Jenkinsfile from ...
Les identifiants Docker Hub sont enregistrés dans les Jenkins Credentials.
Le pipeline utilise ces credentials pour se connecter au registre Docker Hub sans exposer le mot de passe dans les journaux.
La connexion est réalisée avec :
docker login --username kaman2803 --password-stdinLe pipeline utilise withCredentials afin de masquer le mot de passe.
Le résultat attendu est :
Login Succeeded
À la fin du pipeline, Jenkins ferme également la session Docker Hub :
docker logoutLe pipeline construit les trois images principales :
smarttask-frontend
smarttask-backend
smarttask-database
Les images sont ensuite associées à des tags correspondant à la branche et au numéro de build Jenkins.
Pour la branche Dev, un exemple de tag généré est :
Dev-2
Les images sont ensuite publiées sur Docker Hub :
kaman2803/smarttask-frontend
kaman2803/smarttask-backend
kaman2803/smarttask-database
Pour la branche Dev, le pipeline publie notamment :
Dev-2
latest
Pour la branche Prod, le numéro de build est utilisé de la même manière, par exemple :
Prod-1
latest
Le pipeline Jenkins réalise les opérations suivantes :
1. Checkout
↓
2. Construction des images Docker
↓
3. Attribution des tags
↓
4. Connexion à Docker Hub
↓
5. Publication des images
↓
6. Docker logout
Les journaux Jenkins permettent de suivre chaque étape.
Exemple :
[Pipeline] stage
[Pipeline] { (Push Docker Hub)
=== 5. Publication des images ===
Les trois images sont publiées successivement :
kaman2803/smarttask-database
kaman2803/smarttask-backend
kaman2803/smarttask-frontend
Le pipeline de la branche Dev a été exécuté avec succès.
Résultat Jenkins :
Pipeline exécuté avec succès pour la branche Dev.
Finished: SUCCESS
Les trois images ont été publiées sur Docker Hub avec succès.
La branche Prod a également été exécutée avec succès :
Pipeline exécuté avec succès pour la branche Prod.
Finished: SUCCESS
Les journaux Jenkins ont confirmé :
Login Succeeded
ainsi que la publication des images avec leurs différents tags et leurs digest SHA256.
Les dépôts Docker Hub utilisés par le projet sont :
kaman2803/smarttask-frontend
kaman2803/smarttask-backend
kaman2803/smarttask-database
La chaîne CI/CD permet donc de passer automatiquement du code source GitHub à des images Docker publiées dans Docker Hub.
Le projet utilise deux branches principales :
Dev
Prod
La branche Dev est utilisée pour :
- le développement ;
- l'intégration des nouvelles fonctionnalités ;
- les corrections ;
- les tests ;
- la validation de la chaîne CI/CD.
Exemple :
git switch DevVérification :
git statusLa branche Prod représente la version stable destinée à la production.
Exemple :
git switch ProdVérification :
git statusLe workflow prévu est :
Développement
│
▼
Dev
│
│ Validation
▼
Merge
│
▼
Prod
│
│ Jenkins Multibranch
▼
Build Docker
│
▼
Tag Prod-X
│
▼
Publication Docker Hub
La branche Prod bénéficie donc du même mécanisme automatisé de construction et de publication que Dev.
| Élément | Mise en œuvre |
|---|---|
| Gestion du code | Git |
| Hébergement | GitHub |
| Branches | Dev / Prod |
| CI/CD | Jenkins |
| Type de pipeline | Multibranch Pipeline |
| Agent | Agent Docker personnalisé |
| Docker CLI | Installée dans l'agent |
| Docker Engine | Socket /var/run/docker.sock |
| Build | Images Frontend / Backend / Database |
| Registry | Docker Hub |
| Authentification GitHub | Jenkins Credentials |
| Authentification Docker Hub | Jenkins Credentials |
| Tags | Branche + numéro de build |
| Publication | Automatique |
| Gestion des erreurs | Échec du pipeline en cas d'erreur |
| Journaux | Console Jenkins |
La structure du dépôt comprend notamment :
.
├── backend/
├── database/
├── frontend/
├── jenkins-agent/
│ └── Dockerfile
├── .env.example
├── .gitignore
├── docker-compose.yml
├── build-images.sh
├── Jenkinsfile
├── setup.sh
└── README.md
Le répertoire jenkins-agent/ contient l'image personnalisée utilisée par Jenkins pour disposer de la CLI Docker.
| Axe | Objectif | Résultat |
|---|---|---|
| Microservices | Frontend / Backend / Database | ✅ |
| Conteneurisation | Docker | ✅ |
| Orchestration | Docker Compose | ✅ |
| Réseau | smarttask_network |
✅ |
| Persistance | Volume MySQL | ✅ |
| Versionnement | Git | ✅ |
| Dépôt distant | GitHub | ✅ |
| Branches | Dev / Prod |
✅ |
| CI/CD | Jenkins | ✅ |
| Pipeline | Multibranch | ✅ |
| Agent Docker | Personnalisé | ✅ |
| Docker CLI | Installée dans l'agent | ✅ |
| Docker Hub | Authentification | ✅ |
| Build images | Automatisé | ✅ |
| Tags | Automatisés | ✅ |
| Push images | Automatisé | ✅ |
| Frontend | Publié | ✅ |
| Backend | Publié | ✅ |
| Database | Publié | ✅ |
| Branche Dev | Pipeline validé | ✅ |
| Branche Prod | Pipeline validé | ✅ |
Le projet SmartTask DevOps met en œuvre une chaîne DevOps complète allant du développement du code jusqu'à la publication automatisée des images Docker.
L'application est organisée selon une architecture microservices composée d'un Frontend React/Nginx, d'un Backend Node.js/Express et d'une base de données MySQL. L'ensemble est conteneurisé et orchestré avec Docker Compose.
La gestion du code est assurée par Git et GitHub avec une séparation entre les branches Dev et Prod.
La partie CI/CD est automatisée avec Jenkins Multibranch Pipeline. Un agent Docker personnalisé a été créé afin de fournir la CLI Docker à Jenkins et de permettre la construction et la publication des images.
Le pipeline assure automatiquement :
GitHub
↓
Jenkins Multibranch
↓
Checkout
↓
Build Docker
↓
Tag des images
↓
Docker Hub Login
↓
Push des images
↓
Docker Hub
Les pipelines des branches Dev et Prod ont été validés avec un résultat :
Finished: SUCCESS
Les trois images suivantes sont désormais publiées sur Docker Hub :
kaman2803/smarttask-frontend
kaman2803/smarttask-backend
kaman2803/smarttask-database
Le projet répond ainsi aux objectifs du Projet 4 — Mise en place de la CI/CD avec Jenkins, notamment :
- la mise en place de Jenkins ;
- la création d'un agent Docker personnalisé ;
- la configuration de l'authentification GitHub ;
- la configuration de l'authentification Docker Hub ;
- la mise en place d'un pipeline Multibranch ;
- la gestion des branches
DevetProd; - l'automatisation de la construction des images Docker ;
- l'automatisation du tagging ;
- la publication automatique des images sur Docker Hub.
La chaîne complète permet ainsi d'automatiser le cycle :
Code source
↓
GitHub
↓
Jenkins
↓
Build Docker
↓
Tag
↓
Docker Hub
↓
Images disponibles pour le déploiement