Ce projet a été réalisé dans le cadre du cours d'Administration Réseaux Unix (ARU). Il consiste à mettre en place une architecture de haute disponibilité combinant Load Balancing et Failover à l'aide de Docker Compose et Nginx.
Initialement, le projet devait être déployé sur plusieurs machines virtuelles. Afin de simplifier le déploiement et la gestion de l'environnement, l'architecture a finalement été virtualisée dans une seule machine virtuelle Ubuntu exécutant Docker. Cette approche permet de simuler plusieurs serveurs tout en conservant un fonctionnement proche d'une infrastructure réelle.
L'architecture est composée de trois conteneurs Docker : un conteneur Nginx jouant le rôle de Load Balancer et deux conteneurs hébergeant des serveurs web. Lorsque les deux serveurs sont disponibles, les requêtes sont réparties entre eux. En cas de panne d'un serveur, tout le trafic est automatiquement redirigé vers le serveur restant afin d'assurer la continuité du service.
En complément, le projet met en œuvre un mécanisme de synchronisation automatique des fichiers entre les deux serveurs web afin de garantir que leur contenu reste identique.
Les principaux objectifs de ce projet sont :
- Mettre en œuvre une architecture de haute disponibilité.
- Répartir les requêtes entre plusieurs serveurs web.
- Garantir la continuité du service grâce au mécanisme de Failover.
- Simuler une architecture multi-serveurs avec Docker Compose.
- Comprendre le fonctionnement d'un Load Balancer basé sur Nginx.
- Synchroniser automatiquement les fichiers des serveurs web.
- Mettre en pratique les concepts étudiés en Administration Réseaux Unix.
Le projet permet de :
- Déployer automatiquement les conteneurs avec Docker Compose.
- Utiliser Nginx comme Load Balancer.
- Répartir les requêtes entre deux serveurs web.
- Assurer un mécanisme de Failover en cas de panne d'un serveur.
- Héberger une application web de démonstration (Fashion Store).
- Afficher dynamiquement le serveur actuellement utilisé.
- Alterner l'affichage des deux serveurs lorsque ceux-ci sont disponibles.
- Afficher uniquement le serveur restant lorsqu'un serveur devient indisponible.
- Synchroniser automatiquement les fichiers entre les deux serveurs grâce au script
syncweb.sh. - Détecter les modifications des fichiers.
- Empêcher les boucles infinies lors de la synchronisation.
- Ubuntu Server
- Docker
- Docker Compose
- Nginx
- HTML5
- JavaScript
- Bash
Utilisateur
│
▼
Navigateur
│
▼
┌─────────────────────────────────┐
│ Machine Virtuelle Ubuntu │
│ │
│ Docker │
│ │
│ ┌──────────────────────────┐ │
│ │ Conteneur │ │
│ │ Load Balancer │ │
│ └───────────┬──────────────┘ │
│ │ │
│ ┌───────┴────────┐ │
│ ▼ ▼ │
│ ┌──────────┐ ┌──────────┐ │
│ │ Web 1 │ │ Web 2 │ │
│ │ Docker │ │ Docker │ │
│ └──────────┘ └──────────┘ │
└─────────────────────────────────┘
Les deux serveurs web fonctionnent simultanément. Les requêtes sont réparties par le Load Balancer. Lorsqu'un serveur devient indisponible, toutes les requêtes sont automatiquement redirigées vers le serveur restant.
LoadBalancer-Projet/
│
├── docker-compose.yml
├── nginx/
│ └── nginx.conf
│
├── web1/
│ └── index.html
│
├── web2/
│ └── index.html
│
├── syncweb.sh
---
## Installation et exécution
1. Cloner le dépôt GitHub.
2. Se placer dans le dossier du projet.
3. Lancer Docker Compose.
```bash
docker compose up -d
- Vérifier que les trois conteneurs sont démarrés.
docker ps- Ouvrir le navigateur.
http://localhost:8080
- Observer la répartition des requêtes entre les deux serveurs.
Lorsque les deux serveurs sont disponibles :
- les requêtes sont réparties entre Web1 et Web2 ;
- l'interface affiche alternativement les deux serveurs.
Si Web1 est arrêté :
- le Load Balancer détecte son indisponibilité ;
- toutes les requêtes sont redirigées vers Web2 ;
- l'interface n'affiche plus que Web2.
Lorsque Web1 redémarre :
- il rejoint automatiquement le Load Balancer ;
- les requêtes sont de nouveau réparties entre les deux serveurs.
Le projet intègre un script Bash (syncweb.sh) chargé de maintenir les deux serveurs synchronisés.
Son fonctionnement est le suivant :
- il surveille les modifications effectuées dans Web1 et Web2 ;
- lorsqu'un fichier est modifié sur un serveur, il est automatiquement copié vers l'autre serveur ;
- un mécanisme de contrôle empêche les copies répétitives afin d'éviter une boucle infinie de synchronisation.
Ainsi, les deux serveurs possèdent toujours le même contenu.
- Docker Compose
- Conteneurisation
- Nginx
- Load Balancing
- Failover
- Haute disponibilité (High Availability)
- Répartition de charge
- Synchronisation automatique
- Administration Linux
- Réseau Docker
Les tests effectués comprennent :
- démarrage des trois conteneurs Docker ;
- vérification de la communication entre Nginx et les serveurs web ;
- validation de la répartition des requêtes ;
- simulation de la panne d'un serveur ;
- vérification du basculement automatique (Failover) ;
- redémarrage du serveur et retour dans la répartition des requêtes ;
- test de la synchronisation automatique des fichiers ;
- vérification de la prévention des boucles infinies.
Au cours de ce projet, j'ai développé les compétences suivantes :
- Déploiement d'une architecture multi-conteneurs.
- Configuration de Nginx comme Load Balancer.
- Mise en œuvre d'un mécanisme de Failover.
- Administration d'un environnement Linux.
- Utilisation de Docker Compose.
- Création de scripts Bash.
- Synchronisation automatique des fichiers.
- Gestion des réseaux Docker.
** RAHARINDRIAKA Harilanto Angella **
Étudiante en Licence 3 – École Nationale d'Informatique (ENI), Madagascar.
GitHub : https://github.com/Angellatoky