Apache

Installation et Configuration Apache HTTPD

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.

1 — Installation et Configuration Apache

Installation et configuration du serveur web Apache HTTPD

Installation des packages

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

dnf install httpd mod_ssl -y

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

rpm -qa | grep httpd

Résultat attendu dans la console :

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

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 :

Listen 80
#ServerName www.example.com:80

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 :

Listen *:80
ServerName web:80

Démarrage du service HTTPD

Démarrage du service Apache :

systemctl start httpd.service --now

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

systemctl enable httpd.service --now

Vérification du service

Vérifier que le service fonctionne correctement :

ss -atnp | grep httpd

Résultat attendu dans la console :

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))

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 :

vi /etc/sysconfig/iptables

Ajouter les règles suivantes :

-I INPUT 2 -p tcp --dport 80 -j ACCEPT
-I INPUT 3 -p tcp --dport 443 -j ACCEPT

Appliquer les changements :

systemctl reload iptables

Vérifier les règles :

iptables -nvL

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.

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

Création de la page d’accueil

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

vi /var/www/html/index.html

Exemple de contenu :

cc

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

chown apache.apache -R /var/www/html

Vérification finale

Tester l’accès au serveur avec curl :

curl 192.168.10.251

Résultat attendu dans la console :

cc

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

Important

La procédure doit être répétée sur votre second serveur afin de compléter l’infrastructure.

2 — Configuration HTTPS (SSL/TLS)

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 :

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

Configuration Apache HTTPS

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

Modifier le fichier de configuration SSL :

vi /etc/httpd/conf.d/ssl.conf

Localiser et adapter les lignes suivantes :

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

Redémarrer le service Apache pour appliquer les modifications :

systemctl restart httpd

Vérification du fonctionnement HTTPS

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

curl -k https://IP_SERVEUR

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

Résultat attendu dans la console :

cc

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

3 — Load Balancing avec HAProxy

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.

                ┌─────────────────────────────────────────────────────────────┐
                │                     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)  │
                        └───────────────┘             └───────────────┘

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 :

vi /etc/httpd/conf/httpd.conf

Localiser et modifier les lignes suivantes :

• Avant:

Listen *:80
ServerName web:80

• Après:

Listen *:8080
ServerName web:8080

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

httpd -S

Résultat attendu dans la console :

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

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

httpd -k graceful

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 :

vi /etc/sysconfig/iptables

Ajouter :

-I INPUT 1 -p tcp --dport 8080 -j ACCEPT

Appliquer les changements au pare-feu :

systemctl reload iptables

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

iptables -nvL | grep 8080

Résultat attendu dans la console :

    0     0 ACCEPT  tcp  --  *   *   0.0.0.0/0  0.0.0.0/0  tcp dpt:8080

Installation HAProxy

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

Installation du package HAProxy :

dnf install haproxy -y

Configuration HAProxy

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

Modifier le fichier de configuration principal :

vi /etc/haproxy/haproxy.cfg

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

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

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 :

systemctl enable haproxy --now

Vérifier que le service fonctionne correctement :

systemctl status haproxy

Résultat attendu dans la console :

● 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."

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 :

curl 192.168.10.251

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

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

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 :

dnf install keepalived -y

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 :

echo > /etc/keepalived/keepalived.conf

Éditer le fichier de configuration :

vi /etc/keepalived/keepalived.conf

Ajouter la configuration suivante pour le serveur MASTER :

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
    }
}

Démarrer et activer le service Keepalived :

systemctl enable keepalived --now
systemctl start keepalived --now

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 :

vi /etc/keepalived/keepalived.conf

Ajouter la configuration suivante pour le serveur BACKUP :

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
    }
}

Activer et démarrer le service :

systemctl enable keepalived --now
systemctl start keepalived --now

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 :

ip a

Résultat attendu dans la console :

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

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 :

ip a

Résultat attendu dans la console :

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

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

Cela confirme que la haute disponibilité fonctionne correctement.

5 — Synchronisation des serveurs

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 :

dnf install lsyncd -y

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 :

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

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

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

Configuration de lsyncd

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

Créer le répertoire de configuration :

mkdir -p /etc/lsyncd

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.

vi /etc/lsyncd/lsyncd.conf.lua

Ajouter la configuration suivante :

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"}
   }
} 

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

Éditer le fichier sur les deux serveurs :

vi /usr/lib/systemd/system/lsyncd.service

Modifier les paramètres suivants :

• User=rootpour donner les droits nécessaires
• ExecStartpour indiquer le bon chemin vers le fichier de configuration.

Configuration finale :

[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 

Recharger la configuration systemd pour prendre en compte les modifications :

Sur les deux serveurs, exécuter :

systemctl daemon-reload

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

systemctl enable lsyncd

• 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.

systemctl start lsyncd

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`) :

#!/bin/bash
systemctl start lsyncd

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

#!/bin/bash
systemctl stop lsyncd

Rendre les scripts exécutables :

chmod +x /etc/keepalived/master.sh
chmod +x /etc/keepalived/backup.sh

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 :

#!/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

Rendre le script exécutable :

chmod +x /usr/local/bin/check_lsyncd_sync.sh

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

vi /etc/keepalived/keepalived.conf

Remplacer le contenu par la configuration suivante :

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"
} 

Redémarrer le service Keepalived pour appliquer les changements :

systemctl restart keepalived

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 :

systemctl status lsyncd

Résultat attendu dans la console :

● 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)

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

systemctl status lsyncd

Résultat attendu dans la console :

● 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

Test de la synchronisation

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

Modifier la page HTML sur le serveur maître :

vi /var/www/html/index.html

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

cat /var/www/html/index.html

Résultat attendu dans la console :

cc

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 :

systemctl status lsyncd

Résultat attendu dans la console :

● 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)

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

vi /var/www/html/index.html

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

cat /var/www/html/index.html

Résultat attendu dans la console :

cc

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) :

systemctl status lsyncd

Résultat attendu dans la console :

● 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)

Sur le serveur qui est redevenu esclave (BACKUP) :

systemctl status lsyncd

Résultat attendu dans la console :

● 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

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.