Installierte Software erfüllt ihren Zweck erst dann, wenn sie zur richtigen Zeit mit der passenden Konfiguration ausgeführt wird. Bei einem Desktop-Programm entscheidet darüber häufig der Benutzer. Ein SSH-Dienst, eine Datenbank oder ein regelmäßig ausgeführter Sicherungsauftrag benötigt dagegen einen geregelten Lebenszyklus: starten, betriebsbereit werden, überwacht werden und bei Bedarf kontrolliert enden.
Service-Management beschäftigt sich mit dieser Steuerung. Unter Linux übernimmt ein **Dienstmanager**, wie [systemd](https://systemd.io/), Aufgaben wie das Starten und Überwachen von Prozessen, die Verwaltung von Abhängigkeiten und die Einbindung in den Systemstart. systemd verbindet diese Aufgaben mit weiteren Funktionen wie zeit- und ereignisgesteuerter Aktivierung, Ressourcenverwaltung und der Konfiguration von Ausführungsumgebungen.
Dieser Beitrag gibt einen Überblick aus Sicht der Systemadministration. Im Mittelpunkt stehen die Zusammenhänge und betrieblichen Entscheidungen. Konkrete Befehle, eigene Dienstdefinitionen und ausführliche Fehleranalysen folgen später in separaten Praxisbeiträgen.
Was bedeutet Service-Management?
--------------------------------
> Service-Management bezeichnet hier die technische Verwaltung von Diensten auf einem Linux-System.
Gemeint ist nicht ein umfassendes organisatorisches IT-Service-Management, sondern die Frage, **wie Anwendungen und Hintergrundaufgaben kontrolliert ausgeführt werden**.
Aus administrativer Sicht gehören dazu mehrere Entscheidungen:
- Wann soll ein Dienst starten?
- Welche Voraussetzungen benötigt er?
- Unter welchem Benutzerkonto läuft er?
- Auf welche Dateien und Ressourcen darf er zugreifen?
- Woran wird sein Zustand erkannt?
- Wie soll auf Fehler reagiert werden?
- Wie wird er aktualisiert und kontrolliert beendet?
Ein Dienstmanager bildet viele dieser Entscheidungen in einer maschinenlesbaren Konfiguration ab. Bei systemd werden unter anderem Startbefehle, Prozessüberwachung, Abhängigkeiten und Ausführungsbedingungen über **Units** beschrieben.
### Mehr als Starten und Stoppen
Ein funktionierender Dienstbetrieb besteht nicht nur daraus, einen Prozess im Hintergrund zu starten. Er soll auch nach einem Neustart nachvollziehbar verfügbar sein, Fehler erkennbar machen und sich kontrolliert verändern lassen.
> Der Dienstmanager ist dabei ein Werkzeug des Betriebs. Er ersetzt weder eine korrekte Anwendungskonfiguration noch Datensicherung, fachliche Funktionsprüfungen oder ein durchdachtes Zugriffskonzept.
Programme, Prozesse, Daemons und Dienste
----------------------------------------
Für das Verständnis hilft es, einige Begriffe auseinanderzuhalten:
| Begriff | Bedeutung |
|---|---|
| Programm | Die ausführbare Software einschließlich ihrer Programmdateien. |
| Prozess | Eine konkrete laufende Instanz eines Programms. |
| Daemon | Ein typischerweise länger laufender Hintergrundprozess, der Aufgaben oder Anfragen bearbeitet. |
| Dienst | Eine verwaltete Funktion oder Aufgabe, die durch einen oder mehrere Prozesse umgesetzt werden kann. |
Eine Datenbank ist aus Anwendungssicht ein Dienst. Technisch kann sie aus mehreren Prozessen bestehen. Eine **systemd-Service-Unit** beschreibt, wie diese Prozesse gestartet und verwaltet werden.
> Nicht jeder Dienst muss dauerhaft laufen: Auch eine einmalige Aufgabe kann als Service ausgeführt werden. systemd unterstützt dafür unter anderem den Diensttyp `oneshot`.
### Systemfunktion oder bereitgestellte Anwendung?
Dienste lassen sich nach ihrem Zweck unterscheiden:
- Systemnahe Dienste unterstützen beispielsweise die grundlegenden Funktionen des Hosts.
- Infrastruktur- und Anwendungsdienste stellen Funktionen für andere Systeme oder Benutzer bereit.
Das ist keine harte technische Trennung. Ein Webserver kann fachlich ein Anwendungsdienst und zugleich technisch ein systemweit verwalteter systemd-Dienst sein.
Für die Administration ist deshalb hilfreich, zwei Fragen getrennt zu beantworten: Welche Funktion stellt der Dienst bereit – und wie wird er ausgeführt?
Init-System und Dienstmanager
-----------------------------
Beim Systemstart wird zunächst die grundlegende Umgebung aufgebaut, in der Benutzerprogramme und Dienste laufen können. Mit „Umgebung“ sind hier die technischen Voraussetzungen gemeint: Dateisysteme werden eingebunden, Geräte verfügbar gemacht und benötigte Verzeichnisse wie `/tmp` für temporäre Dateien bereitgestellt. systemd koordiniert diese Einrichtung und startet Dienste entsprechend ihren Abhängigkeiten, sobald die jeweils benötigten Voraussetzungen erfüllt sind.
systemd selbst kann in mehreren getrennten Instanzen laufen: einer Systeminstanz und zusätzlichen Benutzerinstanzen. Jede Instanz ist eine eigene laufende Ausführung von systemd und damit ein eigenständiger Prozess mit einer bestimmten Verwaltungsaufgabe.
- **Systeminstanz**: Sie läuft mit der Prozess-ID **1** und verwaltet die Dienste des gesamten Systems.
- **Benutzerinstanzen**: Sie laufen als zusätzliche systemd-Prozesse mit jeweils einer eigenen, anderen Prozess-ID. Jede Benutzerinstanz verwaltet die Dienste eines bestimmten Benutzers.
Laufen beispielsweise die Systeminstanz und eine Benutzerinstanz, gibt es somit zwei separate systemd-Prozesse – dasselbe Programm läuft zweimal, aber mit unterschiedlichen Verwaltungsaufgaben.
Dabei sind zwei Aufgaben eng verbunden:
- Die Systeminitialisierung stellt die benötigte Benutzerumgebung bereit.
- Die Dienstverwaltung steuert den weiteren Lebenszyklus der Dienste.
Der Systemstart ist somit nur der Anfang. Auch danach müssen Dienste aktiviert, beendet, neu gestartet und überwacht werden.
### Schwerpunkt dieses Beitrags
Die folgenden Abschnitte verwenden systemd als konkretes Modell. Neben systemd existieren andere Init-Systeme und Werkzeuge zur Dienstverwaltung, etwa SysVinit, OpenRC und runit. systemd hat sich jedoch bei den meisten weitverbreiteten Linux-Distributionen als De-facto-Standard etabliert – sowohl im Unternehmensumfeld als auch im privaten Einsatz. Das gilt beispielsweise für Debian, Ubuntu, Fedora, Red Hat Enterprise Linux und openSUSE. Einzelne Distributionen wie Alpine Linux und Void Linux setzen weiterhin auf Alternativen.
Die grundlegenden administrativen Fragen – Startverhalten, Berechtigungen, Abhängigkeiten, Fehlerbehandlung und Nachvollziehbarkeit – lassen sich jedoch unabhängig vom verwendeten Werkzeug betrachten.
systemd und das Konzept der Units
---------------------------------
**systemd verwaltet nicht ausschließlich Hintergrundprozesse.** Seine grundlegenden Verwaltungseinheiten heißen **Units**. Unterschiedliche Unit-Typen beschreiben verschiedene Ressourcen und Aufgaben.
| Unit-Typ | Aufgabe |
|---|---|
| `.service` | Prozesse starten und als Dienst verwalten. |
| `.socket` | Kommunikationsendpunkte bereitstellen und Dienste darüber aktivieren. |
| `.timer` | Zeitgesteuerte Aktivierung auslösen. |
| `.path` | Auf bestimmte Dateisystemereignisse reagieren. |
| `.target` | Units zu einem gemeinsamen Aktivierungsziel zusammenfassen. |
| `.mount` | Einen Dateisystem-Mount beschreiben. |
| `.slice` | Units für die Ressourcenverwaltung hierarchisch gruppieren. |
| `.scope` | Bereits anderweitig erzeugte Prozesse als Gruppe verwalten. |
Diese Typen gehören zum gemeinsamen Verwaltungsmodell von systemd. Dadurch können beispielsweise Dienste und die von ihnen benötigten Mounts in demselben Abhängigkeitsmodell berücksichtigt werden.
Zwischen „Lösung für alles“ und einheitlicher Verwaltung
--------------------------------------------------------
systemd wird dafür kritisiert, immer mehr Aufgaben zu übernehmen, die traditionell getrennte Werkzeuge erledigt haben. Kritiker sehen darin eine Abkehr vom Unix-Prinzip kleiner, spezialisierter Programme: Die enge Integration könne die Komplexität erhöhen und den Austausch einzelner Komponenten erschweren. Dabei ist zwischen systemd als Dienstmanager und dem größeren Softwareprojekt mit zusätzlichen Komponenten zu unterscheiden.
Die unterschiedlichen **Unit-Typen** liefern allerdings ein nachvollziehbares Argument für einen gemeinsamen Verwaltungsansatz: Dienste, Sockets, Timer und Mounts erfüllen zwar verschiedene Aufgaben, hängen im Betrieb aber häufig voneinander ab. Ein Dienst benötigt beispielsweise ein eingebundenes Dateisystem oder wird durch einen Timer beziehungsweise einen Socket aktiviert. systemd bildet diese Zusammenhänge in einem einheitlichen Modell ab, statt sie über voneinander getrennte Konfigurationen und Skripte koordinieren zu müssen.
Daraus entstehen mehrere Vorteile:
- Einheitliche Verwaltung: Unterschiedliche Systemressourcen lassen sich mit denselben grundlegenden Werkzeugen starten, stoppen und auf ihren Zustand prüfen.
- Explizite Abhängigkeiten: Benötigte Ressourcen und die Reihenfolge ihrer Aktivierung lassen sich direkt beschreiben.
- Bedarfsgesteuerte Aktivierung: Dienste können zeitgesteuert, bei Dateisystemereignissen oder bei eingehenden Verbindungen gestartet werden.
- Gemeinsame Ressourcenverwaltung: `.service`, `.scope` und `.slice` ermöglichen es, Prozessgruppen zu organisieren und ihre Ressourcennutzung zu steuern.
Die Unit-Typen widerlegen damit nicht jede Kritik am Umfang des systemd-Projekts. Sie zeigen aber, warum es technisch sinnvoll sein kann, zusammenhängende Verwaltungsaufgaben unter einem gemeinsamen Modell zu koordinieren.
Targets
-------
Ein Target bündelt zusammengehörige Units zu einem gemeinsamen Aktivierungsziel und dient als Synchronisationspunkt. Damit lässt sich beispielsweise festlegen, welche Dienste und anderen Ressourcen für den Mehrbenutzerbetrieb oder eine grafische Anmeldung benötigt werden. Ein Target führt selbst kein Programm aus: Über seine Abhängigkeiten veranlasst es die Aktivierung anderer Units und kann in deren Startreihenfolge eingebunden werden.
Beim Systemstart aktiviert systemd gewöhnlich `default.target`, das meist auf das gewünschte Betriebsziel verweist. Targets werden aber nicht nur beim Start verwendet, sondern auch, um andere Betriebszustände und gemeinsame Aufgaben zu koordinieren – etwa Wartung oder Herunterfahren.
Targets sind daher keine einfachen, linearen Startstufen und schließen sich nicht gegenseitig aus. Mehrere Targets können gleichzeitig aktiv sein und aufeinander aufbauen. Dahinter steht ein Netz von Abhängigkeiten, in dem voneinander unabhängige Aufgaben parallel ausgeführt werden können.
Dienstzustand und Startverhalten
--------------------------------
Eine der wichtigsten Unterscheidungen im Service-Management betrifft den aktuellen Zustand und die vorgesehene Aktivierung.
Ein Dienst kann jetzt laufen, ohne für den automatischen Start eingerichtet zu sein. Umgekehrt kann er für den Systemstart aktiviert sein und trotzdem gerade gestoppt oder fehlgeschlagen sein.
### Unterschiedliche Verwaltungsaktionen
| Aktion | Bedeutung |
|---|---|
| Starten | Den Dienst jetzt aktivieren. |
| Stoppen | Den Dienst jetzt beenden. |
| Neustarten | Den Dienst stoppen und erneut starten. |
| Aktivieren | Die vorgesehene Einbindung über die Installationsregeln der Unit herstellen. |
| Deaktivieren | Diese Einbindung entfernen. |
| Maskieren | Eine Aktivierung der Unit blockieren. |
Aktivieren und Starten sind somit unterschiedliche Vorgänge. Ebenso beendet das Deaktivieren einen laufenden Dienst nicht automatisch. Eine deaktivierte Unit kann weiterhin manuell oder über andere Aktivierungswege gestartet werden; Maskierung ist die stärkere Sperre: Sie verhindert, dass systemd die betreffende Unit startet – unabhängig davon, ob der Start manuell, durch eine Abhängigkeit oder über einen anderen Aktivierungsweg angefordert wird.
Maskierungen sind dafür gedacht, eine Unit gezielt gegen unerwünschtes oder versehentliches Starten zu sperren, beispielsweise während Wartungsarbeiten oder wenn ein Dienst ausdrücklich nicht verwendet werden soll
### Aktiv bedeutet nicht immer „Prozess läuft“
systemd unterscheidet allgemeine Zustände wie `active`, `inactive`, `activating` und `failed` sowie genauere Unterzustände. Ihre Bedeutung hängt vom Unit- und Diensttyp ab.
Eine erfolgreich abgeschlossene einmalige Aufgabe ist anders zu bewerten als ein dauerhaft laufender Webserver. Für die Administration genügt deshalb nicht allein die Frage: „Ist die Unit aktiv?“ Entscheidend ist, ob ihr Zustand zur vorgesehenen Aufgabe passt.
Abhängigkeiten, Reihenfolge und Betriebsbereitschaft
----------------------------------------------------
Dienste arbeiten selten vollständig unabhängig voneinander.
Eine Webanwendung benötigt möglicherweise:
- ein eingebundenes Datenverzeichnis,
- eine erreichbare Datenbank,
- vorhandene Zugangsdaten,
- eine funktionierende Netzwerkverbindung.
Dabei müssen drei unterschiedliche Fragen getrennt werden.
### Was soll mitgestartet werden?
Anforderungsabhängigkeiten beschreiben, welche weiteren Units bei einer Aktivierung einbezogen werden. systemd unterscheidet beispielsweise die schwächere Beziehung `Wants=` und die stärkere Beziehung `Requires=`.
### Was soll zuerst starten?
Ordnungsabhängigkeiten wie `After=` und `Before=` regeln die Reihenfolge beteiligter Start- und Stoppvorgänge.
Wichtig: `After=` startet die genannte Unit nicht automatisch mit. Umgekehrt legt eine Anforderungsabhängigkeit für sich allein keine Startreihenfolge fest. Beide Aspekte werden getrennt beschrieben.
### Wann ist der Dienst wirklich bereit?
Ein erzeugter Prozess ist nicht zwangsläufig eine betriebsbereite Anwendung. Eine Datenbank kann beispielsweise noch Daten prüfen, während ihr Prozess bereits läuft.
systemd besitzt unterschiedliche Diensttypen, die beeinflussen, wann ein Start als abgeschlossen gilt. Mit `Type=notify` kann eine entsprechend unterstützende Anwendung ihre Bereitschaft ausdrücklich melden.
> Die administrative Konsequenz lautet: Eine passende Startreihenfolge ersetzt keine verlässliche Bereitschaftserkennung. Auch danach muss die Anwendung mit vorübergehend nicht verfügbaren Abhängigkeiten umgehen können.
Dienste bei Bedarf und nach Zeitplan starten
--------------------------------------------
Nicht jeder Dienst muss vom Systemstart bis zum Herunterfahren laufen. systemd unterstützt mehrere Aktivierungsformen.
### Aktivierung über einen Socket
Bei Socket-Aktivierung stellt systemd einen Kommunikationsendpunkt bereit. Geht dort eine Anfrage ein, kann der zugehörige Dienst gestartet werden und den vorbereiteten Socket übernehmen.
Das ist nicht für jede beliebige Anwendung ohne Anpassung geeignet. Die Anwendung muss mit der gewählten Form der Socket-Übergabe zusammenarbeiten können.
Ein vertrautes Beispiel aus dem Containerbereich ist der Podman-Socket: Eine Verwaltungsanwendung kann darüber auf die Podman-API zugreifen.
### Zeitgesteuerte Aufgaben
Timer-Units lösen Aufgaben anhand zeitlicher Vorgaben aus. Damit lassen sich beispielsweise wiederkehrende Wartungs- oder Sicherungsaufgaben in dasselbe Verwaltungsmodell einordnen wie andere Dienste.
Für einen zuverlässigen Ablauf müssen jedoch zusätzlich Laufzeit, mögliche Überschneidungen und Fehlerbehandlung bedacht werden. Ein Zeitplan allein macht einen Sicherungsauftrag noch nicht erfolgreich.
### Ereignisgesteuerte Aufgaben
Path-Units können auf bestimmte Veränderungen im Dateisystem reagieren und eine zugehörige Aufgabe aktivieren. Damit lässt sich beispielsweise die Verarbeitung neu bereitgestellter Dateien anstoßen.
> Die grundsätzliche Frage lautet: Muss die Aufgabe ständig laufen, regelmäßig ausgeführt werden oder erst auf ein Ereignis reagieren?
Dienstdefinition und Anwendungskonfiguration
--------------------------------------------
Beim Betrieb existieren häufig zwei verschiedene Konfigurationsebenen.
### Die Dienstdefinition
Sie beschreibt, wie die Anwendung ausgeführt wird:
- Startbefehl und Arbeitsverzeichnis,
- Benutzer und Gruppe,
- Abhängigkeiten,
- Zeitlimits und Neustartverhalten,
- Ressourcen- und Sicherheitsvorgaben.
> **Beispiel:** nginx soll nach einem unerwarteten Absturz automatisch wieder gestartet werden. Dafür können in der systemd-Dienstdefinition folgende Einstellungen stehen:
>
> ```
> `[Service]Restart=on-failureRestartSec=5s`
> ```
>
> Sie legen fest, dass systemd den Dienst nach einem Fehler mit fünf Sekunden Verzögerung erneut startet. Diese Einstellungen betreffen den Betrieb des Prozesses – nicht die Webseiten, die nginx bereitstellt. Solche lokalen Anpassungen lassen sich über ein Drop-in (siehe unten) hinterlegen.
### Die Anwendungskonfiguration
Sie beschreibt, was die Anwendung fachlich tun soll:
- Welche Datenbank wird verwendet?
- Unter welcher Adresse lauscht der Dienst?
- Welche Verzeichnisse werden bereitgestellt?
- Welche Benutzer dürfen zugreifen?
> **Beispiel:** nginx soll eine interne Website auf Port `8080` bereitstellen und deren Dateien aus dem Verzeichnis `/srv/intranet` ausliefern. Dafür wird in der nginx-Konfiguration innerhalb des `http`-Bereichs ein passender `server`-Block eingerichtet:
>
> ```
> `server { listen 8080; server_name intranet.example; root /srv/intranet;}`
> ```
>
> Hier wird beschrieben, welche Anfragen nginx annimmt und welche Inhalte es bereitstellt. Das gehört zur Anwendungskonfiguration, nicht zur systemd-Dienstdefinition. Ein erfolgreich gestarteter nginx-Prozess bedeutet deshalb noch nicht, dass der gewünschte Port oder das richtige Webseitenverzeichnis konfiguriert ist.
### Reload, Restart und daemon-reload
Diese Begriffe betreffen unterschiedliche Ebenen:
| Vorgang | Wirkung |
|---|---|
| Reload | Die Anwendung wird aufgefordert, ihre eigene Konfiguration neu einzulesen, sofern sie das unterstützt. |
| Restart | Der Dienst wird beendet und neu gestartet. |
| daemon-reload | systemd liest seine Unit-Konfiguration neu ein und baut das Abhängigkeitsmodell neu auf. |
> **Beispiel für Reload**
>
> Das Webseitenverzeichnis wurde in der nginx-Konfiguration von `/srv/intranet` auf `/srv/intranet-neu` geändert. nginx soll die neue Konfiguration übernehmen, ohne den gesamten Dienst zu stoppen und neu zu starten:
>
> ```
> `sudo nginx -t && sudo systemctl reload nginx.service`
> ```
>
> `nginx -t` prüft zunächst die Konfiguration; nur bei erfolgreicher Prüfung folgt der Reload. nginx startet dabei neue Worker-Prozesse mit der neuen Konfiguration. Die bisherigen Worker bearbeiten bestehende Verbindungen zu Ende und werden anschließend beendet. Voraussetzung für den Aufruf über `systemctl` ist eine entsprechend eingerichtete Reload-Funktion in der Unit.
>
> **Beispiel für Restart**
>
> In der Dienstdefinition wurde das Limit für offene Dateien mit `LimitNOFILE=` geändert. Die bereits laufenden Prozesse sollen durch neu gestartete Prozesse mit dem geänderten Limit ersetzt werden:
>
> ```
> `sudo systemctl daemon-reloadsudo systemctl restart nginx.service`
> ```
>
> Der Restart beendet den Dienst und startet ihn anschließend neu. Im Unterschied zum nginx-Reload können dabei bestehende Verbindungen unterbrochen werden. Das vorangestellte `daemon-reload` ist hier erforderlich, weil die systemd-Konfiguration verändert wurde.
>
> **Beispiel für daemon-reload**
>
> Ein Administrator hat eine Drop-in-Datei für `nginx.service` direkt mit einem Texteditor geändert. Damit systemd diese geänderte Dienstdefinition neu einliest, führt er aus:
>
> ```
> `sudo systemctl daemon-reload`
> ```
>
> Damit kennt systemd die neuen Einstellungen. nginx selbst wird dadurch weder neu gestartet noch zum Einlesen seiner Anwendungskonfiguration aufgefordert. Ob ein zusätzlicher Neustart erforderlich ist, hängt von der geänderten Einstellung ab; bei `LimitNOFILE=` erfolgt er im obigen Beispiel ausdrücklich.
### Eigene Anpassungen mit Drop-ins
Von Paketen mitgelieferte Unit-Dateien sollten nicht beiläufig direkt verändert werden. systemd unterstützt ergänzende Drop-in-Dateien, mit denen bestimmte Einstellungen überschrieben oder ergänzt werden können.
Dadurch lässt sich die lokale Anpassung vom mitgelieferten Ausgangszustand trennen. Trotzdem muss bei Updates geprüft werden, ob sie weiterhin zur neuen Paketversion passt.
> **Beispiel:**
>
> nginx muss viele Verbindungen und Dateien gleichzeitig offen halten. Statt die vom Paket gelieferte Unit-Datei zu verändern, wird ein lokales Drop-in erstellt:
>
> ```
> `sudo systemctl edit nginx.service`
> ```
>
> Darin wird folgende Ergänzung gespeichert:
>
> ```
> `[Service]LimitNOFILE=65536`
> ```
>
> Das Drop-in ergänzt beziehungsweise überschreibt die entsprechende Einstellung der mitgelieferten Unit. Beim üblichen Aufruf von `systemctl edit` liest systemd nach erfolgreichem Speichern die Unit-Konfiguration automatisch neu ein; ein gesondertes `daemon-reload` ist dann nicht nötig. Anschließend wird nginx neu gestartet, damit die neuen Prozesse das geänderte Limit erhalten:
>
> ```
> `sudo systemctl restart nginx.service`
> ```
>
> Die lokale Anpassung bleibt damit von der Paketdatei getrennt. Sie wird bei Paketupdates nicht einfach durch eine neue Herstellerdatei ersetzt, muss aber weiterhin auf Verträglichkeit mit den aktualisierten Vorgaben geprüft werden.
Systemdienste und Benutzerdienste
---------------------------------
systemd kann Dienste systemweit und über benutzerbezogene Instanzen verwalten. Diese Ebenen besitzen unterschiedliche Zuständigkeiten und Konfigurationen.
### Systemdienste
Systemdienste gehören zur systemweiten Verwaltungsinstanz. Sie können unabhängig von einer persönlichen Anmeldung betrieben werden.
Das bedeutet nicht, dass ihre Prozesse als Root laufen müssen. Eine systemweit verwaltete Unit kann ausdrücklich ein eingeschränktes Dienstkonto verwenden.
### Benutzerdienste
Benutzerdienste werden durch den Dienstmanager eines Benutzerkontos verwaltet. Sie eignen sich beispielsweise für persönliche Hintergrundaufgaben oder benutzerbezogene Container.
Der Lebenszyklus des Benutzermanagers ist dabei gesondert zu betrachten. Mit aktiviertem Linger kann er bereits beim Systemstart gestartet und nach Abmeldungen weiterbetrieben werden.
> **Linger** ist eine benutzerspezifische systemd-Einstellung, durch die die Benutzerinstanz bereits beim Systemstart gestartet wird und nach dem Abmelden weiterläuft. Dadurch können Benutzerdienste unabhängig von einer aktiven Anmeldung betrieben werden.
### Die administrative Entscheidung
Die Wahl sollte sich danach richten:
- Wer ist für den Dienst verantwortlich?
- Muss er ohne Anmeldung verfügbar sein?
- Welche Rechte und Dateien benötigt er?
- Gehört er zum Gesamtsystem oder zu einer persönlichen Arbeitsumgebung?
Systemdienst und Root-Prozess sind ebenso wenig gleichbedeutend wie Benutzerdienst und grafischer Autostart.
Sicherheit und Ressourcenverwaltung
-----------------------------------
Ein Dienst läuft unter bestimmten Berechtigungen und kann Ressourcen des Hosts beanspruchen. Beides gehört zur Dienstdefinition und nicht erst zur späteren Fehlerbehebung.
### Möglichst wenige Rechte
systemd ermöglicht unter anderem die Ausführung unter einem festgelegten Benutzerkonto, die Begrenzung zugänglicher Dateisystembereiche und das Verhindern zusätzlicher Privilegiengewinne.
Das Ziel ist, die Auswirkungen eines Fehlers oder Angriffs zu begrenzen. Ein Webdienst benötigt beispielsweise nicht automatisch Schreibzugriff auf das gesamte System.
> Solche Einschränkungen müssen zur Anwendung passen. Zu weitreichende Freigaben schwächen den Schutz; unpassende Beschränkungen können den Dienst unbrauchbar machen.
### Ressourcen bewusst verteilen
Über **cgroups** und systemd lassen sich unter anderem CPU- und Arbeitsspeicherressourcen steuern. Für Speicher stehen beispielsweise Schwellen und harte Obergrenzen zur Verfügung.
Damit soll verhindert werden, dass ein einzelner Dienst den gesamten Host beeinträchtigt. Ein zu knappes Limit kann jedoch seinerseits Fehler verursachen. Die Dokumentation empfiehlt deshalb, `MemoryHigh=` als primären Steuerungsmechanismus und `MemoryMax=` als letzte Begrenzung zu betrachten.
> Ressourcenlimits ersetzen keine Kapazitätsplanung. Sie müssen anhand des tatsächlichen Verhaltens bewertet werden.
Protokolle, Überwachung und Fehleranalyse
-----------------------------------------
Für die Administration sind drei Ebenen zu unterscheiden:
| Ebene | Leitfrage |
|---|---|
| Prozesszustand | Läuft der erwartete Prozess? |
| Dienstzustand | Bewertet der Dienstmanager den Ablauf als erfolgreich? |
| Anwendungsfunktion | Erbringt die Anwendung tatsächlich die gewünschte Leistung? |
Ein Webserver kann laufen und trotzdem Fehlerseiten ausliefern. Eine Datenbank kann gestartet sein und dennoch keine nutzbaren Anmeldungen erlauben.
### Protokolle als Diagnosegrundlage
**systemd-journald** sammelt strukturierte Protokolldaten aus verschiedenen Quellen. Dazu gehören auch Standardausgabe und Fehlerausgabe von Diensten. Die Speicherung kann flüchtig oder dauerhaft konfiguriert sein.
Für die Fehleranalyse sind insbesondere Zeitpunkt, Unit-Zuordnung, Fehlermeldung und Zusammenhang mit vorherigen Änderungen relevant.
Protokollierung muss deshalb bewusst geplant werden: Welche Informationen bleiben erhalten, wer darf sie lesen und wie lange werden sie benötigt?
### Automatische Neustarts
systemd kann abhängig von der Konfiguration nach bestimmten Fehlern einen Neustart auslösen. Zeitlimits und Startbegrenzungen beeinflussen dieses Verhalten.
Ein automatischer Neustart kann die Verfügbarkeit verbessern. Er beseitigt aber keine Ursache wie eine ungültige Konfiguration oder ein fehlendes Datenverzeichnis. Wiederholte Neustarts sind daher ein Diagnosehinweis, keine erfolgreiche Reparatur.
### Watchdogs und externe Prüfungen
Ein anwendungsseitig unterstützter Watchdog ermöglicht es systemd, ausbleibende Lebenszeichen zu erkennen.
> Ein **Watchdog** ist ein Überwachungsmechanismus, der regelmäßige Lebenszeichen erwartet. Bei systemd muss ein entsprechend eingerichteter Dienst diese innerhalb einer festgelegten Frist senden. Bleiben sie aus, beendet systemd den Dienst und startet ihn – je nach Konfiguration – neu. So können auch hängende Dienste erkannt werden, deren Prozesse noch laufen.
Davon zu unterscheiden sind externe Funktionsprüfungen, die beispielsweise einen tatsächlichen Zugriff auf die bereitgestellte Anwendung testen. Für einen wichtigen Dienst sind beide Perspektiven interessant: interne Ausführung und von außen wahrnehmbare Funktion.
> Ein **systemd-Watchdog** prüft, ob ein Dienst regelmäßig interne Lebenszeichen sendet. Eine **externe Funktionsprüfung** testet dagegen unabhängig vom Dienst, ob seine angebotene Funktion tatsächlich nutzbar ist – beispielsweise, ob ein Webserver auf eine Anfrage rechtzeitig mit der erwarteten Antwort reagiert.
>
> Ein Webserver kann weiterhin Lebenszeichen senden, obwohl Nutzer seine Website wegen eines Netzwerk- oder Konfigurationsproblems nicht erreichen. Deshalb ergänzen sich beide Prüfungen: Der Watchdog überwacht die interne Rückmeldung, die externe Prüfung die von außen wahrnehmbare Funktion. Wie aussagekräftig sie sind, hängt davon ab, was jeweils konkret geprüft wird.
Änderungen, Wartung und Wiederherstellung
-----------------------------------------
Service-Management ist auch Änderungsmanagement. Eine neue Konfiguration oder Softwareversion kann Verbindungen unterbrechen, Datenformate verändern oder bisherige Berechtigungen unbrauchbar machen.
Ein sinnvoller administrativer Ablauf besteht deshalb aus mehreren Schritten:
1. Ausgangszustand und Abhängigkeiten verstehen.
2. Änderung und möglichen Einfluss auf Benutzer bewerten.
3. Konfiguration und erforderliche Daten sichern.
4. Änderung vorab prüfen, soweit möglich.
5. Reload oder Neustart gezielt durchführen.
6. Dienstzustand und Anwendungsfunktion kontrollieren.
7. Ergebnis und Anpassungen dokumentieren.
### Kontrolliert herunterfahren
Das Stoppen eines Dienstes sollte der Anwendung Gelegenheit geben, laufende Arbeiten zu beenden. systemd besitzt dafür Einstellungen zur Prozessbeendigung und zu Zeitlimits.
Gerade bei Datenbanken oder schreibenden Anwendungen ist ein kontrolliertes Ende etwas anderes als das sofortige Beenden sämtlicher Prozesse.
### Einen Rückweg vorbereiten
Ein Rückweg kann die vorherige Konfiguration, ein älteres Paket und gegebenenfalls eine Datenwiederherstellung umfassen.
Nur die vorige Programmversion bereitzuhalten reicht nicht immer: Hat die neue Version Daten verändert, müssen Software und Datenbestand weiterhin zueinander passen.
Container und Service-Management
--------------------------------
Container verändern die Bereitstellungsform, beseitigen aber nicht die Aufgaben des Dienstbetriebs. Auch ein containerisierter Dienst benötigt Regeln für Start, Stopp, Protokolle, Ressourcen und Wiederherstellung.
Mit Podman und Quadlet lassen sich Container deklarativ in systemd integrieren. Quadlet erzeugt aus entsprechenden Beschreibungen systemd-Dienste. Damit verbindet sich die Containerbereitstellung mit der Dienstverwaltung des Hosts.
### Zuständigkeiten festlegen
Bei mehreren Verwaltungsebenen muss klar sein, wer den Lebenszyklus kontrolliert:
- die Anwendung selbst,
- die Container-Engine,
- der Dienstmanager des Hosts,
- gegebenenfalls eine Orchestrierungsplattform.
> Insbesondere Neustartregeln sollten nicht unabhängig voneinander geplant werden. Für einen nachvollziehbaren Betrieb muss erkennbar sein, welche Ebene einen Fehler bewertet und welche darauf reagiert.
### Ein Host ist noch kein Cluster
systemd verwaltet Dienste innerhalb seines jeweiligen Systems. Eine Orchestrierungsplattform wie Kubernetes ergänzt Aufgaben wie die Platzierung und Wiederherstellung von Workloads über mehrere Rechner hinweg.
Die Ebenen ergänzen sich: Kenntnisse über lokale Dienste bleiben auch dann wichtig, wenn später Container und Cluster hinzukommen.
Fazit
-----
Service-Management verbindet installierte Software mit einem kontrollierten Betrieb. Es legt fest, wann ein Dienst startet, welche Voraussetzungen er benötigt, mit welchen Rechten er arbeitet und wie auf Fehler reagiert wird.
systemd bietet dafür ein gemeinsames Modell aus Units, Abhängigkeiten, Aktivierungswegen und Ausführungsregeln. Entscheidend sind dabei die richtigen Unterscheidungen: gestartet ist nicht automatisch aktiviert, ein laufender Prozess ist nicht zwangsläufig betriebsbereit und ein automatischer Neustart ist noch keine Fehlerbehebung.
Aus Sicht der Systemadministration entsteht Zuverlässigkeit erst durch das Zusammenspiel von Dienstdefinition, Anwendungskonfiguration, Sicherheit, Beobachtbarkeit und geregelten Änderungen. Diese Grundlagen gelten für einen lokalen Hintergrunddienst ebenso wie für eine Datenbank auf dem Homeserver oder eine containerisierte Anwendung.
Service-Management unter Linux – Dienste verstehen und zuverlässig betreiben
Submitted 4 hours ago by
blog@andreas-moor.de to random@mbin.linuxnation.social
https://andreas-moor.de/?p=78624