Linux-Speicherberichterstattung

Einführung

Die Speicherverwaltung ist ein entscheidender Aspekt der Linux-Systemadministration, der direkt die Systemleistung und -stabilität beeinflusst. Das Verständnis, wie Speicher in Linux-Systemen zugewiesen, genutzt und gemeldet wird, ermöglicht es Administratoren, die Leistung zu optimieren, Probleme zu beheben und sicherzustellen, dass genügend Ressourcen für Anwendungen zur Verfügung stehen.

In diesem Lab werden Sie lernen, wie Sie die Speicherauslastung in Linux-Systemen mit Befehlszeilentools überwachen und analysieren können. Sie werden den free-Befehl untersuchen, der wesentliche Informationen über die System-Speicherzuweisung und -nutzung liefert. Durch das Beherrschen dieser Tools werden Sie die Fähigkeiten erwerben, die erforderlich sind, um die System-Speicherressourcen effektiv zu überwachen und fundierte Entscheidungen zur Systemoptimierung zu treffen.

Bis zum Ende dieses Labs können Sie den System-Speicherstatus überprüfen, Speicherstatistiken interpretieren und grundlegende Berichte über die Speicherauslastung erstellen. Dies sind grundlegende Fähigkeiten für jeden Linux-Benutzer oder Systemadministrator.

Verwendung des grundlegenden free-Befehls

Der free-Befehl ist ein grundlegendes Linux-Werkzeug, das die Menge an freiem und genutztem Speicher in Ihrem System anzeigt. Diese Informationen helfen Ihnen, den aktuellen Speicherzustand Ihres Systems zu verstehen und zu bestimmen, ob Sie genügend Ressourcen für Ihre Anwendungen haben.

Ausführen des grundlegenden free-Befehls

Öffnen Sie Ihr Terminal im Standardarbeitsbereich unter /home/labex/project und führen Sie den grundlegenden free-Befehl aus:

free

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

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

Die Ausgabe zeigt die Speicherwerte in Bytes an, was schwer lesbar sein kann. Für ein lesbareres Format verwenden Sie die Option -h (menschenlesbar):

free -h

Jetzt sollte die Ausgabe eher so aussehen:

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

Dieses Format zeigt die Speichergrößen mit geeigneten Einheiten (KB, MB, GB) an, was die Interpretation viel einfacher macht.

Erstellen eines Verzeichnisses für Ihre Arbeit

Erstellen wir ein Verzeichnis, um die Dateien zu speichern, die Sie während dieses Labs erstellen werden:

mkdir -p ~/project/memory_data

Speichern von Speicherstatistiken in einer Datei

Jetzt speichern wir die Ausgabe des free -h-Befehls in einer Datei für die spätere Referenz:

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

Um zu überprüfen, ob die Datei erstellt wurde und die erwarteten Informationen enthält, verwenden Sie den cat-Befehl:

cat ~/project/memory_data/memory_stats.txt

Sie sollten die gleiche Ausgabe sehen, die zuvor in Ihrem Terminal angezeigt wurde.

Grundlegendes zu den Spalten der Arbeitsspeicherausgabe

Nachdem Sie nun die grundlegenden Speicherstatistiken haben, lernen wir, was jede Spalte in der Ausgabe des free-Befehls bedeutet. Dieses Wissen wird Ihnen helfen, den System-Speicherstatus effektiver zu interpretieren.

Erklärung der Spalten der Speicherausgabe

Öffnen Sie die Speicherstatistikdatei, die Sie im vorherigen Schritt erstellt haben:

cat ~/project/memory_data/memory_stats.txt

Die Ausgabe enthält mehrere Spalten:

total: Die Gesamtmenge an installiertem Arbeitsspeicher (RAM) im System.
used: Die Menge an Speicher, die derzeit vom System verwendet wird.
free: Die Menge an Speicher, die derzeit für nichts verwendet wird.
shared: Speicher, der von mehreren Prozessen geteilt wird, oft von tmpfs (temporäre Dateisysteme) und geteilten Speichersegmenten genutzt.
buff/cache: Speicher, der von Kernel-Puffern und Seiten-Cache verwendet wird:
- buffers: Speicher, den der Kernel verwendet, um Daten vor dem Schreiben auf die Festplatte temporär zu speichern.
- caches: Speicher, der verwendet wird, um von der Festplatte gelesene Daten für einen schnelleren Zugriff zu speichern.
available: Eine Schätzung darüber, wie viel Speicher für das Starten neuer Anwendungen zur Verfügung steht, ohne dass der Swap-Speicher verwendet wird.

Erstellen eines Speicherberichts

Jetzt erstellen wir einen detaillierten Speicherbericht, der erklärt, was jede Spalte bedeutet, und die aktuellen Werte aufzeichnet. Erstellen Sie eine neue Datei namens memory_report.txt:

nano ~/project/memory_data/memory_report.txt

Im nano-Editor fügen Sie den folgenden Inhalt hinzu (ersetzen Sie die Platzhalterwerte durch die tatsächlichen Werte Ihres Systems):

Memory Report - Created on $(date)

total: [Your value here]
Die Gesamtmenge an physischem RAM, das im System installiert ist.

used: [Your value here]
Die Menge an Speicher, die derzeit von Anwendungen und dem Betriebssystem verwendet wird.

free: [Your value here]
Die Menge an Speicher, der vollständig ungenutzt und verfügbar ist.

shared: [Your value here]
Speicher, der von tmpfs und geteilten Speichersegmenten verwendet wird und von mehreren Prozessen zugänglich ist.

buff/cache: [Your value here]
Speicher, der für Kernel-Puffer und Festplatten-Cache verwendet wird, um die Systemleistung zu verbessern.

available: [Your value here]
Eine Schätzung darüber, wie viel Speicher für das Starten neuer Anwendungen ohne Swapping zur Verfügung steht.

Um die aktuellen Werte zu erhalten, können Sie sich auf die zuvor gespeicherte Datei memory_stats.txt beziehen.

Nachdem Sie den Inhalt hinzugefügt haben, speichern Sie die Datei, indem Sie Strg+O und dann Enter drücken. Verlassen Sie dann nano, indem Sie Strg+X drücken.

Anzeigen des Speichers in verschiedenen Einheiten

Der free-Befehl ermöglicht es Ihnen, den Speicher in verschiedenen Einheiten anzuzeigen. Erstellen wir eine Datei, die den Speicher in verschiedenen Einheiten zeigt:

free -b | head -2 > ~/project/memory_data/memory_units.txt
echo "Memory in bytes (above)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -k | head -2 >> ~/project/memory_data/memory_units.txt
echo "Memory in kilobytes (above)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -m | head -2 >> ~/project/memory_data/memory_units.txt
echo "Memory in megabytes (above)" >> ~/project/memory_data/memory_units.txt
echo "" >> ~/project/memory_data/memory_units.txt

free -g | head -2 >> ~/project/memory_data/memory_units.txt
echo "Memory in gigabytes (above)" >> ~/project/memory_data/memory_units.txt

Sehen Sie sich die Datei an, um den Speicher in verschiedenen Einheiten dargestellt zu sehen:

cat ~/project/memory_data/memory_units.txt

Dies hilft Ihnen zu verstehen, wie Sie die Speicherinformationen in der für Ihre Bedürfnisse am besten geeigneten Einheit anzeigen können.

Echtzeitüberwachung des Arbeitsspeichers

Systemadministratoren müssen oft die Arbeitsspeicherauslastung im Laufe der Zeit überwachen, um Trends zu erkennen oder Probleme zu beheben. In diesem Schritt lernen Sie, wie Sie die Arbeitsspeicherauslastung in Echtzeit überwachen und ein einfaches Skript erstellen, um die Arbeitsspeicherauslastung in regelmäßigen Abständen zu protokollieren.

Verwendung des watch-Befehls mit free

Der watch-Befehl ermöglicht es Ihnen, einen Befehl in regelmäßigen Abständen auszuführen und seine Ausgabe anzuzeigen. Dies ist sehr nützlich für die Echtzeitüberwachung der Arbeitsspeicherauslastung:

watch -n 2 free -h

Dieser Befehl führt free -h alle 2 Sekunden aus und zeigt die aktualisierte Ausgabe an. Sie sollten sehen, wie sich die Arbeitsspeicherstatistiken in Echtzeit aktualisieren.

Um den watch-Befehl zu beenden, drücken Sie Strg+C.

Verwendung von free mit Intervalloption

Der free-Befehl selbst kann die Arbeitsspeicherauslastung in regelmäßigen Abständen anzeigen. Die Syntax lautet:

free -s [seconds] -c [count]

Dabei:

-s gibt das Intervall in Sekunden zwischen den Aktualisierungen an
-c gibt an, wie viele Aktualisierungen angezeigt werden sollen

Überwachen wir die Arbeitsspeicherauslastung alle 3 Sekunden für insgesamt 4 Aktualisierungen:

free -h -s 3 -c 4

Dies wird die Arbeitsspeicherstatistiken 4 Mal anzeigen, mit einer Pause von 3 Sekunden zwischen jeder Aktualisierung.

Erstellen eines Skripts zur Arbeitsspeicherüberwachung

Erstellen wir ein Skript, das die Informationen zur Arbeitsspeicherauslastung in regelmäßigen Abständen protokolliert. Zunächst erstellen Sie eine neue Skriptdatei:

nano ~/project/memory_data/memory_monitor.sh

Fügen Sie der Datei den folgenden Inhalt hinzu:

#!/bin/bash

## Erstellen einer Protokolldatei mit aktuellem Datum und Uhrzeit
log_file=~/project/memory_data/memory_log_$(date +%Y%m%d_%H%M%S).txt

## Schreiben der Überschrift in die Protokolldatei
echo "Memory Usage Log - Started at $(date)" > $log_file
echo "Monitoring every 5 seconds for 5 readings" >> $log_file
echo "----------------------------------------" >> $log_file

## Fünfmalige Schleife, Erfassung der Arbeitsspeicherinformationen alle 5 Sekunden
for i in {1..5}; do
  echo "Reading $i - $(date)" >> $log_file
  free -h >> $log_file
  echo "----------------------------------------" >> $log_file
  sleep 5
done

echo "Monitoring completed at $(date)" >> $log_file
echo "Log saved to $log_file"

Speichern Sie die Datei, indem Sie Strg+O und dann Enter drücken, und verlassen Sie nano mit Strg+X.

Machen Sie nun das Skript ausführbar:

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

Führen Sie das Skript aus:

~/project/memory_data/memory_monitor.sh

Das Skript wird etwa 25 Sekunden lang (5 Sekunden × 5 Messungen) laufen und eine Protokolldatei mit Informationen zur Arbeitsspeicherauslastung erstellen. Nach Abschluss des Skripts sehen Sie eine Meldung, die angibt, wo die Protokolldatei gespeichert ist.

Um die Protokolldatei anzuzeigen:

cat ~/project/memory_data/memory_log_*

Diese Protokolldatei zeigt, wie sich die Arbeitsspeicherauslastung im Laufe der Zeit ändert, was für die Behebung von Arbeitsspeicherproblemen oder das Verständnis von Arbeitsspeicherverbrauchsmustern wertvoll ist.

Erkundung fortgeschrittener Arbeitsspeicherinformationen

Linux bietet detailliertere Arbeitsspeicherinformationen als der grundlegende free-Befehl an. In diesem Schritt werden Sie zusätzliche Quellen für Arbeitsspeicherinformationen erkunden und eine umfassende Arbeitsspeichersummary erstellen.

Erkundung von /proc/meminfo

Die Datei /proc/meminfo enthält detaillierte Informationen über den Arbeitsspeicher Ihres Systems. Betrachten wir sie:

head -20 /proc/meminfo

Diese Datei enthält Dutzende von Arbeitsspeicher-relevanten Werten, darunter:

MemTotal: Gesamt verfügbarer Arbeitsspeicher (RAM)
MemFree: Freier Arbeitsspeicher
MemAvailable: Verfügbarer Arbeitsspeicher
Buffers: Arbeitsspeicher, der von Kernel-Puffern verwendet wird
Cached: Arbeitsspeicher, der für die Dateicaching verwendet wird
SwapTotal: Gesamtgröße des Swap-Speichers
SwapFree: Freier Swap-Speicher

Extrahieren wir einige Schlüsselinformationen aus dieser Datei:

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

Sehen Sie sich die extrahierten Informationen an:

cat ~/project/memory_data/meminfo_excerpt.txt

Erstellung einer umfassenden Arbeitsspeichersummary

Jetzt erstellen wir ein Skript, das einen umfassenden Bericht über den Arbeitsspeicherstatus generiert. Erstellen Sie eine neue Skriptdatei:

nano ~/project/memory_data/create_summary.sh

Fügen Sie den folgenden Inhalt hinzu:

#!/bin/bash

## Setzen der Ausgabedatei mit Zeitstempel
output_file=~/project/memory_data/memory_summary_$(date +%Y%m%d_%H%M%S).txt

## Erstellen der Überschrift
echo "LINUX MEMORY SUMMARY REPORT" > $output_file
echo "===========================" >> $output_file
echo "Date: $(date)" >> $output_file
echo "" >> $output_file

## Grundlegende Arbeitsspeicherstatistiken
echo "BASIC MEMORY STATISTICS:" >> $output_file
free -h >> $output_file
echo "" >> $output_file

## Detaillierte Arbeitsspeicherinformationen
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

## Swap-Informationen
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

## Berechnung des Arbeitsspeichernutzungsanteils
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"

Speichern Sie die Datei, indem Sie Strg+O und dann Enter drücken, und verlassen Sie nano mit Strg+X.

Machen Sie das Skript ausführbar:

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

Führen Sie das Skript aus, um den Summary-Bericht zu generieren:

~/project/memory_data/create_summary.sh

Nach Abschluss des Skripts sehen Sie sich den generierten Summary-Bericht an:

cat ~/project/memory_data/memory_summary_*

Dieser umfassende Bericht gibt Ihnen einen detaillierten Überblick über den Arbeitsspeicherstatus Ihres Systems, indem er Daten aus mehreren Quellen kombiniert.

Erstellung eines einfachen Befehls für den Arbeitsspeicherstatus

Schließlich erstellen wir einen einfachen Einzeilenbefehl, der den aktuellen Arbeitsspeicherstatus in einem kompakten Format anzeigt:

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

Sehen Sie sich den Arbeitsspeicherstatus an:

cat ~/project/memory_data/memory_status.txt

Dieser Befehl extrahiert die wichtigsten Informationen aus der Ausgabe des free-Befehls und präsentiert sie in einem kompakten Format.

Zusammenfassung

In diesem Lab haben Sie essentielle Techniken zur Überwachung und Analyse des Arbeitsspeicherverbrauchs in Linux-Systemen kennengelernt. Sie sind von der grundlegenden Arbeitsspeicherberichterstattung zur fortgeschrittenen Analyse vorgegangen und haben wertvolle Fähigkeiten für die Systemadministration und die Fehlerbehebung erworben.

Wichtige Konzepte und Fähigkeiten, die Sie gelernt haben:

Grundlegende Arbeitsspeicherberichterstattung: Sie haben den free-Befehl verwendet, um grundlegende Arbeitsspeicherstatistiken anzuzeigen, und gelernt, wie man die Ausgabespalten interpretiert.
Verständnis von Arbeitsspeichermetriken: Sie haben untersucht, was jede Arbeitsspeichermetrik bedeutet (Gesamt, belegt, frei, geteilt, Puffer/Cache, verfügbar) und wie man den Arbeitsspeicher in verschiedenen Einheiten anzeigt.
Echtzeitüberwachung: Sie haben gelernt, wie man den Arbeitsspeicherverbrauch in Echtzeit mit dem watch-Befehl überwacht und ein Skript erstellt, um den Arbeitsspeicherverbrauch in regelmäßigen Abständen zu protokollieren.
Fortgeschrittene Arbeitsspeicheranalyse: Sie haben detaillierte Arbeitsspeicherinformationen aus der Datei /proc/meminfo untersucht und umfassende Arbeitsspeichersummary-Berichte erstellt.

Diese Fähigkeiten sind für eine effektive Systemadministration unerlässlich, da die Arbeitsspeicherverwaltung direkt die Systemleistung beeinflusst. Durch die Überwachung des Arbeitsspeicherverbrauchs können Sie:

Arbeitsspeicherbezogene Probleme identifizieren
Feststellen, ob ein System mehr Ressourcen benötigt
Verstehen, wie Anwendungen den Arbeitsspeicher nutzen
Arbeitsspeicherlecks oder übermäßigen Arbeitsspeicherverbrauch erkennen
fundierte Entscheidungen über die Systemoptimierung treffen

Die Techniken, die Sie in diesem Lab gelernt haben, bilden eine solide Grundlage für die Arbeitsspeicherverwaltung in Linux-Systemen und können mit fortschrittlicheren Tools und Automatisierungstechniken erweitert werden.