Répartition de Charge avec NGINX

Le but de l'exercice est de mettre en place un load balancer. Un load balancer est, comme un reverse proxy, le point d'entrée des connexions au service web. C'est lui qui va décider quel serveur (backend) utiliser réellement. Si l'un des serveurs tombe, il sera capable d'utiliser les autres de manière transparente.

A l'aide de Docker et de docker-compose , créer une redondance avec 2 serveurs NGINX grâce à un 3ème serveur NGINX (cf répartition de charge avec NGINX)

1. Créer un fichier Dockerfile pour le serveur NGINX (modifiez le fichier index.html de chaque serveur afin de pouvoir les identifier)

2. Créer un fichier Dockerfile pour le loadbalancer NGINX

3. Créer un fichier docker-compose.yml qui lie le tout

Rappel : Configuration de Nginx comme load balancer

Copy

nano /etc/nginx/conf.d/load-balancer.conf

Dans ce fichier de configuration, il va falloir configurer deux parties, « upstream » et « server », voici un fichier comme exemple :

A réaliser :

Mettre en place un load balancing basique en HTTP (pas de HTTPS). Quand on demande le site, une fois sur trois on obtient Site 1, deux fois sur trois on obtient Site 2. Pour tester le load balancing, on identifie nos serveurs web avec avec un fichier index.html différent

Livrable attendu : les dockefiles (serveur front, serveur 1 et server 2) et le fichier docker-compose.yml qui lie le tout décrivant votre configuration de Docker Compose pour faire fonctionner votre infrastructure.

---

Structure des fichiers

Exercice3/
├── backend1/
│   └── index.html
├── backend2/
│   └── index.html
├── docker-compose.yml
├── Dockerfile-backend1
├── Dockerfile-backend2
├── Dockerfile-loadbalancer
└── load-balancer.conf

---

index.html (Backend 1) :

<h1>Serveur 1</h1>

index.html (Backend 2) :

<h1>Serveur 2</h1>

Dockerfile-backend1 :

FROM nginx:alpine
COPY backend1/index.html /usr/share/nginx/html/index.html

Dockerfile-backend2 :

FROM nginx:alpine
COPY backend2/index.html /usr/share/nginx/html/index.html

Dockerfile-loadbalancer :

FROM nginx:alpine
COPY load-balancer.conf /etc/nginx/conf.d/default.conf

load-balancer.conf :

upstream backend {
    server backend1:80 weight=1; # Serveur 1
    server backend2:80 weight=2; # Serveur 2
}

server {
    listen 80;

    location / {
        proxy_pass http://backend;
    }
}

docker-compose.yml :

services:
  backend1:
    build:
      context: .
      dockerfile: Dockerfile-backend1
    container_name: backend1
    volumes:
      - ./backend1:/usr/share/nginx/html
    networks:
      - webnet

  backend2:
    build:
      context: .
      dockerfile: Dockerfile-backend2
    container_name: backend2
    volumes:
      - ./backend2:/usr/share/nginx/html
    networks:
      - webnet

  loadbalancer:
    build:
      context: .
      dockerfile: Dockerfile-loadbalancer
    container_name: loadbalancer
    ports:
      - "80:80"
    networks:
      - webnet

networks:
  webnet:

---

1. Construisez et démarrez les conteneurs :

   docker-compose up --build -d

2. Accédez au site via le load balancer :

   • Utilisez un navigateur ou curl pour vérifier que la charge est bien répartie entre backend1 et backend2 :

     curl http://localhost

   • Vous devriez voir alterner les réponses :

     <h1>Serveur 1</h1>

     <h1>Serveur 2</h1>

3. Vérifiez les logs du load balancer pour confirmer la répartition :

   docker-compose logs loadbalancer

---

1. Arrêtez le conteneur backend2 :

   docker stop backend2

2. Accédez à nouveau au site via le load balancer :

   • Utilisez curl ou un navigateur :

     curl http://localhost

   • Vous ne devriez plus voir que le contenu de backend1 :

     <h1>Serveur 1</h1>

3. Redémarrez backend2 pour rétablir la redondance :

   docker start backend2

4. Vérifiez que la répartition est de nouveau active :

   curl http://localhost