# systemctl: Systemd-Dienste und Einheiten Verwalten Unter Linux spielt systemctl eine zentrale Rolle bei der Verwaltung des Init-Systems und Service-Managers systemd. Mit systemctl haben Benutzende die Kontrolle über systemd-Dienste, -Einheiten und -Konfigurationen, was es zu einem unverzichtbaren Werkzeug für die Systemadministration macht. Von der Startkontrolle bis zur Anpassung von Systemzuständen bietet systemctl eine umfassende Palette an Funktionen. ## Was ist systemctl? systemctl ist ein Kommandozeilenwerkzeug zur Verwaltung von **systemd**, einem Init-System und Systemmanager für Linux-Betriebssysteme. systemd ist mittlerweile das Standard-Init-System bei vielen Linux-Distributionen bzw. Linux-Server-Distributionen wie Ubuntu, Debian, Fedora, Red Hat Enterprise Linux (RHEL), CentOS, Arch Linux, Mageia oder Gentoo, jedoch nicht durchgängig in allen Distributionen implementiert. Im systemd-Ökosystem spielt systemctl eine **zentrale Rolle bei der Verwaltung von Systemdiensten, Konfiguration, Startverhalten und Systemwartung**. Die Funktionalität des Tools geht dabei über das einfache Starten und Beenden von Diensten hinaus und bietet eine umfassende Kontrolle über nahezu alle Aspekte eines Linux-Systems. Im nachfolgenden Tutorial finden Sie praktische Codebeispiele und [Linux-Befehle](https://www.ionos.com/de-ch/digitalguide/server/konfiguration/linux-befehle-terminal-kommandos-im-ueberblick/) zur Verwendung von systemctl auf Basis von **Ubuntu 22.04**. ## Verwaltung von Diensten Das primäre Ziel des Init-Systems ist es, die Komponenten zu starten, die nach dem Booten des Linux-Kernels Linux-Kernels benötigt werden („userland“-Komponenten). Darüber hinaus dient das Init-System dazu, Dienste und Daemons auf einem Server zu jedem Zeitpunkt des Systemlaufs effektiv zu steuern. Innerhalb von systemd konzentrieren sich die meisten Prozesse auf sogenannte **Units**, also Ressourcen, die von systemd verwaltet werden. Diese Units werden nach dem Typ der Ressource, die sie repräsentieren, klassifiziert und durch die sogenannten Unit-Dateien definiert. Der Typ einer Unit ist an der Dateiendung erkennbar. Bei der Verwaltung von Diensten stehen speziell die Dienst-Units im Vordergrund, die mit dem Suffix *.service* enden. Häufig ist es bei Dienstverwaltungsbefehlen jedoch nicht nötig, dieses Suffix anzugeben, da systemd in der Lage ist zu erkennen, dass mit diesen Befehlen in der Regel Dienste gemeint sind. ### Starten und Anhalten von Diensten Zu den häufigsten Aufgaben, die unter Linux mit systemctl durchgeführt werden, gehören das Starten und Anhalten von Diensten. Diese Funktionen sind grundlegend für die Systemverwaltung und ermöglichen es, die Kontrolle über die auf einem System laufenden Prozesse zu behalten. Um einen Dienst zu starten, verwenden Sie den Befehl `start`. Wenn Sie als Benutzerin bzw. Benutzer ohne Root-Rechte arbeiten, müssen Sie dabei `sudo` verwenden: ```bash $ sudo systemctl start application.service ``` Da systemd darauf ausgelegt ist, automatisch nach .service-Dateien für Dienstverwaltungsbefehle zu suchen, kann der Befehl auch vereinfacht eingegeben werden: ```bash $ sudo systemctl start application ``` Um beispielsweise den Apache-Webserver zu starten, würden Sie eingeben: ```bash $ sudo systemctl start apache2 ``` Wenn Sie einen laufenden Dienst anhalten möchten, verwenden Sie `stop`: ```bash $ sudo systemctl stop application.service ``` ### Neustart und Neuladen Um einen Dienst neu zu starten, was oft nach einer Konfigurationsänderung erforderlich ist, verwenden Sie den Befehl `restart`: ```bash $ sudo systemctl restart application.service ``` Wenn die entsprechende Anwendung in der Lage ist, ihre **Konfigurationsdateien ohne Neustart neu zu laden**, kann der Befehl `reload` verwendet werden, um diesen Vorgang zu initiieren: ```bash $ sudo systemctl reload application.service ``` Wenn Sie unsicher sind, ob ein Dienst die Möglichkeit bietet, seine Konfiguration neu zu laden, können Sie den Befehl `reload-or-restart` verwenden. Dieser lädt die Konfiguration erneut, falls diese Option unterstützt wird. Sollte das nicht möglich sein, führt der Befehl stattdessen einen Neustart des Dienstes durch, um die aktualisierte Konfiguration zu übernehmen. ```bash $ sudo systemctl reload-or-restart application.service ``` ### Aktivieren und Deaktivieren von Diensten Durch das Aktivieren und Deaktivieren von Diensten können Sie festlegen, ob ein Dienst beim Booten des Systems automatisch gestartet werden soll oder nicht. Dies spielt insbesondere für die Systemleistung, die Sicherheit und das Management von Abhängigkeiten zwischen verschiedenen Diensten eine zentrale Rolle. Um einen Dienst so zu konfigurieren, dass er **beim Systemstart automatisch ausgeführt** wird, verwenden Sie den Befehl `enable`: ```bash $ sudo systemctl enable application.service ``` Indem dieser Prozess ausgeführt wird, entsteht ein symbolischer Link. Dieser Link verbindet die Kopie der Systemdienstdatei, die üblicherweise unter */lib/systemd/system* oder */etc/systemd/system* zu finden ist, mit dem Verzeichnis auf der Festplatte, in dem systemd nach Dateien für den Autostart sucht, was in der Regel unter */etc/systemd/system/some\_target.target.wants* geschieht. ```bash $ sudo systemctl enable application.service ``` Um zu verhindern, dass ein Dienst beim Booten automatisch startet, verwenden Sie `disable`: ```bash $ sudo systemctl disable application.service ``` Hierdurch wird der symbolische Link gelöscht, der zuvor festlegte, dass der Dienst automatisch starten soll. **Achtung**: Das bloße Aktivieren eines Dienstes startet diesen nicht sofort in der aktuellen Sitzung. Um den Dienst sofort zu starten und für den automatischen Start beim Hochfahren zu konfigurieren, müssen Sie sowohl den `start`- als auch den `enable`-Befehl ausführen. ### Überprüfen des Status von Diensten Mit systemctl lassen sich detaillierte Informationen über den Status von Diensten anzeigen. Diese Funktion ist besonders nützlich, um den aktuellen Zustand von System- und Anwendungsdiensten zu überwachen und zu diagnostizieren. Für die Überprüfung verwenden Sie den Befehl `status`: ```bash $ systemctl status application.service ``` Dieser Befehl liefert eine Vielzahl von Informationen, darunter den aktuellen Zustand des Dienstes (aktiv, inaktiv, fehlerhaft etc.), die zuletzt ausgeführten Prozesse und Logmeldungen, die cgroup-Hierarchie und die ersten Protokollzeilen. Um den aktuellen Aktivitätsstatus eines Dienstes unter Linux mit systemctl zu überprüfen, wird `is-active` verwendet. Dieser Befehl gibt an, ob ein Dienst aktuell aktiv ist oder nicht: ```bash $ systemctl is-active application.service ``` Der aktuelle Zustand wird dabei in der Regel mit `active` angegeben, wenn der Dienst aktiv ist, oder `inactive`, wenn der Dienst inaktiv ist. Um zu überprüfen, ob ein Dienst so konfiguriert ist, dass er beim Systemstart automatisch aktiviert wird, können Sie den Befehl `is-enabled` nutzen. Dies ist besonders nützlich, um die Startkonfiguration von Diensten auf einem Linux-System zu verwalten. ```bash $ systemctl is-enabled application.service ``` Der Command zeigt an, ob der Dienst aktiviert oder deaktiviert ist und legt dementsprechend den Exit-Code auf „0“ oder „1“ fest, basierend auf der Rückmeldung. Mit dem Befehl `is-failed` können Sie zudem überprüfen, ob ein bestimmter **Dienst einen Fehlerstatus aufweist**: ```bash $ systemctl is-failed application.service ``` Bei erfolgreicher Ausführung wird `active` ausgegeben, falls ein Fehler vorliegt `failed`. Wenn die Einheit absichtlich gestoppt wurde, kann `unknown` oder `inactive` als Antwort erscheinen. Ein Exit-Status `0` signalisiert das Auftreten eines Fehlers, während `1` auf jeden anderen Zustand hinweist. ## Übersicht über den Systemstatus Die bisher vorgestellten Befehle konzentrierten sich auf das Management einzelner Dienste, aber sie bieten keinen umfassenden Einblick in den gegenwärtigen Systemzustand. Es existiert jedoch eine Vielzahl an systemctl-Commands, die genau diese Art von Informationen liefern. `list-units` ist ein nützliches Werkzeug, um sich einen Überblick über die aktuellen Units auf Linux zu verschaffen: ```bash $ systemctl list-units ``` Wenn Sie den Befehl ausführen, zeigt systemctl eine Liste von Units an, die systemd verwaltet. Die Ausgabe dieser Liste beinhaltet verschiedene Spalten mit spezifischen Informationen über jede Unit. Diese Spalten werden Ihnen angezeigt: - **UNIT**: Der Name der Einheit, oft der Dateiname der entsprechenden Unit-Datei, z. B. *sshd.service* für den SSH-Daemon - **LOAD**: Zeigt an, ob die Unit-Datei erfolgreich geladen wurde; mögliche Werte sind `loaded`, `not-found` oder `error`. - **ACTIVE**: Der Aktivitätsstatus der Einheit; dieser kann Werte wie `active`, `inactive`, `activating` oder `deactivating` annehmen. - **SUB**: Der untergeordnete Aktivitätsstatus, der weitere Details zum Zustand der Einheit gibt; z. B. könnte eine `active`-Einheit einen SUB-Status von `running`, `exited` oder `failed` haben. - **DESCRIPTION**: Eine kurze Beschreibung der Einheit, die oft den Zweck oder die Funktionalität der Einheit wiedergibt Allerdings zeigt der Befehl **standardmäßig nur aktive Einheiten** an, weshalb in der Ausgabe die Spalte LOAD typischerweise `loaded` und die Spalte ACTIVE `active` anzeigt. Mit zusätzlichen Flags lässt sich systemctl so konfigurieren, dass es auch erweiterte Informationen anzeigt. Um z. B. alle von systemd geladenen Einheiten unabhängig von ihrem aktuellen Aktivitätsstatus anzuzeigen, nutzen Sie das Flag `--all`: ```bash $ systemctl list-units --all ``` Die Ausgabe kann weiter verfeinert werden, indem Sie zusätzliche Flags wie `--state=` verwenden, um spezifische Zustände in den Kategorien LOAD, ACTIVE oder SUB zu filtern. Wichtig ist dabei, das `--all`-Flag beizubehalten, damit auch inaktive Einheiten angezeigt werden: ```bash $ systemctl list-units --all --state=inactive ``` Mit dem Filter `--type=` können Sie sich zusätzlich nur bestimmte Arten von Einheiten anzeigen lassen, um z. B. ausschließlich aktive Dienst-Einheiten zu sehen: ```bash $ systemctl list-units --type=service ``` ### Auflisten aller Unit-Dateien Um eine Liste aller Unit-Dateien auf Linux mit systemctl anzuzeigen – inklusive derjenigen, die systemd nicht versucht hat zu laden –, können Sie `list-unit-files` verwenden. Dieser Befehl zeigt alle Unit-Dateien an, die systemd bekannt sind, einschließlich Diensten, Sockets, Targets und mehr. ```bash $ systemctl list-units-files ``` Der Command zeigt verschiedene Zustände von Unit-Dateien an. Diese Zustände geben an, wie die jeweiligen Units konfiguriert sind, insbesondere in Bezug auf ihr Verhalten beim Systemstart. Die häufigsten Zustände sind: - **Enabled**: Die Unit ist so konfiguriert, dass sie automatisch beim Systemstart aktiviert wird. - **Disabled**: Die Unit ist nicht für den automatischen Start beim Bootvorgang konfiguriert. - **Masked**: Die Unit ist vollständig deaktiviert, sodass sie nicht manuell oder automatisch gestartet werden kann. - **Static**: Die Unit wird nicht eigenständig gestartet, sondern hängt typischerweise von einer anderen Unit ab und wird nur in diesem Kontext gestartet. ## Verwaltung von Einheiten Die Verwaltung von Einheiten ist eine der Hauptaufgaben von systemctl. Um spezifischere Informationen über einzelne Einheiten zu erhalten und diese zu verwalten, bietet systemctl eine Reihe von nützlichen Befehlen und Optionen. ### Anzeigen einer Unit-Datei Mit dem Befehl `cat` können Sie sich den Inhalt einer bestimmten Unit-Datei direkt in der Konsole anzeigen lassen. Um z. B. die Unit-Datei eines Dienstes wie *ssh.service* anzusehen, geben Sie ein: ```bash $ systemctl cat ssh.service ``` ### Anzeigen von Abhängigkeiten Abhängigkeiten einer bestimmten Einheit lassen sich durch `list-dependencies` als Baumstruktur anzeigen. Der Befehl sieht wie folgt aus: ```bash $ systemctl list-dependencies sshd.service ``` Standardmäßig werden die Abhängigkeiten für `.target`-Einheiten angezeigt, die verschiedene Systemzustände repräsentieren. Für eine vollständige, rekursive Auflistung aller Abhängigkeiten nutzen Sie das Flag `--all`. Zur Darstellung umgekehrter Abhängigkeiten, also Einheiten, die von der spezifizierten abhängen, fügen Sie `--reverse` zum Befehl hinzu. Zusätzlich ermöglichen die Flags `--before` und `--after`, die Abhängigkeiten zu sehen, die vor bzw. nach der betreffenden Einheit starten. ### Maskieren und Demaskieren von Einheiten Durch das Maskieren einer Einheit wird diese effektiv deaktiviert, sodass sie weder manuell noch automatisch gestartet werden kann. Dies wird oft verwendet, um sicherzustellen, dass ein Dienst oder eine Einheit nicht versehentlich oder automatisch durch Abhängigkeiten gestartet wird. Das Maskieren erfolgt durch Erstellen eines symbolischen Links der betreffenden Unit-Datei zu `/dev/null` mit dem Befehl `mask`: ```bash $ sudo systemctl mask nginx.service ``` Dadurch wird sichergestellt, dass der Nginx-Service, solange er im Maskierungsmodus ist, weder manuell noch automatisch gestartet werden kann. Demaskieren hebt den Maskierungszustand einer Einheit auf, sodass diese wieder normal gestartet werden kann. Der Befehl zum Demaskieren lautet `unmask`: ```bash $ sudo systemctl unmask nginx.service ``` ## Bearbeiten von Unit-Dateien systemctl verfügt über Optionen, um Unit-Dateien anzupassen und zu modifizieren. Diese Fähigkeit wurde mit der Version 218 von systemd eingeführt. Wenn Sie den Befehl `edit` nutzen, wird automatisch eine Unit-Datei der gewählten Einheit zur Bearbeitung geöffnet: ```bash $ sudo systemctl edit nginx.service ``` Bei der Bearbeitung wird eine leere Datei erstellt, um spezifische Anweisungen zu einer Unit-Definition hinzuzufügen oder zu ändern. Für jede Einheit, z.B. `nginx.service`, wird im Verzeichnis `/etc/systemd/system` ein Unterordner angelegt, der den Namen der Datei mit angehängtem `.d` trägt – in diesem Fall also `nginx.service.d`. In diesem Unterordner wird die Datei `override.conf` erzeugt. Wenn systemd die Einheit lädt, kombiniert es den Inhalt dieser Snippet-Datei mit der originalen Unit-Datei, wobei die Anweisungen des Snippets Priorität haben. Um die gesamte Unit-Datei zu bearbeiten, kann das Flag `--full` verwendet werden: ```bash $ sudo systemctl edit --full nginx.service ``` Durch `--full` wird die bestehende Unit-Datei in einem Editor geöffnet, um Modifikationen vorzunehmen. Beim Verlassen des Editors speichert das System die bearbeitete Datei in `/etc/systemd/system`. Um selbst vorgenommene Änderungen rückgängig zu machen, können Sie entweder das Konfigurationsverzeichnis `.d` der Einheit oder die modifizierte Datei in `/etc/systemd/system` löschen: ```bash $ sudo rm -r /etc/systemd/system/nginx.service.d ``` Eine komplett überarbeitete Unit-Datei wird mit folgendem Befehl gelöscht: ```bash $ sudo rm /etc/systemd/system/nginx.service ``` Nach dem Entfernen der Datei oder des Verzeichnisses ist es notwendig, systemd neu zu laden, damit es aufhört, auf die gelöschten Dateien zu verweisen und stattdessen wieder auf die systemeigene Kopie zurückgreift: ```bash $ sudo systemctl daemon-reload ``` ## Anpassen des Systemzustands (Runlevel) mit Zielen Ziele dienen in systemd primär dazu, verschiedene Einheiten zu gruppieren, um spezifische Systemzustände zu realisieren – ähnlich wie Runlevel in anderen Init-Systemen. Die Dateien mit dem Suffix `.target` fungieren als Orientierungspunkte, die den Verfügbarkeitsstatus bestimmter Funktionen anzeigen, sodass Nutzende den gewünschten Gesamtzustand anstatt der einzelnen nötigen Einheiten spezifizieren können. Ein praktisches Beispiel ist das `swap.target`, das den Zustand der Swap-Bereitschaft markiert. Einheiten, die am Swap-Prozess beteiligt sind, können sich mittels Konfigurationsoptionen wie `WantedBy=` oder `RequiredBy=` auf dieses Ziel abstimmen. Einheiten hingegen, die auf Swap angewiesen sind, können dies durch Einstellungen wie `Wants=`, `Requires=` und `After=` kennzeichnen, um ihre Abhängigkeit und Startreihenfolge im Verhältnis zum Swap auszudrücken. ### Abrufen und Einrichten des Standardziels Das Abrufen und Einrichten des Standardziels ermöglicht es, einen Standard-Systemzustand zu bestimmen, den Ihr System beim Start erreichen soll. So finden Sie das Standardziel für Ihr System: ```bash $ systemctl get-default Output multi-user.target ``` Wenn Sie das Standardziel ändern möchten, verwenden Sie den Command `set-default` zusammen mit dem Namen des Ziels. Mit folgendem Befehl setzen Sie das Standardziel auf `graphical.target`, wodurch eine grafische Benutzeroberfläche startet: ```bash $ sudo systemctl set-default graphical.target ``` ### Auflisten verfügbarer Ziele Um alle auf Ihrem System verfügbaren Ziele aufzulisten, können Sie folgenden Befehl verwenden: ```bash $ systemctl list-unit-files --type=target ``` Dies zeigt eine Liste aller auf Ihrem System installierten Ziel-Unit-Dateien an. Für jedes Ziel werden der Pfad und der aktuelle Status (z. B. aktiviert oder deaktiviert) angezeigt. ### Isolieren von Zielen Mit `isolate` lassen sich alle Einheiten aktivieren, die mit einem bestimmten Ziel verbunden sind, und gleichzeitig alle anderen, nicht damit verbundenen Einheiten stoppen. Nehmen wir an, Sie arbeiten in einer Umgebung mit dem aktiven `graphical.target` und möchten auf einen reinen Multi-User-Modus ohne grafische Oberfläche wechseln. In diesem Fall können Sie durch Isolieren des `multi-user.target` das grafische System deaktivieren. Da das `graphical.target` von `multi-user.target` abhängig ist, aber nicht umgekehrt, werden beim Wechsel alle grafischen Services gestoppt. Allerdings sollten Sie vor dem Isolieren eines Ziels die damit verbundenen Abhängigkeiten überprüfen. So vermeiden Sie das ungewollte Anhalten wichtiger Prozesse. ```bash $ systemctl list-dependencies multi-user.target ``` Falls Sie die aktiven Einheiten, die Sie beibehalten möchten, überprüft haben und damit einverstanden sind, können Sie das gewünschte Ziel isolieren: ```bash $ sudo systemctl isolate multi-user.target ``` ### Verwenden von Shortcuts für wichtige Ereignisse Es gibt spezifische Ziele für wesentliche Vorgänge wie das Herunterfahren oder Neustarten des Systems. Unter Linux bietet systemctl jedoch auch praktische Abkürzungen, die zusätzliche Funktionen bereitstellen. Um z. B. das System in den Rettungsmodus (Single-User-Modus) zu versetzen, können Sie einfach `rescue` anstelle von `isolate rescue.target` verwenden: ```bash $ sudo systemctl rescue ``` Mit `halt` können Sie das System anhalten: ```bash $ sudo systemctl halt ``` Ein vollständiges Herunterfahren können Sie mit `poweroff` einleiten: ```bash $ sudo systemctl poweroff ``` Mit `reboot` leiten Sie dagegen einen Neustart ein: ```bash $ sudo systemctl reboot ``` Diese Befehle informieren eingeloggte Nutzerinnen und Nutzer über bevorstehende Ereignisse, was durch reines Ausführen oder Isolieren des Ziels nicht erreicht wird. Es ist wichtig zu wissen, dass viele Rechner die kürzeren Befehle für diese Aktionen mit systemd verknüpfen, um eine korrekte Ausführung zu gewährleisten. Für einen Systemneustart etwa ist normalerweise der folgende Befehl ausreichend: ```bash $ sudo reboot ``` This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/server/konfiguration/systemctl/](https://www.ionos.com/de-ch/digitalguide/server/konfiguration/systemctl/) for AI/LLM consumption.