= Installation et Configuration Apache HTTPD =

{| style="width:100%; background:#fff6e6; border:1px solid #f1d6a8; padding:15px; border-radius:10px; overflow:hidden;"
|

Cette section décrit l’installation et la configuration complète d’un serveur web Apache (HTTPD) avec SSL. 
Elle permet de rendre votre serveur accessible sur le réseau et d’héberger des pages web. 
Elle inclut également la mise en place d’un système de load balancing avec HAProxy, d’une architecture haute disponibilité avec Keepalived, ainsi qu’un mécanisme de synchronisation entre les serveurs afin d’assurer la continuité de service, la répartition de charge et la tolérance aux pannes.
|}

__TOC__

 
= 1 — Installation et Configuration Apache =

{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
Installation et configuration du serveur web Apache HTTPD
|}

== Installation des packages ==

Installation du serveur Apache ainsi que du module SSL pour HTTPS :

<pre>
dnf install httpd mod_ssl -y
</pre>

Vérifier que l’installation s’est bien déroulée :

<pre>
rpm -qa | grep httpd
</pre>

Résultat attendu dans la console :

<pre>
httpd-2.4.57-5.el9.x86_64
httpd-tools-2.4.57-5.el9.x86_64
httpd-filesystem-2.4.57-5.el9.noarch
mod_ssl-2.4.57-5.el9.x86_64
</pre>

== Configuration du serveur ==

Tout d’abord, il faut paramétrer le nom de la machine ainsi que l’adresse d’écoute du serveur web.

Modifier le fichier :

/etc/httpd/conf/httpd.conf

Chercher les lignes suivantes :

<pre>
Listen 80
#ServerName www.example.com:80
</pre>

Instructions :

* Décommenter la ligne ServerName
* Adapter le nom en fonction de votre configuration réseau (/etc/sysconfig/network)
* Définir l'écoute sur toutes les interfaces

Configuration finale :

<pre>
Listen *:80
ServerName web:80
</pre>

== Démarrage du service HTTPD ==

Démarrage du service Apache :

<pre>
systemctl start httpd.service --now
</pre>

Activation automatique au démarrage du système (création du lien symbolique) :

<pre>
systemctl enable httpd.service --now
</pre>

== Vérification du service ==

Vérifier que le service fonctionne correctement :

<pre>
ss -atnp | grep httpd
</pre>

Résultat attendu dans la console :

<pre>
LISTEN 0 511 0.0.0.0:80 0.0.0.0:* users:(("httpd",pid=1234,fd=4))
LISTEN 0 511 0.0.0.0:443 0.0.0.0:* users:(("httpd",pid=1234,fd=6))
</pre>

Si Apache fonctionne correctement, les ports 80 (HTTP) et 443 (HTTPS) doivent apparaître en écoute.

== Ouverture des ports dans iptables ==

Pour rendre votre site accessible depuis le réseau, il est nécessaire d’ouvrir les ports 80 et 443.
Sans cette étape, votre navigateur affichera une erreur de connexion refusée.

Modifier :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter les règles suivantes :

<pre>
-I INPUT 2 -p tcp --dport 80 -j ACCEPT
-I INPUT 3 -p tcp --dport 443 -j ACCEPT
</pre>

Appliquer les changements :

<pre>
systemctl reload iptables
</pre>

Vérifier les règles :

<pre>
iptables -nvL
</pre>

== Résultat attendu ==

Après vérification, vous devez voir apparaître les règles pour les ports HTTP et HTTPS.

IMPORTANT : les 2 lignes en gras ci-dessous doivent absolument être visibles.
Ce sont elles qui autorisent l’accès au serveur web.

<div>
pkts bytes target prot opt in out source destination
81 5840 ACCEPT all -- * * 0.0.0.0/0 0.0.0.0/0 state RELATED,ESTABLISHED
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:80'''
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:443'''
0 0 ACCEPT icmp -- * * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT all -- lo * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:22
0 0 REJECT all -- * * 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
</div>

== Création de la page d’accueil ==

Créer la première page de votre site web :

<pre>
vi /var/www/html/index.html
</pre>

Exemple de contenu :

<pre>
cc
</pre>

Attribuer les droits au dossier pour qu’Apache puisse accéder aux fichiers :

<pre>
chown apache.apache -R /var/www/html
</pre>

== Vérification finale ==

Tester l’accès au serveur avec curl :

<pre>
curl 192.168.10.251
</pre>

Résultat attendu dans la console :

<pre>
cc
</pre>

Vous devez voir apparaître le contenu de votre page web.

== Important ==
{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
La procédure doit être répétée sur votre second serveur afin de compléter l’infrastructure.
|}

 

= 2 — Configuration HTTPS (SSL/TLS) =

{| style="width:100%; background:#ebf5fb; border:1px solid #aed6f1; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place du chiffrement SSL/TLS pour sécuriser les communications web.
|}

== Principe ==

HTTPS permet de chiffrer les échanges entre client et serveur, de garantir l'intégrité des données et d'authentifier le serveur.

Le protocole utilise le port '''443'''.

== Création d'un certificat auto-signé ==

Pour activer HTTPS, il est nécessaire de générer un certificat SSL/TLS.
Dans un environnement de test, un certificat auto-signé suffit.

Générer un certificat SSL valide pour 365 jours :

<pre>
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/pki/tls/private/apache.key \
-out /etc/pki/tls/certs/apache.crt
</pre>

== Configuration Apache HTTPS ==

Il faut maintenant indiquer à Apache l'emplacement du certificat et de la clé privée.

Modifier le fichier de configuration SSL :

<pre>
vi /etc/httpd/conf.d/ssl.conf
</pre>

Localiser et adapter les lignes suivantes :

<pre>
SSLCertificateFile /etc/pki/tls/certs/apache.crt
SSLCertificateKeyFile /etc/pki/tls/private/apache.key
</pre>

Redémarrer le service Apache pour appliquer les modifications :

<pre>
systemctl restart httpd
</pre>

== Vérification du fonctionnement HTTPS ==

Tester l'accès sécurisé au serveur web via HTTPS :

<pre>
curl -k https://IP_SERVEUR
</pre>

Le paramètre -k permet d'ignorer l'avertissement lié au certificat auto-signé.

Résultat attendu dans la console :

<pre>
cc
</pre>

Si la configuration est correcte, vous devez voir le contenu de votre page web.

 

= 3 — Load Balancing avec HAProxy =

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Répartition de charge entre plusieurs serveurs web afin d’améliorer les performances et la disponibilité des services.
|}

== Principe ==

Le Load Balancing permet de répartir les requêtes clients sur plusieurs serveurs web, d'améliorer les performances globales, de réduire la charge sur chaque serveur et d'augmenter la disponibilité du service.

HAProxy agit comme point d'entrée unique et distribue les requêtes vers les serveurs backend.

<pre>
┌─────────────────────────────────────────────────────────────┐
│ ARCHITECTURE HAPROXY │
└─────────────────────────────────────────────────────────────┘

┌──────────┐
│ Client │
└─────┬────┘
│
│ Requêtes HTTP/HTTPS
│
▼
┌──────────────┐
│ HAProxy │
│ Load Balancer│
│ (Port 80) │
└──────┬───────┘
│
┌──────────────┴──────────────┐
│ │
│ Round Robin │
│ │
▼ ▼
┌───────────────┐ ┌───────────────┐
│ Serveur Web 1 │ │ Serveur Web 2 │
│ Apache │ │ Apache │
│ (Port 8080) │ │ (Port 8080) │
└───────────────┘ └───────────────┘
</pre>

== Préparation des serveurs Apache (Backend) ==

Pour que HAProxy puisse prendre le contrôle du port 80, les serveurs Apache doivent être configurés pour écouter sur un autre port.
Nous allons les faire écouter sur le port 8080.

Modifier la configuration Apache sur chaque serveur web :

<pre>
vi /etc/httpd/conf/httpd.conf
</pre>

Localiser et modifier les lignes suivantes :

*Avant:
<pre>
Listen *:80
ServerName web:80
</pre>

*Après:
<pre>
Listen *:8080
ServerName web:8080
</pre>

Vérifier que la configuration ne contient pas d'erreur de syntaxe :

<pre>
httpd -S
</pre>

Résultat attendu dans la console :

<pre>
VirtualHost configuration:
*:8080 web (/etc/httpd/conf/httpd.conf:42)
ServerRoot: "/etc/httpd"
Main DocumentRoot: "/var/www/html"
Main ErrorLog: "/etc/httpd/logs/error_log"
Syntax OK
</pre>

Redémarrer Apache en mode gracieux (sans couper les connexions en cours) :

<pre>
httpd -k graceful
</pre>

== Ouverture du port 8080 sur les serveurs web ==

Pour que HAProxy puisse communiquer avec les serveurs Apache, il est nécessaire d'autoriser le trafic sur le port 8080.

Modifier le fichier de configuration iptables :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter :

<pre>
-I INPUT 1 -p tcp --dport 8080 -j ACCEPT
</pre>

Appliquer les changements au pare-feu :

<pre>
systemctl reload iptables
</pre>

Vérifier que la règle a bien été ajoutée :

<pre>
iptables -nvL | grep 8080
</pre>

Résultat attendu dans la console :

<pre>
0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:8080
</pre>

== Installation HAProxy ==

HAProxy doit être installé sur le serveur qui jouera le rôle de répartiteur de charge.

Installation du package HAProxy :

<pre>
dnf install haproxy -y
</pre>

== Configuration HAProxy ==

La configuration de HAProxy définit comment les requêtes seront distribuées entre les serveurs.

Modifier le fichier de configuration principal :

<pre>
vi /etc/haproxy/haproxy.cfg
</pre>

Exemple de configuration utilisant l'algorithme round robin pour la répartition de charge :

<pre>
global
log /dev/log local0
maxconn 2000
daemon

defaults
mode http
timeout connect 5s
timeout client 50s
timeout server 50s

frontend http_front
bind *:80
default_backend web_back

backend web_back
balance roundrobin
option httpchk
server web1 192.168.10.252:8080 check
server web2 192.168.10.251:8080 check
</pre>

Le mode roundrobin distribue les requêtes alternativement entre les serveurs, assurant une répartition équilibrée de la charge.

== Démarrage du service HAProxy ==

Activer et démarrer le service HAProxy :

<pre>
systemctl enable haproxy --now
</pre>

Vérifier que le service fonctionne correctement :

<pre>
systemctl status haproxy
</pre>

Résultat attendu dans la console :

<pre>
● haproxy.service - HAProxy Load Balancer
Loaded: loaded (/usr/lib/systemd/system/haproxy.service; enabled; vendor preset: disabled)
Active: active (running) since Sat 2026-02-21 17:00:00 CET; 5s ago
Main PID: 1234 (haproxy)
Status: "Ready."
</pre>

== Test du Load Balancing ==

Vérifier que le système de répartition de charge fonctionne correctement.

Tester l'accès via l'adresse IP du serveur HAProxy :

<pre>
curl 192.168.10.251
</pre>

Effectuer plusieurs requêtes successives pour observer le mécanisme de distribution.

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Si la configuration fonctionne correctement, les réponses doivent alterner entre les différents serveurs web selon l'algorithme round robin.
|}

 
= 4 — Haute Disponibilité avec Keepalived =

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place d’une adresse IP virtuelle (VIP) afin d’assurer la continuité de service en cas de panne d’un serveur.
|}

== Principe ==

Keepalived permet d'assurer la continuité du service (Haute Disponibilité), de basculer automatiquement vers un serveur secondaire en cas de panne, d'utiliser une adresse IP virtuelle partagée entre plusieurs serveurs (VIP) et de superviser l'état du service HAProxy.

Fonctionnement :

Un serveur est '''MASTER''' (actif), un serveur est '''BACKUP''' (passif). Si le serveur MASTER tombe, le BACKUP récupère automatiquement l'IP virtuelle

== Installation de Keepalived ==

Keepalived doit être installé sur les deux serveurs qui assureront la haute disponibilité (MASTER et BACKUP).

Installation du package Keepalived :

<pre>
dnf install keepalived -y
</pre>

== Configuration du serveur maître (MASTER) ==

Le serveur MASTER sera le serveur actif qui portera l'adresse IP virtuelle en temps normal.

Vider le fichier de configuration par défaut :

<pre>
echo > /etc/keepalived/keepalived.conf
</pre>

Éditer le fichier de configuration :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Ajouter la configuration suivante pour le serveur MASTER :

<pre>
global_defs {
router_id WEB1
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Démarrer et activer le service Keepalived :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Configuration du serveur secondaire (BACKUP) ==

Le serveur BACKUP reste en veille et ne prendra le relais qu'en cas de défaillance du serveur MASTER.

Sur la seconde machine, éditer le fichier de configuration :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Ajouter la configuration suivante pour le serveur BACKUP :

<pre>
global_defs {
router_id WEB2
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 51
priority 90
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Activer et démarrer le service :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Vérification du fonctionnement ==

Vérifier que l'adresse IP virtuelle est bien active sur le serveur MASTER.

Sur le serveur MASTER, afficher les adresses IP :

<pre>
ip a
</pre>

Résultat attendu dans la console :

<pre>
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 52:54:00:12:34:56 brd ff:ff:ff:ff:ff:ff
inet 192.168.10.252/24 brd 192.168.10.255 scope global eth0
valid_lft forever preferred_lft forever
inet 192.168.10.250/32 scope global eth0
valid_lft forever preferred_lft forever
</pre>

L'adresse IP physique du serveur et l'adresse IP virtuelle 192.168.10.250 doivent apparaître sur l'interface réseau.

Test du mécanisme de basculement :

1. Arrêter le serveur MASTER ou stopper le service Keepalived
2. Sur le serveur BACKUP, exécuter la commande suivante :

<pre>
ip a
</pre>

Résultat attendu dans la console :

<pre>
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 52:54:00:12:34:57 brd ff:ff:ff:ff:ff:ff
inet 192.168.10.251/24 brd 192.168.10.255 scope global eth0
valid_lft forever preferred_lft forever
inet 192.168.10.250/32 scope global eth0
valid_lft forever preferred_lft forever
</pre>

L'adresse IP virtuelle doit apparaître automatiquement sur le serveur secondaire.

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Cela confirme que la haute disponibilité fonctionne correctement.
|}

 
= 5 — Synchronisation des serveurs =

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Synchronisation des fichiers web entre les serveurs pour garantir la cohérence des données.
|}

== Principe ==

La synchronisation permet de maintenir les mêmes fichiers sur plusieurs serveurs, d'assurer la cohérence des données et de faciliter la haute disponibilité.

== Installation de lsyncd ==

Lsyncd est un outil de synchronisation temps réel basé sur inotify et rsync.

Installation du package lsyncd :

<pre>
dnf install lsyncd -y
</pre>

== Génération des clés SSH ==

Pour permettre la synchronisation automatique sans saisie de mot de passe, il est nécessaire de configurer l'authentification par clés SSH.

Générer les clés SSH sur chaque serveur et les échanger.

Sur le serveur 1, générer la clé et la copier vers le serveur 2 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.251
</pre>

Sur le serveur 2, générer la clé et la copier vers le serveur 1 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.252
</pre>

== Configuration de lsyncd ==

La configuration de lsyncd définit les répertoires à synchroniser et les serveurs cibles.

Créer le répertoire de configuration :

<pre>
mkdir -p /etc/lsyncd
</pre>

Créer le fichier de configuration pour synchroniser le répertoire /var/www/html/ :

*Remarque: adapter l'adresse IP cible en fonction du serveur où vous créez la configuration.

<pre>
vi /etc/lsyncd/lsyncd.conf.lua
</pre>

Ajouter la configuration suivante :

<pre>
settings {
logfile = "/var/log/lsyncd.log",
statusFile = "/var/log/lsyncd.status",
nodaemon = false,
}

sync {
default.rsync,
source = "/var/www/html/",
target = "root@192.168.10.251:/var/www/html/",

rsync = {
archive = true,
compress = true,
_extra = {"--delete"}
}
}
</pre>

Modifier le fichier de service systemd pour adapter les permissions et le chemin de configuration.

Éditer le fichier sur les deux serveurs :

<pre>
vi /usr/lib/systemd/system/lsyncd.service
</pre>

Modifier les paramètres suivants :
*User=rootpour donner les droits nécessaires
*ExecStartpour indiquer le bon chemin vers le fichier de configuration.

Configuration finale :

<pre>
[Unit]
Description=Live Syncing (Mirror) Daemon
Documentation=man:lsyncd(1) https://axkibe.github.io/lsyncd/
After=network.target

[Service]
User=root
Type=simple
EnvironmentFile=-/etc/sysconfig/lsyncd
ExecStart=/usr/bin/lsyncd -nodaemon /etc/lsyncd/lsyncd.conf.lua
Restart=on-failure

[Install]
WantedBy=multi-user.target
</pre>

Recharger la configuration systemd pour prendre en compte les modifications :

Sur les deux serveurs, exécuter :

<pre>
systemctl daemon-reload
</pre>

Activer le service au démarrage sur les deux serveurs :

<pre>
systemctl enable lsyncd
</pre>

*Important: démarrer le service uniquement sur le serveur maître (MASTER).
Le serveur de secours (BACKUP) activera automatiquement le service lors d'une bascule.

<pre>
systemctl start lsyncd
</pre>

== Reconfiguration de Keepalived ==

Pour que Keepalived gère automatiquement le démarrage et l'arrêt de lsyncd lors des basculements, il faut créer des scripts de notification.

Créer deux scripts bash dans le répertoire /etc/keepalived/ sur les deux serveurs.

*Script pour le serveur MASTER(`master.sh`) :

<pre>
#!/bin/bash
systemctl start lsyncd
</pre>

*Script pour le serveur BACKUP(`backup.sh`) :

<pre>
#!/bin/bash
systemctl stop lsyncd
</pre>

Rendre les scripts exécutables :

<pre>
chmod +x /etc/keepalived/master.sh
chmod +x /etc/keepalived/backup.sh
</pre>

Créer un script de vérification de l'état de synchronisation.

Ce script permet à Keepalived de surveiller l'état de lsyncd.

Créer le fichier /usr/local/bin/check_lsyncd_sync.sh :

<pre>
#!/bin/bash

STATUS_FILE="/var/log/lsyncd.status"

systemctl is-active --quiet lsyncd
if [ $? -ne 0 ]; then
exit 1
fi

if grep -q "Syncing" "$STATUS_FILE"; then
exit 1
fi

exit 0
</pre>

Rendre le script exécutable :

<pre>
chmod +x /usr/local/bin/check_lsyncd_sync.sh
</pre>

Modifier la configuration de Keepalived pour intégrer les scripts de notification et de vérification :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Remplacer le contenu par la configuration suivante :

<pre>
bal_defs {
router_id WEB1
}
vrrp_script check_sync {
script "/usr/local/bin/check_lsyncd_sync.sh"
interval 2
weight 2
}
vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1
nopreempt

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
check_sync
}
notify_master "/etc/keepalived/master.sh"
notify_backup "/etc/keepalived/backup.sh"
notify_fault "/etc/keepalived/backup.sh"
}
</pre>

Redémarrer le service Keepalived pour appliquer les changements :

<pre>
systemctl restart keepalived
</pre>

== Vérification de la synchronisation ==

Vérifier que le service lsyncd est actif uniquement sur le serveur maître.

Sur le serveur maître (MASTER), vérifier l'état du service :

<pre>
systemctl status lsyncd
</pre>

Résultat attendu dans la console :

<pre>
● lsyncd.service - Live Syncing (Mirror) Daemon
Loaded: loaded (/usr/lib/systemd/system/lsyncd.service; enabled; vendor preset: disabled)
Active: active (running) since Sat 2026-02-21 17:05:00 CET; 10s ago
Main PID: 5678 (lsyncd)
</pre>

Sur le serveur de secours (BACKUP), vérifier que le service est bien arrêté :

<pre>
systemctl status lsyncd
</pre>

Résultat attendu dans la console :

<pre>
● lsyncd.service - Live Syncing (Mirror) Daemon
Loaded: loaded (/usr/lib/systemd/system/lsyncd.service; enabled; vendor preset: disabled)
Active: failed (Result: exit-code) since Sat 2026-02-21 17:05:00 CET; 2min ago
</pre>

== Test de la synchronisation ==

Tester le mécanisme de synchronisation automatique en temps réel.

Modifier la page HTML sur le serveur maître :

<pre>
vi /var/www/html/index.html
</pre>

Vérifier que la modification a été automatiquement synchronisée sur le serveur esclave :

<pre>
cat /var/www/html/index.html
</pre>

Résultat attendu dans la console :

<pre>
cc
</pre>

Le contenu doit être identique sur les deux serveurs.

== Test du basculement ==

Simuler une panne en éteignant le serveur maître, puis vérifier que lsyncd démarre automatiquement sur l'esclave :

<pre>
systemctl status lsyncd
</pre>

Résultat attendu dans la console :

<pre>
● lsyncd.service - Live Syncing (Mirror) Daemon
Loaded: loaded (/usr/lib/systemd/system/lsyncd.service; enabled; vendor preset: disabled)
Active: active (running) since Sat 2026-02-21 17:10:00 CET; 5s ago
Main PID: 5890 (lsyncd)
</pre>

Modifier la page HTML sur le serveur qui est maintenant devenu maître (ancien esclave) :

<pre>
vi /var/www/html/index.html
</pre>

Redémarrer l'ancien serveur maître et vérifier que la synchronisation s'effectue dans le bon sens :

<pre>
cat /var/www/html/index.html
</pre>

Résultat attendu dans la console :

<pre>
cc
</pre>

Le contenu modifié sur l'ancien esclave doit être synchronisé vers le serveur qui redémarre.

Vérifier le statut du service lsyncd sur l'ancien serveur maître (qui redevient maître) :

<pre>
systemctl status lsyncd
</pre>

Résultat attendu dans la console :

<pre>
● lsyncd.service - Live Syncing (Mirror) Daemon
Loaded: loaded (/usr/lib/systemd/system/lsyncd.service; enabled; vendor preset: disabled)
Active: active (running) since Sat 2026-02-21 17:12:00 CET; 5s ago
Main PID: 6012 (lsyncd)
</pre>

Sur le serveur qui est redevenu esclave (BACKUP) :

<pre>
systemctl status lsyncd
</pre>

Résultat attendu dans la console :

<pre>
● lsyncd.service - Live Syncing (Mirror) Daemon
Loaded: loaded (/usr/lib/systemd/system/lsyncd.service; enabled; vendor preset: disabled)
Active: failed (Result: exit-code) since Sat 2026-02-21 17:12:00 CET; 10s ago
</pre>

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Votre infrastructure est maintenant complète : serveur Apache avec HTTPS, répartition de charge (HAProxy), haute disponibilité (Keepalived) et synchronisation automatique des fichiers (lsyncd) sont opérationnels.
|}

Iptables

2026-02-27T20:35:02Z

Jung Jean-Marie :

= Iptables =

{| style="width:100%; background:#f3f9f1; border:1px solid #cfe5c9; padding:15px; border-radius:10px; overflow:hidden;"
|

Cette section décrit la mise en place complète d'un firewall iptables. 
Elle couvre l'installation du service, ainsi que les deux méthodes de configuration des règles de filtrage réseau.
|}

__TOC__

 
= 1 — Installation d'Iptables =

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Installation et démarrage du service iptables
|}

== Installation du service ==

Installer le service iptables :

<pre>
dnf -y install iptables-services
</pre>

Activer et démarrer iptables :

<pre>
systemctl enable iptables
systemctl start iptables
</pre>

 

= 2 — Configuration d'Iptables =

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Deux méthodes pour ajouter des règles dans iptables
|}

== Méthode 1 — Édition directe du fichier de configuration ==

Ouvrir le fichier de configuration iptables :

<pre>
vi /etc/sysconfig/iptables
</pre>

Recharger iptables pour appliquer les modifications :

<pre>
systemctl reload iptables
</pre>

{| style="width:100%; background:#fef9e7; border:1px solid #f9e79f; padding:10px; border-radius:8px;"
|
⚠️ Attention : Ne jamais utiliser <code>systemctl restart iptables</code> — cela réinitialise toutes les règles en cours.
|}

== Méthode 2 — Commande en terminal ==

Saisir directement la règle dans le terminal. Exemple pour autoriser le port 80 (HTTP) :

<pre>
iptables -A INPUT -p tcp -m tcp --dport 80 -j ACCEPT
</pre>

Sauvegarder les règles pour les rendre persistantes :

<pre>
iptables-save
</pre>

 

= Remarques Finales =

{| style="width:100%; background:#f3f9f1; border:1px solid #cfe5c9; padding:12px; border-radius:10px; overflow:hidden;"
|
Votre firewall iptables est maintenant fonctionnel. 
Pensez à toujours sauvegarder vos règles avec iptables-save après chaque modification en ligne de commande. 
Privilégiez systemctl reload à systemctl restart pour éviter toute interruption du filtrage réseau.
|}

2026-02-21T15:34:07Z

Jung Jean-Marie : /* Partie 1 — Installation et Configuration Apache */

Apache

2026-02-21T15:33:47Z

Jung Jean-Marie : /* Installation et Configuration Apache HTTPD */

Apache

2026-02-21T15:33:18Z

Jung Jean-Marie : /* Installation et Configuration Apache HTTPD */

= Installation et Configuration Apache HTTPD =

{| style="width:100%; background:#fff6e6; border:1px solid #f1d6a8; padding:15px; border-radius:10px; overflow:hidden;"
|

Cette section décrit l’installation et la configuration complète d’un serveur web Apache (HTTPD) avec SSL. 
Elle permet de rendre votre serveur accessible sur le réseau et d’héberger des pages web. 
Elle inclut également la mise en place d’un système de load balancing avec HAProxy, d’une architecture haute disponibilité avec Keepalived, ainsi qu’un mécanisme de synchronisation entre les serveurs afin d’assurer la continuité de service, la répartition de charge et la tolérance aux pannes.
|}

__TOC__

= Partie 1 — Installation et Configuration Apache =

{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
Installation et configuration du serveur web Apache HTTPD
|}

== Installation des packages ==

Installation du serveur Apache ainsi que du module SSL pour HTTPS :

<pre>
dnf install httpd mod_ssl -y
</pre>

Vérifier que l’installation s’est bien déroulée :

<pre>
rpm -qa | grep httpd
</pre>

== Configuration du serveur ==

Tout d’abord, il faut paramétrer le nom de la machine ainsi que l’adresse d’écoute du serveur web.

Modifier le fichier :

/etc/httpd/conf/httpd.conf

Chercher les lignes suivantes :

<pre>
Listen 80
#ServerName www.example.com:80
</pre>

Instructions :

* Décommenter la ligne ServerName
* Adapter le nom en fonction de votre configuration réseau (/etc/sysconfig/network)
* Définir l’écoute sur toutes les interfaces

Configuration finale :

<pre>
Listen *:80
ServerName web:80
</pre>

== Démarrage du service HTTPD ==

Démarrage du service Apache :

<pre>
systemctl start httpd.service --now
</pre>

Activation automatique au démarrage du système (création du lien symbolique) :

<pre>
systemctl enable httpd.service --now
</pre>

== Vérification du service ==

Vérifier que le service fonctionne correctement :

<pre>
ss -atnp | grep httpd
</pre>

Si Apache fonctionne correctement, les ports **80 (HTTP)** et **443 (HTTPS)** doivent apparaître en écoute.

== Ouverture des ports dans iptables ==

Pour rendre votre site accessible depuis le réseau, il est nécessaire d’ouvrir les ports 80 et 443.
Sans cette étape, votre navigateur affichera une erreur de connexion refusée.

Modifier :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter les règles suivantes :

<pre>
-I INPUT 2 -p tcp --dport 80 -j ACCEPT
-I INPUT 3 -p tcp --dport 443 -j ACCEPT
</pre>

Appliquer les changements :

<pre>
systemctl reload iptables
</pre>

Vérifier les règles :

<pre>
iptables -nvL
</pre>

== Résultat attendu ==

Après vérification, vous devez voir apparaître les règles pour les ports HTTP et HTTPS.

IMPORTANT : les 2 lignes en gras ci-dessous doivent absolument être visibles.
Ce sont elles qui autorisent l’accès au serveur web.

<div>
pkts bytes target prot opt in out source destination
81 5840 ACCEPT all -- * * 0.0.0.0/0 0.0.0.0/0 state RELATED,ESTABLISHED
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:80'''
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:443'''
0 0 ACCEPT icmp -- * * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT all -- lo * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:22
0 0 REJECT all -- * * 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
</div>

== Création de la page d’accueil ==

Créer la première page de votre site web :

<pre>
vi /var/www/html/index.html
</pre>

Exemple de contenu :

<pre>
cc
</pre>

Attribuer les droits au dossier pour qu’Apache puisse accéder aux fichiers :

<pre>
chown apache.apache -R /var/www/html
</pre>

== Vérification finale ==

Tester l’accès au serveur avec curl :

<pre>
curl 192.168.10.251
</pre>

Vous devez voir apparaître le contenu de votre page web.

== Important ==
{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
La procédure doit être répétée sur votre second serveur afin de compléter l’infrastructure.
|}

 

= Partie 2 — Configuration HTTPS (SSL/TLS) =

{| style="width:100%; background:#ebf5fb; border:1px solid #aed6f1; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place du chiffrement SSL/TLS pour sécuriser les communications web.
|}

== Principe ==

HTTPS permet de :

* Chiffrer les échanges entre client et serveur
* Garantir l’intégrité des données
* Authentifier le serveur

Le protocole utilise le port '''443'''.

== Création d’un certificat auto-signé ==

Générer un certificat SSL :

<pre>
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/pki/tls/private/apache.key \
-out /etc/pki/tls/certs/apache.crt
</pre>

== Configuration Apache HTTPS ==

Modifier le fichier :

<pre>
vi /etc/httpd/conf.d/ssl.conf
</pre>

Adapter les lignes suivantes :

<pre>
SSLCertificateFile /etc/pki/tls/certs/apache.crt
SSLCertificateKeyFile /etc/pki/tls/private/apache.key
</pre>

Redémarrer Apache :

<pre>
systemctl restart httpd
</pre>

== Vérification ==

Tester l’accès sécurisé :

<pre>
curl -k https://IP_SERVEUR
</pre>

 

= Partie 3 — Load Balancing avec HAProxy =

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Répartition de charge entre plusieurs serveurs web afin d’améliorer les performances et la disponibilité des services.
|}

== Principe ==

Le Load Balancing permet :

* Répartir les requêtes clients sur plusieurs serveurs web
* Améliorer les performances globales
* Réduire la charge sur chaque serveur
* Augmenter la disponibilité du service

HAProxy agit comme point d’entrée unique et distribue les requêtes vers les serveurs backend.

Architecture :

Client → HAProxy → Serveur Web 1 / Serveur Web 2

== Préparation des serveurs Apache (Backend) ==

Les serveurs Apache doivent écouter sur le port '''8080''' afin que HAProxy utilise le port 80.

Modifier la configuration Apache :

<pre>
vi /etc/httpd/conf/httpd.conf
</pre>

Modifier :

Avant :
<pre>
Listen *:80
ServerName web:80
</pre>

Après :
<pre>
Listen *:8080
ServerName web:8080
</pre>

Vérifier la configuration :

<pre>
httpd -S
</pre>

Redémarrer Apache :

<pre>
httpd -k graceful
</pre>

== Ouverture du port 8080 sur les serveurs web ==

Autoriser le trafic vers Apache sur les serveurs backend.

Modifier iptables :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter :

<pre>
-I INPUT 1 -p tcp --dport 8080 -j ACCEPT
</pre>

Appliquer :

<pre>
systemctl reload iptables
</pre>

== Installation HAProxy ==

Sur le serveur Load Balancer :

<pre>
dnf install haproxy -y
</pre>

== Configuration HAProxy ==

Modifier le fichier :

<pre>
vi /etc/haproxy/haproxy.cfg
</pre>

Configuration exemple en mode '''round robin''' :

<pre>
global
log /dev/log local0
maxconn 2000
daemon

defaults
mode http
timeout connect 5s
timeout client 50s
timeout server 50s

frontend http_front
bind *:80
default_backend web_back

backend web_back
balance roundrobin
option httpchk
server web1 192.168.10.252:8080 check
server web2 192.168.10.251:8080 check
</pre>

Le mode '''roundrobin''' distribue les requêtes alternativement entre les serveurs.

== Démarrage du service HAProxy ==

<pre>
systemctl enable haproxy --now
</pre>

Vérifier le statut :

<pre>
systemctl status haproxy
</pre>

== Ouverture du port 80 sur le Load Balancer ==

Autoriser l’accès client au serveur HAProxy.

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter :

<pre>
-I INPUT 1 -p tcp --dport 80 -j ACCEPT
</pre>

Appliquer :

<pre>
systemctl reload iptables
</pre>

== Test du Load Balancing ==

Tester l’accès via l’adresse IP du serveur HAProxy :

<pre>
curl 192.168.10.251
</pre>

Effectuer plusieurs requêtes successives.

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Si la configuration fonctionne correctement, les réponses doivent alterner entre les différents serveurs web.
|}

 
= Partie 4 — Haute Disponibilité avec Keepalived =

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place d’une adresse IP virtuelle (VIP) afin d’assurer la continuité de service en cas de panne d’un serveur.
|}

== Principe ==

Keepalived permet :

* Assurer la continuité du service (Haute Disponibilité)
* Basculer automatiquement vers un serveur secondaire en cas de panne
* Utiliser une adresse IP virtuelle partagée entre plusieurs serveurs (VIP)
* Superviser l’état du service HAProxy

Fonctionnement :

* Un serveur est '''MASTER''' (actif)
* Un serveur est '''BACKUP''' (passif)
* Si le serveur MASTER tombe, le BACKUP récupère automatiquement l’IP virtuelle

== Installation ==

Installer Keepalived sur les deux serveurs (MASTER et BACKUP) :

<pre>
dnf install keepalived -y
</pre>

== Configuration du serveur maître (MASTER) ==

Vider le fichier de configuration par défaut :

<pre>
echo > /etc/keepalived/keepalived.conf
</pre>

Modifier la configuration :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Configuration du serveur MASTER :

<pre>
global_defs {
router_id WEB1
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Démarrer et activer Keepalived :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Configuration du serveur secondaire (BACKUP) ==

Sur la seconde machine, créer le même fichier avec quelques modifications :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Configuration du serveur BACKUP :

<pre>
global_defs {
router_id WEB2
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 51
priority 90
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Activer le service :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Vérification du fonctionnement ==

Sur le serveur MASTER :

<pre>
ip a
</pre>

Vous devez voir :

* L’adresse IP du serveur
* L’adresse IP virtuelle '''192.168.10.250'''

Test de basculement :

1. Arrêter le serveur MASTER ou le service Keepalived 
2. Sur le serveur BACKUP exécuter :

<pre>
ip a
</pre>

L’adresse IP virtuelle doit apparaître automatiquement sur le serveur secondaire.

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Cela confirme que la haute disponibilité fonctionne correctement.
|}

 
= Partie 5 — Synchronisation des serveurs =

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Synchronisation des fichiers web entre les serveurs pour garantir la cohérence des données.
|}

== Principe ==

La synchronisation permet :

* Maintenir les mêmes fichiers sur plusieurs serveurs
* Assurer la cohérence des données
* Faciliter la haute disponibilité

== Installation de lsyncd ==

<pre>
dnf install lsyncd -y
</pre>

== Génération des clés SSH ==

Depuis les 2 serveurs, générer les clés SSH pour permettre à lsyncd de faire la synchronisation :

Sur serveur 1 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.251
</pre>

Sur serveur 2 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.252
</pre>

== Configuration de lsyncd ==

Créer le dossier de configuration :

<pre>
mkdir -p /etc/lsyncd
</pre>

Créer la configuration et ajouter les éléments nécessaires pour les 2 serveurs :

<pre>
vi /etc/lsyncd/lsyncd.conf.lua
</pre>

Ajouter :

<pre>
settings {
logfile = "/var/log/lsyncd.log",
statusFile = "/var/log/lsyncd.status",
nodaemon = false,
}

sync {
default.rsync,
source = "/var/www/html/",
target = "root@192.168.10.251:/var/www/html/",

rsync = {
archive = true,
compress = true,
_extra = {"--delete"}
}
}
</pre>

Modifier également le daemon lsyncd sur les 2 serveurs :

<pre>
vi /usr/lib/systemd/system/lsyncd.service
</pre>

Ne pas oublier de mettre `User=root` et le chemin correct de la conf.lua dans `ExecStart` :

<pre>
[Unit]
Description=Live Syncing (Mirror) Daemon
Documentation=man:lsyncd(1) https://axkibe.github.io/lsyncd/
After=network.target

[Service]
User=root
Type=simple
EnvironmentFile=-/etc/sysconfig/lsyncd
ExecStart=/usr/bin/lsyncd -nodaemon /etc/lsyncd/lsyncd.conf.lua
Restart=on-failure

[Install]
WantedBy=multi-user.target
</pre>

Redémarrer le daemon sur les 2 serveurs :

<pre>
systemctl daemon-reload
</pre>

Activer le service sur les 2 serveurs :

<pre>
systemctl enable lsyncd
</pre>

Mais démarrer uniquement sur le serveur maître :

<pre>
systemctl start lsyncd
</pre>

== Reconfiguration de Keepalived ==

Créer 2 nouveaux scripts bash dans `/etc/keepalived/` sur les 2 serveurs :

Master (`master.sh`) :

<pre>
#!/bin/bash
systemctl start lsyncd
</pre>

Backup (`backup.sh`) :

<pre>
#!/bin/bash
systemctl stop lsyncd
</pre>

Donner les droits d’exécution :

<pre>
chmod +x /etc/keepalived/master.sh
chmod +x /etc/keepalived/backup.sh
</pre>

Créer un script de vérification : `/usr/local/bin/check_lsyncd_sync.sh`

<pre>
#!/bin/bash

STATUS_FILE="/var/log/lsyncd.status"

systemctl is-active --quiet lsyncd
if [ $? -ne 0 ]; then
exit 1
fi

if grep -q "Syncing" "$STATUS_FILE"; then
exit 1
fi

exit 0
</pre>

Modifier `keepalived.conf` :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Ajouter :

<pre>
bal_defs {
router_id WEB1
}
vrrp_script check_sync {
script "/usr/local/bin/check_lsyncd_sync.sh"
interval 2
weight 2
}
vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1
nopreempt

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
check_sync
}
notify_master "/etc/keepalived/master.sh"
notify_backup "/etc/keepalived/backup.sh"
notify_fault "/etc/keepalived/backup.sh"
}
</pre>

Redémarrer Keepalived :

<pre>
systemctl restart keepalived
</pre>

== Vérification ==

Sur le serveur maître :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Sur le serveur esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
failed
</pre>

== Test de la synchronisation ==

Modifier la page HTML sur le maître :

<pre>
vi /var/www/html/index.html
</pre>

Vérifier la synchro sur l’esclave :

<pre>
cat /var/www/html/index.html
</pre>

Éteindre le maître et vérifier l’état sur l’esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Modifier la page HTML sur l’esclave :

<pre>
vi /var/www/html/index.html
</pre>

Redémarrer le maître et vérifier la synchronisation :

<pre>
cat /var/www/html/index.html
</pre>

Vérifier le status du maître :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Sur l’esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
failed
</pre>

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Vous avez votre serveur Apache avec HTTPS, le loadbalancing et la synchronisation fonctionnels.
|}

Apache

2026-02-21T15:32:50Z

Jung Jean-Marie : /* Installation et Configuration Apache HTTPD */

= Installation et Configuration Apache HTTPD =

{| style="width:100%; background:#fff6e6; border:1px solid #f1d6a8; padding:15px; border-radius:10px; overflow:hidden;"
|

Cette section décrit l’installation et la configuration complète d’un serveur web Apache (HTTPD) avec SSL.
Elle permet de rendre votre serveur accessible sur le réseau et d’héberger des pages web.
Elle inclut également la mise en place d’un système de load balancing avec HAProxy, d’une architecture haute disponibilité avec Keepalived, ainsi qu’un mécanisme de synchronisation entre les serveurs afin d’assurer la continuité de service, la répartition de charge et la tolérance aux pannes.
|}

__TOC__

= Partie 1 — Installation et Configuration Apache =

{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
Installation et configuration du serveur web Apache HTTPD
|}

== Installation des packages ==

Installation du serveur Apache ainsi que du module SSL pour HTTPS :

<pre>
dnf install httpd mod_ssl -y
</pre>

Vérifier que l’installation s’est bien déroulée :

<pre>
rpm -qa | grep httpd
</pre>

== Configuration du serveur ==

Tout d’abord, il faut paramétrer le nom de la machine ainsi que l’adresse d’écoute du serveur web.

Modifier le fichier :

/etc/httpd/conf/httpd.conf

Chercher les lignes suivantes :

<pre>
Listen 80
#ServerName www.example.com:80
</pre>

Instructions :

* Décommenter la ligne ServerName
* Adapter le nom en fonction de votre configuration réseau (/etc/sysconfig/network)
* Définir l’écoute sur toutes les interfaces

Configuration finale :

<pre>
Listen *:80
ServerName web:80
</pre>

== Démarrage du service HTTPD ==

Démarrage du service Apache :

<pre>
systemctl start httpd.service --now
</pre>

Activation automatique au démarrage du système (création du lien symbolique) :

<pre>
systemctl enable httpd.service --now
</pre>

== Vérification du service ==

Vérifier que le service fonctionne correctement :

<pre>
ss -atnp | grep httpd
</pre>

Si Apache fonctionne correctement, les ports **80 (HTTP)** et **443 (HTTPS)** doivent apparaître en écoute.

== Ouverture des ports dans iptables ==

Pour rendre votre site accessible depuis le réseau, il est nécessaire d’ouvrir les ports 80 et 443.
Sans cette étape, votre navigateur affichera une erreur de connexion refusée.

Modifier :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter les règles suivantes :

<pre>
-I INPUT 2 -p tcp --dport 80 -j ACCEPT
-I INPUT 3 -p tcp --dport 443 -j ACCEPT
</pre>

Appliquer les changements :

<pre>
systemctl reload iptables
</pre>

Vérifier les règles :

<pre>
iptables -nvL
</pre>

== Résultat attendu ==

Après vérification, vous devez voir apparaître les règles pour les ports HTTP et HTTPS.

IMPORTANT : les 2 lignes en gras ci-dessous doivent absolument être visibles.
Ce sont elles qui autorisent l’accès au serveur web.

<div>
pkts bytes target prot opt in out source destination
81 5840 ACCEPT all -- * * 0.0.0.0/0 0.0.0.0/0 state RELATED,ESTABLISHED
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:80'''
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:443'''
0 0 ACCEPT icmp -- * * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT all -- lo * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:22
0 0 REJECT all -- * * 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
</div>

== Création de la page d’accueil ==

Créer la première page de votre site web :

<pre>
vi /var/www/html/index.html
</pre>

Exemple de contenu :

<pre>
cc
</pre>

Attribuer les droits au dossier pour qu’Apache puisse accéder aux fichiers :

<pre>
chown apache.apache -R /var/www/html
</pre>

== Vérification finale ==

Tester l’accès au serveur avec curl :

<pre>
curl 192.168.10.251
</pre>

Vous devez voir apparaître le contenu de votre page web.

== Important ==
{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
La procédure doit être répétée sur votre second serveur afin de compléter l’infrastructure.
|}

 

= Partie 2 — Configuration HTTPS (SSL/TLS) =

{| style="width:100%; background:#ebf5fb; border:1px solid #aed6f1; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place du chiffrement SSL/TLS pour sécuriser les communications web.
|}

== Principe ==

HTTPS permet de :

* Chiffrer les échanges entre client et serveur
* Garantir l’intégrité des données
* Authentifier le serveur

Le protocole utilise le port '''443'''.

== Création d’un certificat auto-signé ==

Générer un certificat SSL :

<pre>
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/pki/tls/private/apache.key \
-out /etc/pki/tls/certs/apache.crt
</pre>

== Configuration Apache HTTPS ==

Modifier le fichier :

<pre>
vi /etc/httpd/conf.d/ssl.conf
</pre>

Adapter les lignes suivantes :

<pre>
SSLCertificateFile /etc/pki/tls/certs/apache.crt
SSLCertificateKeyFile /etc/pki/tls/private/apache.key
</pre>

Redémarrer Apache :

<pre>
systemctl restart httpd
</pre>

== Vérification ==

Tester l’accès sécurisé :

<pre>
curl -k https://IP_SERVEUR
</pre>

 

= Partie 3 — Load Balancing avec HAProxy =

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Répartition de charge entre plusieurs serveurs web afin d’améliorer les performances et la disponibilité des services.
|}

== Principe ==

Le Load Balancing permet :

* Répartir les requêtes clients sur plusieurs serveurs web
* Améliorer les performances globales
* Réduire la charge sur chaque serveur
* Augmenter la disponibilité du service

HAProxy agit comme point d’entrée unique et distribue les requêtes vers les serveurs backend.

Architecture :

Client → HAProxy → Serveur Web 1 / Serveur Web 2

== Préparation des serveurs Apache (Backend) ==

Les serveurs Apache doivent écouter sur le port '''8080''' afin que HAProxy utilise le port 80.

Modifier la configuration Apache :

<pre>
vi /etc/httpd/conf/httpd.conf
</pre>

Modifier :

Avant :
<pre>
Listen *:80
ServerName web:80
</pre>

Après :
<pre>
Listen *:8080
ServerName web:8080
</pre>

Vérifier la configuration :

<pre>
httpd -S
</pre>

Redémarrer Apache :

<pre>
httpd -k graceful
</pre>

== Ouverture du port 8080 sur les serveurs web ==

Autoriser le trafic vers Apache sur les serveurs backend.

Modifier iptables :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter :

<pre>
-I INPUT 1 -p tcp --dport 8080 -j ACCEPT
</pre>

Appliquer :

<pre>
systemctl reload iptables
</pre>

== Installation HAProxy ==

Sur le serveur Load Balancer :

<pre>
dnf install haproxy -y
</pre>

== Configuration HAProxy ==

Modifier le fichier :

<pre>
vi /etc/haproxy/haproxy.cfg
</pre>

Configuration exemple en mode '''round robin''' :

<pre>
global
log /dev/log local0
maxconn 2000
daemon

defaults
mode http
timeout connect 5s
timeout client 50s
timeout server 50s

frontend http_front
bind *:80
default_backend web_back

backend web_back
balance roundrobin
option httpchk
server web1 192.168.10.252:8080 check
server web2 192.168.10.251:8080 check
</pre>

Le mode '''roundrobin''' distribue les requêtes alternativement entre les serveurs.

== Démarrage du service HAProxy ==

<pre>
systemctl enable haproxy --now
</pre>

Vérifier le statut :

<pre>
systemctl status haproxy
</pre>

== Ouverture du port 80 sur le Load Balancer ==

Autoriser l’accès client au serveur HAProxy.

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter :

<pre>
-I INPUT 1 -p tcp --dport 80 -j ACCEPT
</pre>

Appliquer :

<pre>
systemctl reload iptables
</pre>

== Test du Load Balancing ==

Tester l’accès via l’adresse IP du serveur HAProxy :

<pre>
curl 192.168.10.251
</pre>

Effectuer plusieurs requêtes successives.

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Si la configuration fonctionne correctement, les réponses doivent alterner entre les différents serveurs web.
|}

 
= Partie 4 — Haute Disponibilité avec Keepalived =

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place d’une adresse IP virtuelle (VIP) afin d’assurer la continuité de service en cas de panne d’un serveur.
|}

== Principe ==

Keepalived permet :

* Assurer la continuité du service (Haute Disponibilité)
* Basculer automatiquement vers un serveur secondaire en cas de panne
* Utiliser une adresse IP virtuelle partagée entre plusieurs serveurs (VIP)
* Superviser l’état du service HAProxy

Fonctionnement :

* Un serveur est '''MASTER''' (actif)
* Un serveur est '''BACKUP''' (passif)
* Si le serveur MASTER tombe, le BACKUP récupère automatiquement l’IP virtuelle

== Installation ==

Installer Keepalived sur les deux serveurs (MASTER et BACKUP) :

<pre>
dnf install keepalived -y
</pre>

== Configuration du serveur maître (MASTER) ==

Vider le fichier de configuration par défaut :

<pre>
echo > /etc/keepalived/keepalived.conf
</pre>

Modifier la configuration :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Configuration du serveur MASTER :

<pre>
global_defs {
router_id WEB1
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Démarrer et activer Keepalived :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Configuration du serveur secondaire (BACKUP) ==

Sur la seconde machine, créer le même fichier avec quelques modifications :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Configuration du serveur BACKUP :

<pre>
global_defs {
router_id WEB2
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 51
priority 90
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Activer le service :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Vérification du fonctionnement ==

Sur le serveur MASTER :

<pre>
ip a
</pre>

Vous devez voir :

* L’adresse IP du serveur
* L’adresse IP virtuelle '''192.168.10.250'''

Test de basculement :

1. Arrêter le serveur MASTER ou le service Keepalived 
2. Sur le serveur BACKUP exécuter :

<pre>
ip a
</pre>

L’adresse IP virtuelle doit apparaître automatiquement sur le serveur secondaire.

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Cela confirme que la haute disponibilité fonctionne correctement.
|}

 
= Partie 5 — Synchronisation des serveurs =

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Synchronisation des fichiers web entre les serveurs pour garantir la cohérence des données.
|}

== Principe ==

La synchronisation permet :

* Maintenir les mêmes fichiers sur plusieurs serveurs
* Assurer la cohérence des données
* Faciliter la haute disponibilité

== Installation de lsyncd ==

<pre>
dnf install lsyncd -y
</pre>

== Génération des clés SSH ==

Depuis les 2 serveurs, générer les clés SSH pour permettre à lsyncd de faire la synchronisation :

Sur serveur 1 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.251
</pre>

Sur serveur 2 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.252
</pre>

== Configuration de lsyncd ==

Créer le dossier de configuration :

<pre>
mkdir -p /etc/lsyncd
</pre>

Créer la configuration et ajouter les éléments nécessaires pour les 2 serveurs :

<pre>
vi /etc/lsyncd/lsyncd.conf.lua
</pre>

Ajouter :

<pre>
settings {
logfile = "/var/log/lsyncd.log",
statusFile = "/var/log/lsyncd.status",
nodaemon = false,
}

sync {
default.rsync,
source = "/var/www/html/",
target = "root@192.168.10.251:/var/www/html/",

rsync = {
archive = true,
compress = true,
_extra = {"--delete"}
}
}
</pre>

Modifier également le daemon lsyncd sur les 2 serveurs :

<pre>
vi /usr/lib/systemd/system/lsyncd.service
</pre>

Ne pas oublier de mettre `User=root` et le chemin correct de la conf.lua dans `ExecStart` :

<pre>
[Unit]
Description=Live Syncing (Mirror) Daemon
Documentation=man:lsyncd(1) https://axkibe.github.io/lsyncd/
After=network.target

[Service]
User=root
Type=simple
EnvironmentFile=-/etc/sysconfig/lsyncd
ExecStart=/usr/bin/lsyncd -nodaemon /etc/lsyncd/lsyncd.conf.lua
Restart=on-failure

[Install]
WantedBy=multi-user.target
</pre>

Redémarrer le daemon sur les 2 serveurs :

<pre>
systemctl daemon-reload
</pre>

Activer le service sur les 2 serveurs :

<pre>
systemctl enable lsyncd
</pre>

Mais démarrer uniquement sur le serveur maître :

<pre>
systemctl start lsyncd
</pre>

== Reconfiguration de Keepalived ==

Créer 2 nouveaux scripts bash dans `/etc/keepalived/` sur les 2 serveurs :

Master (`master.sh`) :

<pre>
#!/bin/bash
systemctl start lsyncd
</pre>

Backup (`backup.sh`) :

<pre>
#!/bin/bash
systemctl stop lsyncd
</pre>

Donner les droits d’exécution :

<pre>
chmod +x /etc/keepalived/master.sh
chmod +x /etc/keepalived/backup.sh
</pre>

Créer un script de vérification : `/usr/local/bin/check_lsyncd_sync.sh`

<pre>
#!/bin/bash

STATUS_FILE="/var/log/lsyncd.status"

systemctl is-active --quiet lsyncd
if [ $? -ne 0 ]; then
exit 1
fi

if grep -q "Syncing" "$STATUS_FILE"; then
exit 1
fi

exit 0
</pre>

Modifier `keepalived.conf` :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Ajouter :

<pre>
bal_defs {
router_id WEB1
}
vrrp_script check_sync {
script "/usr/local/bin/check_lsyncd_sync.sh"
interval 2
weight 2
}
vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1
nopreempt

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
check_sync
}
notify_master "/etc/keepalived/master.sh"
notify_backup "/etc/keepalived/backup.sh"
notify_fault "/etc/keepalived/backup.sh"
}
</pre>

Redémarrer Keepalived :

<pre>
systemctl restart keepalived
</pre>

== Vérification ==

Sur le serveur maître :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Sur le serveur esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
failed
</pre>

== Test de la synchronisation ==

Modifier la page HTML sur le maître :

<pre>
vi /var/www/html/index.html
</pre>

Vérifier la synchro sur l’esclave :

<pre>
cat /var/www/html/index.html
</pre>

Éteindre le maître et vérifier l’état sur l’esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Modifier la page HTML sur l’esclave :

<pre>
vi /var/www/html/index.html
</pre>

Redémarrer le maître et vérifier la synchronisation :

<pre>
cat /var/www/html/index.html
</pre>

Vérifier le status du maître :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Sur l’esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
failed
</pre>

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Vous avez votre serveur Apache avec HTTPS, le loadbalancing et la synchronisation fonctionnels.
|}

Apache

2026-02-21T15:32:19Z

Jung Jean-Marie : /* Installation et Configuration Apache HTTPD */

= Installation et Configuration Apache HTTPD =

{| style="width:100%; background:#fff6e6; border:1px solid #f1d6a8; padding:15px; border-radius:10px; overflow:hidden;"
|

Cette section décrit l’installation et la configuration complète d’un serveur web Apache (HTTPD) avec SSL. Elle permet de rendre votre serveur accessible sur le réseau et d’héberger des pages web. Elle inclut également la mise en place d’un système de load balancing avec HAProxy, d’une architecture haute disponibilité avec Keepalived, ainsi qu’un mécanisme de synchronisation entre les serveurs afin d’assurer la continuité de service, la répartition de charge et la tolérance aux pannes.
|}

__TOC__

= Partie 1 — Installation et Configuration Apache =

{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
Installation et configuration du serveur web Apache HTTPD
|}

== Installation des packages ==

Installation du serveur Apache ainsi que du module SSL pour HTTPS :

<pre>
dnf install httpd mod_ssl -y
</pre>

Vérifier que l’installation s’est bien déroulée :

<pre>
rpm -qa | grep httpd
</pre>

== Configuration du serveur ==

Tout d’abord, il faut paramétrer le nom de la machine ainsi que l’adresse d’écoute du serveur web.

Modifier le fichier :

/etc/httpd/conf/httpd.conf

Chercher les lignes suivantes :

<pre>
Listen 80
#ServerName www.example.com:80
</pre>

Instructions :

* Décommenter la ligne ServerName
* Adapter le nom en fonction de votre configuration réseau (/etc/sysconfig/network)
* Définir l’écoute sur toutes les interfaces

Configuration finale :

<pre>
Listen *:80
ServerName web:80
</pre>

== Démarrage du service HTTPD ==

Démarrage du service Apache :

<pre>
systemctl start httpd.service --now
</pre>

Activation automatique au démarrage du système (création du lien symbolique) :

<pre>
systemctl enable httpd.service --now
</pre>

== Vérification du service ==

Vérifier que le service fonctionne correctement :

<pre>
ss -atnp | grep httpd
</pre>

Si Apache fonctionne correctement, les ports **80 (HTTP)** et **443 (HTTPS)** doivent apparaître en écoute.

== Ouverture des ports dans iptables ==

Pour rendre votre site accessible depuis le réseau, il est nécessaire d’ouvrir les ports 80 et 443.
Sans cette étape, votre navigateur affichera une erreur de connexion refusée.

Modifier :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter les règles suivantes :

<pre>
-I INPUT 2 -p tcp --dport 80 -j ACCEPT
-I INPUT 3 -p tcp --dport 443 -j ACCEPT
</pre>

Appliquer les changements :

<pre>
systemctl reload iptables
</pre>

Vérifier les règles :

<pre>
iptables -nvL
</pre>

== Résultat attendu ==

Après vérification, vous devez voir apparaître les règles pour les ports HTTP et HTTPS.

IMPORTANT : les 2 lignes en gras ci-dessous doivent absolument être visibles.
Ce sont elles qui autorisent l’accès au serveur web.

<div>
pkts bytes target prot opt in out source destination
81 5840 ACCEPT all -- * * 0.0.0.0/0 0.0.0.0/0 state RELATED,ESTABLISHED
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:80'''
'''0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 tcp dpt:443'''
0 0 ACCEPT icmp -- * * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT all -- lo * 0.0.0.0/0 0.0.0.0/0
0 0 ACCEPT tcp -- * * 0.0.0.0/0 0.0.0.0/0 state NEW tcp dpt:22
0 0 REJECT all -- * * 0.0.0.0/0 0.0.0.0/0 reject-with icmp-host-prohibited
</div>

== Création de la page d’accueil ==

Créer la première page de votre site web :

<pre>
vi /var/www/html/index.html
</pre>

Exemple de contenu :

<pre>
cc
</pre>

Attribuer les droits au dossier pour qu’Apache puisse accéder aux fichiers :

<pre>
chown apache.apache -R /var/www/html
</pre>

== Vérification finale ==

Tester l’accès au serveur avec curl :

<pre>
curl 192.168.10.251
</pre>

Vous devez voir apparaître le contenu de votre page web.

== Important ==
{| style="width:100%; background:#fff8ec; border:1px solid #f5cba7; padding:12px; border-radius:10px; overflow:hidden;"
|
La procédure doit être répétée sur votre second serveur afin de compléter l’infrastructure.
|}

 

= Partie 2 — Configuration HTTPS (SSL/TLS) =

{| style="width:100%; background:#ebf5fb; border:1px solid #aed6f1; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place du chiffrement SSL/TLS pour sécuriser les communications web.
|}

== Principe ==

HTTPS permet de :

* Chiffrer les échanges entre client et serveur
* Garantir l’intégrité des données
* Authentifier le serveur

Le protocole utilise le port '''443'''.

== Création d’un certificat auto-signé ==

Générer un certificat SSL :

<pre>
openssl req -x509 -nodes -days 365 -newkey rsa:2048 \
-keyout /etc/pki/tls/private/apache.key \
-out /etc/pki/tls/certs/apache.crt
</pre>

== Configuration Apache HTTPS ==

Modifier le fichier :

<pre>
vi /etc/httpd/conf.d/ssl.conf
</pre>

Adapter les lignes suivantes :

<pre>
SSLCertificateFile /etc/pki/tls/certs/apache.crt
SSLCertificateKeyFile /etc/pki/tls/private/apache.key
</pre>

Redémarrer Apache :

<pre>
systemctl restart httpd
</pre>

== Vérification ==

Tester l’accès sécurisé :

<pre>
curl -k https://IP_SERVEUR
</pre>

 

= Partie 3 — Load Balancing avec HAProxy =

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Répartition de charge entre plusieurs serveurs web afin d’améliorer les performances et la disponibilité des services.
|}

== Principe ==

Le Load Balancing permet :

* Répartir les requêtes clients sur plusieurs serveurs web
* Améliorer les performances globales
* Réduire la charge sur chaque serveur
* Augmenter la disponibilité du service

HAProxy agit comme point d’entrée unique et distribue les requêtes vers les serveurs backend.

Architecture :

Client → HAProxy → Serveur Web 1 / Serveur Web 2

== Préparation des serveurs Apache (Backend) ==

Les serveurs Apache doivent écouter sur le port '''8080''' afin que HAProxy utilise le port 80.

Modifier la configuration Apache :

<pre>
vi /etc/httpd/conf/httpd.conf
</pre>

Modifier :

Avant :
<pre>
Listen *:80
ServerName web:80
</pre>

Après :
<pre>
Listen *:8080
ServerName web:8080
</pre>

Vérifier la configuration :

<pre>
httpd -S
</pre>

Redémarrer Apache :

<pre>
httpd -k graceful
</pre>

== Ouverture du port 8080 sur les serveurs web ==

Autoriser le trafic vers Apache sur les serveurs backend.

Modifier iptables :

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter :

<pre>
-I INPUT 1 -p tcp --dport 8080 -j ACCEPT
</pre>

Appliquer :

<pre>
systemctl reload iptables
</pre>

== Installation HAProxy ==

Sur le serveur Load Balancer :

<pre>
dnf install haproxy -y
</pre>

== Configuration HAProxy ==

Modifier le fichier :

<pre>
vi /etc/haproxy/haproxy.cfg
</pre>

Configuration exemple en mode '''round robin''' :

<pre>
global
log /dev/log local0
maxconn 2000
daemon

defaults
mode http
timeout connect 5s
timeout client 50s
timeout server 50s

frontend http_front
bind *:80
default_backend web_back

backend web_back
balance roundrobin
option httpchk
server web1 192.168.10.252:8080 check
server web2 192.168.10.251:8080 check
</pre>

Le mode '''roundrobin''' distribue les requêtes alternativement entre les serveurs.

== Démarrage du service HAProxy ==

<pre>
systemctl enable haproxy --now
</pre>

Vérifier le statut :

<pre>
systemctl status haproxy
</pre>

== Ouverture du port 80 sur le Load Balancer ==

Autoriser l’accès client au serveur HAProxy.

<pre>
vi /etc/sysconfig/iptables
</pre>

Ajouter :

<pre>
-I INPUT 1 -p tcp --dport 80 -j ACCEPT
</pre>

Appliquer :

<pre>
systemctl reload iptables
</pre>

== Test du Load Balancing ==

Tester l’accès via l’adresse IP du serveur HAProxy :

<pre>
curl 192.168.10.251
</pre>

Effectuer plusieurs requêtes successives.

{| style="width:100%; background:#eafaf1; border:1px solid #a9dfbf; padding:12px; border-radius:10px; overflow:hidden;"
|
Si la configuration fonctionne correctement, les réponses doivent alterner entre les différents serveurs web.
|}

 
= Partie 4 — Haute Disponibilité avec Keepalived =

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Mise en place d’une adresse IP virtuelle (VIP) afin d’assurer la continuité de service en cas de panne d’un serveur.
|}

== Principe ==

Keepalived permet :

* Assurer la continuité du service (Haute Disponibilité)
* Basculer automatiquement vers un serveur secondaire en cas de panne
* Utiliser une adresse IP virtuelle partagée entre plusieurs serveurs (VIP)
* Superviser l’état du service HAProxy

Fonctionnement :

* Un serveur est '''MASTER''' (actif)
* Un serveur est '''BACKUP''' (passif)
* Si le serveur MASTER tombe, le BACKUP récupère automatiquement l’IP virtuelle

== Installation ==

Installer Keepalived sur les deux serveurs (MASTER et BACKUP) :

<pre>
dnf install keepalived -y
</pre>

== Configuration du serveur maître (MASTER) ==

Vider le fichier de configuration par défaut :

<pre>
echo > /etc/keepalived/keepalived.conf
</pre>

Modifier la configuration :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Configuration du serveur MASTER :

<pre>
global_defs {
router_id WEB1
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Démarrer et activer Keepalived :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Configuration du serveur secondaire (BACKUP) ==

Sur la seconde machine, créer le même fichier avec quelques modifications :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Configuration du serveur BACKUP :

<pre>
global_defs {
router_id WEB2
}

vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state BACKUP
interface eth0
virtual_router_id 51
priority 90
advert_int 1

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
}
}
</pre>

Activer le service :

<pre>
systemctl enable keepalived --now
systemctl start keepalived --now
</pre>

== Vérification du fonctionnement ==

Sur le serveur MASTER :

<pre>
ip a
</pre>

Vous devez voir :

* L’adresse IP du serveur
* L’adresse IP virtuelle '''192.168.10.250'''

Test de basculement :

1. Arrêter le serveur MASTER ou le service Keepalived 
2. Sur le serveur BACKUP exécuter :

<pre>
ip a
</pre>

L’adresse IP virtuelle doit apparaître automatiquement sur le serveur secondaire.

{| style="width:100%; background:#f4ecf7; border:1px solid #d2b4de; padding:12px; border-radius:10px; overflow:hidden;"
|
Cela confirme que la haute disponibilité fonctionne correctement.
|}

 
= Partie 5 — Synchronisation des serveurs =

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Synchronisation des fichiers web entre les serveurs pour garantir la cohérence des données.
|}

== Principe ==

La synchronisation permet :

* Maintenir les mêmes fichiers sur plusieurs serveurs
* Assurer la cohérence des données
* Faciliter la haute disponibilité

== Installation de lsyncd ==

<pre>
dnf install lsyncd -y
</pre>

== Génération des clés SSH ==

Depuis les 2 serveurs, générer les clés SSH pour permettre à lsyncd de faire la synchronisation :

Sur serveur 1 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.251
</pre>

Sur serveur 2 :

<pre>
ssh-keygen -t rsa -b 4096 -f ~/.ssh/id_rsa -N ""
ssh-copy-id -i ~/.ssh/id_rsa.pub root@192.168.10.252
</pre>

== Configuration de lsyncd ==

Créer le dossier de configuration :

<pre>
mkdir -p /etc/lsyncd
</pre>

Créer la configuration et ajouter les éléments nécessaires pour les 2 serveurs :

<pre>
vi /etc/lsyncd/lsyncd.conf.lua
</pre>

Ajouter :

<pre>
settings {
logfile = "/var/log/lsyncd.log",
statusFile = "/var/log/lsyncd.status",
nodaemon = false,
}

sync {
default.rsync,
source = "/var/www/html/",
target = "root@192.168.10.251:/var/www/html/",

rsync = {
archive = true,
compress = true,
_extra = {"--delete"}
}
}
</pre>

Modifier également le daemon lsyncd sur les 2 serveurs :

<pre>
vi /usr/lib/systemd/system/lsyncd.service
</pre>

Ne pas oublier de mettre `User=root` et le chemin correct de la conf.lua dans `ExecStart` :

<pre>
[Unit]
Description=Live Syncing (Mirror) Daemon
Documentation=man:lsyncd(1) https://axkibe.github.io/lsyncd/
After=network.target

[Service]
User=root
Type=simple
EnvironmentFile=-/etc/sysconfig/lsyncd
ExecStart=/usr/bin/lsyncd -nodaemon /etc/lsyncd/lsyncd.conf.lua
Restart=on-failure

[Install]
WantedBy=multi-user.target
</pre>

Redémarrer le daemon sur les 2 serveurs :

<pre>
systemctl daemon-reload
</pre>

Activer le service sur les 2 serveurs :

<pre>
systemctl enable lsyncd
</pre>

Mais démarrer uniquement sur le serveur maître :

<pre>
systemctl start lsyncd
</pre>

== Reconfiguration de Keepalived ==

Créer 2 nouveaux scripts bash dans `/etc/keepalived/` sur les 2 serveurs :

Master (`master.sh`) :

<pre>
#!/bin/bash
systemctl start lsyncd
</pre>

Backup (`backup.sh`) :

<pre>
#!/bin/bash
systemctl stop lsyncd
</pre>

Donner les droits d’exécution :

<pre>
chmod +x /etc/keepalived/master.sh
chmod +x /etc/keepalived/backup.sh
</pre>

Créer un script de vérification : `/usr/local/bin/check_lsyncd_sync.sh`

<pre>
#!/bin/bash

STATUS_FILE="/var/log/lsyncd.status"

systemctl is-active --quiet lsyncd
if [ $? -ne 0 ]; then
exit 1
fi

if grep -q "Syncing" "$STATUS_FILE"; then
exit 1
fi

exit 0
</pre>

Modifier `keepalived.conf` :

<pre>
vi /etc/keepalived/keepalived.conf
</pre>

Ajouter :

<pre>
bal_defs {
router_id WEB1
}
vrrp_script check_sync {
script "/usr/local/bin/check_lsyncd_sync.sh"
interval 2
weight 2
}
vrrp_script chk_haproxy {
script "pidof haproxy"
interval 2
}

vrrp_instance VI_1 {
state MASTER
interface eth0
virtual_router_id 51
priority 100
advert_int 1
nopreempt

authentication {
auth_type PASS
auth_pass 1234
}

virtual_ipaddress {
192.168.10.250
}

track_script {
chk_haproxy
check_sync
}
notify_master "/etc/keepalived/master.sh"
notify_backup "/etc/keepalived/backup.sh"
notify_fault "/etc/keepalived/backup.sh"
}
</pre>

Redémarrer Keepalived :

<pre>
systemctl restart keepalived
</pre>

== Vérification ==

Sur le serveur maître :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Sur le serveur esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
failed
</pre>

== Test de la synchronisation ==

Modifier la page HTML sur le maître :

<pre>
vi /var/www/html/index.html
</pre>

Vérifier la synchro sur l’esclave :

<pre>
cat /var/www/html/index.html
</pre>

Éteindre le maître et vérifier l’état sur l’esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Modifier la page HTML sur l’esclave :

<pre>
vi /var/www/html/index.html
</pre>

Redémarrer le maître et vérifier la synchronisation :

<pre>
cat /var/www/html/index.html
</pre>

Vérifier le status du maître :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
Active
</pre>

Sur l’esclave :

<pre>
systemctl status lsyncd
</pre>

Vous devriez voir :

<pre>
failed
</pre>

{| style="width:100%; background:#f2f4f4; border:1px solid #d5d8dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Vous avez votre serveur Apache avec HTTPS, le loadbalancing et la synchronisation fonctionnels.
|}

DHCP

2026-02-21T15:27:43Z

Jung Jean-Marie : /* Modes */

= DHCP =

{| style="width:100%; background:#f0f4f8; border:1px solid #c7d3e0; padding:15px; border-radius:10px; overflow:hidden;"
|

Le DHCP (Dynamic Host Configuration Protocol) permet d’attribuer automatiquement des adresses IP aux machines d’un réseau.

|}

= Infrastructure DHCP — Rocky Linux =

{| style="width:100%; background:#f5f7fa; border:1px solid #d6dbe1; padding:15px; border-radius:10px; overflow:hidden;"
|

Documentation complète de mise en place d’une infrastructure DHCP sous Rocky Linux

|}

__TOC__

= 1 — Création du Serveur DHCP =

{| style="width:100%; background:#f3f9f1; border:1px solid #cfe5c9; padding:12px; border-radius:10px; overflow:hidden;"
|
Installation et configuration du service DHCP
|}

== Installation du service ==

<pre>
dnf install dhcp-server -y
</pre>

Vérifier l’installation :

<pre>
rpm -qa | grep dhcp
</pre>

== Configuration principale ==

<pre>
vi /etc/dhcp/dhcpd.conf
</pre>

Configuration minimale :

<pre>
subnet 192.168.30.0 netmask 255.255.255.0 {
authoritative;

option routers 192.168.30.254;
option domain-name-servers 192.168.40.253;
range 192.168.30.10 192.168.30.50;
}
</pre>

== Vérification de la configuration ==

<pre>
dhcpd -t
</pre>

== Démarrage du service ==

<pre>
systemctl enable dhcpd
systemctl start dhcpd
systemctl status dhcpd
</pre>

== Ouverture de iptables ==

<pre>
vi /etc/sysconfig/iptables
-I INPUT 2 -p udp --dport 67 -j ACCEPT
</pre>

== Enregistrement des changements ==

<pre>
systemctl reload iptables
</pre>

----

= 2 — Configuration DHCP détaillée =

{| style="width:100%; background:#fff6e6; border:1px solid #f1d6a8; padding:12px; border-radius:10px; overflow:hidden;"
|
Configuration avancée du serveur DHCP
|}

== Explication des directives ==

{| class="wikitable" style="width:50%; background:#ffffff; border:1px solid #fad7a0; border-radius:10px; overflow:hidden;"
! Directive !! Description
|-
| subnet || Réseau géré
|-
| authoritative || Serveur DHCP officiel
|-
| option routers || Passerelle réseau
|-
| option domain-name-servers || Serveurs DNS fournis
|-
| range || Plage IP distribuée
|}

== Attribution d’une IP fixe ==

<pre>
host dhcp1 {
hardware ethernet 00:00:00:00:00:00;
fixed-address 192.168.40.253;
}
</pre>

== Plusieurs réseaux ==

Répétez cette procédure pour tous les réseaux nécessaires.

----

= 3 — DHCP Relay sur Firewall =

{| style="width:100%; background:#f5eef8; border:1px solid #d7c6e6; padding:12px; border-radius:10px; overflow:hidden;"
|
Transmission des requêtes DHCP entre réseaux
|}

== Principe ==

{| style="width:100%; background:#fafafa; border:1px solid #ddd; padding:12px; border-radius:10px; overflow:hidden;"
|
Le DHCP fonctionne en broadcast.
Les routeurs bloquent ces requêtes.
Le DHCP Relay transmet les requêtes vers un serveur distant.
|}

Architecture :

<pre>
Client → Firewall → Serveur DHCP
</pre>

== Installation ==

<pre>
dnf install dhcp-relay -y
</pre>

== Configuration ==

<pre>
cp /lib/systemd/system/dhcrelay.service /etc/systemd/system/
vi /etc/systemd/system/dhcrelay.service
ExecStart=/usr/sbin/dhcrelay -d --no-pid -i pri -i lan -i dmz 192.168.40.253 192.168.40.251
systemctl daemon-reload
vi /etc/sysconfig/dhcrelay
</pre>

Ajouter :

<pre>
INTERFACES="dmz pri lan"
DHCPSERVERS="192.168.40.253"
</pre>

== Activation ==

<pre>
systemctl enable dhcrelay
systemctl start dhcrelay
</pre>

----

= 4 — DHCP Maître / Esclave (Failover) =

{| style="width:100%; background:#fdeeee; border:1px solid #efc2c2; padding:12px; border-radius:10px; overflow:hidden;"
|
Haute disponibilité du service DHCP
|}

== Objectif ==

* Continuité de service
* Synchronisation des baux
* Prévention des conflits IP

== Modes ==

{| class="wikitable" style="width:35%; border:1px solid #f5b7b1; border-radius:10px; overflow:hidden;"
! Mode !! Description
|-
| Load Balance || Partage de charge
|-
| Hot Standby || Serveur secondaire de secours
|}

----

= 5 — Configuration DHCP Maître / Esclave =

{| style="width:100%; background:#eef7f6; border:1px solid #bfe1dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Configuration complète du failover DHCP
|}

== Architecture ==

<pre>
MASTER : 192.168.40.253
SLAVE : 192.168.40.251
</pre>

Installation sur les deux serveurs :

<pre>
dnf install dhcp-server -y
</pre>

== Configuration MASTER ==

<pre>
failover peer "dhcp" {
primary;
address 192.168.40.253;
port 520;
peer address 192.168.40.251;
peer port 520;
max-response-delay 60;
max-unacked-updates 10;
mclt 3600;
split 128;
load balance max seconds 3;
}

subnet 192.168.30.0 netmask 255.255.255.0 {
authoritative;

option routers 192.168.30.254;
option domain-name-servers 192.168.40.253;

pool {
failover peer "dhcp";
option routers 192.168.30.254;
range 192.168.30.10 192.168.30.50;
}
}
</pre>

== Configuration SLAVE ==

<pre>
failover peer "dhcp" {
secondary;
address 192.168.40.251;
port 520;
peer address 192.168.40.253;
peer port 520;
max-response-delay 60;
max-unacked-updates 10;
mclt 3600;
}
subnet 192.168.30.0 netmask 255.255.255.0 {
option routers 192.168.30.254;
option domain-name-servers 192.168.40.253;

pool {
failover peer "dhcp";
option routers 192.168.30.254;
range 192.168.30.10 192.168.30.50;
}
}
</pre>

== Ouverture du port failover ==

<pre>
vi /etc/sysconfig/iptables
-I INPUT 2 -p tcp --dport 520 -j ACCEPT
systemctl reload iptables
</pre>

== Redémarrage du service DHCP ==

<pre>
systemctl restart dhcpd
</pre>

----

{| style="width:100%; background:#e8f5e9; border:1px solid #c8e6c9; padding:15px; border-radius:10px; overflow:hidden;"
|

Infrastructure DHCP opérationnelle

|}

DHCP

2026-02-21T15:27:30Z

Jung Jean-Marie : /* Modes */

= DHCP =

{| style="width:100%; background:#f0f4f8; border:1px solid #c7d3e0; padding:15px; border-radius:10px; overflow:hidden;"
|

Le DHCP (Dynamic Host Configuration Protocol) permet d’attribuer automatiquement des adresses IP aux machines d’un réseau.

|}

= Infrastructure DHCP — Rocky Linux =

{| style="width:100%; background:#f5f7fa; border:1px solid #d6dbe1; padding:15px; border-radius:10px; overflow:hidden;"
|

Documentation complète de mise en place d’une infrastructure DHCP sous Rocky Linux

|}

__TOC__

= 1 — Création du Serveur DHCP =

{| style="width:100%; background:#f3f9f1; border:1px solid #cfe5c9; padding:12px; border-radius:10px; overflow:hidden;"
|
Installation et configuration du service DHCP
|}

== Installation du service ==

<pre>
dnf install dhcp-server -y
</pre>

Vérifier l’installation :

<pre>
rpm -qa | grep dhcp
</pre>

== Configuration principale ==

<pre>
vi /etc/dhcp/dhcpd.conf
</pre>

Configuration minimale :

<pre>
subnet 192.168.30.0 netmask 255.255.255.0 {
authoritative;

option routers 192.168.30.254;
option domain-name-servers 192.168.40.253;
range 192.168.30.10 192.168.30.50;
}
</pre>

== Vérification de la configuration ==

<pre>
dhcpd -t
</pre>

== Démarrage du service ==

<pre>
systemctl enable dhcpd
systemctl start dhcpd
systemctl status dhcpd
</pre>

== Ouverture de iptables ==

<pre>
vi /etc/sysconfig/iptables
-I INPUT 2 -p udp --dport 67 -j ACCEPT
</pre>

== Enregistrement des changements ==

<pre>
systemctl reload iptables
</pre>

----

= 2 — Configuration DHCP détaillée =

{| style="width:100%; background:#fff6e6; border:1px solid #f1d6a8; padding:12px; border-radius:10px; overflow:hidden;"
|
Configuration avancée du serveur DHCP
|}

== Explication des directives ==

{| class="wikitable" style="width:50%; background:#ffffff; border:1px solid #fad7a0; border-radius:10px; overflow:hidden;"
! Directive !! Description
|-
| subnet || Réseau géré
|-
| authoritative || Serveur DHCP officiel
|-
| option routers || Passerelle réseau
|-
| option domain-name-servers || Serveurs DNS fournis
|-
| range || Plage IP distribuée
|}

== Attribution d’une IP fixe ==

<pre>
host dhcp1 {
hardware ethernet 00:00:00:00:00:00;
fixed-address 192.168.40.253;
}
</pre>

== Plusieurs réseaux ==

Répétez cette procédure pour tous les réseaux nécessaires.

----

= 3 — DHCP Relay sur Firewall =

{| style="width:100%; background:#f5eef8; border:1px solid #d7c6e6; padding:12px; border-radius:10px; overflow:hidden;"
|
Transmission des requêtes DHCP entre réseaux
|}

== Principe ==

{| style="width:100%; background:#fafafa; border:1px solid #ddd; padding:12px; border-radius:10px; overflow:hidden;"
|
Le DHCP fonctionne en broadcast.
Les routeurs bloquent ces requêtes.
Le DHCP Relay transmet les requêtes vers un serveur distant.
|}

Architecture :

<pre>
Client → Firewall → Serveur DHCP
</pre>

== Installation ==

<pre>
dnf install dhcp-relay -y
</pre>

== Configuration ==

<pre>
cp /lib/systemd/system/dhcrelay.service /etc/systemd/system/
vi /etc/systemd/system/dhcrelay.service
ExecStart=/usr/sbin/dhcrelay -d --no-pid -i pri -i lan -i dmz 192.168.40.253 192.168.40.251
systemctl daemon-reload
vi /etc/sysconfig/dhcrelay
</pre>

Ajouter :

<pre>
INTERFACES="dmz pri lan"
DHCPSERVERS="192.168.40.253"
</pre>

== Activation ==

<pre>
systemctl enable dhcrelay
systemctl start dhcrelay
</pre>

----

= 4 — DHCP Maître / Esclave (Failover) =

{| style="width:100%; background:#fdeeee; border:1px solid #efc2c2; padding:12px; border-radius:10px; overflow:hidden;"
|
Haute disponibilité du service DHCP
|}

== Objectif ==

* Continuité de service
* Synchronisation des baux
* Prévention des conflits IP

== Modes ==

{| class="wikitable" style="width:50%; border:1px solid #f5b7b1; border-radius:10px; overflow:hidden;"
! Mode !! Description
|-
| Load Balance || Partage de charge
|-
| Hot Standby || Serveur secondaire de secours
|}

----

= 5 — Configuration DHCP Maître / Esclave =

{| style="width:100%; background:#eef7f6; border:1px solid #bfe1dc; padding:12px; border-radius:10px; overflow:hidden;"
|
Configuration complète du failover DHCP
|}

== Architecture ==

<pre>
MASTER : 192.168.40.253
SLAVE : 192.168.40.251
</pre>

Installation sur les deux serveurs :

<pre>
dnf install dhcp-server -y
</pre>

== Configuration MASTER ==

<pre>
failover peer "dhcp" {
primary;
address 192.168.40.253;
port 520;
peer address 192.168.40.251;
peer port 520;
max-response-delay 60;
max-unacked-updates 10;
mclt 3600;
split 128;
load balance max seconds 3;
}

subnet 192.168.30.0 netmask 255.255.255.0 {
authoritative;

option routers 192.168.30.254;
option domain-name-servers 192.168.40.253;

pool {
failover peer "dhcp";
option routers 192.168.30.254;
range 192.168.30.10 192.168.30.50;
}
}
</pre>

== Configuration SLAVE ==

<pre>
failover peer "dhcp" {
secondary;
address 192.168.40.251;
port 520;
peer address 192.168.40.253;
peer port 520;
max-response-delay 60;
max-unacked-updates 10;
mclt 3600;
}
subnet 192.168.30.0 netmask 255.255.255.0 {
option routers 192.168.30.254;
option domain-name-servers 192.168.40.253;

pool {
failover peer "dhcp";
option routers 192.168.30.254;
range 192.168.30.10 192.168.30.50;
}
}
</pre>

== Ouverture du port failover ==

<pre>
vi /etc/sysconfig/iptables
-I INPUT 2 -p tcp --dport 520 -j ACCEPT
systemctl reload iptables
</pre>

== Redémarrage du service DHCP ==

<pre>
systemctl restart dhcpd
</pre>

----

{| style="width:100%; background:#e8f5e9; border:1px solid #c8e6c9; padding:15px; border-radius:10px; overflow:hidden;"
|

Infrastructure DHCP opérationnelle

|}