Nicht jeder Dienst muss vom Systemstart bis zum Herunterfahren laufen. Manche Programme werden nur gelegentlich benötigt, andere erledigen regelmäßig eine abgeschlossene Aufgabe oder sollen erst auf eine Veränderung reagieren. Für die Systemadministration ergibt sich daraus eine grundlegende Frage: > Muss eine Aufgabe dauerhaft laufen, regelmäßig ausgeführt werden oder erst bei einem konkreten Anlass starten? Die Aktivierungsform nach der Aufgabe auswählen ----------------------------------------------- | Anforderung | Geeigneter Ansatz | |---|---| | Ein Programm verarbeitet ständig Anfragen und soll dauerhaft verfügbar sein. | Dauerhaft laufende Service-Unit. | | Ein kompatibler Dienst wird erst bei einer Verbindung benötigt. | Socket-Aktivierung. | | Eine Wartungsaufgabe soll täglich oder in bestimmten Abständen laufen. | Timer-Aktivierung. | | Eine Verarbeitung soll auf Dateien oder Änderungen reagieren. | Path-Aktivierung. | > Socket-, Timer- und Path-Units übernehmen dabei nicht selbst die fachliche Verarbeitung. Sie stellen einen Auslöser bereit und aktivieren eine zugehörige Unit. Diese Trennung erleichtert die Verwaltung: Dieselbe Aufgabe kann unabhängig von ihrem automatischen Auslöser auch manuell gestartet und untersucht werden. Socket-Aktivierung: Ein Dienst startet bei eingehender Kommunikation -------------------------------------------------------------------- Bei Socket-Aktivierung stellt systemd einen Kommunikationsendpunkt bereit, beispielsweise einen lokalen Unix-Socket. Verbindet sich ein Client, kann systemd den zugehörigen Dienst starten und ihm den bereits vorbereiteten Socket übergeben. ``` Client stellt Verbindung her │ ▼ beispiel.socket │ aktiviert ▼ beispiel.service │ ▼ Anwendung verarbeitet die Kommunikation ``` Die Socket-Unit kann also bereits auf Verbindungen warten, während das eigentliche Dienstprogramm noch nicht läuft. ### Wann ist das sinnvoll? Socket-Aktivierung ist interessant, wenn ein Dienst nur gelegentlich benötigt wird und die Anwendung die vorgesehene Socket-Übergabe unterstützt. > Eine beliebige Anwendung wird nicht allein dadurch kompatibel, dass eine `.socket`-Datei angelegt wird. Sie muss mit dem von systemd übergebenen Kommunikationsendpunkt umgehen können. Außerdem bedeutet Socket-Aktivierung nicht automatisch, dass sich der gestartete Dienst später wieder beendet. Das hängt vom Verhalten und der Konfiguration der Anwendung ab. ### Praxisbeispiel: Der Podman-Socket Podman unterstützt Socket-Aktivierung für seinen API-Dienst. Eine Verwaltungsanwendung kann sich mit dem Socket verbinden; systemd startet daraufhin bei Bedarf den API-Prozess. Nach einer konfigurierten Inaktivitätszeit kann dieser wieder enden. Der Socket bleibt als Auslöser verfügbar. Für einen Benutzer lässt sich der Socket beispielsweise so aktivieren und unmittelbar starten: ``` systemctl --user enable --now podman.socket ``` Dabei sind zwei Ebenen zu unterscheiden: - `podman.socket` wartet auf Verbindungen. - `podman.service` stellt bei Bedarf die API bereit. Das betrifft den API-Dienst. Die laufenden Container werden dadurch nicht automatisch zu dauerhaft vom API-Prozess abhängigen Unterprozessen. Bei Benutzer-Units muss außerdem der Lebenszyklus des Benutzer-Dienstmanagers berücksichtigt werden. Soll der Socket unabhängig von einer Anmeldung nach dem Booten bereitstehen, kann eine entsprechende Linger-Konfiguration erforderlich sein. > Die **Linger-Konfiguration** sorgt dafür, dass der systemd-Dienstmanager eines Benutzers bereits beim Systemstart startet und nach dessen Abmeldung weiterläuft. Dadurch können Benutzer-Dienste, Timer und Sockets unabhängig von einer aktiven Anmeldung betrieben werden. Aktiviert wird sie mit: > > ``` > `loginctl enable-linger BENUTZERNAME` > ``` ### Sicherheit des Podman-Sockets Der API-Zugriff erlaubt weitreichende Aktionen mit den Rechten des Benutzers, unter dem der API-Dienst läuft. Der Socket sollte deshalb nur vertrauenswürdigen Anwendungen zugänglich sein und nicht ungeschützt im Netzwerk bereitgestellt werden. Timer-Aktivierung: Aufgaben nach Zeitplan ausführen --------------------------------------------------- Timer-Units legen fest, wann eine andere Unit aktiviert wird. Typischerweise gehört zu einem Timer eine gleichnamige Service-Unit: ``` backup.timer │ aktiviert ▼ backup.service │ startet ▼ Backup-Programm ``` Die Service-Unit beschreibt die Ausführung. Die Timer-Unit beschreibt die Zeitplanung. ### Beispiel: Ein tägliches Backup Voraussetzung ist ein vorhandenes, getestetes und ausführbares Backup-Skript. Datei `/etc/systemd/system/backup.service`: ``` [Unit] Description=Datensicherung ausführen RequiresMountsFor=/srv/daten [Service] Type=oneshot ExecStart=/usr/local/sbin/backup-erstellen TimeoutStartSec=2h ``` `Type=oneshot` passt zu einer Aufgabe, die ausgeführt wird und anschließend endet. Das Startzeitlimit begrenzt hier die Ausführungsdauer der Aufgabe. Die erforderlichen Mounts für `/srv/daten` werden in die Abhängigkeiten einbezogen. Ohne `User=` läuft dieser Systemdienst standardmäßig mit Root-Rechten. Für einen echten Einsatz sollte geprüft werden, welche Rechte das Backup tatsächlich benötigt. Datei `/etc/systemd/system/backup.timer`: ``` [Unit] Description=Taegliche Datensicherung einplanen [Timer] OnCalendar=*-*-* 02:00:00 Persistent=true RandomizedDelaySec=10min [Install] WantedBy=timers.target ``` Diese Einstellungen bedeuten: | Einstellung | Wirkung | |---|---| | `OnCalendar=*-*-* 02:00:00` | Täglicher Termin um 02:00 Uhr nach lokaler Systemzeit. | | `Persistent=true` | Eine während der Inaktivität verpasste Aktivierung kann nachgeholt werden. | | `RandomizedDelaySec=10min` | Ergänzt eine zufällige Verzögerung von bis zu zehn Minuten, um gleichzeitige Lastspitzen zu verteilen. | Zusätzlich wirkt das Genauigkeitsfenster des Timers, standardmäßig eine Minute. Der Eintrag garantiert deshalb keinen sekundengenauen Start um 02:00 Uhr. Nach dem Anlegen: ``` sudo systemctl daemon-reload sudo systemctl enable --now backup.timer ``` Die Aufgabe lässt sich unabhängig vom Timer manuell ausführen: ``` sudo systemctl start backup.service ``` Kalendertermine oder relative Abstände? --------------------------------------- Timer können nicht nur feste Uhrzeiten verwenden. ``` [Timer] OnBootSec=5min OnUnitInactiveSec=1h ``` Diese Kombination aktiviert die Aufgabe erstmals fünf Minuten nach dem Systemstart und anschließend jeweils eine Stunde nach der letzten Deaktivierung der zugehörigen Unit. Für eine abgeschlossene Oneshot-Aufgabe bedeutet das normalerweise: eine Stunde nach ihrem Ende. Das ist etwas anderes als ein stündlicher Kalendertermin: - Kalenderbasiert: „Starte jeweils zur vollen Stunde.“ - Relativ zum Aufgabenende: „Warte nach dem Abschluss eine Stunde.“ Der zweite Ansatz eignet sich beispielsweise, wenn die Laufzeit stark schwankt und zwischen zwei Durchläufen bewusst eine Pause liegen soll. > `Persistent=true` wirkt dagegen nur bei kalenderbasierten Timern mit `OnCalendar=` (siehe oben). Es ist keine allgemeine Nachholfunktion für sämtliche Timer-Arten. Laufzeit und Überschneidungen berücksichtigen --------------------------------------------- Ein Zeitplan allein verhindert noch keine betrieblichen Probleme. ### Was passiert, wenn die Aufgabe noch läuft? Ist die vom Timer aktivierte Unit beim nächsten Termin bereits aktiv, startet systemd sie nicht erneut und lässt sie weiterlaufen. Für eine korrekt konfigurierte Oneshot-Aufgabe verhindert das einen zusätzlichen gleichzeitigen Durchlauf derselben Service-Unit. Dabei gibt es zwei wichtige Grenzen: - Es entsteht keine automatische Warteschlange für alle währenddessen verpassten Durchläufe. - Das gleiche Skript könnte außerhalb dieser Unit oder durch eine andere Unit trotzdem zusätzlich gestartet werden. Wer eine globale Sperre benötigt, muss daher auch andere Startwege berücksichtigen. ### `RemainAfterExit=yes` ist für wiederkehrende Aufgaben meist unpassend Bleibt eine Oneshot-Unit nach ihrem Ende durch `RemainAfterExit=yes` aktiv, löst der Timer keinen neuen Durchlauf aus, solange sie aktiv bleibt. Für regelmäßig wiederkehrende, abgeschlossene Aufgaben sollte die Service-Unit deshalb normalerweise nach Abschluss wieder inaktiv werden. ### Nachholen ist nicht Wiederholen bei Fehlern `Persistent=true` berücksichtigt verpasste Kalendertermine. Es prüft nicht, ob das letzte Backup erfolgreich war, und wiederholt einen fehlgeschlagenen Auftrag nicht automatisch. Dafür braucht es eine passende Fehlerbehandlung, etwa: - aussagekräftige Exit-Codes, - verständliche Protokolle, - begrenzte Wiederholungsversuche, - eine Benachrichtigung oder Überwachung bei Fehlern. Cron oder systemd-Timer? ------------------------ Cron ist weiterhin ein geeigneter Zeitplaner für viele Aufgaben. Ein einfacher täglicher Aufruf lässt sich in einer Benutzer-Crontab knapp ausdrücken: ``` 0 2 * * * /usr/local/sbin/backup-erstellen ``` Der Eintrag startet den Befehl täglich um 02:00 Uhr. Cron führt die Befehle einer Benutzer-Crontab mit den Rechten ihres Besitzers aus. Die entscheidende Frage ist nicht, welches Werkzeug grundsätzlich moderner ist, sondern wie eng die Aufgabe in die übrige Dienstverwaltung eingebunden werden soll. | Situation | Eher geeignet | |---|---| | Einfache Aufgabe mit einem überschaubaren Kalenderplan. | Cron. | | Bestehende, zuverlässig betriebene Cron-Umgebung ohne zusätzlichen Integrationsbedarf. | Cron beibehalten. | | Betrieb auf Systemen ohne systemd oder möglichst systemd-unabhängige Bereitstellung. | Cron beziehungsweise der dort verfügbare Zeitplaner. | | Abhängigkeiten zu Mounts und anderen Units erforderlich. | systemd-Timer mit Service-Unit. | | Einheitliche Verwaltung von Status, Laufzeit, Rechten und Ressourcen gewünscht. | systemd-Timer mit Service-Unit. | | Relative Planung nach dem Ende des vorherigen Durchlaufs benötigt. | systemd-Timer. | | Verpasste Kalendertermine sollen gezielt nachgeholt werden. | systemd-Timer mit `Persistent=true`. | Cron bietet eine kompakte Zeitplanbeschreibung. systemd-Timer verbinden die Zeitplanung dagegen mit den Betriebsfunktionen von Service-Units. Das heißt nicht, dass Cron grundsätzlich ohne Protokollierung oder Fehlerbenachrichtigung arbeitet: Übliche Implementierungen wie Cronie können Ausgaben beispielsweise per E-Mail versenden, wenn die dafür nötige Mail-Infrastruktur eingerichtet ist. Auch Erweiterungen und ergänzende Werkzeuge können zusätzliche Anforderungen abdecken. Eine pauschale Migration aller Cronjobs ist deshalb nicht nötig. Auf einem systemd-Host lohnt sich ein Timer besonders dann, wenn aus einem einfachen Skript ein administrativ betreuter Auftrag mit klaren Betriebsanforderungen wird. Path-Aktivierung: Auf Dateien reagieren --------------------------------------- Path-Units können eine Aufgabe auslösen, wenn bestimmte Dateisystembedingungen erfüllt sind. Beispielsweise soll ein Import starten, sobald Dateien in einem Eingangsverzeichnis liegen: Datei `/etc/systemd/system/datenimport.path`: ``` [Unit] Description=Importverzeichnis ueberwachen [Path] DirectoryNotEmpty=/srv/import/eingang Unit=datenimport.service [Install] WantedBy=multi-user.target ``` Die dazugehörige Service-Unit: ``` [Unit] Description=Bereitgestellte Dateien importieren [Service] Type=oneshot ExecStart=/usr/local/sbin/dateien-importieren TimeoutStartSec=10min ``` > **Wichtig:** Das Verzeichnis und das Importprogramm müssen vorher passend eingerichtet werden. Der Ablauf: ``` Dateien liegen im Eingangsverzeichnis │ ▼ datenimport.path erkennt die Bedingung │ ▼ datenimport.service verarbeitet die Dateien ``` Ist das Verzeichnis beim Start der Path-Unit bereits nicht leer, kann die Verarbeitung unmittelbar ausgelöst werden. ### Vollständige Dateien bereitstellen Eine Datei kann bereits sichtbar sein, während sie noch geschrieben wird. Ein zuverlässiger Übergabeprozess sollte deshalb verhindern, dass der Import halbfertige Dateien verarbeitet. Ein möglicher Ansatz ist, Dateien zunächst außerhalb des überwachten Verzeichnisses fertigzustellen und sie anschließend durch Umbenennen innerhalb desselben Dateisystems in das Eingangsverzeichnis zu übergeben. ### Die auslösende Bedingung muss wieder verschwinden Nach dem Ende des Dienstes prüft systemd die Bedingung erneut. Bleibt das Verzeichnis nicht leer, kann der Dienst sofort wieder gestartet werden. Das Importprogramm muss deshalb auch mit fehlerhaften Dateien sinnvoll umgehen, beispielsweise durch eine getrennte Ablage für abgeschlossene und abgelehnte Dateien. Andernfalls kann eine Aktivierungsschleife entstehen, die schließlich durch die Startbegrenzung (TimeoutStartSec=10min) beendet wird. Path-Units sind außerdem keine vollständige Nachrichtenwarteschlange. Sie verwenden inotify und unterliegen dessen Einschränkungen. Änderungen durch andere Rechner auf entfernten NFS-Dateisystemen lassen sich damit beispielsweise nicht zuverlässig überwachen. > **inotify** ist eine Schnittstelle des Linux-Kernels, über die Programme über Ereignisse an überwachten Dateien und Verzeichnissen informiert werden – beispielsweise das Erstellen, Ändern oder Löschen einer Datei. Dadurch müssen sie nicht ständig selbst nach Veränderungen suchen. Auslöser und Aufgabenerfolg getrennt überwachen ----------------------------------------------- Eine aktive Timer-Unit zeigt zunächst, dass die Zeitplanung aktiv ist. Eine aktive Path-Unit zeigt, dass die Überwachung eingerichtet ist. Beides beweist noch nicht, dass die ausgelöste Aufgabe erfolgreich arbeitet. Für den Beispiel-Timer helfen: ``` systemctl list-timers --all systemctl status backup.timer systemctl status backup.service journalctl -u backup.service -b ``` Bei Sicherungen muss zusätzlich geprüft werden, ob die erzeugten Daten verwendbar und wiederherstellbar sind. Ein erfolgreich beendeter Prozess ist ein wichtiges Signal, aber noch kein vollständiger Nachweis eines brauchbaren Backups. Ebenso beendet das Stoppen des Timers nicht automatisch einen bereits laufenden Backup-Durchlauf. Auslöser und ausgeführte Aufgabe bleiben getrennte Units. Fazit ----- Bedarfsgesteuerte Aktivierung ermöglicht es, Aufgaben passend zu ihrem tatsächlichen Zweck zu betreiben: - Socket-Units reagieren auf Kommunikation. - Timer-Units reagieren auf zeitliche Vorgaben. - Path-Units reagieren auf bestimmte Dateisystembedingungen. - Service-Units beschreiben die eigentliche Ausführung. Cron bleibt für einfache Zeitpläne eine gute Wahl. systemd-Timer sind besonders interessant, wenn Aufgaben dieselben Verwaltungs-, Abhängigkeits- und Diagnosefunktionen erhalten sollen wie andere Dienste. Entscheidend ist jedoch nicht nur der richtige Auslöser. Zu einem zuverlässigen Auftrag gehören auch passende Rechte, begrenzte Laufzeiten, ein bewusstes Verhalten bei Überschneidungen und eine überprüfbare Fehlerbehandlung.