Tuning TCP/IP Linux : BBR, kernel parameters et optimisations réseau

Les paramètres réseau Linux par défaut visent la compatibilité, pas la performance. Pour des serveurs qui poussent du débit, ils laissent énormément de bande passante sur la table. Activer BBR, ajuster les buffers et adapter les paramètres kernel : voici comment récupérer ce débit et faire chuter la latence.

• Comprendre les goulots d'étranglement TCP
• Algorithme de congestion BBR vs CUBIC
• Optimisation des buffers TCP
• Paramètres sysctl essentiels (voir tuning kernel complet)
• Tuning spécifique par cas d'usage
• Benchmarking et validation (voir diagnostic réseau Linux)
• Conclusion (voir tuning performance général)

Limitations courantes :

1. Algorithme de congestion obsolète : CUBIC (défaut) n'est pas taillé pour les réseaux modernes
2. Buffers sous-dimensionnés : Limite le débit sur liens haute latence
3. Queue disciplines inadaptées : FIFO simple crée du bufferbloat
4. Paramètres kernel conservateurs : Conçus pour compatibilité, pas performance

Impact mesurable :

• Débit limité à 10-20 % de la capacité réelle
• Latence élevée sous charge (bufferbloat)
• Pertes de paquets inutiles
• Utilisation CPU excessive

Qu'est-ce que BBR ?

BBR (Bottleneck Bandwidth and Round-trip propagation time) est un algorithme de congestion TCP développé par Google qui :

• Mesure la bande passante disponible réelle
• Minimise la latence (pas de bufferbloat)
• Récupère rapidement après perte de paquets
• Fonctionne sur tous les types de réseaux (WiFi, cellulaire, satellite)

CUBIC (défaut Linux) :

• Basé sur les pertes de paquets comme signal de congestion
• Remplit les buffers → bufferbloat
• Lent à récupérer après perte

Activer BBR

# Vérifier la disponibilité (kernel 4.9+)
modprobe tcp_bbr
lsmod | grep bbr

# Activer temporairement
sysctl -w net.ipv4.tcp_congestion_control=bbr
sysctl -w net.core.default_qdisc=fq

# Activer de façon permanente
cat >> /etc/sysctl.d/99-bbr.conf << EOF
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr
EOF

sysctl -p /etc/sysctl.d/99-bbr.conf

# Vérifier l'activation
sysctl net.ipv4.tcp_congestion_control
# net.ipv4.tcp_congestion_control = bbr

ss -ti | grep bbr
# bbr wscale:7,7 rto:204 rtt:3.5/1.75 ato:40 mss:1448 pmtu:1500 rcvmss:1448 advmss:1448 cwnd:10 bytes_sent:123 bytes_acked:123 bytes_received:456 segs_out:3 segs_in:4 data_segs_out:1 data_segs_in:1 send 33.1Mbps lastsnd:1234 lastrcv:1234 lastack:1234 pacing_rate 66.3Mbps delivery_rate 33.1Mbps delivered:1 app_limited busy:12ms rcv_space:14600 rcv_ssthresh:64088 minrtt:3.5 snd_wnd:14600

Comparaison de performance

Test avec iperf3 :

# Serveur
iperf3 -s

# Client CUBIC
sysctl -w net.ipv4.tcp_congestion_control=cubic
iperf3 -c server_ip -t 60 -P 4

# Client BBR
sysctl -w net.ipv4.tcp_congestion_control=bbr
iperf3 -c server_ip -t 60 -P 4

Résultats typiques :

• Liens haute latence (>50ms) : BBR +40-60 % débit
• Liens avec pertes : BBR +200-300 % débit
• Latence sous charge : BBR -50-70 % (réduction bufferbloat)

Calcul de la taille optimale

Formule : Buffer optimal = Bande passante × RTT

Exemple : Lien 10 Gbps avec RTT de 20ms

10 Gbps = 1.25 GB/s
Buffer = 1.25 GB/s × 0.020s = 25 MB

Configuration des buffers

# /etc/sysctl.d/99-tcp-buffers.conf

# Buffers TCP de lecture (min, default, max en bytes)
net.ipv4.tcp_rmem = 4096 87380 33554432
# 4KB min, 85KB default, 32MB max

# Buffers TCP d'écriture
net.ipv4.tcp_wmem = 4096 65536 33554432
# 4KB min, 64KB default, 32MB max

# Buffer global max (pour tous les sockets)
net.core.rmem_max = 33554432  # 32 MB
net.core.wmem_max = 33554432  # 32 MB

# Buffer par défaut
net.core.rmem_default = 262144   # 256 KB
net.core.wmem_default = 262144   # 256 KB

# Activer l'auto-tuning TCP (important !)
net.ipv4.tcp_moderate_rcvbuf = 1

Pour serveurs 10G+ :

# Buffers encore plus larges
net.ipv4.tcp_rmem = 4096 87380 134217728  # 128 MB max
net.ipv4.tcp_wmem = 4096 65536 134217728  # 128 MB max
net.core.rmem_max = 134217728
net.core.wmem_max = 134217728

Optimisation des queues réseau

# Augmenter la queue du backlog (connexions en attente)
net.core.netdev_max_backlog = 5000

# SYN backlog (protection SYN flood)
net.ipv4.tcp_max_syn_backlog = 8192

# Socket listen backlog
net.core.somaxconn = 4096

Configuration complète haute performance

# /etc/sysctl.d/99-network-performance.conf

# === Algorithme de congestion ===
net.core.default_qdisc = fq
net.ipv4.tcp_congestion_control = bbr

# === Buffers TCP ===
net.ipv4.tcp_rmem = 4096 87380 67108864
net.ipv4.tcp_wmem = 4096 65536 67108864
net.core.rmem_max = 67108864
net.core.wmem_max = 67108864
net.core.rmem_default = 262144
net.core.wmem_default = 262144

# === Queues ===
net.core.netdev_max_backlog = 10000
net.ipv4.tcp_max_syn_backlog = 8192
net.core.somaxconn = 4096

# === TCP Keepalive ===
net.ipv4.tcp_keepalive_time = 600
net.ipv4.tcp_keepalive_intvl = 60
net.ipv4.tcp_keepalive_probes = 3

# === Fast Open (TFO) ===
net.ipv4.tcp_fastopen = 3
# 1 = client, 2 = server, 3 = both

# === Réutilisation des sockets TIME_WAIT ===
net.ipv4.tcp_tw_reuse = 1

# === Window Scaling ===
net.ipv4.tcp_window_scaling = 1

# === SACK (Selective Acknowledgment) ===
net.ipv4.tcp_sack = 1

# === Timestamps TCP ===
net.ipv4.tcp_timestamps = 1

# === MTU Probing (évite black holes) ===
net.ipv4.tcp_mtu_probing = 1

# === Augmenter le nombre de connexions en tracking ===
net.netfilter.nf_conntrack_max = 262144

# === Timeouts connection tracking ===
net.netfilter.nf_conntrack_tcp_timeout_established = 1200

# === IPv6 si utilisé ===
net.ipv6.conf.all.forwarding = 0
net.ipv6.conf.default.forwarding = 0

Appliquer :

sysctl -p /etc/sysctl.d/99-network-performance.conf

# Vérifier
sysctl -a | grep -E 'tcp_congestion|tcp_rmem|tcp_wmem|bbr'

Serveur Web (Nginx/Apache)

# Optimisé pour nombreuses connexions courtes

# Réutiliser TIME_WAIT rapidement
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 15

# Fast Open
net.ipv4.tcp_fastopen = 3

# Limite de connexions
net.core.somaxconn = 4096
net.ipv4.tcp_max_syn_backlog = 8192

# Keepalive court
net.ipv4.tcp_keepalive_time = 300

Nginx :

# /etc/nginx/nginx.conf
events {
    worker_connections 4096;
    use epoll;
    multi_accept on;
}

http {
    sendfile on;
    tcp_nopush on;
    tcp_nodelay on;
    keepalive_timeout 30;
    keepalive_requests 100;
}

Proxy/Load Balancer (HAProxy)

# Très nombreuses connexions simultanées

# Augmenter limites fichiers
fs.file-max = 2097152

# Connexions tracking
net.netfilter.nf_conntrack_max = 1048576

# Buffers larges
net.ipv4.tcp_rmem = 4096 87380 134217728
net.ipv4.tcp_wmem = 4096 65536 134217728

# TIME_WAIT agressif
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 10

HAProxy limits :

# /etc/security/limits.conf
haproxy soft nofile 1000000
haproxy hard nofile 1000000

Transfert de fichiers haute performance

# Optimisé pour gros transferts longue durée

# Buffers très larges
net.ipv4.tcp_rmem = 4096 262144 268435456  # 256 MB
net.ipv4.tcp_wmem = 4096 262144 268435456
net.core.rmem_max = 268435456
net.core.wmem_max = 268435456

# BBR obligatoire
net.ipv4.tcp_congestion_control = bbr

# Désactiver slow start après idle
net.ipv4.tcp_slow_start_after_idle = 0

VPN/Tunnel (Wireguard, OpenVPN)

# Optimisé pour overhead encapsulation

# MTU discovery
net.ipv4.tcp_mtu_probing = 1
net.ipv4.ip_no_pmtu_disc = 0

# Buffers moyens
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# BBR pour absorber la latence ajoutée
net.ipv4.tcp_congestion_control = bbr

Test de débit avec iperf3

# Serveur
iperf3 -s

# Client : test simple
iperf3 -c server_ip -t 60

# Test avec plusieurs flux parallèles
iperf3 -c server_ip -t 60 -P 10

# Test reverse (download)
iperf3 -c server_ip -t 60 -R

# Test avec fenêtre spécifique
iperf3 -c server_ip -t 60 -w 4M

Test de latence sous charge

# Terminal 1 : Générer du trafic
iperf3 -c server_ip -t 300

# Terminal 2 : Mesurer latence
ping -i 0.2 server_ip

# Résultats attendus avec BBR :
# - CUBIC : latence passe de 5ms à 200ms sous charge
# - BBR : latence reste 5-15ms sous charge

Monitoring en production

# Script de monitoring TCP
#!/bin/bash
# tcp-monitor.sh

echo "=== TCP Stats ==="
ss -s

echo -e "\n=== Connexions par état ==="
ss -tan | awk '{print $1}' | sort | uniq -c | sort -rn

echo -e "\n=== Algorithme de congestion ==="
sysctl net.ipv4.tcp_congestion_control

echo -e "\n=== Retransmissions ==="
netstat -s | grep -i retrans

echo -e "\n=== Drops ==="
netstat -s | grep -i drop

Outils de diagnostic avancés

# Installation
apt install ethtool nicstat

# Statistiques carte réseau
ethtool -S eth0

# Drops hardware
ethtool -S eth0 | grep -i drop

# Débit temps réel
nicstat 1

# TCP windows et RTT
ss -ti

Débit limité malgré BBR

Vérifier :

# 1. BBR vraiment actif ?
ss -ti | grep bbr

# 2. Buffers suffisants ?
sysctl net.ipv4.tcp_rmem
sysctl net.ipv4.tcp_wmem

# 3. MTU optimal ?
ip link show eth0 | grep mtu
# Tester jumbo frames si réseau le supporte
ip link set eth0 mtu 9000

# 4. TSO/GSO activés ?
ethtool -k eth0 | grep segmentation
ethtool -K eth0 tso on gso on

Bufferbloat persistant

# Test bufferbloat
# Terminal 1
iperf3 -c server_ip -t 300

# Terminal 2
ping server_ip -i 0.2

# Si latence explose, vérifier :
sysctl net.core.default_qdisc
# Doit être "fq" pas "pfifo_fast"

# Forcer FQ queue
tc qdisc replace dev eth0 root fq

Drops et retransmissions

# Statistiques détaillées
nstat -az | grep -i tcp

# Si beaucoup de retransmissions :
# 1. Vérifier MTU path
tracepath server_ip

# 2. Augmenter buffers
sysctl -w net.ipv4.tcp_rmem="4096 131072 67108864"

# 3. Vérifier erreurs matérielles
ethtool -S eth0 | grep err

✅ Basique (tous serveurs) :

• BBR activé
• FQ queue discipline
• Buffers TCP ajustés (min 32MB max)
• TCP Fast Open
• Window scaling, SACK, timestamps

✅ Serveurs web :

• tcp_tw_reuse = 1
• tcp_fin_timeout = 15
• somaxconn = 4096
• Nginx : worker_connections 4096

✅ Haute performance :

• Buffers 128-256 MB
• Jumbo frames (MTU 9000)
• TSO/GSO activés
• IRQ balancing
• CPU affinity

✅ Monitoring :

• iperf3 benchmarks
• Latence sous charge
• ss -s quotidien
• Drops/retransmissions

Le tuning TCP/IP sur Linux paie vite : BBR réduit la latence de 50 à 70 % et augmente le débit de 40 à 200 % selon les conditions. Reste à dimensionner les buffers correctement et à coller les paramètres kernel au cas d'usage. C'est là que se joue le gain réel.

Actions prioritaires :

1. Activer BBR (kernel 4.9+)
2. Ajuster buffers TCP selon bande passante × RTT
3. Configurer FQ queue discipline
4. Activer TCP Fast Open
5. Benchmarker avant/après avec iperf3

Gains mesurables :

• Débit : +40 à +200 % selon le réseau
• Latence sous charge : -50 à -70 %
• Connexions simultanées : +300 %
• Retransmissions : -60 %