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.

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é

Générer un certificat SSL :

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

Modifier le fichier :

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

Adapter les lignes suivantes :

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

Redémarrer Apache :

systemctl restart httpd

Vérification

Tester l’accès sécurisé :

curl -k https://IP_SERVEUR

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)

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

Modifier la configuration Apache :

vi /etc/httpd/conf/httpd.conf

Modifier :

Avant :

Listen *:80
ServerName web:80

Après :

Listen *:8080
ServerName web:8080

Vérifier la configuration :

httpd -S

Redémarrer Apache :

httpd -k graceful

Ouverture du port 8080 sur les serveurs web

Autoriser le trafic vers Apache sur les serveurs backend.

Modifier iptables :

vi /etc/sysconfig/iptables

Ajouter :

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

Appliquer :

systemctl reload iptables

Installation HAProxy

Sur le serveur Load Balancer :

dnf install haproxy -y

Configuration HAProxy

Modifier le fichier :

vi /etc/haproxy/haproxy.cfg

Configuration exemple en mode round robin :

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.

Démarrage du service HAProxy

systemctl enable haproxy --now

Vérifier le statut :

systemctl status haproxy

Ouverture du port 80 sur le Load Balancer

Autoriser l’accès client au serveur HAProxy.

vi /etc/sysconfig/iptables

Ajouter :

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

Appliquer :

systemctl reload iptables

Test du Load Balancing

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

curl 192.168.10.251

Effectuer plusieurs requêtes successives.

Si la configuration fonctionne correctement, les réponses doivent alterner entre les différents serveurs web.

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

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

dnf install keepalived -y

Configuration du serveur maître (MASTER)

Vider le fichier de configuration par défaut :

echo > /etc/keepalived/keepalived.conf

Modifier la configuration :

vi /etc/keepalived/keepalived.conf

Configuration du 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 Keepalived :

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

Configuration du serveur secondaire (BACKUP)

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

vi /etc/keepalived/keepalived.conf

Configuration du 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 le service :

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

Vérification du fonctionnement

Sur le serveur MASTER :

ip a

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 :

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

dnf install lsyncd -y

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 :

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

Configuration de lsyncd

Créer le dossier de configuration :

mkdir -p /etc/lsyncd

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

vi /etc/lsyncd/lsyncd.conf.lua

Ajouter :

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 également le daemon lsyncd sur les 2 serveurs :

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

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

[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 

Redémarrer le daemon sur les 2 serveurs :

systemctl daemon-reload

Activer le service sur les 2 serveurs :

systemctl enable lsyncd

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

systemctl start lsyncd

Reconfiguration de Keepalived

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

Master (`master.sh`) :

#!/bin/bash
systemctl start lsyncd

Backup (`backup.sh`) :

#!/bin/bash
systemctl stop lsyncd

Donner les droits d’exécution :

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

Créer un script de vérification : `/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

Modifier `keepalived.conf` :

vi /etc/keepalived/keepalived.conf

Ajouter :

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

systemctl restart keepalived

Vérification

Sur le serveur maître :

systemctl status lsyncd

Vous devriez voir :

Active

Sur le serveur esclave :

systemctl status lsyncd

Vous devriez voir :

failed

Test de la synchronisation

Modifier la page HTML sur le maître :

vi /var/www/html/index.html

Vérifier la synchro sur l’esclave :

cat /var/www/html/index.html

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

systemctl status lsyncd

Vous devriez voir :

Active

Modifier la page HTML sur l’esclave :

vi /var/www/html/index.html

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

cat /var/www/html/index.html

Vérifier le status du maître :

systemctl status lsyncd

Vous devriez voir :

Active

Sur l’esclave :

systemctl status lsyncd

Vous devriez voir :

failed

Vous avez votre serveur Apache avec HTTPS, le loadbalancing et la synchronisation fonctionnels.