HAProxy : load balancing et haute disponibilité

Ce guide vous permet de déployer HAProxy pour répartir le trafic HTTP entre plusieurs serveurs backend. Vous apprendrez à configurer le load balancing round-robin, les health checks automatiques, les sticky sessions et la protection contre les abus. À la fin, vous disposerez d’un reverse proxy prêt pour la production.

Public cible : administrateurs système, DevOps, développeurs souhaitant améliorer la disponibilité de leurs applications.

Prérequis : un système Linux (Ubuntu/Debian) avec accès root, et au moins deux serveurs backend (ou containers Docker).

Qu’est-ce que HAProxy ?

HAProxy (High Availability Proxy) est un répartiteur de charge (load balancer) et reverse proxy open source. Créé en 2000 par Willy Tarreau, il est utilisé par des entreprises comme GitHub, Reddit et Netflix pour gérer des millions de connexions simultanées.

Analogie : imaginez un standardiste téléphonique qui reçoit tous les appels entrants et les distribue aux différents opérateurs disponibles. HAProxy joue ce rôle pour vos serveurs web : il reçoit les requêtes des utilisateurs et les répartit intelligemment entre vos serveurs.

Pourquoi utiliser HAProxy ?

Sans HAProxy	Avec HAProxy
Un seul serveur reçoit tout le trafic	Le trafic est réparti entre plusieurs serveurs
Si le serveur tombe, le site est indisponible	Le trafic bascule automatiquement vers les serveurs sains
Pas de protection contre les pics de charge	Gestion des files d’attente et rate limiting
Configuration SSL sur chaque serveur	Terminaison SSL centralisée

Glissez pour voir

Prérequis

Avant de commencer

• Système : Ubuntu 22.04+ ou Debian 12+ (ce guide utilise le PPA officiel pour Ubuntu)
• Accès : privilèges root ou sudo
• Réseau : ports 80, 443 et 8404 (stats) libres
• Backends : au moins deux serveurs web à load-balancer (ou des containers Docker)

Installation de HAProxy 3.0 LTS

La version 3.0 est une version LTS (Long Term Support) maintenue jusqu’en 2029. Elle apporte de nombreuses améliorations en termes de sécurité, performance et configuration.

Ubuntu/Debian (PPA)

Pour obtenir la dernière version stable (recommandé) :

1. Ajoutez le PPA officiel HAProxy maintenu par Vincent Bernat :

   sudo add-apt-repository -y ppa:vbernat/haproxy-3.0
   sudo apt update

2. Installez HAProxy :

   sudo apt install -y haproxy

3. Vérifiez l’installation :

   haproxy -v

   Vous devriez voir :

   HAProxy version 3.0.15-1ppa1~noble 2026/01/31 - https://haproxy.org/
   Status: long-term supported branch - will stop receiving fixes around Q2 2029.

Rocky Linux/RHEL

1. Installez les dépendances :

   sudo dnf install -y epel-release
   sudo dnf update

2. Installez HAProxy :

   sudo dnf install -y haproxy

3. Vérifiez l’installation :

   haproxy -v

Version dans les dépôts

Les dépôts par défaut peuvent fournir une version plus ancienne. Pour HAProxy 3.0, compilez depuis les sources ou utilisez le dépôt COPR.

Concepts clés de HAProxy

Avant de configurer HAProxy, comprenons les briques fondamentales de son architecture.

Frontend, Backend et Listen

HAProxy utilise trois types de blocs de configuration :

Bloc	Rôle	Analogie
frontend	Point d’entrée qui reçoit les connexions clients	L’accueil d’un hôtel
backend	Groupe de serveurs qui traitent les requêtes	Les chambres disponibles
listen	Combine frontend + backend en un seul bloc	Un hôtel simple avec accueil intégré

Glissez pour voir

┌──────────────────────────────────────────────────────────────┐
│                         HAProxy                              │
│  ┌─────────────┐           ┌─────────────────────────────┐   │
│  │  Frontend   │           │         Backend             │   │
│  │  (port 80)  │──────────▶│  ┌──────┐  ┌──────┐        │   │
│  │             │           │  │Web 1 │  │Web 2 │ ...    │   │
│  └─────────────┘           │  └──────┘  └──────┘        │   │
│                            └─────────────────────────────┘   │
└──────────────────────────────────────────────────────────────┘

Algorithmes de répartition de charge

HAProxy propose plusieurs méthodes pour distribuer le trafic :

Algorithme	Description	Cas d’usage
roundrobin	Distribue les requêtes à tour de rôle	Serveurs identiques, charge équilibrée
leastconn	Envoie vers le serveur avec le moins de connexions	Requêtes longues (téléchargements, WebSocket)
source	Hash basé sur l’IP source (sticky)	Affinité de session sans cookie
uri	Hash basé sur l’URI	Cache distribué
random	Sélection aléatoire	Simple et efficace à grande échelle

Glissez pour voir

ACLs (Access Control Lists)

Les ACLs permettent de prendre des décisions de routage basées sur des conditions :

acl is_api path_beg /api      # Vrai si le chemin commence par /api
acl is_admin hdr(host) -i admin.example.com   # Vrai si Host = admin...

use_backend api_servers if is_api
use_backend admin_servers if is_admin
default_backend web_servers

Types de conditions courantes :

Condition	Description
path_beg /api	Le chemin commence par “/api”
path_end .jpg	Le chemin finit par “.jpg”
hdr(host) -i example.com	L’en-tête Host vaut “example.com”
src 192.168.1.0/24	L’IP source est dans ce sous-réseau

Glissez pour voir

Health Checks

Les health checks vérifient automatiquement que vos serveurs backend fonctionnent :

• TCP check : vérifie que le port répond (par défaut)
• HTTP check : envoie une requête HTTP et attend un code 200
• Si un serveur ne répond pas, HAProxy le retire automatiquement du pool

Configuration de base

Le fichier de configuration principal est /etc/haproxy/haproxy.cfg. Voici une configuration minimale fonctionnelle :

/etc/haproxy/haproxy.cfg

global
    log /dev/log local0
    log /dev/log local1 notice
    maxconn 4096
    user haproxy
    group haproxy
    daemon

defaults
    mode http
    log global
    option httplog
    option dontlognull
    timeout connect 5s
    timeout client 30s
    timeout server 30s
    timeout http-request 10s

# Page de statistiques
listen stats
    bind *:8404
    stats enable
    stats uri /stats
    stats refresh 10s
    stats admin if LOCALHOST

# Frontend HTTP
frontend http_front
    bind *:80
    default_backend web_backend

# Backend avec load balancing
backend web_backend
    balance roundrobin
    option httpchk GET /health
    http-check expect status 200
    server web1 192.168.1.10:80 check
    server web2 192.168.1.11:80 check

Structure du fichier

Le fichier se compose de quatre sections principales :

1. global : paramètres du processus HAProxy (logs, utilisateur, limites)
2. defaults : valeurs par défaut pour les frontends/backends
3. frontend/listen : points d’entrée du trafic
4. backend : groupes de serveurs destination

Validation et démarrage

Avant d’appliquer une configuration, toujours la valider :

# Vérifie la syntaxe
sudo haproxy -c -f /etc/haproxy/haproxy.cfg

Si aucune erreur n’est affichée, la configuration est valide.

# Démarrer le service
sudo systemctl enable haproxy
sudo systemctl start haproxy

# Vérifier le statut
sudo systemctl status haproxy

Vérification

Testez que le load balancing fonctionne :

# Envoyez plusieurs requêtes
for i in {1..4}; do curl -s http://localhost/ | head -1; done

Vous devriez voir les réponses alterner entre vos backends.

Accédez à la page de statistiques : http://votre-ip:8404/stats

Cas pratiques avancés

Sticky Sessions (sessions persistantes)

Les sticky sessions garantissent qu’un utilisateur est toujours renvoyé vers le même serveur backend. Indispensable pour les applications qui stockent l’état de session côté serveur.

backend web_backend
    balance roundrobin
    cookie SERVERID insert indirect nocache
    server web1 192.168.1.10:80 check cookie web1
    server web2 192.168.1.11:80 check cookie web2

Comment ça fonctionne :

1. À la première connexion, HAProxy choisit un serveur (ex: web1)
2. Il ajoute un cookie SERVERID=web1 dans la réponse
3. Les requêtes suivantes avec ce cookie vont toujours vers web1

Vérification :

# Première requête : récupère le cookie
curl -c cookies.txt http://localhost/

# Requêtes suivantes : utilise le cookie (même serveur)
curl -b cookies.txt http://localhost/
curl -b cookies.txt http://localhost/

Routage basé sur l’URL (Path-based routing)

Envoyez différents types de requêtes vers différents backends :

frontend http_front
    bind *:80

    # Définition des ACLs
    acl is_api path_beg /api
    acl is_static path_beg /static /images /css /js
    acl is_websocket hdr(Upgrade) -i WebSocket

    # Routage vers les backends appropriés
    use_backend api_backend if is_api
    use_backend static_backend if is_static
    use_backend websocket_backend if is_websocket
    default_backend web_backend

backend api_backend
    balance leastconn
    server api1 192.168.1.20:3000 check
    server api2 192.168.1.21:3000 check

backend static_backend
    balance roundrobin
    server static1 192.168.1.30:80 check

backend websocket_backend
    balance source
    option http-server-close
    server ws1 192.168.1.40:8080 check

Health Checks HTTP personnalisés

Configurez des vérifications de santé plus précises :

backend web_backend
    balance roundrobin

    # Vérifie l'endpoint /health
    option httpchk GET /health HTTP/1.1\r\nHost:\ localhost

    # Attend un code 200
    http-check expect status 200

    # Ou vérifie le contenu de la réponse
    # http-check expect string "status":"healthy"

    # Paramètres des checks
    server web1 192.168.1.10:80 check inter 5s fall 3 rise 2
    server web2 192.168.1.11:80 check inter 5s fall 3 rise 2

Paramètres des serveurs :

Paramètre	Description
check	Active les health checks
inter 5s	Intervalle entre les checks (5 secondes)
fall 3	Nombre d’échecs avant de considérer le serveur DOWN
rise 2	Nombre de succès pour remettre le serveur UP

Glissez pour voir

Terminaison SSL/TLS

HAProxy peut gérer le chiffrement SSL à la place de vos backends :

frontend https_front
    bind *:443 ssl crt /etc/haproxy/certs/site.pem alpn h2,http/1.1
    bind *:80

    # Redirige HTTP vers HTTPS
    http-request redirect scheme https unless { ssl_fc }

    # Ajoute l'en-tête X-Forwarded-Proto
    http-request set-header X-Forwarded-Proto https if { ssl_fc }

    default_backend web_backend

backend web_backend
    balance roundrobin
    server web1 192.168.1.10:80 check
    server web2 192.168.1.11:80 check

Certificat PEM

Le fichier .pem doit contenir dans l’ordre :

1. Le certificat du site
2. Les certificats intermédiaires
3. La clé privée

cat site.crt intermediate.crt site.key > /etc/haproxy/certs/site.pem
chmod 600 /etc/haproxy/certs/site.pem

Sécurisation de HAProxy

Rate Limiting (limitation de requêtes)

Protégez vos backends contre les abus et les attaques DDoS :

frontend http_front
    bind *:80

    # Table de suivi des requêtes par IP
    stick-table type ip size 100k expire 30s store http_req_rate(10s)

    # Comptabilise les requêtes par IP
    http-request track-sc0 src

    # Bloque si plus de 50 requêtes en 10 secondes
    http-request deny deny_status 429 if { sc_http_req_rate(0) gt 50 }

    default_backend web_backend

Explication :

• stick-table : crée une table pour stocker les compteurs par IP
• track-sc0 : associe chaque requête à son IP source
• deny_status 429 : renvoie “Too Many Requests” si la limite est dépassée

Headers de sécurité

Ajoutez des en-têtes de sécurité aux réponses :

frontend https_front
    bind *:443 ssl crt /etc/haproxy/certs/site.pem

    # Headers de sécurité
    http-response set-header Strict-Transport-Security "max-age=31536000; includeSubDomains"
    http-response set-header X-Frame-Options "SAMEORIGIN"
    http-response set-header X-Content-Type-Options "nosniff"
    http-response set-header X-XSS-Protection "1; mode=block"

    default_backend web_backend

Bloquer des IPs malveillantes

Utilisez une ACL pour bloquer des IPs spécifiques :

frontend http_front
    bind *:80

    # Liste noire d'IPs (fichier externe)
    acl blocked_ips src -f /etc/haproxy/blocked_ips.txt
    http-request deny if blocked_ips

    default_backend web_backend

Contenu de /etc/haproxy/blocked_ips.txt :

192.168.1.100
10.0.0.0/8

Monitoring et logs

Page de statistiques

La page de stats intégrée fournit une vue en temps réel :

listen stats
    bind *:8404
    stats enable
    stats uri /stats
    stats refresh 10s
    stats show-legends
    stats show-node
    stats admin if LOCALHOST

Accédez à http://votre-ip:8404/stats pour voir :

• L’état de chaque backend (UP/DOWN)
• Le nombre de connexions actives
• Les taux de requêtes
• Les temps de réponse

Logs au format JSON (HAProxy 3.0+)

HAProxy 3.0 permet de formater les logs en JSON pour une meilleure intégration avec des outils comme ELK ou Loki :

defaults
    mode http
    log-format "%{+json}o %(client_ip)ci %(status)ST %(bytes)B %(duration)Ta %(backend)b %(server)s"

Intégration Prometheus

Exposez des métriques au format Prometheus :

frontend prometheus
    bind *:8405
    http-request use-service prometheus-exporter if { path /metrics }
    stats enable
    stats uri /stats

Configurez ensuite Prometheus pour scraper http://haproxy:8405/metrics.

Dépannage

Problèmes courants

Symptôme	Cause probable	Solution
”bind: cannot bind socket”	Port déjà utilisé	Vérifiez avec ss -tlnp | grep 80
Serveur DOWN dans les stats	Health check échoue	Vérifiez que l’endpoint /health répond 200
Pas de load balancing	Un seul serveur UP	Vérifiez les health checks des autres serveurs
Erreur 503	Tous les serveurs DOWN	Vérifiez la connectivité réseau aux backends
Cookie de session qui change	Mauvaise config cookie	Vérifiez le paramètre cookie sur chaque server

Glissez pour voir

Commandes utiles

# Vérifier la configuration
sudo haproxy -c -f /etc/haproxy/haproxy.cfg

# Recharger sans interruption (hitless reload)
sudo systemctl reload haproxy

# Voir les logs en temps réel
sudo journalctl -u haproxy -f

# Vérifier les ports d'écoute
ss -tlnp | grep haproxy

# Tester une requête avec verbose
curl -v http://localhost/

Mode diagnostic (HAProxy 3.0+)

Lancez HAProxy en mode diagnostic pour détecter les problèmes de configuration :

haproxy -dD -f /etc/haproxy/haproxy.cfg

Cette option signale les directives problématiques sans empêcher le démarrage.

À retenir

1. HAProxy est un reverse proxy et load balancer qui répartit le trafic entre plusieurs serveurs pour assurer haute disponibilité et performance.

2. Les blocs frontend/backend séparent la réception du trafic (frontend) de sa distribution (backend).

3. Les health checks retirent automatiquement les serveurs défaillants du pool — toujours les activer avec check.

4. Les sticky sessions (cookies) maintiennent l’affinité client-serveur pour les applications avec état.

5. Le rate limiting protège vos backends contre les abus — configurez une stick-table avec des limites raisonnables.

6. Validez toujours la configuration avec haproxy -c avant de recharger.

7. La page de statistiques (port 8404) donne une vue temps réel de l’état de votre infrastructure.

Prochaines étapes

Traefik : reverse proxy moderne Découvrez Traefik, alternative cloud-native avec configuration automatique.

Comprendre les reverse proxies Concepts fondamentaux des reverse proxies et leurs cas d'usage.

Sécuriser SSH Durcissez l'accès SSH à vos serveurs HAProxy.

Documentation officielle HAProxy Référence complète de toutes les directives de configuration.

×

📖 Voir la documentation →