Beenden von Linux-Prozessen

Einführung

In diesem Lab werden Sie grundlegende Fähigkeiten zur Linux-Prozessverwaltung erlernen, wobei der Schwerpunkt darauf liegt, wie man Prozesse identifiziert und beendet. Die Prozessverwaltung ist eine grundlegende Fähigkeit für jeden Linux-Benutzer oder -Administrator, da sie es Ihnen ermöglicht, die Systemressourcen effektiv zu verwalten.

Sie werden lernen, wie Sie den Befehl ps verwenden, um laufende Prozesse zu identifizieren, und den Befehl kill, um diese bei Bedarf zu beenden. Diese Tools sind unerlässlich für die Aufrechterhaltung der Systemleistung und die Behandlung unresponsive Anwendungen.

Am Ende dieses Labs können Sie Prozesse identifizieren, ihre Attribute verstehen und sie mit verschiedenen Methoden beenden. Diese Fähigkeiten sind wertvoll für die Fehlerbehebung und die effiziente Verwaltung von Linux-Systemen.

Skills Graph

Prozesse identifizieren

In Linux wird jedes laufende Programm oder jede laufende Anwendung als ein Prozess betrachtet. Jeder Prozess hat einen eindeutigen Bezeichner, der als Prozess-ID (PID) bezeichnet wird. Bevor Sie einen Prozess beenden können, müssen Sie ihn anhand seiner PID identifizieren.

Beginnen wir damit, zu lernen, wie man laufende Prozesse mit dem Befehl ps anzeigt. Dieser Befehl zeigt Informationen über aktive Prozesse in Ihrem System an.

Öffnen Sie zunächst ein Terminal in der LabEx-VM-Umgebung und führen Sie den folgenden Befehl aus:

ps

Sie werden eine grundlegende Liste der Prozesse sehen, die in Ihrer aktuellen Terminalsitzung laufen. Die Ausgabe sollte in etwa so aussehen:

  PID TTY          TIME CMD
 2104 pts/0    00:00:00 zsh
 2116 pts/0    00:00:00 ps

Diese Ausgabe zeigt:

• PID: Die Prozess-ID-Nummer
• TTY: Der Terminaltyp, auf dem der Prozess läuft
• TIME: Die von dem Prozess verwendete CPU-Zeit
• CMD: Der Befehl, der den Prozess gestartet hat

Um eine umfassendere Liste aller auf dem System laufenden Prozesse zu sehen, verwenden Sie den folgenden Befehl mit zusätzlichen Optionen:

ps -aux

Die Optionen bedeuten:

• -a: Zeige Prozesse aller Benutzer an
• -u: Zeige eine detaillierte, benutzerorientierte Formatierung an
• -x: Schließe Prozesse ohne Steuerterminal ein

Die Ausgabe wird viel länger und detaillierter sein und alle auf dem System laufenden Prozesse anzeigen:

USER         PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root           1  0.0  0.1 167936 11876 ?        Ss   10:30   0:01 /sbin/init
root           2  0.0  0.0      0     0 ?        S    10:30   0:00 [kthreadd]
...
labex       2104  0.0  0.1  11108  5456 pts/0    Ss   10:35   0:00 zsh
labex       2130  0.0  0.0   9828  3384 pts/0    R+   10:36   0:00 ps -aux

Nun erstellen wir einen einfachen Hintergrundprozess, den wir zur Übung verwenden können:

sleep 300 &
sleep_pid=$!

Dieser Befehl startet einen Prozess, der 300 Sekunden (5 Minuten) lang "schlafen" (nichts tun) wird. Das Symbol & lässt ihn im Hintergrund laufen, und $! erfasst die PID des zuletzt gestarteten Hintergrundprozesses.

Lassen Sie uns überprüfen, ob der Prozess läuft:

echo "The sleep process ID is: $sleep_pid"
ps | grep sleep

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

The sleep process ID is: 2135
 2135 pts/0    00:00:00 sleep

Jetzt wissen Sie, wie Sie Prozesse identifizieren und ihre PIDs finden. Im nächsten Schritt lernen wir, wie man diesen Prozess beendet.

Prozesse mit 'kill' beenden

Nachdem Sie nun einen Prozess und seine PID identifiziert haben, können Sie lernen, wie Sie ihn mit dem Befehl kill beenden. Der kill-Befehl sendet ein Signal an einen Prozess, um ihn anzuweisen, sich zu beenden.

Die grundlegende Syntax für den kill-Befehl lautet:

kill [options] <PID>

Beenden wir nun den "sleep"-Prozess, den wir im vorherigen Schritt erstellt haben. Wir haben seine PID in der Variable $sleep_pid gespeichert. Verwenden Sie den folgenden Befehl, um ihn zu beenden:

kill $sleep_pid

Falls Sie die PID vergessen haben, können Sie sie erneut mit folgendem Befehl finden:

ps | grep sleep

Nachdem Sie den kill-Befehl ausgeführt haben, überprüfen Sie, ob der Prozess beendet wurde:

ps | grep sleep

Wenn der Prozess erfolgreich beendet wurde, sollten Sie keine Ausgabe sehen oder nur den grep-Prozess selbst in der Ausgabe. Dies bedeutet, dass der "sleep"-Prozess nicht mehr läuft.

Wenn Sie es gründlich angehen möchten, können Sie erneut den ps-Befehl verwenden, um alle Prozesse aufzulisten:

ps -aux | grep sleep

Dies könnte etwas wie Folgendes anzeigen:

labex       2156  0.0  0.0   7236   720 pts/0    S+   10:40   0:00 grep --color=auto sleep

Der einzige angezeigte Prozess ist der grep-Befehl selbst, was darauf hinweist, dass der "sleep"-Prozess beendet wurde.

Standardmäßig sendet der kill-Befehl ein TERM (beenden)-Signal an den Prozess, das es dem Prozess ermöglicht, sich nach der Durchführung aller Bereinigungsoperationen gracefully (ordnungsgemäß) zu beenden. In den meisten Fällen reicht dies aus, um einen Prozess zu beenden.

Sie haben nun erfolgreich einen Prozess identifiziert und mit dem kill-Befehl beendet, was eine grundlegende Fähigkeit für die Prozessverwaltung in Linux ist.

Verständnis von Kill-Signalen

In Linux kann der kill-Befehl verschiedene Arten von Signalen an Prozesse senden, nicht nur Beendigungssignale. Das Verständnis dieser Signale gibt Ihnen mehr Kontrolle darüber, wie Prozesse beendet werden.

Zunächst lassen Sie uns alle verfügbaren Signale anzeigen, indem wir folgenden Befehl ausführen:

kill -l

Dies listet alle Signale auf, die der kill-Befehl senden kann. Die Ausgabe sieht wie folgt aus:

 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
...

Die am häufigsten verwendeten Signale sind:

• SIGTERM (15): Standard-Signal, das vom kill-Befehl gesendet wird. Fordert den Prozess auf, sich gracefully (ordnungsgemäß) zu beenden.
• SIGKILL (9): Erzwingt die sofortige Beendigung des Prozesses. Verwenden Sie es, wenn ein Prozess nicht auf SIGTERM reagiert.
• SIGHUP (1): Traditionell verwendet, um Konfigurationsdateien zurückzusetzen oder neu zu laden.
• SIGINT (2): Wird gesendet, wenn Sie in der Konsole Ctrl+C drücken.

Erstellen wir nun einen weiteren "sleep"-Prozess, um damit zu üben:

sleep 300 &
sleep_pid=$!
echo "The new sleep process ID is: $sleep_pid"

Jetzt senden wir ein bestimmtes Signal an den Prozess mithilfe der Signalnummer:

kill -15 $sleep_pid

Dies entspricht dem Standard-kill-Befehl, da er SIGTERM (Signal 15) sendet.

Überprüfen Sie, ob der Prozess beendet wurde:

ps | grep sleep

Erstellen wir noch einen "sleep"-Prozess, um das SIGKILL-Signal zu demonstrieren:

sleep 300 &
sleep_pid=$!
echo "The third sleep process ID is: $sleep_pid"

Jetzt verwenden wir das SIGKILL-Signal, um den Prozess zwangsweise zu beenden:

kill -9 $sleep_pid

Überprüfen Sie, ob der Prozess beendet wurde:

ps | grep sleep

Das SIGKILL-Signal (9) ist eine "letzte Rettungsmethode", weil:

1. Es dem Prozess nicht erlaubt, seine eigenen Ressourcen aufzuräumen.
2. Es Ressourcen in einem inkonsistenten Zustand lassen kann.
3. Es zu Datenverlust führen kann, wenn der Prozess gerade Daten schreibt.

Versuchen Sie immer zunächst SIGTERM, und verwenden Sie SIGKILL nur, wenn der Prozess auf SIGTERM nicht reagiert.

Fortgeschrittene Prozessverwaltung

Linux bietet zusätzliche Befehle zur Prozessverwaltung, die über die grundlegenden ps- und kill-Befehle hinausgehen. Diese Tools bieten mehr Flexibilität und Komfort bei der Identifizierung und Beendigung von Prozessen.

Der pgrep-Befehl

Der pgrep-Befehl ermöglicht es Ihnen, Prozesse anhand ihres Namens zu finden, anstatt die Ausgabe von ps visuell durchsuchen zu müssen:

pgrep sleep

Dieser Befehl findet alle Prozesse, deren Name "sleep" enthält, und gibt ihre PIDs aus.

Der pkill-Befehl

Der pkill-Befehl kombiniert die Funktionen von pgrep und kill – er sucht Prozesse anhand ihres Namens und sendet ihnen ein Signal:

## Start two sleep processes
sleep 300 &
sleep 300 &

## Kill all sleep processes
pkill sleep

Überprüfen Sie, ob alle "sleep"-Prozesse beendet wurden:

ps | grep sleep

Der killall-Befehl

Ähnlich wie pkill beendet der killall-Befehl Prozesse anhand ihres Namens:

## Start two more sleep processes
sleep 300 &
sleep 300 &

## Kill all sleep processes
killall sleep

Überprüfen Sie erneut:

ps | grep sleep

Prozesspriorität mit nice und renice

Linux ermöglicht es Ihnen auch, die Priorität von Prozessen mit den Befehlen nice und renice zu steuern.

Starten wir einen Prozess mit einer niedrigeren Priorität:

nice -n 10 sleep 300 &

Der nice-Wert reicht von -20 (höchste Priorität) bis 19 (niedrigste Priorität). Der Standardwert ist 0. Nur der Root-Benutzer kann negative nice-Werte festlegen.

Sie können die Priorität eines laufenden Prozesses mit renice ändern:

sleep_pid=$!
echo "Sleep process ID with lower priority: $sleep_pid"
renice -n 15 -p $sleep_pid

Lassen Sie uns die neue Priorität überprüfen:

ps -o pid,nice,cmd -p $sleep_pid

Beenden Sie schließlich diesen Prozess:

kill $sleep_pid

Diese fortgeschrittenen Prozessverwaltungsbefehle bieten effizientere Möglichkeiten zur Verwaltung mehrerer Prozesse und zur Steuerung von Systemressourcen. Dies ist besonders nützlich auf ausgelasteten Systemen oder bei der Fehlersuche bei Leistungsproblemen.

Zusammenfassung

In diesem Lab haben Sie essentielle Linux-Prozessverwaltungsfähigkeiten gelernt, die für die Systemadministration und die Fehlersuche von großem Wert sind:

1. Identifizierung von Prozessen: Sie haben gelernt, wie Sie den ps-Befehl verwenden, um laufende Prozesse aufzulisten und ihre Prozess-IDs (PIDs) zu finden.

2. Beendigung von Prozessen: Sie haben geübt, den kill-Befehl zu verwenden, um Beendigungssignale an Prozesse mithilfe ihrer PIDs zu senden.

3. Verständnis von Kill-Signalen: Sie haben verschiedene Arten von Signalen erkundet, die an Prozesse gesendet werden können, einschließlich SIGTERM (15) für eine ordnungsgemäße Beendigung und SIGKILL (9) für eine zwangsweise Beendigung.

4. Fortgeschrittene Prozessverwaltung: Sie haben leistungsfähigere Tools wie pgrep, pkill und killall entdeckt, um Prozesse anhand ihres Namens zu finden und zu beenden, sowie gelernt, wie Sie die Prozesspriorität mit nice und renice steuern können.

Diese Fähigkeiten ermöglichen es Ihnen:

• Systemprozesse effektiv zu überwachen
• unresponsive Anwendungen zu beenden
• Systemressourcen zu verwalten
• Leistungsprobleme zu beheben

Die Prozessverwaltung ist ein grundlegender Aspekt der Linux-Systemadministration, und die Befehle, die Sie in diesem Lab gelernt haben, werden täglich von Linux-Administratoren und -Benutzern verwendet, um die Systemleistung und -stabilität aufrechtzuerhalten.