Dienste arbeiten selten vollständig unabhängig voneinander. Eine Webanwendung benötigt möglicherweise ein eingebundenes Datenverzeichnis, eine erreichbare Datenbank, passende Zugangsdaten und eine funktionierende Netzwerkverbindung.
Damit sie zuverlässig startet, müssen drei unterschiedliche Fragen beantwortet werden:
1. Was soll mitgestartet werden?
2. Was soll zuerst starten?
3. Wann ist eine Komponente tatsächlich betriebsbereit?
systemd behandelt diese Fragen getrennt: Anforderungsabhängigkeiten beziehen andere Units ein, Ordnungsabhängigkeiten koordinieren ihre Abläufe, und der Diensttyp beeinflusst, wann ein Start als abgeschlossen gilt. Erst das passende Zusammenspiel ergibt eine zuverlässige Startkoordination.
Drei Ebenen, die nicht verwechselt werden dürfen
------------------------------------------------
| Ebene | Leitfrage | Typische Einstellungen |
|---|---|---|
| Anforderung | Welche weiteren Units sollen aktiviert werden? | `Wants=`, `Requires=` |
| Reihenfolge | Welche Startvorgänge müssen vorher abgeschlossen sein? | `After=`, `Before=` |
| Bereitschaft | Wann gilt der Dienststart als abgeschlossen? | `Type=exec`, `Type=oneshot`, `Type=notify` |
Die Einstellungen erfüllen unterschiedliche Aufgaben. `After=` startet keine andere Unit mit. `Requires=` stellt allein keine Startreihenfolge her. Und selbst die richtige Reihenfolge garantiert nur dann eine passende Bereitschaft, wenn systemd den Startabschluss sinnvoll beurteilen kann.
Ein hilfreicher Merksatz lautet:
> Anforderung bestimmt, wer beteiligt ist. Reihenfolge bestimmt, wer wartet. Bereitschaft bestimmt, worauf gewartet wird.
Anforderungsabhängigkeiten: Was soll mitgestartet werden?
---------------------------------------------------------
Anforderungsabhängigkeiten beschreiben Beziehungen zwischen Units. Besonders häufig werden `Wants=` und `Requires=` verwendet.
### `Wants=`: Mitstarten, ohne den eigenen Start zwingend davon abhängig zu machen
Angenommen, eine Anwendung soll einen zusätzlichen Hilfsdienst mit aktivieren, kann aber grundsätzlich auch ohne ihn arbeiten:
```
[Unit]
Description=Beispielanwendung
Wants=hilfsdienst.service
```
Beim Aktivieren dieser Unit versucht systemd, auch `hilfsdienst.service` zu aktivieren. Scheitert der Hilfsdienst, verhindert das aufgrund dieser Beziehung nicht den Start der Anwendung.
Das passt zu einer erwünschten, aber nicht zwingenden Ergänzung.
> **Wichtig**: Ohne zusätzliche Reihenfolge können beide Dienste parallel starten. `Wants=` bedeutet nicht „Warte zuerst auf den Hilfsdienst“.
### `Requires=`: Eine stärkere Anforderung ausdrücken
Benötigt eine Anwendung zwingend eine lokale Datenbank, könnte ihre Unit enthalten:
```
[Unit]
Description=Beispielanwendung
Requires=datenbank.service
After=datenbank.service
```
Die Kombination bewirkt:
- `Requires=` bezieht die Datenbank in die Aktivierung ein.
- `After=` ordnet den Anwendungsstart nach dem Startvorgang der Datenbank ein.
- Schlägt die Aktivierung der Datenbank fehl, wird die Anwendung aufgrund dieser Kombination nicht gestartet.
Die Unit-Namen sind Beispiele. Der tatsächliche Datenbankdienst kann je nach Distribution, Paket und Instanz anders heißen.
### `Requires=` ist keine allgemeine Gesundheitsüberwachung
Eine wichtige Einschränkung: `Requires=` bedeutet nicht, dass die andere Unit während des gesamten Betriebs zwingend aktiv und fachlich gesund bleiben muss.
Wird die erforderliche Unit ausdrücklich gestoppt, wird auch die anfordernde Unit gestoppt. Ein selbstständiges Ende einer erforderlichen Unit wird jedoch nicht in jedem Fall entsprechend weitergegeben. Für eine engere Bindung existiert `BindsTo=`.
Welche Beziehung sinnvoll ist, hängt vom gewünschten Verhalten ab: Soll die Anwendung bei einem Ausfall weiterlaufen und Verbindungen erneut aufbauen – oder ausdrücklich mitgestoppt werden?
Ordnungsabhängigkeiten: Was soll zuerst starten?
------------------------------------------------
`After=` und `Before=` beschreiben die Reihenfolge beteiligter Vorgänge.
### `After=`: Nach dem Startvorgang einer anderen Unit
```
[Unit]
After=datenbank.service
```
Wenn beide Units gestartet werden, beginnt der Start dieser Unit erst, nachdem der Startvorgang von `datenbank.service` abgeschlossen ist. Allein durch diesen Eintrag wird die Datenbank jedoch nicht gestartet.
Wird nur die Anwendung angefordert und gibt es keinen anderen Aktivierungsweg für die Datenbank, erzeugt `After=` keinen zusätzlichen Datenbankstart.
### `Before=`: Den eigenen Start vorher abschließen
```
[Unit]
Before=anwendung.service
```
Wenn beide Units gestartet werden, wird der Start von `anwendung.service` hinter dem eigenen Startvorgang eingeordnet. Auch `Before=` aktiviert die genannte Unit nicht automatisch.
Die Beziehung muss nicht auf beiden Seiten eingetragen werden: `After=datenbank.service` in der Anwendung beschreibt dieselbe Reihenfolge wie `Before=anwendung.service` in der Datenbank.
### Beim Stoppen kehrt sich die Reihenfolge um
Wenn beide Units gestoppt werden, wird die konfigurierte Startreihenfolge umgekehrt:
```
Start:
Datenbank → Anwendung
Stopp:
Anwendung → Datenbank
```
Dadurch kann die Anwendung ihre Verbindungen beenden, bevor die Datenbank heruntergefahren wird. Die Reihenfolge allein bewirkt aber nicht, dass beide Units gemeinsam gestoppt werden – dafür sind die jeweiligen Anforderungs- und Lebenszyklusbeziehungen entscheidend.
Warum `After=` keine erfolgreiche Aktivierung garantiert
--------------------------------------------------------
Eine Reihenfolge beschreibt zunächst nur, wann ein Vorgang an die Reihe kommt.
Beispiel:
```
[Unit]
Wants=datenbank.service
After=datenbank.service
```
Die Anwendung wartet auf den Abschluss des Datenbank-Startvorgangs. Scheitert dieser, darf die Anwendung wegen der schwächeren `Wants=`-Beziehung trotzdem starten.
Mit:
```
[Unit]
Requires=datenbank.service
After=datenbank.service
```
wird dagegen auch der erfolgreiche Start der erforderlichen Unit relevant.
| Kombination | Grundlegendes Verhalten |
|---|---|
| Nur `After=` | Reihenfolge, aber kein Mitstarten. |
| Nur `Wants=` | Mitstarten, aber keine festgelegte Reihenfolge. |
| `Wants=` und `After=` | Mitstarten und warten; ein Fehlschlag der anderen Unit blockiert den eigenen Start nicht grundsätzlich. |
| `Requires=` und `After=` | Mitstarten und warten; ein Aktivierungsfehler der erforderlichen Unit verhindert den eigenen Start. |
Diese Unterschiede sind besonders bei der Fehlersuche wichtig: Eine Anwendung, die trotz gescheiterter Datenbank startet, muss nicht auf einen Fehler in systemd hindeuten. Möglicherweise entspricht genau das den konfigurierten Beziehungen.
Betriebsbereitschaft: Worauf wartet systemd tatsächlich?
--------------------------------------------------------
Ein erzeugter Prozess ist nicht zwangsläufig eine einsatzbereite Anwendung.
Eine Datenbank kann nach dem Programmstart beispielsweise noch interne Initialisierungsschritte durchführen. Der Diensttyp legt fest, welches Ereignis systemd als Startabschluss bewertet.
| Diensttyp | Zeitpunkt des Startabschlusses |
|---|---|
| `Type=simple` | Bereits nach dem Erzeugen des Startprozesses. |
| `Type=exec` | Nach dem erfolgreichen Aufruf des Dienstprogramms. |
| `Type=oneshot` | Nach dem erfolgreichen Abschluss der vorgesehenen Startbefehle. |
| `Type=notify` | Nach der ausdrücklichen Bereitschaftsmeldung der Anwendung. |
Für Ordnungsabhängigkeiten werden außerdem konfigurierte `ExecStartPost=`-Befehle zum Startvorgang gezählt.
### Beispiel: Richtige Reihenfolge, trotzdem zu früher Zugriff
Angenommen, eine Datenbank wird mit `Type=exec` betrieben:
```
Datenbankprogramm wurde aufgerufen
│
├── systemd betrachtet diesen Startschritt als erfolgreich
│
├── Anwendung startet entsprechend ihrer Reihenfolge
│
└── Datenbank initialisiert sich noch
```
Die Anwendung kann zu diesem Zeitpunkt bereits eine Verbindung versuchen, obwohl die Datenbank sie noch nicht verarbeiten kann.
`After=datenbank.service` wurde dabei korrekt umgesetzt. Ungeeignet war die Annahme, dass ein erfolgreicher Programmaufruf bereits Datenbankbereitschaft bedeutet.
### `Type=notify`: Bereitschaft ausdrücklich melden
Unterstützt die Datenbank das Notify-Protokoll, kann sie nach abgeschlossener Initialisierung `READY=1` melden:
```
Datenbankprogramm startet
│
▼
Initialisierung
│
▼
READY=1
│
▼
Anwendung darf entsprechend ihrer Reihenfolge starten
```
> Dafür muss die Anwendung beziehungsweise Datenbank ausdrücklich Unterstützung mitbringen. Nur `Type=notify` in eine beliebige Unit einzutragen, reicht nicht. Ohne Meldung wartet systemd bis zum Startzeitlimit und wertet den Start anschließend als fehlgeschlagen.
Dateisysteme als Voraussetzung berücksichtigen
----------------------------------------------
Benötigt ein Dienst Daten unter `/srv/anwendungsdaten`, eignet sich:
```
[Unit]
RequiresMountsFor=/srv/anwendungsdaten
```
systemd ergänzt dadurch `Requires=`– und `After=`-Abhängigkeiten auf die Mount-Units, die für den Zugriff auf diesen Pfad benötigt werden.
Das ist übersichtlicher, als notwendige Mount-Units einschließlich übergeordneter Mounts selbst aufzulisten.
### Wichtige Einschränkung
Die Einstellung erstellt keinen Mount und erklärt ein gewöhnliches Verzeichnis nicht automatisch zu einem separaten Dateisystem.
Der gewünschte Datenträger oder Netzwerkspeicher muss bereits passend eingerichtet sein, beispielsweise über `/etc/fstab` oder eine Mount-Unit. Sonst kann der Pfad weiterhin auf dem normalen Root-Dateisystem liegen.
Für die Administration lautet die Konsequenz: Nicht nur prüfen, ob das Verzeichnis existiert, sondern auch, ob dort tatsächlich der vorgesehene Speicher eingebunden ist.
Netzwerk: „Gestartet“ ist nicht dasselbe wie „erreichbar“
---------------------------------------------------------
Bei Netzwerkabhängigkeiten werden besonders häufig falsche Erwartungen an Targets gestellt.
### `network.target`
```
[Unit]
After=network.target
```
`network.target` zeigt an, dass der Netzwerkverwaltungsstack gestartet wurde. Es garantiert nicht, dass Schnittstellen bereits passende Adressen besitzen oder entfernte Systeme erreichbar sind.
Eine wichtige Wirkung liegt in der Stopp-Reihenfolge: Ein entsprechend angeordneter Dienst wird beim Herunterfahren vor dem Netzwerk gestoppt.
### `network-online.target`
Für einen Dienst, der beim Start auf eine eingerichtete Netzwerkverbindung warten muss, kommt beispielsweise infrage:
```
[Unit]
Wants=network-online.target
After=network-online.target
```
Was „online“ bedeutet, bestimmen der zuständige Wait-Online-Dienst und seine Konfiguration. Beispiele sind `NetworkManager-wait-online.service` und `systemd-networkd-wait-online.service`.
Das Target garantiert deshalb nicht automatisch:
- die Erreichbarkeit einer bestimmten Datenbank,
- funktionierende Zugangsdaten,
- die Verfügbarkeit einer externen API,
- dauerhafte Netzwerkverfügbarkeit nach dem Start.
`network-online.target` ist ein Synchronisationspunkt für den Start, keine laufende Netzwerküberwachung. Es sollte nur eingebunden werden, wenn der Dienst diese Wartebedingung tatsächlich benötigt.
Lokale Units und entfernte Dienste unterscheiden
------------------------------------------------
Eine Beziehung wie:
```
Requires=datenbank.service
```
bezieht sich auf eine Unit im zuständigen systemd-Dienstmanager. Sie prüft nicht automatisch eine Datenbank auf einem anderen Rechner.
Bei entfernten Abhängigkeiten muss die Anwendung selbst oder eine gezielte Prüfung feststellen, ob der benötigte Dienst erreichbar und nutzbar ist.
Für eine Datenbank kann das beispielsweise mehr erfordern als einen offenen TCP-Port:
- Ist die Anmeldung möglich?
- Existiert die benötigte Datenbank?
- Sind die erforderlichen Berechtigungen vorhanden?
- Passt der Datenbankzustand zur Anwendung?
Die Netzwerkdokumentation von systemd betont entsprechend, dass Anwendungen mit wechselnder Erreichbarkeit umgehen und Verbindungsversuche wiederholen können müssen. Ein einmal erreichter Netzwerkzustand bleibt nicht garantiert bestehen.
Praxisbeispiel: Eine Anwendung mit lokaler Datenbank
----------------------------------------------------
Die folgende Unit zeigt das Zusammenspiel der drei Ebenen:
```
[Unit]
Description=Beispiel-Webanwendung
Requires=datenbank.service
After=datenbank.service
RequiresMountsFor=/srv/anwendungsdaten
[Service]
Type=notify
User=webanwendung
Group=webanwendung
WorkingDirectory=/srv/anwendungsdaten
ExecStart=/usr/local/bin/webanwendung
TimeoutStartSec=90s
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=multi-user.target
```
Das Beispiel setzt voraus, dass:
- `datenbank.service` tatsächlich vorhanden ist,
- Benutzer und Gruppe `webanwendung` existieren,
- das Programm vorhanden und ausführbar ist,
- der Datenpfad korrekt eingerichtet und zugänglich ist,
- die Webanwendung das Notify-Protokoll unterstützt.
### Was die Konfiguration erreicht
1. Die lokale Datenbank wird in die Aktivierung einbezogen (`Requires=datenbank.service`)
2. Der Anwendungsstart wird hinter dem Datenbank-Startvorgang eingeordnet. (`After=datenbank.service`)
3. Erforderliche Mounts werden berücksichtigt. (`RequiresMountsFor=/srv/anwendungsdaten`)
4. Die Webanwendung gilt erst nach ihrer eigenen Bereitschaftsmeldung als gestartet. (`Type=notify`)
5. Bestimmte Fehler können einen erneuten Startversuch auslösen. (`Restart=on-failure`)
### Was sie nicht automatisch erreicht
`Type=notify` in dieser Unit beschreibt die Bereitschaft der Webanwendung – nicht die der Datenbank. Ob die Datenbank zu diesem Zeitpunkt wirklich nutzbar ist, hängt weiterhin von ihrer eigenen Unit und dem Verhalten der Anwendung ab.
Ebenso stellt `Restart=on-failure` keine vollständige Wiederherstellungsstrategie dar. Es steuert den Wiederanlauf bei bestimmten Fehlern und unterliegt den Startbegrenzungen von systemd.
Warum feste Wartezeiten meistens keine gute Bereitschaftsprüfung sind
---------------------------------------------------------------------
Ein vermeintlich einfacher Ausweg ist:
```
ExecStartPre=/usr/bin/sleep 10
```
Das verzögert den Start um zehn Sekunden. Es prüft jedoch nicht, ob die benötigte Komponente tatsächlich bereit ist.
Ist sie nach zwei Sekunden bereit, wird unnötig gewartet. Benötigt sie unter Last zwanzig Sekunden, startet die Anwendung trotzdem zu früh.
Besser ist eine zur Anwendung passende Bereitschaftsmeldung oder eine gezielte Prüfung. Falls eine solche Prüfung über einen eigenen Befehl umgesetzt wird, sollte sie ein begrenztes Zeitbudget besitzen und Fehler nachvollziehbar melden. `ExecStartPre=`-Fehler können den Start abbrechen; `ExecStartPost=` wird ebenfalls bei der Startreihenfolge berücksichtigt.
Angenommen, eine Webanwendung benötigt eine Datenbank.
- **Feste Wartezeit**: „Warte zehn Sekunden und starte dann die Webanwendung.“ Ob die Datenbank bereit ist, bleibt unbekannt.
- **Bereitschaftsmeldung**: Die Datenbank teilt systemd selbst mit: „Meine Initialisierung ist abgeschlossen.“
- **Gezielte Prüfung**: Ein Prüfprogramm versucht beispielsweise, sich an der Datenbank anzumelden und eine einfache Abfrage auszuführen.
Die Bereitschaftsmeldung kann bei unterstützenden Anwendungen über `Type=notify` erfolgen. Ohne diese Unterstützung kann ein eigener Prüfbefehl eine Alternative sein.
### `ExecStartPre=`: Vor dem Start prüfen
In der Unit der Webanwendung könnte stehen:
```
[Service]
Type=exec
ExecStartPre=/usr/local/bin/datenbank-pruefen
ExecStart=/usr/local/bin/webanwendung
```
Die Programme sind beispielhafte eigene Programme und müssten entsprechend erstellt werden.
Der Ablauf:
```
Datenbank prüfen
│
├── Prüfung erfolgreich → Webanwendung starten
│
└── Prüfung fehlgeschlagen → Start abbrechen
```
`ExecStartPre=` bedeutet also: „Führe diesen Befehl vor dem eigentlichen Dienstprogramm aus.“ Meldet die Prüfung einen Fehler, wird `ExecStart=` normalerweise nicht ausgeführt und die Unit gilt als fehlgeschlagen.
Mit einem begrenzten Zeitbudget ist gemeint: Das Prüfprogramm soll beispielsweise höchstens 30 Sekunden lang Verbindungsversuche unternehmen. Danach soll es mit einer verständlichen Fehlermeldung abbrechen, statt unbegrenzt zu warten. systemd kann Startvorgänge zusätzlich über `TimeoutStartSec=` begrenzen.
### `ExecStartPost=`: Nach dem Programmstart noch etwas erledigen
Ein anderes Beispiel: Ein API-Dienst läuft bereits als Prozess, braucht aber noch etwas Zeit, bis er Anfragen beantwortet.
```
[Service]
Type=exec
ExecStart=/usr/local/bin/meine-api
ExecStartPost=/usr/local/bin/api-bereitschaft-pruefen
```
Der Ablauf:
```
API-Programm starten
│
▼
Prüfen, ob die API antwortet
│
▼
Startvorgang vollständig abgeschlossen
│
▼
Nachfolgende Units dürfen starten
```
Der entscheidende Punkt: Für eine andere Unit mit `After=meine-api.service` wartet systemd auch darauf, dass `ExecStartPost=` abgeschlossen ist. „Post“ bedeutet hier also nach dem eigentlichen Programmstart, aber noch als Teil des gesamten Startvorgangs. Scheitert diese Prüfung, gilt der Dienststart normalerweise ebenfalls als fehlgeschlagen.
Kurz gesagt: `ExecStartPre=` prüft Voraussetzungen vor dem Programmstart. `ExecStartPost=` kann nach dem Programmstart prüfen, ob der gerade gestartete Dienst wirklich nutzbar ist. Eine eingebaute Bereitschaftsmeldung (`Type=notify`) der Anwendung kann diese zusätzliche Prüfung überflüssig machen.
Auch eine erfolgreiche Prüfung gilt natürlich nur für ihren Zeitpunkt. Sie ersetzt keine Fehlerbehandlung im laufenden Betrieb.
Verhalten nach einem späteren Ausfall bewusst festlegen
-------------------------------------------------------
Eine erfolgreiche Startkoordination löst nicht automatisch alle späteren Ausfallsituationen.
Für eine engere Kopplung gibt es beispielsweise:
```
[Unit]
BindsTo=datenbank.service
After=datenbank.service
```
`BindsTo=` ist stärker als `Requires=` und berücksichtigt auch das unerwartete Inaktivwerden der anderen Unit. Zusammen mit `After=` lässt sich eine enge Bindung der Aktivitätszustände herstellen.
Das ist aber nicht immer die beste Lösung. Wenn eine Anwendung eine kurze Datenbankunterbrechung selbst überbrücken kann, kann es sinnvoller sein, sie weiterlaufen und ihre Verbindung erneut aufbauen zu lassen.
Außerdem folgt aus einer solchen Bindung kein allgemeiner automatischer Wiederanlauf aller abhängigen Dienste, sobald die Datenbank zurückkehrt. Start-, Stopp- und Wiederherstellungsverhalten müssen getrennt geplant werden.
Abhängigkeiten und Startabläufe untersuchen
-------------------------------------------
Für die Analyse helfen unter anderem folgende Befehle:
```
systemctl cat webanwendung.service
```
Zeigt die Unit-Dateien und zugehörigen Drop-ins.
```
systemctl show webanwendung.service
-p Wants
-p Requires
-p After
-p Before
```
Zeigt ausgewählte, von systemd aufgelöste Eigenschaften. Dabei können auch automatisch ergänzte Beziehungen sichtbar werden. Nicht jede Abhängigkeit muss ausdrücklich in der eigenen Unit-Datei stehen.
Für den zeitlichen Ablauf:
```
journalctl -b
-u datenbank.service
-u webanwendung.service
-o short-monotonic
```
Dabei beschränkt `-b` die Ausgabe auf den aktuellen Systemstart. Die beiden `-u`-Angaben beziehen die Meldungen beider Units ein. `short-monotonic` stellt Zeitangaben relativ zum Systemstart dar und erleichtert damit den Vergleich der Ereignisse.
Besonders hilfreich sind folgende Fragen:
- Wurde die benötigte Unit überhaupt aktiviert?
- Ist die Reihenfolge korrekt?
- Wann hat systemd den jeweiligen Start als abgeschlossen bewertet?
- Welche Meldung gab die Anwendung beim Verbindungsversuch aus?
- Handelt es sich um ein Startproblem oder einen späteren Verfügbarkeitsverlust?
Fazit
-----
Zuverlässige Dienstkoordination entsteht nicht allein dadurch, dass eine Unit „nach“ einer anderen startet.
`Wants=` und `Requires=` bestimmen, welche Units einbezogen werden. `After=` und `Before=` regeln die Reihenfolge. Der Diensttyp und die Bereitschaftserkennung bestimmen, was ein abgeschlossener Start tatsächlich bedeutet.
Für die Systemadministration ist deshalb entscheidend, diese Ebenen bewusst zu kombinieren und ihre Grenzen zu kennen. Auch nach einem korrekt koordinierten Start können Netzwerk und andere Abhängigkeiten ausfallen. Robuste Anwendungen und ein durchdachtes Betriebskonzept müssen mit solchen Unterbrechungen umgehen können.
Abhängigkeiten, Reihenfolge und Betriebsbereitschaft – Dienste mit systemd zuverlässig koordinieren
Submitted 8 hours ago by
blog@andreas-moor.de to random@mbin.linuxnation.social
https://andreas-moor.de/?p=78743