F. Courouge
Avancé
⭐ Article vedette

Optimisation des Performances Linux : Guide Complet pour la Production

Techniques avancées pour optimiser les performances de vos serveurs Linux en production : tuning kernel, gestion mémoire, I/O et monitoring.

Publié le
16 décembre 2024
Lecture
18 min
Vues
0
Auteur
Florian Courouge
Linux
Performance
Tuning
Kernel
Production
Monitoring

Table des matières

📋 Vue d'ensemble rapide des sujets traités dans cet article

Cliquez sur les sections ci-dessous pour naviguer rapidement

Optimisation des Performances Linux : Guide Complet pour la Production

L'optimisation des performances Linux est un art qui combine compréhension théorique et expérience pratique. Dans cet article, nous explorerons les techniques avancées pour maximiser les performances de vos serveurs en production.

💡Architecture et Métriques Fondamentales

Comprendre les Goulots d'Étranglement

Les performances d'un système Linux dépendent de quatre ressources principales :

CPU (Processeur)

  • •Utilisation et saturation
  • •Context switches
  • •Interruptions
  • •Load average

Mémoire (RAM)

  • •Utilisation physique vs virtuelle
  • •Cache et buffers
  • •Swap et paging
  • •Memory leaks

Stockage (I/O)

  • •Latence et débit
  • •Queue depth
  • •IOPS (Input/Output Operations Per Second)
  • •Fragmentation

Réseau

  • •Bande passante
  • •Latence
  • •Packet loss
  • •Buffer overflows

Outils de Monitoring Essentiels

# Monitoring CPU
top -p $(pgrep -d',' java)
htop
sar -u 1 10

# Monitoring Mémoire
free -h
vmstat 1 10
cat /proc/meminfo

# Monitoring I/O
iostat -x 1 10
iotop
lsof +D /var/log

# Monitoring Réseau
iftop
netstat -i
ss -tuln

# Monitoring Global
dstat -cdngy
atop

💡Optimisation du Kernel Linux

Paramètres Sysctl Critiques

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

# === NETWORK PERFORMANCE ===
# Augmenter les buffers réseau
net.core.rmem_default = 262144
net.core.rmem_max = 16777216
net.core.wmem_default = 262144
net.core.wmem_max = 16777216

# TCP tuning
net.ipv4.tcp_rmem = 4096 65536 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216
net.ipv4.tcp_congestion_control = bbr
net.ipv4.tcp_slow_start_after_idle = 0

# Réduire les timeouts
net.ipv4.tcp_fin_timeout = 30
net.ipv4.tcp_keepalive_time = 1200
net.ipv4.tcp_keepalive_probes = 7
net.ipv4.tcp_keepalive_intvl = 30

# === MEMORY MANAGEMENT ===
# Swappiness (0-100, plus bas = moins de swap)
vm.swappiness = 10

# Dirty pages (cache d'écriture)
vm.dirty_background_ratio = 5
vm.dirty_ratio = 10
vm.dirty_expire_centisecs = 12000
vm.dirty_writeback_centisecs = 1200

# === FILE SYSTEM ===
# Augmenter les limites de fichiers
fs.file-max = 2097152
fs.nr_open = 1048576

# === KERNEL ===
# Shared memory
kernel.shmmax = 68719476736
kernel.shmall = 4294967296

# Appliquer les changements
sysctl -p /etc/sysctl.d/99-performance.conf

Optimisation du Scheduler

# Vérifier le scheduler actuel
cat /sys/block/sda/queue/scheduler

# Pour SSD : noop ou deadline
echo noop > /sys/block/sda/queue/scheduler

# Pour HDD : cfq ou deadline
echo deadline > /sys/block/sda/queue/scheduler

# Rendre permanent dans /etc/default/grub
GRUB_CMDLINE_LINUX="elevator=deadline"

💡Gestion Avancée de la Mémoire

Analyse des Fuites Mémoire

# Script de monitoring mémoire
#!/bin/bash
# memory-monitor.sh

LOG_FILE="/var/log/memory-monitor.log"
THRESHOLD=80  # Seuil d'alerte en %

while true; do
    TIMESTAMP=$(date '+%Y-%m-%d %H:%M:%S')
    
    # Récupérer les stats mémoire
    TOTAL=$(free | grep Mem | awk '{print $2}')
    USED=$(free | grep Mem | awk '{print $3}')
    AVAILABLE=$(free | grep Mem | awk '{print $7}')
    
    USAGE_PERCENT=$((USED * 100 / TOTAL))
    
    echo "[$TIMESTAMP] Memory: ${USAGE_PERCENT}% used" >> $LOG_FILE
    
    if [ $USAGE_PERCENT -gt $THRESHOLD ]; then
        echo "[$TIMESTAMP] ALERT: High memory usage!" >> $LOG_FILE
        
        # Top 10 des processus consommateurs
        ps aux --sort=-%mem | head -11 >> $LOG_FILE
        
        # Analyser les caches
        echo "Cache analysis:" >> $LOG_FILE
        cat /proc/meminfo | grep -E "(Cached|Buffers|Slab)" >> $LOG_FILE
    fi
    
    sleep 60
done

Optimisation des Huge Pages

# Vérifier le support des huge pages
grep -i hugepage /proc/meminfo

# Configurer les huge pages
echo 1024 > /proc/sys/vm/nr_hugepages

# Rendre permanent
echo 'vm.nr_hugepages = 1024' >> /etc/sysctl.conf

# Pour les applications Java/Kafka
echo 'vm.hugetlb_shm_group = 1001' >> /etc/sysctl.conf

💡Optimisation du Système de Fichiers

Choix et Configuration du FS

# Ext4 optimisé pour les performances
mkfs.ext4 -F -O ^has_journal /dev/sdb1

# XFS pour les gros volumes
mkfs.xfs -f -s size=4096 /dev/sdc1

# Options de montage optimisées
# /etc/fstab
/dev/sdb1 /data ext4 noatime,nodiratime,nobarrier,data=writeback 0 0
/dev/sdc1 /logs xfs noatime,nodiratime,nobarrier,logbufs=8,logbsize=256k 0 0

Monitoring I/O Avancé

# Script d'analyse I/O
#!/bin/bash
# io-analysis.sh

echo "=== I/O Performance Analysis ==="

# Latence par device
for device in $(lsblk -d -o NAME | tail -n +2); do
    echo "Device: $device"
    
    # Statistiques actuelles
    iostat -x 1 3 | grep $device | tail -1
    
    # Queue depth
    cat /sys/block/$device/queue/nr_requests
    
    # Scheduler
    cat /sys/block/$device/queue/scheduler
    
    echo "---"
done

# Top des processus I/O
echo "Top I/O processes:"
iotop -b -n 1 | head -20

# Analyse des fichiers ouverts
echo "Open files by process:"
lsof | awk '{print $2}' | sort | uniq -c | sort -nr | head -10

💡Optimisation Réseau

Configuration Avancée TCP

# Script d'optimisation réseau
#!/bin/bash
# network-tuning.sh

echo "=== Network Performance Tuning ==="

# Augmenter les buffers de réception
echo 'net.core.netdev_max_backlog = 5000' >> /etc/sysctl.conf

# Optimiser TCP
cat >> /etc/sysctl.conf << EOF
# TCP Window Scaling
net.ipv4.tcp_window_scaling = 1

# TCP Selective Acknowledgments
net.ipv4.tcp_sack = 1

# TCP Timestamps
net.ipv4.tcp_timestamps = 1

# TCP SYN cookies (protection DDoS)
net.ipv4.tcp_syncookies = 1

# Réduire les retransmissions
net.ipv4.tcp_retries2 = 5
EOF

# Appliquer
sysctl -p

# Monitoring réseau en temps réel
watch -n 1 'cat /proc/net/dev'

Optimisation des Interruptions

# Vérifier la distribution des interruptions
cat /proc/interrupts

# Script d'équilibrage IRQ
#!/bin/bash
# irq-balance.sh

# Désactiver irqbalance pour contrôle manuel
systemctl stop irqbalance
systemctl disable irqbalance

# Identifier les IRQ réseau
NETWORK_IRQS=$(grep eth0 /proc/interrupts | cut -d: -f1 | tr -d ' ')

# Distribuer sur les CPUs
CPU_COUNT=$(nproc)
i=0

for irq in $NETWORK_IRQS; do
    cpu=$((i % CPU_COUNT))
    echo $((2**cpu)) > /proc/irq/$irq/smp_affinity
    echo "IRQ $irq -> CPU $cpu"
    ((i++))
done

💡Monitoring et Alerting

Dashboard de Performance

#!/bin/bash
# performance-dashboard.sh

LOGFILE="/var/log/performance.log"

while true; do
    clear
    echo "=== PERFORMANCE DASHBOARD ==="
    echo "Timestamp: $(date)"
    echo
    
    # CPU
    echo "=== CPU ==="
    CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
    LOAD_AVG=$(uptime | awk -F'load average:' '{print $2}')
    echo "CPU Usage: ${CPU_USAGE}%"
    echo "Load Average:${LOAD_AVG}"
    
    # Memory
    echo
    echo "=== MEMORY ==="
    free -h | grep -E "(Mem|Swap)"
    
    # Disk I/O
    echo
    echo "=== DISK I/O ==="
    iostat -x 1 1 | grep -E "(Device|sd|nvme)" | tail -5
    
    # Network
    echo
    echo "=== NETWORK ==="
    ss -tuln | wc -l | xargs echo "Active connections:"
    
    # Top processes
    echo
    echo "=== TOP PROCESSES ==="
    ps aux --sort=-%cpu | head -6
    
    # Log critical metrics
    echo "$(date),$CPU_USAGE,$LOAD_AVG" >> $LOGFILE
    
    sleep 5
done

Alerting Automatisé

#!/bin/bash
# performance-alerts.sh

# Configuration
CPU_THRESHOLD=80
MEMORY_THRESHOLD=85
DISK_THRESHOLD=90
LOAD_THRESHOLD=4.0

# Fonction d'alerte
send_alert() {
    local message="$1"
    echo "ALERT: $message" | logger -t performance-monitor
    
    # Envoyer par email (optionnel)
    # echo "$message" | mail -s "Performance Alert" admin@example.com
    
    # Webhook Slack/Teams (optionnel)
    # curl -X POST -H 'Content-type: application/json' \
    #   --data "{\"text\":\"$message\"}" \
    #   YOUR_WEBHOOK_URL
}

# Vérifications
check_cpu() {
    CPU_USAGE=$(top -bn1 | grep "Cpu(s)" | awk '{print $2}' | cut -d'%' -f1)
    if (( $(echo "$CPU_USAGE > $CPU_THRESHOLD" | bc -l) )); then
        send_alert "High CPU usage: ${CPU_USAGE}%"
    fi
}

check_memory() {
    MEMORY_USAGE=$(free | grep Mem | awk '{printf "%.1f", $3/$2 * 100.0}')
    if (( $(echo "$MEMORY_USAGE > $MEMORY_THRESHOLD" | bc -l) )); then
        send_alert "High memory usage: ${MEMORY_USAGE}%"
    fi
}

check_disk() {
    df -h | awk 'NR>1 {print $5 " " $6}' | while read output; do
        usage=$(echo $output | awk '{print $1}' | cut -d'%' -f1)
        partition=$(echo $output | awk '{print $2}')
        if [ $usage -gt $DISK_THRESHOLD ]; then
            send_alert "High disk usage: ${usage}% on ${partition}"
        fi
    done
}

check_load() {
    LOAD_1MIN=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | cut -d',' -f1)
    if (( $(echo "$LOAD_1MIN > $LOAD_THRESHOLD" | bc -l) )); then
        send_alert "High load average: $LOAD_1MIN"
    fi
}

# Exécution des vérifications
check_cpu
check_memory
check_disk
check_load

💡Cas d'Usage Spécifiques

Optimisation pour Kafka

# Optimisations spécifiques pour Kafka
cat >> /etc/sysctl.conf << EOF
# Kafka optimizations
vm.max_map_count = 262144
vm.dirty_background_ratio = 5
vm.dirty_ratio = 60
vm.dirty_expire_centisecs = 12000
vm.swappiness = 1

# Network for Kafka
net.core.rmem_default = 262144
net.core.rmem_max = 134217728
net.core.wmem_default = 262144
net.core.wmem_max = 134217728
net.ipv4.tcp_window_scaling = 1
net.ipv4.tcp_max_syn_backlog = 40000
net.core.netdev_max_backlog = 50000
EOF

Optimisation pour Elasticsearch

# Optimisations pour Elasticsearch
echo 'vm.max_map_count = 262144' >> /etc/sysctl.conf
echo '* soft nofile 65536' >> /etc/security/limits.conf
echo '* hard nofile 65536' >> /etc/security/limits.conf
echo 'elasticsearch soft memlock unlimited' >> /etc/security/limits.conf
echo 'elasticsearch hard memlock unlimited' >> /etc/security/limits.conf

💡Automatisation et Maintenance

Script de Maintenance Automatique

#!/bin/bash
# system-maintenance.sh

LOG_FILE="/var/log/maintenance.log"

log_message() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a $LOG_FILE
}

log_message "Starting system maintenance..."

# Nettoyage des logs
log_message "Cleaning old logs..."
find /var/log -name "*.log" -mtime +30 -delete
journalctl --vacuum-time=30d

# Nettoyage du cache
log_message "Cleaning caches..."
sync && echo 3 > /proc/sys/vm/drop_caches

# Vérification de l'espace disque
log_message "Checking disk space..."
df -h | awk 'NR>1 {if($5+0 > 90) print "WARNING: " $6 " is " $5 " full"}'

# Mise à jour des statistiques
log_message "Updating system statistics..."
updatedb
mandb

# Optimisation des bases de données
log_message "Optimizing databases..."
if systemctl is-active --quiet mysql; then
    mysqlcheck --optimize --all-databases
fi

log_message "Maintenance completed."

💡Conclusion

L'optimisation des performances Linux est un processus continu qui nécessite :

Monitoring Constant

Approche Méthodique

Adaptation aux Workloads

Maintenance Préventive

Les techniques présentées dans cet article vous permettront d'optimiser significativement les performances de vos serveurs Linux en production. N'oubliez pas que chaque environnement est unique et nécessite une approche adaptée.

Pour un accompagnement personnalisé dans l'optimisation de vos infrastructures Linux, n'hésitez pas à me contacter pour une consultation.

À propos de l'auteur

Florian Courouge - Expert DevOps et Apache Kafka avec plus de 5 ans d'expérience dans l'architecture de systèmes distribués et l'automatisation d'infrastructures.

Cet article vous a été utile ?

Découvrez mes autres articles techniques ou contactez-moi pour discuter de vos projets DevOps et Kafka.