HAProxy : Load balancing et haute disponibilité

Prérequis

• Système d'exploitation : Debian 12+, Ubuntu 22.04+ ou CentOS/RHEL 8+
• Privilèges : Accès root ou sudo
• Réseau : Au moins 2 serveurs backend pour tester le load balancing
• Ressources : 1 vCPU, 512 Mo RAM minimum (HAProxy est très léger)
• Ports : 80, 443 disponibles sur le serveur HAProxy

Installation

Installation via les dépôts (Debian/Ubuntu)

La méthode la plus simple pour installer HAProxy sur Debian ou Ubuntu :

sudo apt update
sudo apt install -y haproxy

Vérifiez la version installée :

haproxy -v

Installation depuis le PPA officiel (version récente)

Pour obtenir une version plus récente avec les dernières fonctionnalités :

sudo apt install -y software-properties-common
sudo add-apt-repository ppa:vbernat/haproxy-2.8 -y
sudo apt update
sudo apt install -y haproxy=2.8.*

Compilation depuis les sources

Pour un contrôle total sur les options de compilation :

# Dépendances de compilation
sudo apt install -y build-essential libssl-dev libpcre3-dev zlib1g-dev

# Téléchargement et compilation
wget https://www.haproxy.org/download/2.8/src/haproxy-2.8.5.tar.gz
tar xzf haproxy-2.8.5.tar.gz
cd haproxy-2.8.5

make TARGET=linux-glibc USE_OPENSSL=1 USE_PCRE=1 USE_ZLIB=1
sudo make install

Activez et démarrez le service :

sudo systemctl enable haproxy
sudo systemctl start haproxy
sudo systemctl status haproxy

Architecture HAProxy

HAProxy repose sur trois composants principaux qui définissent le flux du trafic :

• Frontend : Point d'entrée du trafic. Il définit l'adresse et le port d'écoute, le protocole (HTTP/TCP) et les règles de routage vers les backends.
• Backend : Groupe de serveurs qui reçoivent le trafic. Il définit l'algorithme de répartition, les health checks et la liste des serveurs cibles.
• Listen : Combinaison d'un frontend et d'un backend dans un seul bloc. Pratique pour les configurations simples.

                   +-----------+
  Client --------->| Frontend  |
                   | (port 80) |
                   +-----+-----+
                         |
                    ACL / Routage
                    /          
           +-------+--+    +--+-------+
           | Backend  |    | Backend  |
           |   web    |    |   api    |
           +--+----+--+    +--+----+--+
              |    |          |    |
           srv1  srv2      srv3  srv4

Configuration de base

Le fichier de configuration principal se trouve dans /etc/haproxy/haproxy.cfg. Il est structuré en sections :

Section global

Paramètres système qui s'appliquent à l'ensemble du processus HAProxy :

global
    log /dev/log local0
    log /dev/log local1 notice
    chroot /var/lib/haproxy
    stats socket /run/haproxy/admin.sock mode 660 level admin
    stats timeout 30s
    user haproxy
    group haproxy
    daemon

    # Paramètres SSL
    ssl-default-bind-ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256
    ssl-default-bind-ciphersuites TLS_AES_128_GCM_SHA256:TLS_AES_256_GCM_SHA384
    ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets

Section defaults

Valeurs par défaut héritées par les frontends et backends :

defaults
    log     global
    mode    http
    option  httplog
    option  dontlognull
    timeout connect 5000
    timeout client  50000
    timeout server  50000
    errorfile 400 /etc/haproxy/errors/400.http
    errorfile 403 /etc/haproxy/errors/403.http
    errorfile 500 /etc/haproxy/errors/500.http
    errorfile 502 /etc/haproxy/errors/502.http
    errorfile 503 /etc/haproxy/errors/503.http
    errorfile 504 /etc/haproxy/errors/504.http

Load balancing HTTP

La configuration la plus courante consiste à répartir le trafic HTTP entre plusieurs serveurs web.

Configuration frontend et backend

frontend http_front
    bind *:80
    default_backend http_back

backend http_back
    balance roundrobin
    option httpchk GET /health
    http-check expect status 200
    server web1 192.168.1.10:80 check inter 3s fall 3 rise 2
    server web2 192.168.1.11:80 check inter 3s fall 3 rise 2
    server web3 192.168.1.12:80 check inter 3s fall 3 rise 2 backup

Algorithmes de répartition

HAProxy propose plusieurs algorithmes adaptés à différents cas d'usage :

# Roundrobin : distribution cyclique (défaut)
balance roundrobin

# Leastconn : serveur avec le moins de connexions actives
# Idéal pour les requêtes de durées variables
balance leastconn

# Source : affinité de session par IP source
# Le même client va toujours sur le même serveur
balance source

# URI : hash sur l'URI pour optimiser le cache
balance uri

# First : remplit un serveur avant de passer au suivant
# Utile pour réduire le nombre de serveurs actifs
balance first

Health checks HTTP

Les health checks vérifient que les serveurs backend sont opérationnels :

backend http_back
    balance roundrobin
    option httpchk GET /health
    http-check expect status 200

    # inter : intervalle entre checks (défaut 2s)
    # fall : nombre d'échecs avant de déclarer DOWN
    # rise : nombre de succès avant de déclarer UP
    server web1 192.168.1.10:80 check inter 3s fall 3 rise 2 weight 100
    server web2 192.168.1.11:80 check inter 3s fall 3 rise 2 weight 100

Load balancing TCP

HAProxy peut aussi répartir du trafic TCP brut pour des services comme MySQL, PostgreSQL ou Redis.

Load balancing MySQL (lectures)

listen mysql_cluster
    bind *:3306
    mode tcp
    balance leastconn
    option mysql-check user haproxy_check

    server mysql1 192.168.1.20:3306 check inter 5s fall 3 rise 2
    server mysql2 192.168.1.21:3306 check inter 5s fall 3 rise 2
    server mysql3 192.168.1.22:3306 check inter 5s fall 3 rise 2 backup

Load balancing Redis

listen redis_cluster
    bind *:6379
    mode tcp
    balance first
    option tcp-check

    tcp-check send PING

    tcp-check expect string +PONG

    server redis1 192.168.1.30:6379 check inter 3s fall 3 rise 2
    server redis2 192.168.1.31:6379 check inter 3s fall 3 rise 2

SSL/TLS Termination

HAProxy peut gérer la terminaison SSL pour décharger vos serveurs backend du traitement cryptographique.

Préparation du certificat

HAProxy nécessite un fichier PEM combinant le certificat et la clé privée :

# Combiner certificat + clé privée + chaîne intermédiaire
cat /etc/letsencrypt/live/example.com/fullchain.pem \
    /etc/letsencrypt/live/example.com/privkey.pem \
    > /etc/haproxy/certs/example.com.pem

# Sécuriser le fichier
chmod 600 /etc/haproxy/certs/example.com.pem

Configuration HTTPS avec redirection

frontend https_front
    bind *:80
    bind *:443 ssl crt /etc/haproxy/certs/example.com.pem

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

    # Headers de sécurité
    http-response set-header Strict-Transport-Security "max-age=31536000; includeSubDomains"

    default_backend http_back

backend http_back
    balance roundrobin
    # Transmettre l'IP réelle du client
    option forwardfor
    http-request set-header X-Forwarded-Proto https if { ssl_fc }

    server web1 192.168.1.10:80 check
    server web2 192.168.1.11:80 check

ACLs et Routage

Les ACLs (Access Control Lists) permettent de router le trafic de manière conditionnelle selon divers critères.

Routage par nom de domaine

frontend http_front
    bind *:80

    # ACLs basées sur le Host header
    acl is_api hdr(host) -i api.example.com
    acl is_app hdr(host) -i app.example.com
    acl is_static hdr(host) -i static.example.com

    # Routage vers les backends correspondants
    use_backend api_back if is_api
    use_backend app_back if is_app
    use_backend static_back if is_static
    default_backend app_back

Routage par chemin URL

frontend http_front
    bind *:80

    # ACLs basées sur le chemin
    acl is_api path_beg /api/
    acl is_admin path_beg /admin/
    acl is_websocket hdr(Upgrade) -i websocket

    use_backend api_back if is_api
    use_backend admin_back if is_admin
    use_backend ws_back if is_websocket
    default_backend web_back

Routage par header et méthode HTTP

frontend http_front
    bind *:80

    # Routage par méthode HTTP
    acl is_post method POST
    acl is_get method GET

    # Routage par header personnalisé
    acl is_mobile hdr_sub(User-Agent) -i mobile
    acl is_json hdr(Accept) -i application/json

    use_backend api_write if is_post is_api
    use_backend api_read if is_get is_api
    use_backend mobile_back if is_mobile

Health Checks avancés

Les health checks permettent à HAProxy de détecter et retirer automatiquement les serveurs défaillants.

HTTP health checks

backend web_back
    option httpchk
    http-check send meth GET uri /health ver HTTP/1.1 hdr Host www.example.com
    http-check expect status 200

    # Check avec contenu attendu
    http-check expect string "status":"ok"

    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

TCP health checks personnalisés

backend smtp_back
    mode tcp
    option tcp-check

    tcp-check connect
    tcp-check expect string 220
    tcp-check send EHLO haproxy

    tcp-check expect string 250
    tcp-check send QUIT


    server smtp1 192.168.1.40:25 check

Options de health check

backend app_back
    # Vérification toutes les 5 secondes
    # DOWN après 3 échecs consécutifs
    # UP après 2 succès consécutifs
    server app1 192.168.1.10:8080 check inter 5s fall 3 rise 2

    # Serveur en mode drain (finit les sessions en cours)
    server app2 192.168.1.11:8080 check drain

    # Serveur de secours (activé uniquement si tous les autres sont DOWN)
    server app3 192.168.1.12:8080 check backup

    # Slowstart : montée progressive de la charge (60 secondes)
    server app4 192.168.1.13:8080 check slowstart 60s

Statistiques et Monitoring

HAProxy intègre une page de statistiques très complète pour surveiller l'état de votre infrastructure en temps réel.

Activation de la page stats

listen stats
    bind *:8404
    stats enable
    stats uri /stats
    stats refresh 10s
    stats admin if LOCALHOST
    stats auth admin:VotreMotDePasse

Accédez ensuite à http://votre-serveur:8404/stats pour visualiser les métriques.

Métriques disponibles

• Sessions : Connexions actives, totales, taux par seconde
• Bytes : Trafic entrant et sortant par serveur
• Status : État de chaque serveur (UP, DOWN, DRAIN, MAINT)
• Temps de réponse : Moyenne, max, percentiles
• Erreurs : Erreurs de connexion, timeouts, codes HTTP 4xx/5xx

Export Prometheus

HAProxy 2.x supporte nativement l'export de métriques au format Prometheus :

frontend prometheus
    bind *:8405
    http-request use-service prometheus-exporter if { path /metrics }
    no log

Haute disponibilité

Pour éviter que HAProxy lui-même ne devienne un point de défaillance unique (SPOF), déployez deux instances avec Keepalived.

Architecture actif/passif

              IP virtuelle (VIP)
              192.168.1.100
                    |
            +-------+-------+
            |               |
    +-------+---+   +---+-------+
    | HAProxy 1 |   | HAProxy 2 |
    |  (MASTER) |   |  (BACKUP) |
    +-----+-----+   +-----+-----+
          |               |
    +-----+-----+---------+-----+
    |           |               |
  srv1        srv2            srv3

Installation et configuration de Keepalived

sudo apt install -y keepalived

Configuration du nœud MASTER (/etc/keepalived/keepalived.conf) :

vrrp_script check_haproxy {
    script "/usr/bin/killall -0 haproxy"
    interval 2
    weight 2
}

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

    authentication {
        auth_type PASS
        auth_pass VotreMotDePasse
    }

    virtual_ipaddress {
        192.168.1.100/24
    }

    track_script {
        check_haproxy
    }
}

Configuration du nœud BACKUP (identique sauf) :

vrrp_instance VI_1 {
    state BACKUP
    priority 100
    # Le reste est identique au MASTER
}

# Démarrer Keepalived sur les deux noeuds
sudo systemctl enable keepalived
sudo systemctl start keepalived

# Vérifier que la VIP est active sur le MASTER
ip addr show eth0 | grep 192.168.1.100

Sécurisation

Rate limiting

Protégez vos backends contre les abus en limitant le nombre de requêtes par IP :

frontend http_front
    bind *:80

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

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

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

Blacklist et whitelist

frontend http_front
    bind *:80

    # Blacklist par fichier
    acl is_blacklisted src -f /etc/haproxy/blacklist.txt
    http-request deny if is_blacklisted

    # Whitelist pour l'administration
    acl is_admin_ip src 10.0.0.0/8
    acl is_admin_path path_beg /admin
    http-request deny if is_admin_path !is_admin_ip

Headers de sécurité

frontend http_front
    bind *:443 ssl crt /etc/haproxy/certs/example.com.pem

    # Headers de sécurité
    http-response set-header X-Frame-Options DENY
    http-response set-header X-Content-Type-Options nosniff
    http-response set-header X-XSS-Protection "1; mode=block"
    http-response set-header Referrer-Policy strict-origin-when-cross-origin
    http-response set-header Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"

    # Masquer la version du serveur backend
    http-response del-header Server

Troubleshooting

Vérification de la configuration

# Valider la syntaxe de la configuration
sudo haproxy -c -f /etc/haproxy/haproxy.cfg

# Recharger sans interruption de service
sudo systemctl reload haproxy

Commandes de diagnostic

# Consulter les logs HAProxy
sudo journalctl -u haproxy -f

# Vérifier les ports en écoute
sudo ss -tlnp | grep haproxy

# Interagir avec la socket d'administration
echo "show stat" | sudo socat stdio /run/haproxy/admin.sock

# Afficher l'état des backends
echo "show servers state" | sudo socat stdio /run/haproxy/admin.sock

# Désactiver un serveur pour maintenance
echo "disable server http_back/web1" | sudo socat stdio /run/haproxy/admin.sock

# Réactiver un serveur
echo "enable server http_back/web1" | sudo socat stdio /run/haproxy/admin.sock

Erreurs courantes

• 503 Service Unavailable : Tous les serveurs backend sont DOWN. Vérifiez les health checks et la connectivité réseau.
• 502 Bad Gateway : Le backend répond mais avec une erreur. Vérifiez les logs du serveur applicatif.
• 408 Request Timeout : Le client ou le backend est trop lent. Augmentez les valeurs timeout client ou timeout server.
• Connection refused : Vérifiez que le service backend écoute bien sur le port configuré.

Conclusion

HAProxy est un outil essentiel pour toute infrastructure qui nécessite de la répartition de charge et de la haute disponibilité. Avec ce tutoriel, vous disposez des connaissances pour :

• Installer et configurer HAProxy sur un serveur Linux
• Répartir le trafic HTTP et TCP entre plusieurs serveurs
• Mettre en place la terminaison SSL/TLS
• Router le trafic avec des ACLs conditionnelles
• Surveiller votre infrastructure via les statistiques intégrées
• Assurer la haute disponibilité avec Keepalived
• Sécuriser votre load balancer avec du rate limiting et des headers

Pour aller plus loin, explorez les fonctionnalités avancées de HAProxy comme le support du protocole PROXY, les maps dynamiques, les Lua scripts pour la logique personnalisée, et le multithreading pour exploiter pleinement les serveurs multi-coeurs.