Planification de capacité Linux avec exemples pratiques : guide hands-on

Intro

La planification de capacité sous Linux consiste à garantir que vos systèmes disposent de suffisamment de ressources pour gérer les charges de travail actuelles et futures sans surprovisionnement ni sous-provisionnement. C'est un cycle continu d'observation, de mesure et d'ajustement des ressources telles que le CPU, la mémoire, les E/S disque et la bande passante réseau. Ce guide fournit des exemples pratiques, des commandes et des stratégies pour les développeurs, les ingénieurs DevOps et les équipes techniques de startups qui doivent maintenir des systèmes Linux fiables et rentables.

L'objectif est la sécurité opérationnelle : observer avant de changer, limiter le rayon d'impact de toute modification, utiliser des valeurs fictives plutôt que de vrais secrets, vérifier chaque changement et documenter les chemins de récupération. À la fin de cet article, vous serez en mesure d'inventorier votre environnement, de surveiller les ressources clés, de configurer des limites sûres, de diagnostiquer les problèmes, de récupérer après des échecs et de suivre une liste de contrôle opérationnelle adaptée à la planification de capacité Linux.

Nous utiliserons des outils Linux standard tels que top, vmstat, iostat, free, df, ss et les fonctionnalités de systemd, ainsi que des exemples pratiques que vous pourrez adapter à votre environnement. Tous les exemples utilisent des valeurs fictives (par exemple, your-app, your-service) que vous devez remplacer par vos propres noms. N'utilisez jamais de vrais identifiants, jetons ou clés privées dans les scripts ou fichiers de configuration montrés dans les articles ou les environnements partagés.

Inventaire de la version et de l'environnement

Avant d'apporter des modifications de capacité, vous devez savoir exactement avec quoi vous travaillez. Commencez par identifier la distribution Linux, la version du noyau, les services pertinents et leur utilisation actuelle des ressources. Cette observation en lecture seule établit une base de référence et vous permet de détecter les changements au fil du temps.

1. Identifier le système et le noyau

Exécutez ces commandes pour obtenir la distribution et la version du noyau :

cat /etc/os-release
uname -a

Exemple de sortie :

PRETTY_NAME="Ubuntu 22.04.3 LTS"
...
Linux your-host 5.15.0-91-generic #101-Ubuntu SMP ... x86_64 GNU/Linux

Cela vous indique la version du système d'exploitation et du noyau, ce qui est important car certains paramètres de réglage (comme les réglages sysctl) et outils diffèrent selon les versions du noyau.

2. Lister les services en cours d'exécution et les consommateurs de ressources

Identifiez les services en cours d'exécution et leur empreinte en ressources. Utilisez systemctl pour lister les services actifs :

systemctl list-units --type=service --state=running

Pour voir les principaux processus par CPU et mémoire en temps réel, utilisez top ou ps :

top -b -n 1 | head -20

La sortie affichera quelque chose comme :

top - 14:32:11 up 12 days,  3:04,  2 users,  load average: 0.85, 0.70, 0.65
Tasks: 187 total,   1 running, 186 sleeping,   0 stopped,   0 zombie
%Cpu(s):  1.2 us,  0.6 sy,  0.0 ni, 97.9 id,  0.3 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :  15886.7 total,   1024.5 free,   5102.3 used,   9759.9 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.  10123.4 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
    871 mysql     20   0 2169124 451236  14208 S  12.5   2.8  123:45.67 mysqld

Cet instantané montre la charge moyenne, l'inactivité du CPU, l'utilisation de la mémoire et quel processus consomme le plus de ressources. Dans cet exemple, mysqld utilise 12,5 % du CPU et 2,8 % de la mémoire, ce qui suggère que la base de données pourrait nécessiter une attention pour la planification de capacité.

3. Capturer l'état actuel avec des horodatages

Enregistrez toujours l'état actuel avec des horodatages pour une comparaison future. Par exemple, créez un fichier de base :

date >> /var/log/capacity-baseline.txt
free -h >> /var/log/capacity-baseline.txt
vmstat 1 5 >> /var/log/capacity-baseline.txt

Cela ajoute un horodatage et des statistiques de mémoire/CPU à un fichier journal. Plus tard, après des changements, vous pouvez exécuter les mêmes commandes et comparer les résultats.

Prérequis : Assurez-vous d'avoir un accès en lecture au système et les autorisations nécessaires pour exécuter ces commandes (généralement root ou sudo pour certains fichiers). Rayon d'impact : Ces commandes sont en lecture seule ; elles ne modifient pas l'état du système. Résultat attendu : Vous devriez voir une liste de services et une utilisation des ressources qui correspondent à vos attentes. Signal d'échec : Si un service est absent de la liste ou si l'utilisation des ressources est inhabituellement élevée, enquêtez avant de continuer.

Chemin de configuration sûr

Lorsque vous devez ajuster la capacité, suivez un chemin sûr : apportez de petits changements réversibles avec vérification à chaque étape. Voici les domaines courants où vous pouvez affiner en toute sécurité la capacité Linux.

1. Ajuster les limites du système avec sysctl

Les paramètres du noyau Linux peuvent être ajustés à l'exécution en utilisant sysctl. Par exemple, pour augmenter le nombre maximal de descripteurs de fichiers (utile pour les serveurs web très sollicités), vous pouvez modifier fs.file-max.

D'abord, vérifiez la valeur actuelle :

sysctl fs.file-max

Sortie :

fs.file-max = 9223372036854775807

C'est la limite à l'échelle du système. Pour l'augmenter (si nécessaire), modifiez /etc/sysctl.conf ou un fichier dans /etc/sysctl.d/ et ajoutez ou modifiez :

fs.file-max = 2097152

Puis appliquez le changement :

sudo sysctl -p

Vérifiez :

sysctl fs.file-max

Sortie attendue : fs.file-max = 2097152.

Rayon d'impact : Ce changement affecte tout le système mais est généralement sûr si vous ne définissez pas une valeur extrêmement basse. Récupération : Pour revenir en arrière, restaurez la valeur d'origine et exécutez à nouveau sysctl -p.

2. Configurer les limites utilisateur et processus avec ulimit

Pour des limites de ressources par utilisateur ou par processus, utilisez ulimit ou configurez limits.conf. Par exemple, pour définir une limite souple sur le nombre de fichiers ouverts pour un utilisateur, ajoutez à /etc/security/limits.conf :

your-user soft nofile 65536
your-user hard nofile 65536

Demandez à l'utilisateur de se déconnecter puis de se reconnecter, puis vérifiez :

ulimit -n

Attendu : 65536.

Prérequis : Vous avez besoin de root pour modifier limits.conf. Rayon d'impact : Affecte uniquement les nouvelles sessions de l'utilisateur spécifié. Récupération : Supprimez ou ajustez les lignes et demandez à l'utilisateur de se reconnecter.

3. Utiliser les contrôles de ressources de systemd

Si vos services sont gérés par systemd, vous pouvez définir des limites de ressources directement dans le fichier d'unité ou via systemctl set-property. Par exemple, pour limiter l'utilisation de la mémoire pour un service nommé your-service :

sudo systemctl set-property your-service MemoryMax=1G

Cela s'applique immédiatement et persiste après les redémarrages (cela crée un fichier drop-in). Vérifiez avec :

systemctl show your-service -p MemoryMax

Sortie attendue : MemoryMax=1073741824 (1 Gio en octets).

Pour revenir en arrière, exécutez :

sudo systemctl set-property your-service MemoryMax=infinity

Ou supprimez le fichier drop-in de /etc/systemd/system.control/.

Rayon d'impact : Affecte uniquement le service spécifié. Signal d'échec : Si le service tente de dépasser la limite, il peut être tué par le tueur OOM ; surveillez les journaux et ajustez en conséquence.

4. Ajuster la swappiness

La swappiness contrôle avec quelle agressivité le noyau échange les pages mémoire. Pour les systèmes avec suffisamment de RAM, vous pouvez réduire la swappiness pour diminuer les E/S disque inutiles. Vérifiez la valeur actuelle :

cat /proc/sys/vm/swappiness

La valeur par défaut est généralement 60. Pour la changer à 10, modifiez /etc/sysctl.conf :

vm.swappiness = 10

Appliquez et vérifiez comme précédemment. Rayon d'impact : Affecte la gestion de la mémoire à l'échelle du système mais est sûr pour la plupart des charges de travail. Récupération : Remettez la valeur d'origine (par exemple 60) et réappliquez.

Vérification et diagnostics

Après avoir apporté des modifications ou lorsque des problèmes surviennent, vous devez vérifier que la capacité est suffisante et diagnostiquer les goulots d'étranglement. Voici les domaines clés et les commandes.

1. Surveillance du CPU et charge moyenne

La charge moyenne indique le nombre de processus en attente de CPU. Utilisez uptime ou top :

uptime

Sortie :

 14:45:00 up 12 days,  3:17,  2 users,  load average: 1.10, 0.95, 0.80

Interprétation : Pour un système à un seul cœur, la charge moyenne devrait être inférieure à 1,00 pour éviter l'attente ; pour un système multi-cœurs, divisez par le nombre de cœurs. Si la charge moyenne dépasse constamment le nombre de cœurs CPU, recherchez quels processus consomment du CPU avec top ou pidstat :

pidstat 1 5

Cela montre l'utilisation du CPU par processus au fil du temps, aidant à identifier le coupable.

2. Utilisation de la mémoire et OOM

Vérifiez la mémoire avec free -h :

free -h

Exemple :

              total        used        free      shared  buff/cache   available
Mem:           15Gi       5.0Gi       1.0Gi        50Mi       9.0Gi        9.5Gi
Swap:         2.0Gi          0B       2.0Gi

Concentrez-vous sur la colonne available, qui estime la mémoire disponible pour les nouvelles applications. Si available est faible, vérifiez quels processus utilisent la mémoire avec ps aux --sort=-%mem | head. Surveillez également les tueries OOM (Out Of Memory) dans le journal du noyau :

dmesg | grep -i "out of memory"

Si des tueries OOM se produisent, envisagez d'augmenter la RAM, d'ajouter de l'espace d'échange ou d'ajuster la mémoire de l'application.

3. E/S disque et capacité de stockage

Utilisez iostat pour les statistiques d'E/S (installez sysstat si absent) :

iostat -xz 1 5

Regardez %util et await pour chaque périphérique. Un %util élevé (proche de 100 %) et un await élevé indiquent une saturation du disque. Pour la capacité de stockage, utilisez df -h :

df -h

Exemple :

Filesystem      Size  Used Avail Use% Mounted on
/dev/sda1        50G   40G   10G  80% /

Si un système de fichiers est rempli à plus de 80 %, planifiez un nettoyage ou une expansion.

4. Capacité réseau

Vérifiez le débit de l'interface réseau avec sar -n DEV (de sysstat) ou iftop. Pour un aperçu rapide, utilisez :

sar -n DEV 1 5

La sortie montre rxkB/s et txkB/s par interface. Comparez avec la bande passante maximale de l'interface (par exemple, 1 Gbit/s = ~125 Mo/s). Si la saturation est proche, envisagez un équilibrage de charge ou une mise à niveau.

Modes de défaillance et récupération

Même avec une planification minutieuse, des pannes surviennent. Voici les défaillances courantes liées à la capacité et les étapes de récupération.

1. Charge CPU élevée et réponse lente

Défaillance : La charge moyenne dépasse le nombre de cœurs CPU, les processus deviennent non réactifs. Diagnostic : Utilisez top pour trouver le processus fautif. Atténuation immédiate : Si c'est un processus hors de contrôle, vous pouvez temporairement réduire sa priorité avec renice :

sudo renice +10 -p <PID>

Ou, si c'est un service, redémarrez-le :

sudo systemctl restart your-service

Récupération à long terme : Identifiez la cause (par exemple, bug de code, CPU insuffisant), corrigez-la et envisagez d'ajouter des ressources CPU ou d'optimiser l'application.

2. Tueries OOM (Out Of Memory)

Défaillance : Des applications sont tuées par le tueur OOM. Diagnostic : Vérifiez les journaux :

dmesg | grep -i oom
journalctl -k | grep -i oom

Atténuation immédiate : Si un service a été tué, redémarrez-le. Pour éviter une récurrence immédiate, réduisez temporairement l'utilisation de la mémoire en arrêtant les services non critiques ou en augmentant l'espace d'échange :

sudo fallocate -l 2G /swapfile
sudo chmod 600 /swapfile
sudo mkswap /swapfile
sudo swapon /swapfile

Récupération à long terme : Ajustez la mémoire de l'application, ajustez les limites de mémoire de systemd ou ajoutez de la RAM physique.

3. Disque plein

Défaillance : Plus d'espace sur le périphérique. Diagnostic : df -h montre 100 % d'utilisation. Trouvez les gros fichiers :

sudo du -ah / | sort -rh | head -20

Atténuation immédiate : Supprimez ou compressez les gros fichiers journaux, videz le cache des paquets (sudo apt clean ou sudo yum clean all). Récupération à long terme : Mettez en place la rotation des journaux (logrotate), surveillez l'utilisation du disque et étendez le stockage si nécessaire.

4. Saturation du réseau

Défaillance : Perte de paquets élevée ou latence, interface au débit maximal. Diagnostic : Utilisez sar -n DEV pour voir le débit ; utilisez ping et traceroute pour tester. Atténuation immédiate : Limitez la bande passante des services non critiques avec tc (contrôle du trafic) ou suspendez les travaux lourds. Récupération à long terme : Mettez à niveau le matériel réseau, utilisez des équilibreurs de charge ou optimisez le transfert de données.

Pour toutes les défaillances, documentez l'incident, les mesures prises et la vérification de récupération. Cela vous permettra de gérer des problèmes similaires plus rapidement à l'avenir.

Liste de contrôle des opérations

Utilisez cette liste de contrôle pour chaque tâche de planification de capacité sur Linux afin de garantir sécurité et efficacité.

Cette liste de contrôle peut être adaptée et automatisée. Par exemple, vous pouvez créer un script qui recueille toutes les données de surveillance et alerte en cas de défaillance.

Conclusion

La planification de capacité Linux n'est pas une tâche ponctuelle mais une pratique continue. En inventoriant votre environnement, en surveillant les ressources clés, en ajustant les limites en toute sécurité, en diagnostiquant les problèmes et en vous préparant aux pannes, vous pouvez maintenir vos systèmes fluides et rentables.

Rappelez-vous de toujours observer avant de changer, d'utiliser des commandes en lecture seule pour les bases de référence, de protéger les données sensibles avec des valeurs fictives, de limiter le rayon d'impact de tout changement, de vérifier les résultats avec des commandes concrètes et de documenter les chemins de récupération.

Commencez par une vérification à faible risque sur un système de test : capturez la base de référence actuelle du CPU et de la mémoire, surveillez-la pendant une journée, puis identifiez si une ressource approche de ses limites. Utilisez la liste de contrôle des opérations de cet article pour guider votre processus.

Avec ces exemples pratiques et une approche disciplinée, vous serez bien équipé pour gérer la planification de capacité sur les systèmes Linux.