Linux-Prozessverwaltung: Prozesse mit kill, killall und pkill beenden

Einführung

In diesem Lab erfahren Sie, wie Sie Prozesse in Linux mit den Befehlen kill, killall und pkill beenden können. Diese Befehle sind unerlässlich für die Verwaltung laufender Prozesse und können verwendet werden, um unresponsive Anwendungen zu stoppen oder Systemressourcen freizugeben.

Am Ende dieses Labs können Sie:

Den kill-Befehl verwenden, um einen bestimmten Prozess zu beenden
Den killall-Befehl verwenden, um mehrere Prozesse anhand ihres Namens zu beenden
Den pkill-Befehl als Alternative zu killall verwenden

Grundlagen von Prozess-IDs und Signalen verstehen

Bevor wir beginnen, Prozesse zu beenden, ist es wichtig, zwei Schlüsselkonzepte zu verstehen: Prozess-IDs (PIDs) und Signale.

Öffnen Sie ein Terminal in Ihrer Ubuntu-VM. Standardmäßig sollten Sie sich im Verzeichnis /home/labex/project befinden. Wenn Sie sich nicht sicher sind, können Sie immer Ihren aktuellen Ordner überprüfen, indem Sie pwd eingeben und Enter drücken.
Beginnen wir damit, einen einfachen Hintergrundprozess auszuführen. Geben Sie den folgenden Befehl ein:
```
sleep 1000 &
```
Dieser Befehl startet einen Prozess, der 1000 Sekunden schläft und führt ihn im Hintergrund aus. Das & am Ende teilt der Shell mit, den Befehl im Hintergrund auszuführen, sodass Sie weiterhin das Terminal verwenden können.
Um die laufenden Prozesse anzuzeigen, verwenden Sie den ps-Befehl:
```
ps aux | grep sleep
```
Dieser Befehl zeigt alle laufenden Prozesse (ps aux) an und filtert dann die Ausgabe, um nur die Zeilen anzuzeigen, die "sleep" enthalten (grep sleep).

Sie sollten eine Ausgabe ähnlich dieser sehen:

Die Zahl in der zweiten Spalte ist die Prozess-ID (PID). Wir werden diese später verwenden, um den Prozess zu beenden.

Linux verwendet Signale, um mit Prozessen zu kommunizieren. Die häufigsten Signale zum Beenden von Prozessen sind:
- SIGTERM (15): Beendet den Prozess gracefully (sanft). Dies ist das Standard-Signal, das vom kill-Befehl gesendet wird.
- SIGKILL (9): Beendet den Prozess zwangsweise. Dies sollte als letztes Mittel verwendet werden, wenn SIGTERM nicht funktioniert.

Nachdem wir nun PIDs und Signale verstanden haben, sind wir bereit, mit der Verwendung des kill-Befehls fortzufahren.

Verwendung des kill-Befehls

Der kill-Befehl wird verwendet, um ein Signal an einen bestimmten Prozess zu senden, der anhand seiner PID identifiziert wird. Standardmäßig sendet er das SIGTERM-Signal, das den Prozess auffordert, sich gracefully (sanft) zu beenden.

Versuchen wir, den sleep-Prozess zu beenden, den wir zuvor gestartet haben. Zunächst finden Sie seine PID mit dem ps-Befehl:
```
ps aux | grep sleep
```
Notieren Sie sich die PID des sleep-Prozesses. Es wird eine Zahl in der zweiten Spalte der Ausgabe sein.
Verwenden Sie nun den kill-Befehl, um den Prozess zu beenden:
```
kill <PID>
```
Ersetzen Sie <PID> durch die tatsächliche Prozess-ID, die Sie notiert haben. Wenn die PID beispielsweise 1234 ist, würden Sie kill 1234 eingeben.
Überprüfen Sie, ob der Prozess noch läuft:
```
ps aux | grep sleep
```
Der sleep-Prozess sollte in der Ausgabe nicht mehr erscheinen, außer für den grep-Befehl selbst.

Wenn der Prozess immer noch läuft (was für einen einfachen sleep-Befehl unwahrscheinlich, aber für komplexere Anwendungen möglich ist), können Sie ein stärkeres Signal verwenden:

kill -9 <PID>

Beenden eines Prozesses mit dem kill-Befehl

Dies sendet das SIGKILL-Signal, das den Prozess zwangsweise beendet. Seien Sie bei der Verwendung von SIGKILL vorsichtig, da es dem Prozess nicht erlaubt, seine Ressourcen aufzuräumen, was in komplexeren Anwendungen zu Datenverlust oder anderen Problemen führen kann.

Verwendung des killall-Befehls

Der killall-Befehl ermöglicht es Ihnen, Prozesse anhand ihres Namens zu beenden. Dies kann bequemer sein als die Verwendung von PIDs, insbesondere wenn mehrere Instanzen des gleichen Programms laufen.

Starten Sie mehrere sleep-Prozesse:
```
sleep 2000 &
sleep 2000 &
sleep 2000 &
```
Dieser Befehl startet drei separate sleep-Prozesse, die jeweils 2000 Sekunden im Hintergrund laufen.
Überprüfen Sie, ob die Prozesse laufen:
```
ps aux | grep sleep
```
Sie sollten drei sleep-Prozesse aufgeführt sehen.
Verwenden Sie nun den killall-Befehl, um alle sleep-Prozesse zu beenden:
```
sudo killall sleep
```
Wir verwenden hier sudo, da killall möglicherweise erhöhte Berechtigungen benötigt, um Prozesse zu beenden, die von anderen Benutzern oder Systemprozessen gestartet wurden. Möglicherweise werden Sie aufgefordert, Ihr Passwort einzugeben.
Überprüfen Sie, ob die Prozesse beendet wurden:
```
ps aux | grep sleep
```
Der sleep-Prozess sollte in der Ausgabe nicht mehr erscheinen, außer für den grep-Befehl selbst.

Wenn Sie eine Fehlermeldung "Operation not permitted" erhalten, bedeutet dies, dass Sie nicht über die erforderlichen Berechtigungen verfügen, um bestimmte Prozesse zu beenden. In diesem Fall sollte die Verwendung von sudo, wie oben gezeigt, das Problem beheben.

Verwendung des pkill-Befehls

Der pkill-Befehl ist eine weitere Möglichkeit, Prozesse anhand ihres Namens zu beenden, ähnlich wie killall. Er ist besonders nützlich, wenn Sie Prozesse basierend auf partiellen Namensübereinstimmungen beenden möchten.

Starten Sie noch einige sleep-Prozesse:
```
sleep 3000 &
sleep 3000 &
sleep 3000 &
```
Dies startet drei weitere sleep-Prozesse, die jeweils 3000 Sekunden im Hintergrund laufen.
Verwenden Sie den pkill-Befehl, um diese Prozesse zu beenden:
```
sudo pkill sleep
```
Wie bei killall verwenden wir sudo, um sicherzustellen, dass wir die erforderlichen Berechtigungen haben, um alle übereinstimmenden Prozesse zu beenden.
Überprüfen Sie, ob die Prozesse beendet wurden:
```
ps aux | grep sleep
```
Der sleep-Prozess sollte in der Ausgabe nicht mehr erscheinen, außer für den grep-Befehl selbst.

Der Hauptunterschied zwischen pkill und killall besteht darin, dass pkill auf einen partiellen Prozessnamen matchen kann. Beispielsweise würde pkill fire sowohl firefox- als auch firebird-Prozesse beenden. Dies kann sowohl mächtig als auch gefährlich sein, also überprüfen Sie Ihre pkill-Befehle immer nochmal, bevor Sie sie ausführen.

Übung mit echten Anwendungen

Nachdem Sie gelernt haben, wie Sie kill, killall und pkill verwenden, üben wir nun mit einer realen Anwendung. Wir verwenden Firefox als Beispiel. Sie müssen diesen Schritt in der Desktopumgebung ausführen.

Beispiel für die Beendigung des Firefox-Prozesses

Starten Sie den Firefox-Webbrowser:
```
firefox &
```
Dieser Befehl startet Firefox im Hintergrund. Sie sollten das Firefox-Fenster auf Ihrem Desktop öffnen sehen.
Verwenden Sie den ps-Befehl, um die PID von Firefox zu finden:
```
ps aux | grep firefox
```
Notieren Sie sich die PID des Haupt-Firefox-Prozesses. Dies ist in der Regel der erste aufgeführte Firefox-Prozess.
Verwenden Sie den kill-Befehl, um Firefox zu beenden:
```
kill <PID>
```
Ersetzen Sie <PID> durch die tatsächliche Prozess-ID von Firefox, die Sie notiert haben.
Wenn Firefox nicht schließt (was möglich ist, da einige Anwendungen das SIGTERM-Signal abfangen), versuchen Sie, das SIGKILL-Signal zu verwenden:
```
kill -9 <PID>
```
Denken Sie daran, dass SIGKILL nur als letztes Mittel verwendet werden sollte, da es der Anwendung nicht erlaubt, ihren Zustand zu speichern oder sich ordnungsgemäß aufzuräumen.
Alternativ können Sie killall oder pkill verwenden:
```
sudo killall firefox
```
oder
```
sudo pkill firefox
```
Diese Befehle beenden alle Firefox-Prozesse auf einmal, was bequemer sein kann als das einzelne Beenden von Prozessen.

Denken Sie daran, dass das zwangsweise Beenden von Anwendungen zu Datenverlust führen kann. Es ist daher immer besser, Anwendungen normal zu schließen, wenn möglich. Diese Befehle sollten verwendet werden, wenn eine Anwendung nicht reagiert oder wenn Sie schnell Systemressourcen freigeben müssen.

Zusammenfassung

Herzlichen Glückwunsch! Sie haben diesen Lab (Übungsabschnitt) zum Beenden von Prozessen in Linux erfolgreich abgeschlossen. Sie haben gelernt, wie Sie:

Den kill-Befehl verwenden, um einen bestimmten Prozess anhand seiner PID zu beenden
Den killall-Befehl verwenden, um mehrere Prozesse anhand ihres Namens zu beenden
Den pkill-Befehl als Alternative zu killall nutzen
Diese Befehle sowohl auf einfache Hintergrundprozesse als auch auf reale Anwendungen anwenden

Denken Sie daran, dass diese Befehle zwar mächtige Werkzeuge für die Prozessverwaltung sind, aber vorsichtig eingesetzt werden sollten. Das Beenden kritischer Systemprozesse kann zu Systeminstabilitäten führen. Überprüfen Sie immer den Prozess, den Sie beenden möchten, bevor Sie diese Befehle verwenden.

Im Laufe Ihrer Linux-Reise werden Sie feststellen, dass diese Fähigkeiten in der Prozessverwaltung unschätzbar sind, um ein reibungslos funktionierendes System aufrechtzuerhalten und Probleme zu beheben. Üben Sie diese Befehle weiterhin, um sich mit der Prozessverwaltung in Linux besser auszukennen!

Prozesse in Linux beenden