Rapport sur la mémoire Linux

LinuxLinuxBeginner
Pratiquer maintenant

💡 Ce tutoriel est traduit par l'IA à partir de la version anglaise. Pour voir la version originale, vous pouvez cliquer ici

Introduction

La gestion de la mémoire est un aspect crucial de l'administration des systèmes Linux qui affecte directement les performances et la stabilité du système. Comprendre comment la mémoire est allouée, utilisée et rapportée dans les systèmes Linux permet aux administrateurs d'optimiser les performances, de résoudre les problèmes et de garantir des ressources suffisantes pour les applications.

Dans ce labo (LabEx), vous apprendrez à surveiller et à analyser l'utilisation de la mémoire dans les systèmes Linux à l'aide d'outils en ligne de commande. Vous explorerez la commande free, qui fournit des informations essentielles sur l'allocation et l'utilisation de la mémoire système. En maîtrisant ces outils, vous acquerrez les compétences nécessaires pour surveiller efficacement les ressources mémoire du système et prendre des décisions éclairées concernant l'optimisation du système.

À la fin de ce labo (LabEx), vous serez en mesure de vérifier l'état de la mémoire système, d'interpréter les statistiques de mémoire et de créer des rapports de base sur l'utilisation de la mémoire, qui sont des compétences fondamentales pour tout utilisateur Linux ou administrateur système.


Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL linux(("Linux")) -.-> linux/BasicFileOperationsGroup(["Basic File Operations"]) linux(("Linux")) -.-> linux/FileandDirectoryManagementGroup(["File and Directory Management"]) linux(("Linux")) -.-> linux/TextProcessingGroup(["Text Processing"]) linux(("Linux")) -.-> linux/SystemInformationandMonitoringGroup(["System Information and Monitoring"]) linux(("Linux")) -.-> linux/VersionControlandTextEditorsGroup(["Version Control and Text Editors"]) linux/BasicFileOperationsGroup -.-> linux/cat("File Concatenating") linux/FileandDirectoryManagementGroup -.-> linux/mkdir("Directory Creating") linux/TextProcessingGroup -.-> linux/awk("Text Processing") linux/SystemInformationandMonitoringGroup -.-> linux/watch("Command Repeating") linux/SystemInformationandMonitoringGroup -.-> linux/free("Memory Reporting") linux/VersionControlandTextEditorsGroup -.-> linux/nano("Simple Text Editing") subgraph Lab Skills linux/cat -.-> lab-271285{{"Rapport sur la mémoire Linux"}} linux/mkdir -.-> lab-271285{{"Rapport sur la mémoire Linux"}} linux/awk -.-> lab-271285{{"Rapport sur la mémoire Linux"}} linux/watch -.-> lab-271285{{"Rapport sur la mémoire Linux"}} linux/free -.-> lab-271285{{"Rapport sur la mémoire Linux"}} linux/nano -.-> lab-271285{{"Rapport sur la mémoire Linux"}} end

Utilisation de la commande de base free

La commande free est un utilitaire de base sous Linux qui affiche la quantité de mémoire libre et utilisée dans votre système. Ces informations vous aident à comprendre l'état actuel de la mémoire de votre système et à déterminer si vous disposez de suffisamment de ressources pour vos applications.

Exécution de la commande de base free

Ouvrez votre terminal dans l'espace de travail par défaut à /home/labex/project et exécutez la commande de base free :

free

Vous devriez voir une sortie similaire à celle-ci :

               total        used        free      shared  buff/cache   available
Mem:         8000000     3000000     1000000       25000     4000000     4700000
Swap:             0           0           0

La sortie affiche les valeurs de mémoire en octets, ce qui peut être difficile à lire. Pour un format plus lisible, utilisez l'option -h (human-readable, lisible par l'homme) :

free -h

Maintenant, la sortie ressemblera plus à ceci :

               total        used        free      shared  buff/cache   available
Mem:           7.6Gi       2.9Gi       954Mi        24Mi       3.8Gi       4.5Gi
Swap:             0B          0B          0B

Ce format affiche les tailles de mémoire avec des unités appropriées (KB, MB, GB), ce qui facilite beaucoup l'interprétation.

Création d'un répertoire pour votre travail

Créons un répertoire pour stocker les fichiers que vous allez créer pendant ce labo (LabEx) :

mkdir -p ~/project/memory_data

Enregistrement des statistiques de mémoire dans un fichier

Maintenant, enregistrons la sortie de la commande free -h dans un fichier pour un usage ultérieur :

free -h > ~/project/memory_data/memory_stats.txt

Pour vérifier que le fichier a été créé et contient les informations attendues, utilisez la commande cat :

cat ~/project/memory_data/memory_stats.txt

Vous devriez voir la même sortie que celle qui était précédemment affichée dans votre terminal.

Comprendre les colonnes de la sortie de la mémoire

Maintenant que vous avez les statistiques de base de la mémoire, comprenons ce que signifie chaque colonne dans la sortie de la commande free. Cette connaissance vous aidera à interpréter plus efficacement l'état de la mémoire du système.

Explication des colonnes de la sortie de la mémoire

Ouvrez le fichier de statistiques de mémoire que vous avez créé à l'étape précédente :

cat ~/project/memory_data/memory_stats.txt

La sortie contient plusieurs colonnes :

  1. total : La quantité totale de mémoire (RAM) installée sur le système.

  2. used : La quantité de mémoire actuellement utilisée par le système.

  3. free : La quantité de mémoire qui n'est actuellement utilisée pour rien.

  4. shared : Mémoire partagée par plusieurs processus, souvent utilisée par tmpfs (systèmes de fichiers temporaires) et les segments de mémoire partagée.

  5. buff/cache : Mémoire utilisée par les tampons du noyau et le cache de pages :

    • buffers : Mémoire utilisée par le noyau pour stocker temporairement des données avant de les écrire sur le disque.
    • caches : Mémoire utilisée pour stocker les données lues depuis le disque pour un accès plus rapide.
  6. available : Une estimation de la quantité de mémoire disponible pour démarrer de nouvelles applications sans utiliser le swap.

Création d'un rapport sur la mémoire

Maintenant, créons un rapport détaillé sur la mémoire expliquant ce que signifie chaque colonne et enregistrant les valeurs actuelles. Créez un nouveau fichier nommé memory_report.txt :

nano ~/project/memory_data/memory_report.txt

Dans l'éditeur nano, ajoutez le contenu suivant (remplacez les valeurs fictives par les valeurs réelles de votre système) :

Rapport sur la mémoire - Créé le $(date)

total: [Votre valeur ici]
La quantité totale de RAM physique installée sur le système.

used: [Votre valeur ici]
La quantité de mémoire actuellement utilisée par les applications et le système d'exploitation.

free: [Votre valeur ici]
La quantité de mémoire qui n'est pas du tout utilisée et est disponible.

shared: [Votre valeur ici]
Mémoire utilisée par tmpfs et les segments de mémoire partagée qui peuvent être accédés par plusieurs processus.

buff/cache: [Votre valeur ici]
Mémoire utilisée pour les tampons du noyau et le cache de disque pour améliorer les performances du système.

available: [Votre valeur ici]
Une estimation de la quantité de mémoire disponible pour démarrer de nouvelles applications sans utiliser le swap.

Pour obtenir les valeurs actuelles, vous pouvez vous référer au fichier memory_stats.txt que vous avez enregistré précédemment.

Après avoir ajouté le contenu, enregistrez le fichier en appuyant sur Ctrl+O puis Entrée, puis quittez nano en appuyant sur Ctrl+X.

Affichage de la mémoire en différentes unités

La commande free vous permet d'afficher la mémoire en différentes unités. Créons un fichier montrant la mémoire en diverses unités :

free -b | head -2 > ~/project/memory_data/memory_units.txt
echo "Mémoire en octets (ci-dessus)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -k | head -2 >> ~/project/memory_data/memory_units.txt
echo "Mémoire en kilooctets (ci-dessus)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -m | head -2 >> ~/project/memory_data/memory_units.txt
echo "Mémoire en mégaoctets (ci-dessus)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -g | head -2 >> ~/project/memory_data/memory_units.txt
echo "Mémoire en gigaoctets (ci-dessus)" >> ~/project/memory_data/memory_units.txt

Affichez le fichier pour voir la mémoire représentée en différentes unités :

cat ~/project/memory_data/memory_units.txt

Cela vous aide à comprendre comment afficher les informations sur la mémoire dans l'unité la plus appropriée pour vos besoins.

Surveillance de la mémoire en temps réel

Les administrateurs système ont souvent besoin de surveiller l'utilisation de la mémoire au fil du temps pour détecter des tendances ou résoudre des problèmes. Dans cette étape, vous allez apprendre à surveiller l'utilisation de la mémoire en temps réel et à créer un script simple pour enregistrer l'utilisation de la mémoire à intervalles réguliers.

Utilisation de la commande watch avec free

La commande watch vous permet d'exécuter une commande périodiquement et d'afficher sa sortie. Cela est très utile pour surveiller l'utilisation de la mémoire en temps réel :

watch -n 2 free -h

Cette commande exécute free -h toutes les 2 secondes et affiche la sortie mise à jour. Vous devriez voir les statistiques de mémoire se mettre à jour en temps réel.

Pour quitter la commande watch, appuyez sur Ctrl+C.

Utilisation de free avec l'option d'intervalle

La commande free elle-même peut afficher l'utilisation de la mémoire à intervalles réguliers. La syntaxe est la suivante :

free -s [secondes] -c [nombre]

Où :

  • -s spécifie l'intervalle en secondes entre les mises à jour
  • -c spécifie le nombre de mises à jour à afficher

Voyons comment surveiller l'utilisation de la mémoire toutes les 3 secondes pour un total de 4 mises à jour :

free -h -s 3 -c 4

Cela affichera les statistiques de mémoire 4 fois, avec une pause de 3 secondes entre chaque mise à jour.

Création d'un script de surveillance de la mémoire

Créons un script qui enregistre les informations sur l'utilisation de la mémoire à intervalles réguliers. Tout d'abord, créez un nouveau fichier de script :

nano ~/project/memory_data/memory_monitor.sh

Ajoutez le contenu suivant au fichier :

#!/bin/bash

## Crée un fichier de journal avec la date et l'heure actuelles
log_file=~/project/memory_data/memory_log_$(date +%Y%m%d_%H%M%S).txt

## Écrit l'en-tête dans le fichier de journal
echo "Journal d'utilisation de la mémoire - Démarré le $(date)" > $log_file
echo "Surveillance toutes les 5 secondes pour 5 lectures" >> $log_file
echo "----------------------------------------" >> $log_file

## Boucle 5 fois, capturant les informations sur la mémoire toutes les 5 secondes
for i in {1..5}; do
  echo "Lecture $i - $(date)" >> $log_file
  free -h >> $log_file
  echo "----------------------------------------" >> $log_file
  sleep 5
done

echo "Surveillance terminée le $(date)" >> $log_file
echo "Journal enregistré dans $log_file"

Enregistrez le fichier en appuyant sur Ctrl+O, puis Entrée, et quittez avec Ctrl+X.

Maintenant, rendez le script exécutable :

chmod +x ~/project/memory_data/memory_monitor.sh

Exécutez le script :

~/project/memory_data/memory_monitor.sh

Le script s'exécutera pendant environ 25 secondes (5 secondes × 5 lectures) et créera un fichier de journal avec les informations sur l'utilisation de la mémoire. Une fois terminé, vous verrez un message indiquant où le fichier de journal est enregistré.

Pour afficher le fichier de journal :

cat ~/project/memory_data/memory_log_*

Ce fichier de journal montre comment l'utilisation de la mémoire change au fil du temps, ce qui est précieux pour résoudre les problèmes liés à la mémoire ou comprendre les modèles d'utilisation de la mémoire.

Exploration des informations avancées sur la mémoire

Linux fournit des informations plus détaillées sur la mémoire que celles affichées par la commande de base free. Dans cette étape, vous allez explorer d'autres sources d'informations sur la mémoire et créer un résumé complet de la mémoire.

Exploration de /proc/meminfo

Le fichier /proc/meminfo contient des informations détaillées sur la mémoire de votre système. Examinons-le :

head -20 /proc/meminfo

Ce fichier contient des dizaines de valeurs liées à la mémoire, notamment :

  • MemTotal : RAM totale utilisable
  • MemFree : Mémoire libre
  • MemAvailable : Mémoire disponible
  • Buffers : Mémoire utilisée par les tampons du noyau
  • Cached : Mémoire utilisée pour le cache de fichiers
  • SwapTotal : Espace de swap total
  • SwapFree : Espace de swap libre

Extractions de quelques informations clés de ce fichier :

grep -E "MemTotal|MemFree|MemAvailable|Buffers|Cached|SwapTotal|SwapFree" /proc/meminfo > ~/project/memory_data/meminfo_excerpt.txt

Affichage des informations extraites :

cat ~/project/memory_data/meminfo_excerpt.txt

Création d'un résumé complet de la mémoire

Maintenant, créons un script qui génère un rapport de résumé complet de la mémoire. Créez un nouveau fichier de script :

nano ~/project/memory_data/create_summary.sh

Ajoutez le contenu suivant :

#!/bin/bash

## Définir le fichier de sortie avec un horodatage
output_file=~/project/memory_data/memory_summary_$(date +%Y%m%d_%H%M%S).txt

## Créer l'en-tête
echo "LINUX MEMORY SUMMARY REPORT" > $output_file
echo "===========================" >> $output_file
echo "Date: $(date)" >> $output_file
echo "" >> $output_file

## Statistiques de base de la mémoire
echo "BASIC MEMORY STATISTICS:" >> $output_file
free -h >> $output_file
echo "" >> $output_file

## Informations détaillées sur la mémoire
echo "DETAILED MEMORY INFORMATION:" >> $output_file
echo "Total RAM: $(grep MemTotal /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Free RAM: $(grep MemFree /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Available RAM: $(grep MemAvailable /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Buffer memory: $(grep Buffers /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Cache memory: $(grep "^Cached:" /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "" >> $output_file

## Informations sur le swap
echo "SWAP INFORMATION:" >> $output_file
echo "Total Swap: $(grep SwapTotal /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "Free Swap: $(grep SwapFree /proc/meminfo | awk '{print $2 " " $3}')" >> $output_file
echo "" >> $output_file

## Calcul du pourcentage d'utilisation de la mémoire
total_mem=$(grep MemTotal /proc/meminfo | awk '{print $2}')
used_mem=$(grep MemTotal /proc/meminfo | awk '{print $2}')
used_mem=$((used_mem - $(grep MemFree /proc/meminfo | awk '{print $2}')))
used_mem=$((used_mem - $(grep Buffers /proc/meminfo | awk '{print $2}')))
used_mem=$((used_mem - $(grep "^Cached:" /proc/meminfo | awk '{print $2}')))
mem_percentage=$((used_mem * 100 / total_mem))

echo "MEMORY USAGE SUMMARY:" >> $output_file
echo "Memory usage percentage: ${mem_percentage}%" >> $output_file
echo "" >> $output_file

echo "Memory summary report generated at $output_file"

Enregistrez le fichier en appuyant sur Ctrl+O, puis Entrée, et quittez avec Ctrl+X.

Rendez le script exécutable :

chmod +x ~/project/memory_data/create_summary.sh

Exécutez le script pour générer le rapport de résumé :

~/project/memory_data/create_summary.sh

Après l'exécution du script, affichez le rapport de résumé généré :

cat ~/project/memory_data/memory_summary_*

Ce rapport complet vous donne une vue détaillée de l'état de la mémoire de votre système en combinant des données de plusieurs sources.

Création d'une commande simple d'état de la mémoire

Enfin, créons une commande simple sur une seule ligne qui affiche l'état actuel de la mémoire dans un format concis :

echo "Memory status: $(free -h | grep Mem | awk '{print "Total:"$2, "Used:"$3, "Free:"$4, "Available:"$7}')" > ~/project/memory_data/memory_status.txt

Affichez l'état de la mémoire :

cat ~/project/memory_data/memory_status.txt

Cette commande extrait les informations les plus importantes de la sortie de la commande free et les présente dans un format compact.

Résumé

Dans ce laboratoire (LabEx), vous avez exploré des techniques essentielles pour surveiller et analyser l'utilisation de la mémoire dans les systèmes Linux. Vous êtes passé de la génération de rapports de base sur la mémoire à l'analyse avancée, acquérant ainsi des compétences précieuses pour l'administration système et la résolution de problèmes.

Concepts clés et compétences acquises :

  1. Rapports de base sur la mémoire : Vous avez utilisé la commande free pour afficher les statistiques de base de la mémoire et avez appris à interpréter les colonnes de la sortie.

  2. Compréhension des métriques de mémoire : Vous avez exploré la signification de chaque métrique de mémoire (totale, utilisée, libre, partagée, tampon/cache, disponible) et avez appris à afficher la mémoire dans différentes unités.

  3. Surveillance en temps réel : Vous avez appris à surveiller l'utilisation de la mémoire en temps réel à l'aide de la commande watch et avez créé un script pour enregistrer l'utilisation de la mémoire à intervalles réguliers.

  4. Analyse avancée de la mémoire : Vous avez exploré les informations détaillées sur la mémoire contenues dans le fichier /proc/meminfo et avez créé des rapports de synthèse complets sur la mémoire.

Ces compétences sont essentielles pour une administration système efficace, car la gestion de la mémoire a un impact direct sur les performances du système. En surveillant l'utilisation de la mémoire, vous pouvez :

  • Identifier les problèmes de performance liés à la mémoire
  • Déterminer si un système a besoin de plus de ressources
  • Comprendre comment les applications utilisent la mémoire
  • Détecter des fuites de mémoire ou une utilisation excessive de la mémoire
  • Prendre des décisions éclairées concernant l'optimisation du système

Les techniques que vous avez apprises dans ce laboratoire (LabEx) constituent une base solide pour la gestion de la mémoire dans les systèmes Linux et peuvent être approfondies avec des outils de surveillance plus avancés et des techniques d'automatisation.