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.

Partie 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

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

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

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.

Partie 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
• Garantir l’intégrité des données
• 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é.

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

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

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

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

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

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

Ouverture du port 80 sur le Load Balancer

Pour que les clients puissent accéder au service via HAProxy, le port 80 doit être ouvert sur le serveur Load Balancer.

Modifier la configuration du pare-feu :

vi /etc/sysconfig/iptables

Ajouter la règle d'autorisation :

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

Appliquer les modifications :

systemctl reload iptables

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.

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

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

• L'adresse IP physique du serveur
• L'adresse IP virtuelle **192.168.10.250** doit 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

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

Cela confirme que la haute disponibilité fonctionne correctement.

Partie 5 — Synchronisation des serveurs

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

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=root** : pour donner les droits nécessaires
• **ExecStart** : pour 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 :

Active

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

systemctl status lsyncd

Résultat attendu :

failed

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

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

Active

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

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

systemctl status lsyncd

Résultat attendu :

Active

Sur le serveur qui est redevenu esclave (BACKUP) :

systemctl status lsyncd

Résultat attendu :

failed

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.