Linux-Prozesse verwalten und überwachen

Einleitung

In diesem Lab lernen Sie die wesentlichen Fähigkeiten für die 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, was Ihnen mehr Kontrolle über Ihre Kommandozeilenumgebung und Systemressourcen gibt. Diese praktische Erfahrung ist grundlegend für jeden, der mit Linux arbeitet, von Systemadministratoren bis hin zu Entwicklern.

Sie beginnen damit, einen Hintergrundjob mit dem &-Operator zu starten und dessen Status mit jobs anzuzeigen. Anschließend inspizieren Sie laufende Prozesse mit ps, überwachen Echtzeit-Systemaktivitäten mit top und üben die Jobkontrolle mit fg, bg und Ctrl-Z. Um das Lab abzuschließen, lernen Sie, wie Sie die Priorität eines Prozesses mit renice anpassen und ihn mit dem kill-Befehl beenden, wodurch der gesamte Lebenszyklus des Prozessmanagements abgedeckt wird.

Hintergrundprozess starten und anzeigen mit & und jobs

In diesem Schritt lernen Sie, wie Sie einen Befehl im Hintergrund ausführen und wie Sie den Status von Hintergrundjobs anzeigen. In einer Linux-Shell führen Sie normalerweise einen Befehl aus und warten, bis dieser abgeschlossen ist, bevor die Eingabeaufforderung zurückkehrt. Dies wird als Ausführen eines Prozesses im Vordergrund bezeichnet. Für langlaufende Aufgaben möchten Sie sie jedoch möglicherweise im Hintergrund ausführen, damit Sie Ihr Terminal für andere Befehle weiter verwenden können.

Um einen Befehl im Hintergrund auszuführen, fügen Sie einfach ein kaufmännisches Und (&) am Ende der Befehlszeile hinzu. Versuchen wir dies mit dem sleep-Befehl, einem einfachen Dienstprogramm, das für eine bestimmte Zeit pausiert.

Führen Sie den folgenden Befehl aus, um sleep 300 Sekunden lang im Hintergrund auszuführen. Dies ermöglicht es uns, ihn in den nächsten Schritten zu bearbeiten.

sleep 300 &

Nachdem Sie Enter gedrückt haben, sehen Sie etwas Ähnliches wie die folgende Ausgabe, und die Eingabeaufforderung kehrt sofort zurück, 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 von dem Beispiel abweichen.

Wie können Sie nun den Status des im Hintergrund laufenden Prozesses überprüfen? Sie können den Befehl jobs verwenden, der alle im Hintergrund der aktuellen Shell-Sitzung laufenden Jobs auflistet.

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

jobs

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

[1]+  Running                 sleep 300 &

Sie haben erfolgreich einen Prozess im Hintergrund gestartet und wissen, wie Sie dessen Status überprüfen können. Dies ist eine grundlegende Fähigkeit für die Verwaltung langlaufender Aufgaben unter Linux. In den folgenden Schritten werden wir untersuchen, wie Sie mit diesem Hintergrundjob interagieren können.

Laufende Prozesse mit ps inspizieren

Im vorherigen Schritt haben Sie den Befehl jobs verwendet, um den Hintergrundprozess in Ihrer aktuellen Shell anzuzeigen. 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 einen Schnappschuss der aktuellen Prozesse zum Zeitpunkt seiner Ausführung.

Beginnen wir damit, ps ohne Optionen auszuführen. Dieser Befehl liefert einen Schnappschuss der Prozesse, die dem aktuellen Benutzer gehören und an das aktuelle Terminal angehängt sind.

ps

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

  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 anzuzeigen, nicht nur die in Ihrem Terminal, können Sie ps mit Optionen verwenden. Eine sehr gängige und nützliche Kombination ist ps aux.

• a: zeigt Prozesse aller Benutzer an.
• u: zeigt die Ausgabe in einem benutzerorientierten Format an (zeigt Benutzer, CPU-Auslastung, Speicherauslastung usw.).
• x: schließt Prozesse ein, die nicht an ein Terminal angehängt sind.

Eine lange Liste von Prozessen ist nicht sehr nützlich, wenn Sie nach etwas Bestimmtem suchen. Wir können ps mit dem Befehl grep kombinieren, um die Ausgabe zu filtern. Suchen wir den 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 zu dem Zeitpunkt lief, als ps die Prozessliste erfasste. Beachten Sie, dass die PID für sleep 300 (in diesem Beispiel 23885) mit der übereinstimmt, die Sie gesehen haben, als Sie den Befehl zum ersten Mal im Hintergrund ausgeführt 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" Formatliste an, die nützliche Informationen wie die Prozess-ID des Elternprozesses (PPID) enthält.

Versuchen wir es, wieder mit grep, um unseren sleep-Prozess zu finden.

ps -ef | grep sleep

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

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 mit ps einen Schnappschuss von Systemprozessen erhalten können. Durch die Kombination mit Werkzeugen wie grep können Sie bestimmte Prozesse schnell finden und inspizieren.

Systemressourcen mit top überwachen

In diesem Schritt lernen Sie, top zu verwenden, ein leistungsstarkes Werkzeug zur Echtzeit-Systemüberwachung. Während ps Ihnen einen statischen Schnappschuss von Prozessen liefert, bietet top eine dynamische, kontinuierlich aktualisierte Ansicht der Systemaktivität, was es unschätzbar wertvoll macht, um ressourcenintensive Prozesse zu identifizieren, während sie auftreten.

Um zu beginnen, geben Sie einfach top in Ihr Terminal ein und drücken Sie Enter.

top

Ihr gesamtes Terminalfenster wird von der top-Oberfläche eingenommen. Es wird ungefähr 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 Hauptteile unterteilt:

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

Der Befehl top ist interaktiv. Sie können verschiedene Tastendrücke verwenden, um sein Verhalten zu ändern. Probieren wir ein paar aus:

1. Nach Speichernutzung sortieren: Drücken Sie M (Großbuchstabe 'm'). Die Liste wird basierend auf der Spalte %MEM neu sortiert, wobei die speicherintensivsten Prozesse oben angezeigt werden.
2. Nach CPU-Auslastung sortieren: Drücken Sie P (Großbuchstabe 'p'). Dies sortiert die Liste zurück zur Standardeinstellung, nach der Spalte %CPU.
3. Ihren sleep-Prozess finden: Sie können versuchen, den sleep-Prozess zu finden, den Sie zuvor gestartet haben. Er wird wahrscheinlich weit unten in der Liste stehen, da er keine CPU-Ressourcen verbraucht. Sie können die Tasten Pfeil nach unten und Pfeil nach oben verwenden, um durch die Prozessliste zu scrollen.

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

4. 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 Echtzeitansicht der Systemprozesse und der Ressourcennutzung zu erhalten. Dies ist ein Standardbefehl für jeden Systemadministrator, der Leistungsprobleme behebt.

Job-Steuerung mit fg, bg und Strg-Z verwalten

In diesem Schritt lernen Sie, wie Sie den Status Ihrer laufenden Jobs verwalten. Sie wissen bereits, wie Sie einen Job im Hintergrund starten, aber was ist, wenn Sie einen langlaufenden Befehl im Vordergrund starten und dann feststellen, dass Sie Ihr Terminal zurückbenötigen? Die Job-Steuerung ermöglicht es Ihnen, Prozesse zwischen Vorder- und Hintergrund zu verschieben und sie anzuhalten (zu stoppen) und fortzusetzen.

Arbeiten wir mit dem sleep 300-Prozess, den Sie zuvor gestartet haben. Überprüfen Sie zuerst 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, der ein % vorangestellt ist. 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 vom sleep 300-Befehl "belegt" und wartet darauf, dass er abgeschlossen wird.

[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 Strg-Z (halten Sie die Strg-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; er wird lediglich angehalten. Sie sehen eine Bestätigungsmeldung, und Ihre Eingabeaufforderung kehrt zurück.

[1]  + 394 suspended  sleep 300

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

jobs

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

[1]  + suspended  sleep 300

Ein gestoppter Job kann fortgesetzt werden. Sie können ihn im Vordergrund mit fg oder im Hintergrund mit bg fortsetzen. Lassen Sie uns ihn im Hintergrund fortsetzen, indem wir den Befehl bg verwenden.

bg %1

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

[1]  + 394 continued  sleep 300

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

Prozesspriorität mit renice anpassen

In diesem Schritt lernen Sie, wie Sie die Planungspräferenz (Scheduling Priority) eines laufenden Prozesses beeinflussen können. Unter Linux bestimmt die "Niceness" eines Prozesses, wie viel CPU-Zeit er im Verhältnis 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" zu anderen Prozessen ist und CPU-Zeit leichter abgibt.

Wir werden die Priorität des sleep-Prozesses anpassen, mit dem Sie gearbeitet haben. Dazu benötigen Sie zuerst seine Prozess-ID (PID). Sie können sie erneut mit ps und grep finden.

ps aux | grep sleep

Suchen Sie nach der Zeile, die zu sleep 300 gehört (nicht nach dem grep-Befehl selbst) und notieren Sie sich dessen 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.

Überprüfen wir nun den aktuellen Nice-Wert (NI) des Prozesses. Der ps-Befehl mit der Option -o ermöglicht es Ihnen, benutzerdefinierte Ausgabespalten anzugeben.

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

Ersetzen Sie <IHRE_PID> durch die tatsächliche PID Ihres sleep-Prozesses. Zum 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 nur den Nice-Wert ihrer eigenen Prozesse erhöhen (wodurch sie eine niedrigere Priorität erhalten).

renice -n 10 -p <IHRE_PID>

Ersetzen Sie auch hier <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 abschließend, 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 langlaufende, nicht kritische Hintergrundaufgaben die wichtigere Vordergrundarbeit nicht beeinträchtigen.

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 manuell einen Prozess stoppen, der nicht mehr benötigt wird, sich fehlerhaft verhält oder für temporäre Zwecke gestartet wurde, wie unser sleep-Befehl. Das primäre Werkzeug dafür ist der Befehl kill.

Der Befehl kill sendet ein Signal an einen angegebenen Prozess. Standardmäßig sendet er das SIGTERM (terminate)-Signal, das den Prozess höflich bittet, sich herunterzufahren, und ihm erlaubt, vor dem Beenden alle Bereinigungsoperationen durchzuführen.

Sie können einen Prozess entweder über seine Prozess-ID (PID) oder, für 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, wird die Shell wahrscheinlich eine Meldung auf dem Terminal ausgeben, die anzeigt, dass der Job beendet wurde. Diese Meldung erscheint möglicherweise sofort oder nachdem Sie erneut Enter drücken.

[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 liefern, da in dieser Shell-Sitzung keine aktiven Jobs mehr vorhanden sind. Sie können auch ps zur Überprüfung verwenden.

ps aux | grep sleep

Die einzige Zeile, die Sie möglicherweise 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 stärkeres Signal senden, SIGKILL (Signalnummer 9), das den Prozess sofort beendet, ohne ihm die Möglichkeit zu geben, Bereinigungen durchzuführen. Der Befehl wäre kill -9 %1. Dies sollte als letztes Mittel eingesetzt werden.

Herzlichen Glückwunsch! Sie haben nun den gesamten Lebenszyklus der grundlegenden Prozessverwaltung unter Linux geübt: einen Prozess im Hintergrund starten, ihn mit ps und top inspizieren, ihn mit Job-Steuerung verwalten, seine Priorität anpassen und ihn schließlich beenden.

Zusammenfassung

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

Darüber hinaus haben Sie die Job-Steuerung 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 auch gelernt, wie Sie die Planungspräferenz eines Prozesses mit renice anpassen und wie Sie einen Prozess mit dem Befehl kill und seiner PID ordnungsgemäß beenden.