systemd verwaltet nicht ausschließlich Hintergrundprozesse. Seine grundlegenden Verwaltungseinheiten heißen Units. Sie beschreiben unterschiedliche Ressourcen und Aufgaben eines Linux-Systems: von Diensten über Kommunikationsendpunkte und zeitgesteuerte Aufgaben bis zu Mounts und Ressourcengruppen. Der entscheidende Vorteil ist das gemeinsame Verwaltungsmodell. Ein Dienst und das von ihm benötigte Dateisystem werden nicht als voneinander getrennte Themen behandelt, sondern können innerhalb desselben Abhängigkeitsmodells miteinander verknüpft werden. Für die Systemadministration bedeutet das: Wer Units versteht, kann nicht nur Dienste starten, sondern auch nachvollziehen, warum sie gestartet werden, welche Voraussetzungen sie benötigen und wie sie mit anderen Komponenten zusammenarbeiten. In diesem Blogbeitrag wir auf die Theorie der Units eingegangen, der praktische Umgang mit einzelnen Unit-Typen soll in weiteren Beiträgen in der Tiefe beleuchtet werden. Was ist eine Unit? ------------------ Eine Unit ist ein Objekt, das systemd verwaltet. Sie besitzt einen eindeutigen Namen mit einer Endung, die ihren Typ bestimmt. Beispiele: ``` sshd.service sshd.socket backup.timer datenimport.path multi-user.target srv-daten.mount ``` Die Namen sind Beispiele; welche Units tatsächlich vorhanden sind, hängt von Distribution und installierten Paketen ab. Eine Unit ist dabei nicht dasselbe wie eine Konfigurationsdatei. Viele Units werden durch solche Dateien beschrieben. Andere entstehen automatisch aus dem Systemzustand, werden aus anderen Konfigurationen erzeugt oder zur Laufzeit über Schnittstellen angelegt. > Ein wichtiges Beispiel sind Scope-Units: Sie werden programmgesteuert erstellt und nicht als gewöhnliche `.scope`-Dateien geschrieben. Wo liegen Unit-Dateien? ----------------------- systemd liest Unit-Dateien aus mehreren Verzeichnissen. Dadurch bleiben paketgelieferte Definitionen, dauerhafte lokale Anpassungen und temporäre Konfigurationen voneinander getrennt. Für System-Units sind vor allem diese Pfade wichtig: | Verzeichnis | Zweck | |---|---| | `/usr/lib/systemd/system/` | Unit-Dateien, die üblicherweise durch Distributionspakete installiert werden. | | `/etc/systemd/system/` | Eigene System-Units und dauerhafte administrative Anpassungen. | | `/run/systemd/system/` | Temporäre Unit-Dateien und Anpassungen für die aktuelle Laufzeit; sie gehen beim Neustart verloren. | Bei gleichnamigen vollständigen Unit-Dateien hat innerhalb dieser drei Verzeichnisse `/etc/` Vorrang vor `/run/` und `/run/` vor `/usr/lib/`. Eine lokale Datei kann damit die paketgelieferte Definition ersetzen. Paketgelieferte Dateien sollten nicht direkt verändert werden, da Updates diese Änderungen überschreiben können. Für gezielte Anpassungen eignen sich Drop-ins, beispielsweise: ``` /etc/systemd/system/beispiel.service.d/override.conf ``` Sie ergänzen oder überschreiben einzelne Einstellungen, ohne die gesamte Unit-Datei kopieren zu müssen. Für persönliche Benutzer-Units ist normalerweise `~/.config/systemd/user/` vorgesehen. Systemweit bereitgestellte Benutzer-Units liegen unter anderem in `/etc/systemd/user/` und `/usr/lib/systemd/user/`. Sie gehören zum Benutzer-Dienstmanager und werden mit `systemctl --user` statt über den systemweiten Dienstmanager verwaltet. Die Unit-Typen im Überblick --------------------------- systemd unterscheidet elf Unit-Typen. Die folgende Übersicht ergänzt die häufig verwendeten Typen um Automount-, Device- und Swap-Units. | Unit-Typ | Aufgabe | |---|---| | `.service` | Prozesse starten und als Dienst verwalten. | | `.socket` | Kommunikationsendpunkte bereitstellen und darüber Dienste aktivieren. | | `.timer` | Zeitgesteuerte Aktivierung auslösen. | | `.path` | Bestimmte Dateisystemzustände und Änderungen überwachen und darauf reagieren. | | `.target` | Units gruppieren und gemeinsame Aktivierungs- oder Synchronisationspunkte bilden. | | `.mount` | Einen Dateisystem-Mount beschreiben und verwalten. | | `.automount` | Einen Automount-Punkt bereitstellen, der beim Zugriff den zugehörigen Mount auslöst. | | `.device` | Von systemd erfasste Geräte repräsentieren. | | `.swap` | Auslagerungsdateien oder Auslagerungsbereiche verwalten. | | `.slice` | Units für die Ressourcenverwaltung hierarchisch gruppieren. | | `.scope` | Anderweitig gestartete Prozesse als Gruppe verwalten. | Nicht jeder Typ startet selbst Prozesse. Ein Target ist beispielsweise eine logische Gruppierung, während eine Slice die Ressourcenhierarchie strukturiert. Service-Units: Prozesse als Dienst verwalten -------------------------------------------- Service-Units sind der bekannteste Unit-Typ. Sie beschreiben, wie Programme gestartet und als Dienst betrieben werden. Dazu können unter anderem gehören: - Startbefehl und Ausführungsumgebung, - Benutzer und Gruppe, - Verhalten beim Stoppen, - Zeitlimits, - Neustartregeln, - Sicherheitsvorgaben, - Ressourcenbegrenzungen. ### Ein Dienst muss kein dauerhaft laufender Prozess sein Eine Service-Unit kann einen Webserver verwalten, aber auch eine Aufgabe ausführen, die nach kurzer Zeit endet. Für solche abgeschlossenen Aufgaben gibt es beispielsweise: ``` [Service] Type=oneshot ExecStart=/usr/local/sbin/meine-aufgabe ``` Das angegebene Programm ist ein Platzhalter für ein eigenes, vorhandenes und ausführbares Programm oder Skript. Bei `Type=oneshot` wartet systemd auf den Abschluss des Befehls. > Ohne `RemainAfterExit=yes` ist die Unit nach erfolgreicher Ausführung normalerweise wieder inaktiv. Das ist kein Fehler, sondern passt zu einer abgeschlossenen Aufgabe. ### Diensttyp und Bereitschaft > Der Eintrag `Type=` beeinflusst, wann systemd einen Dienststart als abgeschlossen betrachtet. #### Warum sind Diensttyp und Bereitschaft praktisch wichtig? Ein gestarteter Prozess ist nicht automatisch ein einsatzbereiter Dienst. Eine Anwendung kann bereits laufen, während sie noch Konfigurationen lädt oder Datenbankverbindungen aufbaut. Der Diensttyp bestimmt, wann systemd den Start als abgeschlossen betrachtet und entsprechend angeordnete Folge-Units weiterstartet. **Beispiel:** Eine Webanwendung benötigt eine Datenbank. Selbst mit `After=datenbank.service` kann sie zu früh starten, wenn die Datenbank-Unit bereits als gestartet gilt, obwohl die Datenbank noch keine Verbindungen annimmt. Eine korrekt unterstützte Bereitschaftsmeldung mit `Type=notify` ermöglicht hier eine verlässlichere Startkoordination. Das Wissen hilft deshalb, Startfehler und unnötige Neustarts zu vermeiden sowie Statusmeldungen richtig einzuordnen. Umgekehrt verursacht ein unpassender Typ selbst Probleme: Bei `Type=notify` ohne Unterstützung durch die Anwendung wartet systemd vergeblich auf die Meldung und bricht den Start nach dem Startzeitlimit ab. #### Diensttypen in Übersicht | Einstellung | Bedeutung | |---|---| | `Type=simple` | Der Dienst gilt bereits nach dem Erzeugen des Startprozesses als gestartet. | | `Type=exec` | systemd wartet darauf, dass das Dienstprogramm erfolgreich ausgeführt wurde. | | `Type=oneshot` | systemd wartet auf den Abschluss der vorgesehenen Befehle. | | `Type=notify` | Die Anwendung meldet ihre Bereitschaft ausdrücklich an systemd. | Dabei bedeutet auch `Type=exec` noch nicht, dass eine Anwendung bereits Anfragen verarbeiten kann. Eine explizite Bereitschaftsmeldung mit `Type=notify` setzt entsprechende Unterstützung durch die Anwendung voraus. Socket-Units: Kommunikationsendpunkte vor dem Dienst bereitstellen ------------------------------------------------------------------ Socket-Units beschreiben Kommunikationsendpunkte, beispielsweise einen lokalen Unix-Socket oder einen Netzwerk-Socket. Bei Socket-Aktivierung stellt systemd zunächst diesen Endpunkt bereit. Wenn Kommunikation eingeht, kann systemd den zugehörigen Dienst aktivieren. Vereinfacht: ``` Anfrage │ ▼ beispiel.socket │ aktiviert ▼ beispiel.service ``` Damit muss ein Dienst nicht in jedem Fall dauerhaft laufen, nur um auf mögliche Anfragen zu warten. Wichtig ist die Trennung der Aufgaben: - Die Socket-Unit beschreibt den Kommunikationsendpunkt. - Die Service-Unit beschreibt den auszuführenden Dienst. > Die Anwendung muss die vorgesehene Socket-Übergabe unterstützen. Eine beliebige Anwendung wird nicht allein dadurch socket-aktivierbar, dass man eine zusätzliche Unit-Datei anlegt. Timer-Units: Aufgaben zeitgesteuert aktivieren ---------------------------------------------- Eine Timer-Unit beschreibt, wann eine andere Unit aktiviert werden soll. Typischerweise ist das eine Service-Unit. ``` backup.timer │ aktiviert ▼ backup.service │ führt aus ▼ Backup-Programm ``` Die Zeitplanung und die eigentliche Aufgabe bleiben dadurch getrennt. Standardmäßig aktiviert `backup.timer` die gleichnamige `backup.service`; über `Unit=` kann eine andere Zuordnung festgelegt werden. ### Kalenderbasierte und relative Zeitplanung Timer können sich beispielsweise auf folgende Zeitpunkte beziehen: - einen Kalendertermin, - eine Zeitspanne nach dem Systemstart, - eine Zeitspanne nach der letzten Aktivierung, - eine Zeitspanne nach dem Ende der aktivierten Unit. Bei kalenderbasierten Timern kann `Persistent=true` eine während der Inaktivität verpasste Ausführung nachholen. Das bedeutet nicht, dass sämtliche ausgefallenen Einzeltermine nachträglich abgearbeitet werden. Path-Units: Auf Dateisystemzustände reagieren --------------------------------------------- Path-Units beobachten bestimmte Pfade und aktivieren bei passenden Bedingungen eine andere Unit. Mögliche Auslöser sind beispielsweise: ``` PathExists=/pfad/zur/datei PathChanged=/pfad/zur/datei DirectoryNotEmpty=/pfad/zum/verzeichnis ``` Damit lassen sich unter anderem Import- oder Verarbeitungsaufgaben anstoßen. Standardmäßig aktiviert `datenimport.path` eine zugehörige `datenimport.service`. ### Kein vollständiger Ersatz für eine Aufgabenwarteschlange Path-Units beobachten definierte Bedingungen. Sie garantieren nicht, dass jedes fachliche Ereignis als eigenständiger Auftrag erhalten bleibt. Besonders bei `DirectoryNotEmpty=` muss die Verarbeitung dafür sorgen, dass die auslösende Bedingung wieder verschwindet. Bleiben Dateien unverarbeitet im Verzeichnis, kann die Service-Unit unmittelbar erneut aktiviert werden. systemd begrenzt solche Aktivierungsschleifen. Außerdem gelten Einschränkungen der verwendeten inotify-Schnittstelle: Änderungen, die andere Rechner auf einem entfernten NFS-Dateisystem vornehmen, lassen sich damit beispielsweise nicht zuverlässig überwachen. Targets: Units zu gemeinsamen Zielen zusammenfassen --------------------------------------------------- Targets gruppieren andere Units und bilden gemeinsame Aktivierungs- oder Synchronisationspunkte. Bekannte Beispiele sind: ``` multi-user.target graphical.target timers.target ``` Ein Target ist kein eigener Hintergrundprozess. Es beschreibt einen Zusammenhang zwischen Units. Ein selbst definiertes Target könnte beispielsweise mehrere Dienste einer Anwendung zusammenfassen: ``` anwendung.target ├── frontend.service ├── worker.service └── verarbeitung.timer ``` Die tatsächlichen Beziehungen müssen durch passende Abhängigkeiten eingerichtet werden. > **Wichtig**: Ein aktives Target ist kein umfassender Gesundheitstest der gesamten Anwendung. Ob die beteiligten Komponenten fachlich korrekt zusammenarbeiten, muss zusätzlich geprüft werden. Mounts-, Automounts-, Geräte- und Swap-Units -------------------------------------------- ### Mount-Units > Eine Mount-Unit beschreibt einen Dateisystem-Mount. Ihr Name wird aus dem Mount-Pfad abgeleitet. Beispielsweise gehört zum Pfad: ``` /srv/daten ``` der Unit-Name: ``` srv-daten.mount ``` Mount-Units können auch automatisch aus Einträgen in `/etc/fstab` erzeugt werden. Nicht jeder Mount benötigt deshalb eine manuell geschriebene Unit-Datei. ### Automount-Units > Eine Automount-Unit stellt einen Zugriffspunkt bereit. **Erst ein Zugriff darauf löst den zugehörigen Mount aus.** ``` Zugriff auf /srv/daten │ ▼ srv-daten.automount │ aktiviert ▼ srv-daten.mount ``` Automount und Mount sind dabei zwei unterschiedliche Units mit zusammengehörigen Aufgaben. ### Device-Units Device-Units repräsentieren Geräte, die systemd aus der Geräteverwaltung erfasst. Andere Units können von diesen Geräten abhängen. So erhalten Mount- und Swap-Units gegebenenfalls automatisch Abhängigkeiten zu den zugrunde liegenden Geräten. ### Swap-Units Swap-Units beschreiben Auslagerungsbereiche oder Auslagerungsdateien. Auch sie sind Teil desselben Verwaltungsmodells und können in Abhängigkeiten einbezogen werden. Slice- und Scope-Units: Prozesse und Ressourcen strukturieren ------------------------------------------------------------- ### Slice-Units Slices bilden eine Hierarchie für die Ressourcenverwaltung. Sie gruppieren unter anderem Service- und Scope-Units. Vereinfacht: ``` system.slice ├── webserver.service ├── datenbank.service └── worker.service ``` Dadurch können Ressourcen sowohl für einzelne Dienste als auch für übergeordnete Gruppen betrachtet und begrenzt werden. Die technische Grundlage bilden Linux-cgroups. ### Scope-Units Scope-Units verwalten Prozesse, die außerhalb des Dienstmanagers gestartet wurden. Anders als Service-Units erzeugen sie die verwalteten Prozesse nicht selbst. Ein Beispiel für das Starten eines Befehls innerhalb einer neuen Scope-Unit ist: ``` systemd-run --user --scope sleep 60 ``` Scope-Units werden programmgesteuert angelegt. Sie besitzen außerdem nicht das gleiche Hauptprozessmodell wie Service-Units: Ihr Lebenszyklus orientiert sich daran, ob noch Prozesse in der Gruppe vorhanden sind. Wie ist eine Unit-Datei aufgebaut? ---------------------------------- Unit-Dateien verwenden Abschnitte mit Schlüssel-Wert-Paaren. Eine Service-Unit kann beispielsweise so aufgebaut sein: ``` [Unit] Description=Beschreibung der Aufgabe [Service] Type=oneshot ExecStart=/usr/local/sbin/meine-aufgabe [Install] WantedBy=multi-user.target ``` Die Abschnitte haben unterschiedliche Aufgaben: | Abschnitt | Bedeutung | |---|---| | `[Unit]` | Allgemeine Angaben, Abhängigkeiten und Reihenfolge. | | `[Service]` | Einstellungen speziell für eine Service-Unit. | | `[Install]` | Informationen, die unter anderem von `systemctl enable` ausgewertet werden. | Andere Unit-Typen besitzen passende Abschnitte wie `[Timer]`, `[Socket]`, `[Path]` oder `[Mount]`. Nicht jede Unit benötigt einen `[Install]`-Abschnitt. ### Unit-Dateien sind keine Shell-Skripte Ein Eintrag wie `ExecStart=` wird nicht automatisch durch eine Shell ausgeführt. Shell-Konstrukte wie Pipes und Umleitungen funktionieren dort deshalb nicht einfach wie in einem Terminal. Für umfangreichere Abläufe ist ein separates Skript häufig übersichtlicher. Die Unit beschreibt dann die Ausführungsbedingungen, während das Skript die eigentliche Aufgabe umsetzt. Abhängigkeit und Startreihenfolge unterscheiden ----------------------------------------------- Eine der wichtigsten Grundlagen ist die Trennung von Anforderung und Reihenfolge. | Einstellung | Grundlegende Wirkung | |---|---| | `Wants=` | Die genannte Unit soll mit aktiviert werden; ihr Fehlschlagen verhindert nicht grundsätzlich den Betrieb der anfordernden Unit. | | `Requires=` | Stärkere Anforderungsbeziehung mit zusätzlichen Auswirkungen bei Aktivierung und Deaktivierung. | | `After=` | Ordnet den Start nach der genannten Unit ein, wenn beide gestartet werden. | | `Before=` | Ordnet den Start vor der genannten Unit ein. | `After=` startet die andere Unit nicht automatisch. Umgekehrt legt `Requires=` allein noch keine Startreihenfolge fest. Häufig werden deshalb Anforderungs- und Reihenfolgebeziehungen kombiniert. ### Beispiel: Ein Dienst benötigt ein Dateisystem ``` [Unit] Description=Verarbeitung von Daten RequiresMountsFor=/srv/daten ``` `RequiresMountsFor=` veranlasst systemd, passende Anforderungs- und Reihenfolgeabhängigkeiten zu den Mount-Units einzurichten, die für den Zugriff auf den angegebenen Pfad benötigt werden. > Das ersetzt allerdings nicht die korrekte Einrichtung des gewünschten Mounts. Ein Verzeichnis wird nicht allein durch diese Angabe zu einem separaten Dateisystem. Praxisbeispiel: Eine Aufgabe täglich ausführen ---------------------------------------------- Das folgende Beispiel verbindet eine Service- mit einer Timer-Unit. Voraussetzung ist ein bereits vorhandenes und getestetes Skript: ``` /usr/local/sbin/datenpflege ``` > Es muss ausführbar sein, geeignete Rechte besitzen und bei Fehlern einen passenden Exit-Code zurückgeben. Die folgenden Dateien erstellen dieses Skript nicht. ### Service-Unit Datei: ``` /etc/systemd/system/datenpflege.service ``` Inhalt: ``` [Unit] Description=Regelmaessige Datenpflege RequiresMountsFor=/srv/daten [Service] Type=oneshot ExecStart=/usr/local/sbin/datenpflege TimeoutStartSec=30min ``` Die Service-Unit beschreibt die Aufgabe (*Description=*) und ihre Voraussetzungen (*RequiresMountsFor=*). Das Zeitlimit (*TimeoutStartSec=*) begrenzt bei diesem Oneshot-Dienst die Ausführungsdauer. > Ohne `User=` läuft dieses Beispiel als Systemdienst standardmäßig mit Root-Rechten. Für einen echten Einsatz sollte geprüft werden, ob ein eingeschränktes Dienstkonto und zusätzliche Schutzmaßnahmen ausreichen. ### Timer-Unit Datei: ``` /etc/systemd/system/datenpflege.timer ``` Inhalt: ``` [Unit] Description=Taegliche Datenpflege einplanen [Timer] OnCalendar=*-*-* 02:00:00 Persistent=true [Install] WantedBy=timers.target ``` Dieser Timer plant die Aktivierung täglich um 02:00 Uhr nach der lokalen Systemzeit. Die tatsächliche Ausführung unterliegt dem Genauigkeitsfenster des Timers; standardmäßig beträgt `AccuracySec=` eine Minute. ### Konfiguration einlesen und Timer aktivieren ``` sudo systemctl daemon-reload sudo systemctl enable --now datenpflege.timer ``` Hier wird der Timer aktiviert, nicht die Service-Unit als dauerhaftes Boot-Ziel. - `daemon-reload` lässt systemd geänderte Unit-Dateien neu einlesen. - `enable` richtet die vorgesehene dauerhafte Einbindung ein. - `--now` startet den Timer zusätzlich unmittelbar. Die Aufgabe selbst lässt sich unabhängig vom Zeitplan manuell starten: ``` sudo systemctl start datenpflege.service ``` Das ist ein wesentlicher Vorteil der Trennung: Zeitplanung und Ausführung können unabhängig voneinander geprüft werden. Units im Alltag untersuchen --------------------------- Für die Administration sind folgende Befehle besonders hilfreich: | Befehl | Zweck | |---|---| | `systemctl list-units` | Standardmäßig **aktive** sowie weitere relevante geladene Units anzeigen. | | `systemctl list-units --all` | Auch **inaktive** geladene Units einbeziehen. | | `systemctl list-unit-files` | Bekannte Unit-Dateien und ihren **Einbindungszustand** anzeigen. | | `systemctl status NAME` | **Laufzeitzustand** einer Unit untersuchen. | | `systemctl cat NAME` | Zugehörige Unit-Dateien und Drop-ins anzeigen. | | `systemctl show NAME` | Eigenschaften der Unit abfragen. | | `systemctl list-dependencies NAME` | Abhängigkeiten untersuchen. | | `systemctl list-timers --all` | Timer und geplante Aktivierungen anzeigen. | | `systemctl --failed` | Fehlgeschlagene Units auflisten. | `list-units` und `list-unit-files` beantworten unterschiedliche Fragen: Der erste Befehl betrachtet die im Dienstmanager geladenen Units, der zweite die verfügbaren Unit-Dateien. Für Protokolle der Beispielaufgabe: ``` journalctl -u datenpflege.service ``` Aktiv, aktiviert und geladen sind unterschiedliche Zustände ----------------------------------------------------------- Drei Begriffe sollten getrennt betrachtet werden: - **Geladen**: systemd kennt die Unit und ihre Definition. - **Aktiv**: Die Unit befindet sich aktuell in einem ihrem Typ entsprechenden aktiven Zustand. - **Enabled**: Die vorgesehene Einbindung wurde eingerichtet, beispielsweise über einen symbolischen Link in das Abhängigkeitsverzeichnis eines Targets. Daraus folgt: - Eine aktivierte Unit muss gerade nicht laufen. - Eine laufende Unit muss nicht aktiviert sein. - Eine Unit ohne eigene Aktivierungsinformationen kann trotzdem über Abhängigkeiten oder Auslöser gestartet werden. - Ein erfolgreich beendeter Oneshot-Dienst kann wieder inaktiv sein. Auch `disable` bedeutet nicht „darf niemals starten“. Andere Units oder ein manueller Start können die Unit weiterhin aktivieren. `mask` verhindert dagegen ihre Aktivierung, solange die Maskierung besteht. Eigene Anpassungen sauber verwalten ----------------------------------- Paketgelieferte Unit-Dateien sollten nicht direkt verändert werden. Für lokale Anpassungen eignen sich Drop-ins. Beispiel: ``` sudo systemctl edit beispiel.service ``` Ein solches Drop-in könnte enthalten: ``` [Service] Restart=on-failure RestartSec=5s ``` > Drop-ins ergänzen oder überschreiben Einstellungen der ursprünglichen Unit, ohne deren vollständige Definition kopieren zu müssen. Ihre Zusammenführung folgt festgelegten Vorrangregeln. Für System-Units sind insbesondere diese Verzeichnisse relevant: | Verzeichnis | Typischer Zweck | |---|---| | `/usr/lib/systemd/system/` | Paketgelieferte Unit-Dateien. | | `/etc/systemd/system/` | Dauerhafte lokale Units und Anpassungen. | | `/run/systemd/system/` | Temporäre Laufzeitkonfiguration. | Je nach Distribution können zusätzliche oder abweichend dargestellte Pfade vorkommen. Außerdem gelten für vollständige Unit-Dateien und Drop-ins jeweils eigene Regeln der Zusammenführung. Fazit ----- Units sind das gemeinsame Verwaltungsmodell von systemd. Sie verbinden Prozesse, Aktivierungsmechanismen, Dateisysteme und Ressourcen in einer einheitlichen Struktur. Für die Linux-Systemadministration ist deshalb nicht nur wichtig, einzelne Unit-Typen zu kennen. Entscheidend ist ihr Zusammenspiel: - Eine Timer-Unit bestimmt, wann eine Aufgabe ausgeführt wird. - Eine Service-Unit beschreibt ihre Ausführung. - Mount-Abhängigkeiten stellen benötigte Dateisysteme bereit. - Slices strukturieren die Ressourcenverwaltung. - Targets fassen zusammengehörige Units zu gemeinsamen Zielen zusammen. Wer diese Beziehungen versteht, kann Dienste nicht nur bedienen, sondern ihren Start, ihre Voraussetzungen und ihr Verhalten im Gesamtsystem nachvollziehbar gestalten.