Linux-Prozesse verwalten und überwachen

Einführung

In diesem Lab erlernen Sie die wesentlichen Fähigkeiten zur Verwaltung und Überwachung von Prozessen auf einem Linux-System. Sie werden untersuchen, wie Sie mit Prozessen interagieren, die sowohl im Vordergrund als auch im Hintergrund laufen. Dies gibt Ihnen eine bessere Kontrolle über Ihre Kommandozeilenumgebung und die Systemressourcen. Diese praktische Erfahrung ist grundlegend für jeden, der mit Linux arbeitet, vom Systemadministrator bis zum Entwickler.

Sie beginnen damit, einen Hintergrundjob mit dem Operator & zu starten und dessen Status mit jobs anzuzeigen. Anschließend untersuchen Sie laufende Prozesse mit ps, überwachen die Systemaktivität in Echtzeit mit top und üben die Jobsteuerung mit fg, bg und Ctrl-Z. Zum Abschluss des Labs lernen Sie, wie Sie die Priorität eines Prozesses mit renice anpassen und ihn mit dem Befehl kill beenden, womit Sie den gesamten Lebenszyklus der Prozessverwaltung abdecken.

Hintergrundprozesse mit `&` und `jobs` starten und anzeigen

In diesem Schritt lernen Sie, wie Sie einen Befehl im Hintergrund ausführen und den Status von Hintergrundjobs anzeigen. In einer Linux-Shell führen Sie normalerweise einen Befehl aus und warten auf dessen Abschluss, bevor die Eingabeaufforderung (Prompt) zurückkehrt. Dies nennt man die Ausführung eines Prozesses im Vordergrund. Bei zeitaufwendigen Aufgaben möchten Sie diese jedoch möglicherweise im Hintergrund ausführen, damit Sie Ihr Terminal für andere Befehle weiter nutzen können.

Um einen Befehl im Hintergrund auszuführen, fügen Sie einfach ein kaufmännisches Und-Zeichen (&) am Ende der Befehlszeile hinzu. Wir probieren dies mit dem Befehl sleep aus, einem einfachen Werkzeug, das für eine festgelegte Zeit pausiert.

Führen Sie den folgenden Befehl aus, um sleep für 300 Sekunden im Hintergrund laufen zu lassen. Dies ermöglicht es uns, in den nächsten Schritten damit zu arbeiten.

sleep 300 &

Nachdem Sie die Eingabetaste gedrückt haben, sehen Sie eine Ausgabe ähnlich der folgenden, und die Eingabeaufforderung erscheint sofort wieder, sodass Sie neue Befehle eingeben können.

[1] 12345

Die Shell hat den Befehl sleep 300 als Hintergrundjob gestartet. Die Ausgabe liefert zwei wichtige Informationen:

[1]: Dies ist die Job-ID. Die Shell weist jedem Hintergrundprozess eine eindeutige Job-ID zu.
12345: Dies ist die Prozess-ID (PID). Das Betriebssystem weist jedem laufenden Prozess eine eindeutige PID zu. Ihre PID wird sich von dem Beispiel unterscheiden.

Da der Prozess nun im Hintergrund läuft, wie können Sie seinen Status überprüfen? Dazu verwenden Sie den Befehl jobs, der alle Jobs auflistet, die im Hintergrund der aktuellen Shell-Sitzung laufen.

Führen Sie den Befehl jobs in Ihrem Terminal aus:

jobs

Die Ausgabe zeigt den soeben gestarteten sleep-Befehl zusammen mit seiner Job-ID und dem aktuellen Status an.

[1]+  Running                 sleep 300 &

Sie haben erfolgreich einen Prozess im Hintergrund gestartet und wissen, wie Sie seinen Status überprüfen. Dies ist eine grundlegende Fertigkeit für die Verwaltung lang laufender Aufgaben auf einem Linux-System. In den folgenden Schritten werden wir untersuchen, wie wir mit diesem Hintergrundjob interagieren können.

Laufende Prozesse mit `ps` untersuchen

Im vorherigen Schritt haben Sie den Befehl jobs verwendet, um den Hintergrundprozess in Ihrer aktuellen Shell zu sehen. jobs ist jedoch auf Ihre Sitzung beschränkt. Um einen umfassenderen Überblick über alle auf dem System laufenden Prozesse zu erhalten, benötigen Sie ein leistungsfähigeres Werkzeug: ps (Process Status). Der Befehl ps liefert eine Momentaufnahme der aktuellen Prozesse zum Zeitpunkt der Ausführung.

Beginnen wir mit der Ausführung von ps ohne Optionen. Dieser Befehl zeigt die Prozesse an, die dem aktuellen Benutzer gehören und mit dem aktuellen Terminal verbunden sind.

ps

Die Ausgabe wird minimal sein und wahrscheinlich nur Ihre Shell (zsh) und den soeben ausgeführten ps-Befehl anzeigen. Die PIDs auf Ihrem System werden abweichen.

  PID TTY          TIME CMD
23882 pts/0    00:00:00 zsh
23953 pts/0    00:00:00 ps

Um alle auf dem System laufenden Prozesse zu sehen, nicht nur die in Ihrem Terminal, können Sie ps mit Optionen verwenden. Eine sehr verbreitete und nützliche Kombination ist ps aux.

a: Zeigt Prozesse für alle Benutzer an.
u: Zeigt die Ausgabe in einem benutzerorientierten Format an (einschließlich Benutzer, CPU%, MEM% usw.).
x: Bezieht Prozesse ein, die nicht mit einem Terminal verbunden sind.

Eine lange Liste von Prozessen ist wenig hilfreich, wenn Sie nach etwas Bestimmtem suchen. Wir können ps mit dem Befehl grep kombinieren, um die Ausgabe zu filtern. Suchen wir nach dem sleep-Prozess, den Sie im vorherigen Schritt gestartet haben.

ps aux | grep sleep

Dieser Befehl filtert die Ausgabe von ps aux und zeigt nur die Zeilen an, die das Wort "sleep" enthalten.

labex    23885  0.0  0.0   7264   868 pts/0    S    11:50   0:00 sleep 300
labex    23962  0.0  0.0  10788  2240 pts/0    S+   11:52   0:00 grep --color=auto sleep

Sie werden wahrscheinlich zwei Zeilen in der Ausgabe sehen. Eine ist Ihr sleep 300-Prozess. Die andere ist der grep sleep-Befehl selbst, der in dem Moment lief, als ps die Prozessliste erfasste. Beachten Sie, dass die PID für sleep 300 (in diesem Beispiel 23885) mit der übereinstimmt, die Sie beim ersten Start des Befehls im Hintergrund gesehen haben.

Ein weiteres beliebtes Format zur Anzeige von Prozessen ist ps -ef.

-e: Wählt jeden Prozess auf dem System aus.
-f: Zeigt eine vollständige ("full") Auflistung an, die nützliche Informationen wie die Parent Process ID (PPID) enthält.

Probieren wir es aus, indem wir erneut grep verwenden, um unseren sleep-Prozess zu finden.

ps -ef | grep sleep

Das Ausgabeformat ist anders, bietet aber ähnliche Informationen. Diese Ansicht ist besonders nützlich, um die Prozesshierarchie über die Spalten PID und PPID zu erkennen.

UID        PID  PPID  C STIME TTY          TIME CMD
labex    23885 23882  0 11:50 pts/0    00:00:00 sleep 300
labex    23964 23882  0 11:53 pts/0    00:00:00 grep --color=auto sleep

Sie haben nun gesehen, wie Sie ps verwenden, um eine Momentaufnahme der Systemprozesse zu erhalten. Durch die Kombination mit Werkzeugen wie grep können Sie spezifische Prozesse schnell finden und untersuchen.

Systemressourcen mit `top` überwachen

In diesem Schritt lernen Sie die Verwendung von top, einem leistungsstarken Werkzeug zur Echtzeit-Systemüberwachung. Während ps Ihnen eine statische Momentaufnahme liefert, bietet top eine dynamische, kontinuierlich aktualisierte Ansicht der Systemaktivität. Dies ist unersetzlich, um ressourcenintensive Prozesse im laufenden Betrieb zu identifizieren.

Geben Sie zum Starten einfach top in Ihr Terminal ein und drücken Sie die Eingabetaste.

top

Ihr gesamtes Terminalfenster wird von der top-Oberfläche eingenommen. Es wird etwa so aussehen, wobei die Daten alle paar Sekunden aktualisiert werden.

top - 12:05:15 up 15 min,  1 user,  load average: 0.00, 0.01, 0.00
Tasks: 115 total,   1 running, 114 sleeping,   0 stopped,   0 zombie
%Cpu(s):  0.1 us,  0.1 sy,  0.0 ni, 99.8 id,  0.0 wa,  0.0 hi,  0.0 si,  0.0 st
MiB Mem :   1987.2 total,    985.4 free,    501.8 used,    500.0 buff/cache
MiB Swap:   2048.0 total,   2048.0 free,      0.0 used.   1325.4 avail Mem

    PID USER      PR  NI    VIRT    RES    SHR S  %CPU  %MEM     TIME+ COMMAND
      1 root      20   0  167900  12936   8488 S   0.0   0.6   0:01.15 systemd
      2 root      20   0       0      0      0 S   0.0   0.0   0:00.00 kthreadd
...

Die top-Oberfläche ist in zwei Hauptbereiche unterteilt:

Der Zusammenfassungsbereich oben zeigt systemweite Statistiken wie die Laufzeit (Uptime), die Anzahl der Tasks, die CPU-Auslastung (%Cpu(s)) und die Speichernutzung (MiB Mem).
Die Prozessliste darunter zeigt einzelne Prozesse, standardmäßig sortiert nach der CPU-Auslastung (%CPU).

Der Befehl top ist interaktiv. Sie können verschiedene Tasten verwenden, um sein Verhalten zu ändern. Probieren wir einige aus:

Nach Speichernutzung sortieren: Drücken Sie M (Großbuchstabe 'm'). Die Liste wird basierend auf der Spalte %MEM neu sortiert, sodass die speicherintensivsten Prozesse oben stehen.
Nach CPU-Auslastung sortieren: Drücken Sie P (Großbuchstabe 'p'). Dies sortiert die Liste zurück zum Standard, nach der Spalte %CPU.
Ihren sleep-Prozess finden: Versuchen Sie, den zuvor gestarteten sleep-Prozess zu entdecken. Er wird wahrscheinlich weit unten in der Liste stehen, da er keine CPU verbraucht. Sie können die Tasten Pfeil abwärts und Pfeil aufwärts verwenden, um durch die Prozessliste zu scrollen.

Wenn Sie mit der Beobachtung fertig sind, können Sie top jederzeit beenden.

top beenden: Drücken Sie q, um die top-Oberfläche zu verlassen und zu Ihrer Eingabeaufforderung zurückzukehren.

Sie haben nun top verwendet, um eine Echtzeit-Ansicht der Prozesse und der Ressourcennutzung Ihres Systems zu erhalten. Dies ist der Standardbefehl für jeden Systemadministrator bei der Fehlersuche von Performance-Problemen.

Jobsteuerung mit `fg`, `bg` und Ctrl-Z verwalten

In diesem Schritt lernen Sie, wie Sie den Zustand Ihrer laufenden Jobs verwalten. Sie wissen bereits, wie man einen Job im Hintergrund startet. Aber was ist, wenn Sie einen lang laufenden Befehl im Vordergrund starten und dann feststellen, dass Sie Ihr Terminal wieder benötigen? Die Jobsteuerung ermöglicht es Ihnen, Prozesse zwischen Vorder- und Hintergrund zu verschieben sowie sie zu pausieren (stoppen) und fortzusetzen.

Lassen Sie uns mit dem sleep 300-Prozess arbeiten, den Sie zuvor gestartet haben. Überprüfen Sie zunächst seinen Status mit dem Befehl jobs, um sicherzustellen, dass er noch läuft.

jobs

Sie sollten Ihren sleep-Job im Hintergrund laufen sehen.

[1]  + running    sleep 300

Bringen wir diesen Job nun in den Vordergrund. Verwenden Sie dazu den Befehl fg (Foreground), gefolgt von der Job-ID mit einem vorangestellten %. Da unsere Job-ID 1 ist, lautet der Befehl:

fg %1

Die Shell zeigt den Befehlsnamen mit zusätzlichen Job-Informationen an, und Ihre Eingabeaufforderung verschwindet. Das Terminal ist nun durch den Befehl sleep 300 "belegt" und wartet auf dessen Abschluss.

[1]  + 394 running    sleep 300

Um Ihr Terminal zurückzubekommen, ohne den Prozess zu beenden, können Sie ihn stoppen. Drücken Sie die Tastenkombination Ctrl-Z (halten Sie die Ctrl-Taste gedrückt und drücken Sie Z).

Diese Aktion sendet ein spezielles Signal (SIGTSTP) an den Prozess, das dessen Ausführung pausiert. Der Prozess wird nicht beendet, sondern lediglich suspendiert. Sie sehen eine Bestätigungsmeldung und Ihr Prompt kehrt zurück.

[1]  + 394 suspended  sleep 300

Überprüfen Sie nun erneut den Status Ihrer Jobs:

jobs

Die Ausgabe zeigt den Status des Jobs nun als "suspended" (suspendiert) an.

[1]  + suspended  sleep 300

Ein gestoppter Job kann fortgesetzt werden. Sie können ihn im Vordergrund mit fg oder im Hintergrund mit bg wieder aufnehmen. Lassen Sie uns ihn mit dem Befehl bg im Hintergrund fortsetzen.

bg %1

Die Shell bestätigt, dass der Job nun wieder im Hintergrund läuft.

[1]  + 394 continued  sleep 300

Sie können den Status ein letztes Mal mit jobs überprüfen, um zu sehen, dass er wieder auf "Running" steht. Sie haben nun erfolgreich einen Prozess vom Hintergrund in den Vordergrund verschoben, ihn gestoppt und im Hintergrund wieder fortgesetzt.

Prozesspriorität mit `renice` anpassen

In diesem Schritt lernen Sie, wie Sie die Scheduling-Priorität eines laufenden Prozesses beeinflussen können. Unter Linux bestimmt die "Niceness" eines Prozesses, wie viel CPU-Zeit er im Vergleich zu anderen Prozessen erhält. Der Nice-Wert reicht von -20 (höchste Priorität) bis +19 (niedrigste Priorität). Standardmäßig starten die meisten Prozesse mit einem Nice-Wert von 0. Ein höherer Nice-Wert bedeutet, dass der Prozess "netter" (nicer) zu anderen Prozessen ist und CPU-Zeit bereitwilliger abgibt.

Wir werden die Priorität des sleep-Prozesses anpassen, mit dem Sie gearbeitet haben. Dazu benötigen Sie zunächst dessen Prozess-ID (PID). Sie finden diese wieder mit ps und grep.

ps aux | grep sleep

Suchen Sie nach der Zeile, die sleep 300 entspricht (nicht der grep-Befehl selbst), und notieren Sie die PID aus der zweiten Spalte.

labex    23885  0.0  0.0   7264   868 pts/0    S    11:50   0:00 sleep 300
labex    24101  0.0  0.0  10788  2240 pts/0    S+   12:15   0:00 grep --color=auto sleep

In diesem Beispiel ist die PID 23885. Sie müssen die PID aus Ihrer eigenen Ausgabe in den folgenden Befehlen verwenden.

Prüfen wir nun den aktuellen Nice-Wert (NI) des Prozesses. Der Befehl ps mit der Option -o erlaubt es Ihnen, benutzerdefinierte Ausgabespalten festzulegen.

ps -o pid,ni,cmd -p <IHRE_PID>

Ersetzen Sie <IHRE_PID> durch die tatsächliche PID Ihres sleep-Prozesses. Beispiel: ps -o pid,ni,cmd -p 23885.

    PID  NI CMD
  23885   5 sleep 300

Wie erwartet ist der Standard-Nice-Wert (NI) 5.

Ändern wir diesen Wert nun mit dem Befehl renice. Wir erhöhen den Nice-Wert auf 10, was die Priorität des Prozesses senkt. Normale Benutzer können den Nice-Wert ihrer eigenen Prozesse nur erhöhen (wodurch sie eine niedrigere Priorität erhalten).

renice -n 10 -p <IHRE_PID>

Ersetzen Sie erneut <IHRE_PID> durch die PID Ihres Prozesses. Der Befehl meldet die alte und die neue Priorität.

23885 (process ID) old priority 5, new priority 10

Überprüfen Sie schließlich, ob die Änderung wirksam wurde, indem Sie den ps-Befehl erneut ausführen:

ps -o pid,ni,cmd -p <IHRE_PID>

Die Ausgabe sollte nun den neuen Nice-Wert anzeigen.

    PID  NI CMD
  23885  10 sleep 300

Sie haben erfolgreich die Priorität eines laufenden Prozesses geändert. Dies ist eine nützliche Technik, um sicherzustellen, dass lang laufende, unkritische Hintergrundaufgaben wichtigere Arbeiten im Vordergrund nicht behindern.

Einen Prozess mit `kill` beenden

In diesem letzten Schritt lernen Sie, wie Sie einen Prozess beenden. Während einige Prozesse von selbst enden, müssen Sie oft einen Prozess manuell stoppen, der nicht mehr benötigt wird, sich falsch verhält oder nur zu Testzwecken gestartet wurde, wie unser sleep-Befehl. Das Hauptwerkzeug hierfür ist der Befehl kill.

Der Befehl kill sendet ein Signal an einen bestimmten Prozess. Standardmäßig sendet er das Signal SIGTERM (Terminate), das den Prozess höflich auffordert, sich zu beenden. Dies ermöglicht es dem Prozess, vor dem Beenden Aufräumarbeiten durchzuführen.

Sie können einen Prozess entweder über seine Prozess-ID (PID) oder, bei Hintergrundjobs in Ihrer aktuellen Shell, über seine Job-ID ansprechen. Die Verwendung der Job-ID ist oft bequemer.

Bestätigen wir zunächst, dass unser sleep-Job noch läuft.

jobs

Sie sollten den sleep-Prozess aufgelistet sehen.

[1]+  Running                 sleep 300 &

Verwenden Sie nun den Befehl kill mit der Job-ID (%1), um ihn zu beenden.

kill %1

Nachdem Sie den Befehl ausgeführt haben, gibt die Shell wahrscheinlich eine Meldung im Terminal aus, die besagt, dass der Job beendet wurde. Diese Meldung erscheint entweder sofort oder nachdem Sie erneut die Eingabetaste gedrückt haben.

[1]+  Terminated              sleep 300

Überprüfen wir, ob der Prozess wirklich weg ist. Führen Sie den Befehl jobs erneut aus.

jobs

Der Befehl sollte nun keine Ausgabe mehr erzeugen, da keine aktiven Jobs mehr in dieser Shell-Sitzung vorhanden sind. Sie können dies auch mit ps gegenprüfen.

ps aux | grep sleep

Die einzige Zeile, die Sie eventuell sehen, ist der grep sleep-Befehl selbst. Der ursprüngliche sleep 300-Prozess läuft nicht mehr.

In Fällen, in denen ein Prozess nicht reagiert und nicht auf das Standard-SIGTERM-Signal reagiert, können Sie ein forcefully Signal senden: SIGKILL (Signalnummer 9). Dieses beendet den Prozess sofort, ohne ihm die Chance zum Aufräumen zu geben. Der Befehl lautet dann kill -9 %1. Dies sollte nur als letztes Mittel eingesetzt werden.

Herzlichen Glückwunsch! Sie haben nun den vollständigen Lebenszyklus der grundlegenden Prozessverwaltung unter Linux geübt: Starten eines Prozesses im Hintergrund, Untersuchen mit ps und top, Verwalten über die Jobsteuerung, Anpassen der Priorität und schließlich das Beenden des Prozesses.

Zusammenfassung

In diesem Lab haben Sie die grundlegenden Fähigkeiten zur Verwaltung und Überwachung von Prozessen in einer Linux-Umgebung erlernt. Sie haben damit begonnen, einen Prozess mit dem Operator & im Hintergrund auszuführen und seinen Status mit dem Befehl jobs anzuzeigen. Anschließend haben Sie untersucht, wie man mit ps alle laufenden Prozesse auflistet, um Details wie die Prozess-ID (PID) zu finden, und wie man top zur Echtzeit-Überwachung der Systemressourcen und aktiven Prozesse nutzt.

Darüber hinaus haben Sie die Jobsteuerung geübt, indem Sie einen Vordergrundprozess mit Ctrl-Z suspendiert, ihn mit bg in den Hintergrund verschoben und mit fg wieder in den Vordergrund geholt haben. Sie haben außerdem gelernt, wie man die Scheduling-Priorität eines Prozesses mit renice anpasst und wie man einen Prozess mit dem Befehl kill unter Verwendung seiner PID kontrolliert beendet.