Ein Dienst kann gerade laufen, ohne für den automatischen Start eingerichtet zu sein. Umgekehrt kann er für den Systemstart aktiviert sein und trotzdem gestoppt oder fehlgeschlagen sein.
Das ist kein Widerspruch: systemd unterscheidet zwischen dem aktuellen Laufzeitzustand einer Unit und ihrer vorgesehenen Einbindung in das System. Starten und Aktivieren sind deshalb unterschiedliche Vorgänge. Ebenso beendet das Deaktivieren einen laufenden Dienst nicht automatisch.
Für die Linux-Systemadministration gehört diese Unterscheidung zu den wichtigsten Grundlagen. Sie entscheidet darüber, ob ein Dienst nur jetzt läuft, nach einem Neustart wiederkommt oder während einer Wartung unerwartet erneut gestartet werden kann.
Zwei getrennte Fragen: Was passiert jetzt und was ist eingerichtet?
-------------------------------------------------------------------
Bei der Verwaltung eines Dienstes sollten zunächst zwei Fragen getrennt beantwortet werden:
| Perspektive | Frage | Beispiel |
|---|---|---|
| Laufzeitzustand | Was macht die Unit gerade? | Der Dienst läuft oder ist fehlgeschlagen. |
| Einbindungszustand | Wie ist die Unit für ihre vorgesehene Aktivierung eingebunden? | Der Dienst ist über ein Target für den Systemstart aktiviert. |
Diese Zustände sind unabhängig voneinander. Ein Dienst kann beispielsweise gleichzeitig `active` und `disabled` oder `inactive` und `enabled` sein.
### Beispiel: Ein Dienst wird nur vorübergehend benötigt
```
sudo systemctl start beispiel.service
```
Dieser Befehl startet den Dienst jetzt. Er richtet jedoch keine zusätzliche dauerhafte Einbindung für spätere Systemstarts ein. Ob der Dienst beim nächsten Start trotzdem aktiviert wird, hängt unter anderem von bereits vorhandenen Abhängigkeiten und anderen Aktivierungswegen ab.
### Beispiel: Ein Dienst soll künftig automatisch starten
```
sudo systemctl enable beispiel.service
```
Dieser Befehl stellt die Einbindung anhand der Installationsregeln der Unit her. Er startet den Dienst nicht unmittelbar. Dafür wäre zusätzlich `start` oder die Option `--now` erforderlich.
Die verwendete `beispiel.service` steht in diesem Beitrag für eine vorhandene Unit. Vor Änderungen sollte geprüft werden, welche Aufgaben und Abhängigkeiten der jeweilige Dienst besitzt.
Die wichtigsten Verwaltungsaktionen
-----------------------------------
| Aktion | Befehl | Bedeutung |
|---|---|---|
| Starten | `systemctl start` | Die Unit jetzt aktivieren. |
| Stoppen | `systemctl stop` | Die Unit jetzt deaktivieren beziehungsweise den Dienst beenden. |
| Neustarten | `systemctl restart` | Die Unit stoppen und erneut starten; eine inaktive Unit wird ebenfalls gestartet. |
| Neu laden | `systemctl reload` | Die Anwendung zum erneuten Einlesen ihrer Konfiguration auffordern, sofern unterstützt. |
| Aktivieren | `systemctl enable` | Die vorgesehene Einbindung anhand der Installationsregeln herstellen. |
| Deaktivieren | `systemctl disable` | Die entsprechende Einbindung entfernen. |
| Maskieren | `systemctl mask` | Die Aktivierung der Unit blockieren. |
| Maskierung aufheben | `systemctl unmask` | Die Aktivierungssperre entfernen. |
> Die Laufzeitbefehle und die Befehle zur Einbindung erfüllen unterschiedliche Aufgaben. Insbesondere verändern `start` und `stop` nicht automatisch den Enablement-Zustand.
Starten, stoppen und neu starten
--------------------------------
### Einen Dienst starten
```
sudo systemctl start beispiel.service
```
systemd führt den konfigurierten Startvorgang aus. Wann dieser als abgeschlossen gilt, hängt vom Diensttyp ab: Bei `Type=exec` genügt der erfolgreiche Programmaufruf, bei `Type=notify` wird auf die Bereitschaftsmeldung der Anwendung gewartet.
> `Type=` legt im Abschnitt `[Service]` einer systemd-Service-Unit fest, wann systemd deren Start als abgeschlossen betrachtet – beispielsweise nach dem Programmaufruf (`exec`), nach Abschluss einer einmaligen Aufgabe (`oneshot`) oder nach einer Bereitschaftsmeldung der Anwendung (`notify`).
Ein erfolgreicher Startbefehl bedeutet deshalb nicht bei jedem Diensttyp, dass die Anwendung bereits vollständig einsatzbereit ist.
### Einen Dienst stoppen
```
sudo systemctl stop beispiel.service
```
systemd leitet den vorgesehenen Stoppvorgang ein. Je nach Konfiguration werden Stoppbefehle ausgeführt und Signale an die Dienstprozesse gesendet. Beendet sich ein Dienst nicht innerhalb der vorgesehenen Zeit, können seine Prozesse zwangsweise beendet werden.
Ein `stop` ist jedoch keine dauerhafte Startsperre. Die Unit kann später erneut gestartet werden – beispielsweise manuell oder durch eine weiterhin aktive Socket- oder Timer-Unit. systemctl kann auf solche aktiven Auslöser hinweisen.
### Einen Dienst neu starten
```
sudo systemctl restart beispiel.service
```
Dieser Befehl stoppt den Dienst und startet ihn erneut. War er zuvor inaktiv, wird er ebenfalls gestartet.
Soll nur ein bereits laufender Dienst neu gestartet werden, eignet sich:
```
sudo systemctl try-restart beispiel.service
```
Bei einem inaktiven Dienst führt dieser Befehl keinen Start aus. Das kann etwa in Wartungsskripten sinnvoll sein, die absichtlich gestoppte Dienste nicht unbeabsichtigt aktivieren sollen.
Aktivieren bedeutet nicht einfach „beim Booten starten“
-------------------------------------------------------
Häufig wird `enable` mit „Autostart einschalten“ erklärt. Das ist als Einstieg verständlich, aber nicht vollständig.
Genauer wertet `systemctl enable` die Installationsregeln einer Unit aus und erstellt passende symbolische Links. Dadurch wird die Unit beispielsweise in die Abhängigkeiten eines Targets eingebunden.
Eine Service-Unit könnte enthalten:
```
[Install]
WantedBy=multi-user.target
```
Beim Aktivieren entsteht typischerweise eine Verknüpfung nach diesem Muster:
```
/etc/systemd/system/multi-user.target.wants/beispiel.service
```
Wird `multi-user.target` gestartet, kann die darüber eingebundene Unit mit aktiviert werden. Andere Installationsregeln können jedoch andere Einbindungen vorsehen. Deshalb ist `enabled` nicht gleichbedeutend mit einer universellen Garantie, dass die Unit bei jedem Systemstart läuft.
### Aktivieren und sofort starten
```
sudo systemctl enable --now beispiel.service
```
Damit werden zwei Absichten kombiniert:
1. Die vorgesehene Einbindung herstellen.
2. Die Unit unmittelbar starten.
Auch hier lohnt sich eine anschließende Kontrolle: Die Einbindung kann erfolgreich sein, obwohl der unmittelbare Start wegen eines Konfigurationsfehlers scheitert.
Deaktivieren bedeutet nicht stoppen
-----------------------------------
```
sudo systemctl disable beispiel.service
```
Dieser Befehl entfernt die entsprechenden Verknüpfungen. Ein laufender Dienst wird dadurch nicht automatisch beendet.
Soll beides erfolgen:
```
sudo systemctl disable --now beispiel.service
```
Damit wird die Unit deaktiviert und zusätzlich gestoppt. Andere Aktivierungswege werden dadurch allerdings nicht grundsätzlich blockiert.
### Warum kann ein deaktivierter Dienst trotzdem starten?
Eine deaktivierte Unit kann weiterhin gestartet werden:
- durch einen manuellen Startbefehl,
- als Abhängigkeit einer anderen Unit,
- durch Socket-Aktivierung,
- über eine Timer-Unit,
- über eine Path-Unit.
Bei einem zeitgesteuerten Backup ist daher normalerweise die `backup.timer` der richtige Ansatzpunkt, um die Zeitplanung abzuschalten:
```
sudo systemctl disable --now backup.timer
```
Ein bereits laufender Durchlauf der separat aktivierten `backup.service` wird damit nicht automatisch beendet. Timer und Service bleiben eigenständige Units.
Maskieren: Eine Unit gezielt gegen Starts sperren
-------------------------------------------------
Soll eine Unit nicht nur aus ihrer vorgesehenen Einbindung entfernt, sondern gegen Aktivierung gesperrt werden, gibt es die Maskierung:
```
sudo systemctl mask beispiel.service
```
systemd legt dafür eine Verknüpfung auf `/dev/null` an. Startanforderungen für diese Unit schlagen anschließend fehl – unabhängig davon, ob sie manuell, durch Abhängigkeiten oder über andere Aktivierungswege ausgelöst werden.
Maskierung ist damit stärker als Deaktivierung.
### Eine laufende Unit zusätzlich stoppen
Eine Maskierung allein beendet einen bereits laufenden Dienst nicht automatisch. Soll er gleichzeitig gestoppt werden:
```
sudo systemctl mask --now beispiel.service
```
Die Maskierung kann beispielsweise während Wartungsarbeiten sinnvoll sein, wenn die Unit nicht versehentlich erneut aktiviert werden soll.
### Vorübergehende Maskierung bis zum nächsten Neustart
```
sudo systemctl mask --runtime --now beispiel.service
```
`--runtime` legt die Maskierung nur für die aktuelle Laufzeit an. Nach einem Neustart ist diese temporäre Sperre nicht mehr vorhanden.
### Maskierung aufheben
```
sudo systemctl unmask beispiel.service
```
Das entfernt die Sperre. Der Dienst wird dadurch weder automatisch gestartet noch neu aktiviert. Falls beides gewünscht ist, muss es anschließend ausdrücklich erfolgen.
### Grenzen und Vorsicht
Eine Maskierung blockiert den Start über die betreffende systemd-Unit. Sie verhindert nicht grundsätzlich, dass jemand das zugrunde liegende Programm außerhalb dieser Unit ausführt.
Außerdem können abhängige Dienste durch die Sperre beeinträchtigt werden. Bei selbst angelegten Unit-Dateien direkt unter `/etc/systemd/system/` kann `mask` scheitern, weil der für die Maskierung benötigte Pfad bereits durch die Unit-Datei belegt ist. Eine solche Datei sollte nicht unüberlegt überschrieben werden.
Welche Laufzeitzustände gibt es?
--------------------------------
systemd unterscheidet allgemeine Zustände und typspezifische Unterzustände.
| Allgemeiner Zustand | Bedeutung |
|---|---|
| `active` | Die Unit ist entsprechend ihrem Typ aktiv. |
| `inactive` | Die Unit ist nicht aktiv. |
| `activating` | Die Unit befindet sich im Startvorgang. |
| `deactivating` | Die Unit befindet sich im Stoppvorgang. |
| `reloading` | Die aktive Unit lädt ihre Konfiguration neu. |
| `failed` | Die Unit ist beispielsweise durch einen Fehler, einen Absturz oder ein Timeout fehlgeschlagen. |
Weitere Zustände können abhängig von Unit-Typ und systemd-Version hinzukommen.
Die entscheidende Frage lautet deshalb nicht nur „Ist die Unit aktiv?“, sondern „Passt ihr Zustand zu ihrer vorgesehenen Aufgabe?“.
Aktiv bedeutet nicht immer „Prozess läuft“
------------------------------------------
Zur Prüfung der Aktivität nutze folgenden Befehl:
```
systemctl status beispiel.service
```
Die Ausgaben können unterschiedlich ausfallen. Nachfolgend findest du ein paar Beispiele.
### Dauerhaft laufender Dienst
Bei einem laufenden Webserver wäre beispielsweise zu erwarten:
```
Active: active (running)
```
Die Unit ist aktiv, und ihr Dienst befindet sich im Unterzustand `running`.
### Erfolgreich abgeschlossene einmalige Aufgabe
Eine Service-Unit mit:
```
[Service]
Type=oneshot
ExecStart=/usr/local/sbin/meine-aufgabe
```
kann nach erfolgreicher Ausführung so erscheinen:
```
Active: inactive (dead)
```
> Ohne `RemainAfterExit=yes` bleibt sie nach Abschluss nicht aktiv. Das ist für eine abgeschlossene Aufgabe normal und kein Beleg für einen Fehler.
### Aktive Unit ohne laufenden Prozess
Mit:
```
[Service]
Type=oneshot
ExecStart=/usr/local/sbin/meine-aufgabe
RemainAfterExit=yes
```
kann nach erfolgreicher Ausführung stehen:
```
Active: active (exited)
```
Die Unit wird weiterhin als aktiv betrachtet, obwohl ihr Startprogramm bereits beendet ist. systemd merkt sich hier den erfolgreichen Aktivierungszustand. Es überprüft dadurch nicht automatisch, ob die Wirkung des Programms weiterhin besteht.
### Timer und Sockets
Auch andere Unit-Typen verdeutlichen die Unterscheidung:
```
backup.timer active (waiting)
beispiel.socket active (listening)
```
Der Timer wartet auf einen Termin, der Socket auf Kommunikation. Dafür muss die jeweils zugehörige Service-Unit nicht bereits laufen.
Den Zustand richtig abfragen
----------------------------
### Menschenlesbare Übersicht
```
systemctl status beispiel.service
```
Die Ausgabe enthält unter anderem Ladezustand, Einbindungszustand, Laufzeitzustand und aktuelle Journalmeldungen.
Eine vereinfachte Beispielausgabe:
```
Loaded: <strong>loaded</strong> (/usr/lib/systemd/system/beispiel.service; <strong>disabled</strong>)
Active: <strong>active</strong> (<strong>running</strong>)
```
Das bedeutet:
- Die Unit-Definition wurde geladen.
- Die Unit ist nicht über ihre vorgesehenen Enablement-Regeln eingebunden.
- Der Dienst läuft aktuell.
### Laufzeit und Einbindung getrennt prüfen
```
systemctl is-active beispiel.service
systemctl is-enabled beispiel.service
```
Der erste Befehl prüft den aktuellen Aktivitätszustand. Der zweite betrachtet den Einbindungszustand der Unit-Datei.
### Eigenschaften gezielt ausgeben
```
systemctl show beispiel.service
-p LoadState
-p ActiveState
-p SubState
-p UnitFileState
```
`systemctl show` eignet sich für gezielte und maschinenlesbare Abfragen besser als das Auswerten der formatierten `status`-Ausgabe.
`enabled`, `disabled` und `static` richtig einordnen
----------------------------------------------------
Der Einbindungszustand besitzt mehr Möglichkeiten als nur „an“ und „aus“.
| Zustand | Bedeutung |
|---|---|
| `enabled` | Die Unit ist über entsprechende Verknüpfungen eingebunden. |
| `enabled-runtime` | Die Einbindung gilt nur für die aktuelle Laufzeit. |
| `disabled` | Die Unit besitzt Installationsregeln, ist darüber aber nicht aktiviert. |
| `static` | Die Unit besitzt keine eigenen Regeln für eine solche Aktivierung. |
| `masked` | Die Aktivierung ist gesperrt. |
| `masked-runtime` | Die Aktivierung ist für die aktuelle Laufzeit gesperrt. |
Eine `static`-Unit ist nicht automatisch defekt oder unbenutzbar. Sie kann beispielsweise als Abhängigkeit oder durch einen Timer gestartet werden. Nicht jede Service-Unit muss selbst mit `enable` aktiviert werden.
Auch eine Anzeige wie `preset: enabled` ist vom tatsächlichen Zustand zu unterscheiden: Presets beschreiben Vorgaben einer Richtlinie, während `enabled` oder `disabled` die aktuelle Einbindung wiedergibt.
Fehlgeschlagen ist nicht dasselbe wie gestoppt
----------------------------------------------
`inactive` beschreibt zunächst nur einen inaktiven Zustand. `failed` hält dagegen fest, dass systemd einen Fehler erkannt hat.
Zur Untersuchung eignen sich:
```
systemctl status beispiel.service
journalctl -u beispiel.service -b
```
`journalctl -u beispiel.service -b` zeigt die Journalmeldungen an, wobei `-u beispiel.service` die Ausgabe auf die angegebene **U**nit und `-b` auf den aktuellen Systemstart (**B**oot) begrenzt.
Für eine Übersicht fehlgeschlagener Units:
```
systemctl --failed
```
systemd speichert Informationen über Fehlschläge, damit sie administrativ untersucht werden können.
### Fehlerzustand zurücksetzen
```
sudo systemctl reset-failed beispiel.service
```
> Dieser Befehl setzt den gespeicherten Fehlerzustand und unter anderem die Zähler der Startbegrenzung zurück. Er repariert jedoch weder die Konfiguration noch startet er den Dienst.
Eine sinnvolle Reihenfolge ist daher:
1. Fehler untersuchen.
2. Ursache beheben.
3. Falls erforderlich die Startbegrenzung zurücksetzen.
4. Dienst starten.
5. Zustand und tatsächliche Funktion prüfen.
Automatischer Wiederanlauf ist noch eine eigene Einstellung
-----------------------------------------------------------
Neben Laufzeitzustand und Einbindung gibt es eine weitere wichtige Frage: Was soll passieren, wenn ein laufender Dienst unerwartet endet?
Das wird beispielsweise durch folgende Einstellungen geregelt:
```
[Service]
Restart=on-failure
RestartSec=5s
```
`Restart=on-failure` kann einen automatischen Wiederanlauf nach bestimmten Fehlern auslösen. `RestartSec=` legt die Wartezeit zwischen den Versuchen fest. Diese Einstellungen sind unabhängig davon, ob die Unit mit `enable` eingebunden wurde.
> Ein ausdrücklich mit `systemctl stop` gestoppter Dienst wird nicht allein wegen `Restart=always` oder `Restart=on-failure` sofort wieder gestartet. Andere Aktivierungswege können ihn jedoch erneut anfordern.
Damit sind drei Aspekte zu unterscheiden:
| Aspekt | Leitfrage |
|---|---|
| Laufzeitzustand | Was macht die Unit gerade? |
| Einbindung | Wodurch soll sie künftig aktiviert werden? |
| Wiederanlaufregel | Was passiert nach einem unerwarteten Ende? |
Reload und daemon-reload nicht verwechseln
------------------------------------------
Auch beim Umgang mit Konfigurationsänderungen müssen zwei Ebenen getrennt werden.
### Anwendungskonfiguration neu laden
```
sudo systemctl reload beispiel.service
```
Dieser Befehl fordert die Anwendung auf, ihre eigene Konfiguration neu einzulesen. Das muss von Dienst und Unit unterstützt werden.
### Unit-Dateien neu einlesen
```
sudo systemctl daemon-reload
```
Dieser Befehl lässt systemd seine Unit-Definitionen und Abhängigkeiten neu einlesen. Er startet die betroffenen Dienste nicht automatisch neu und lädt auch nicht automatisch deren Anwendungskonfiguration.
Nach einer Änderung an einer Unit kann deshalb beispielsweise erforderlich sein:
```
sudo systemctl daemon-reload
sudo systemctl restart beispiel.service
```
Ob tatsächlich ein Neustart nötig ist, hängt davon ab, welche Einstellungen verändert wurden und wann sie wirksam werden.
Praktische Entscheidungshilfe
-----------------------------
| Gewünschtes Ergebnis | Passender Befehl |
|---|---|
| Dienst jetzt starten | `sudo systemctl start beispiel.service` |
| Dienst jetzt stoppen | `sudo systemctl stop beispiel.service` |
| Dienst neu starten, auch wenn er gerade inaktiv ist | `sudo systemctl restart beispiel.service` |
| Nur einen **bereits laufenden** Dienst neu starten | `sudo systemctl try-restart beispiel.service` |
| Vorgesehene Einbindung herstellen | `sudo systemctl enable beispiel.service` |
| Einbindung herstellen und sofort starten | `sudo systemctl enable --now beispiel.service` |
| Einbindung entfernen | `sudo systemctl disable beispiel.service` |
| Einbindung entfernen und zusätzlich stoppen | `sudo systemctl disable --now beispiel.service` |
| Aktivierung sperren und zusätzlich stoppen | `sudo systemctl mask --now beispiel.service` |
| Aktivierungssperre entfernen | `sudo systemctl unmask beispiel.service` |
Diese Befehle verändern unterschiedliche Aspekte der Unit-Verwaltung. Sie sollten deshalb nach der gewünschten Wirkung ausgewählt werden, nicht nur nach der umgangssprachlichen Vorstellung von „einschalten“ oder „ausschalten“.
Fazit
-----
Zuverlässiges Service-Management beginnt mit der Trennung von aktuellem Zustand, vorgesehener Einbindung und automatischem Wiederanlauf.
`start` beeinflusst den jetzigen Betrieb. `enable` stellt die vorgesehene Einbindung her. `disable` entfernt diese Einbindung, ohne andere Aktivierungswege grundsätzlich zu sperren. `mask` blockiert dagegen den Start über die betreffende Unit.
Ebenso muss ein Zustand zur Aufgabe passen: Ein Webserver soll normalerweise dauerhaft laufen, ein Backup erfolgreich enden und ein Timer auf seinen nächsten Termin warten. Die administrative Bewertung ergibt sich deshalb nicht aus einem einzelnen Statuswort, sondern aus dem Zusammenspiel von Unit-Typ, Konfiguration und tatsächlicher Funktion.
Dienstzustand und Startverhalten – systemd-Dienste richtig steuern
Submitted 9 hours ago by
blog@andreas-moor.de to random@mbin.linuxnation.social
https://andreas-moor.de/?p=78729