systemd kann Dienste auf zwei Ebenen verwalten: durch die systemweite Instanz und durch benutzerbezogene Dienstmanager. Beide verwenden das Unit-Konzept, unterscheiden sich jedoch bei Zuständigkeit, Lebenszyklus und Berechtigungen.
Für die Systemadministration ist dabei eine Unterscheidung besonders wichtig:
> Wer einen Dienst verwaltet und unter welchem Benutzerkonto seine Prozesse laufen, sind zwei unterschiedliche Fragen.
Ein Systemdienst muss nicht als Root laufen. Ein Benutzerdienst ist wiederum nicht auf den grafischen Desktop beschränkt und kann mit passender Konfiguration auch ohne aktive Anmeldung betrieben werden.
Dieser Beitrag erklärt beiden Ebenen und zeigt, wie sich Dienste mit angemessenen Rechten und Ressourcen betreiben lassen.
Zwei Verwaltungsebenen auf demselben System
-------------------------------------------
Die systemweite systemd-Instanz läuft als PID 1. Zusätzlich kann für ein Benutzerkonto ein eigener Dienstmanager laufen. Dieser verwaltet die Units dieses Benutzers.
Vereinfacht sieht das so aus:
```
Systemweiter Dienstmanager
│
├── Systemdienste
│ ├── Webserver
│ └── Datenbank
│
└── Benutzer-Dienstmanager
├── Persönliche Hintergrundaufgaben
├── Benutzerbezogene Timer
└── Benutzerbezogene Container
```
Der Benutzer-Dienstmanager wird selbst durch eine System-Unit nach dem Muster `user@UID.service` gestartet. Für einen Benutzer mit der UID 1000 wäre das `user@1000.service`. Innerhalb dieser Instanz werden anschließend die Benutzer-Units verwaltet.
### Der wichtigste Unterschied bei den Befehlen
Systemdienst:
```
sudo systemctl status beispiel.service
```
Benutzerdienst des aktuell angemeldeten Benutzers:
```
systemctl --user status beispiel.service
```
Ohne `--user` wird standardmäßig der systemweite Dienstmanager angesprochen. Mit `--user` wird der Dienstmanager des aufrufenden Benutzers angesprochen. Eine gleichnamige Unit kann auf beiden Ebenen existieren und trotzdem jeweils einen anderen Dienst beschreiben.
Systemdienste: Verantwortung auf Systemebene
--------------------------------------------
Systemdienste gehören zur systemweiten Verwaltungsinstanz. Sie können unabhängig von einer persönlichen Anmeldung gestartet und betrieben werden.
Typische Einsatzbereiche sind:
- gemeinsam genutzte Serveranwendungen,
- Datenbanken,
- Infrastruktur- und Netzwerkdienste,
- zentrale Sicherungs- und Wartungsaufgaben.
Ihre Ausführung lässt sich ausdrücklich an ein eingeschränktes Benutzerkonto binden. Dafür stehen unter anderem `User=` und `Group=` zur Verfügung.
### Beispiel: Systemweit verwaltet, ohne Root-Rechte ausgeführt
```
[Unit]
Description=Interner Anwendungsdienst
[Service]
Type=exec
User=anwendungsdienst
Group=anwendungsdienst
ExecStart=/usr/local/bin/interne-anwendung
Restart=on-failure
[Install]
WantedBy=multi-user.target
```
Das Beispiel setzt voraus, dass Benutzer, Gruppe und Programm vorhanden sind und die erforderlichen Dateirechte besitzen.
Die Zuständigkeiten sind getrennt:
- Der systemweite Dienstmanager steuert den Lebenszyklus.
- Die Anwendungsprozesse laufen unter `anwendungsdienst`.
- Die Unit wird administrativ auf Systemebene verwaltet.
Eine lokale Unit würde beispielsweise unter folgendem Pfad liegen:
```
/etc/systemd/system/interne-anwendung.service
```
Aktivieren und starten:
```
sudo systemctl daemon-reload
sudo systemctl enable --now interne-anwendung.service
```
`User=` erstellt das angegebene Konto nicht automatisch. Ohne `DynamicUser=` muss es beim Start bereits existieren; andernfalls schlägt der Programmstart fehl.
> `DynamicUser=yes` lässt systemd für die Laufzeit eines Dienstes ein temporäres Benutzer- und Gruppenkonto bereitstellen, ohne dauerhafte Einträge in `/etc/passwd` oder `/etc/group` anzulegen. So kann ein Systemdienst ohne Root-Rechte laufen, ohne dass zuvor ein eigenes Dienstkonto eingerichtet werden muss. Existiert das konfigurierte Konto bereits, wird dieses stattdessen verwendet. Die Vorgehensweise eignet sich beispielsweise für einen kleinen Webdienst, der nur statische Dateien ausliefert: Er benötigt weder Root-Rechte noch eine dauerhafte Benutzeridentität, sodass systemd ihm automatisch ein temporäres Dienstkonto zuweisen kann – das spart manuelle Kontenverwaltung und trennt ihn von anderen Benutzerkonten.
Benutzerdienste: Verwaltung innerhalb eines Benutzerkontos
----------------------------------------------------------
Benutzerdienste werden vom Dienstmanager eines Benutzerkontos verwaltet. Sie eignen sich beispielsweise für:
- persönliche Synchronisierungsaufgaben,
- benutzerbezogene Hintergrundprogramme,
- persönliche Timer,
- rootless betriebene Container.
Ein gewöhnlicher Benutzer-Dienstmanager kann seine Dienste nicht einfach durch `User=root` mit Root-Rechten ausführen. Seine Prozesse laufen grundsätzlich im Berechtigungskontext des betreffenden Benutzerkontos.
### Beispiel: Persönlicher Hintergrunddienst
Die Datei wird angelegt unter:
```
~/.config/systemd/user/mein-hintergrunddienst.service
```
Inhalt:
```
[Unit]
Description=Persoenlicher Hintergrunddienst
[Service]
Type=exec
ExecStart=%h/.local/bin/mein-hintergrunddienst
Restart=on-failure
[Install]
WantedBy=default.target
```
`%h` steht hier für das Home-Verzeichnis des Benutzers. Das angegebene Programm muss vorhanden und ausführbar sein.
Verwaltung innerhalb der Benutzersitzung:
```
systemctl --user daemon-reload
systemctl --user enable --now mein-hintergrunddienst.service
```
Ein `User=`-Eintrag ist hier normalerweise nicht erforderlich: Der Dienstmanager läuft bereits unter dem zugehörigen Benutzerkonto.
### Klare Trennung der Zuständigkeiten
Die Trennung zwischen System- und Benutzerbetrieb schafft klare Zuständigkeiten: Die Administration verwaltet zentrale Dienste des Gesamtsystems, während Benutzer ihre persönlichen Hintergrundaufgaben selbst steuern können. Dadurch benötigen Benutzer für ihre eigenen Dienste keine administrativen Rechte und können deren Konfiguration ändern, ohne die systemweite Dienstverwaltung verändern zu müssen.
Linger: Benutzerdienste ohne aktive Anmeldung betreiben
-------------------------------------------------------
Der Lebenszyklus des Benutzer-Dienstmanagers muss gesondert betrachtet werden. Ohne besondere Konfiguration ist er typischerweise mit den Anmeldungen des Benutzers verbunden; Einzelheiten hängen von der Systemkonfiguration ab.
Mit aktiviertem **Linger** wird der Benutzer-Dienstmanager bereits beim Systemstart gestartet und nach Abmeldungen weiterbetrieben.
Aktivieren:
```
sudo loginctl enable-linger BENUTZERNAME
```
Zustand prüfen:
```
loginctl show-user BENUTZERNAME -p Linger
```
Mögliche Ausgabe:
```
Linger=yes
```
Deaktivieren:
```
sudo loginctl disable-linger BENUTZERNAME
```
Damit können beispielsweise Benutzer-Timer oder rootless Container unabhängig von einer aktiven Anmeldung betrieben werden.
### Was bedeutet „Linger“?
Das englische Verb **to linger** bedeutet „verweilen“, „bleiben“ oder „noch nicht verschwinden“. Der Name beschreibt bei systemd anschaulich, was passiert: Der Benutzer-Dienstmanager „bleibt da“, auch wenn sich der Benutzer abmeldet; zusätzlich wird er bereits beim Systemstart gestartet.
Wichtig ist die Unterscheidung: Der Dienst läuft nicht benutzerlos, sondern ohne aktive Anmeldung. Er gehört weiterhin zu einem Benutzerkonto und läuft mit dessen Berechtigungen – nur muss keine Person am Desktop oder über SSH angemeldet bleiben.
### Wann braucht man das?
Ein typisches Beispiel ist ein rootless Container auf einem Server:
1. Du meldest dich per SSH an und richtest einen Container als Benutzerdienst ein.
2. Der Container soll dauerhaft eine Anwendung bereitstellen.
3. Du meldest dich wieder ab – die Anwendung soll trotzdem weiterlaufen.
4. Nach einem Neustart soll sie wieder verfügbar sein, ohne dass du dich zuerst anmelden musst.
Linger schafft dafür die Voraussetzung auf Ebene des Benutzer-Dienstmanagers: Er steht auch ohne Anmeldung zur Verfügung. Der Container beziehungsweise seine Unit muss zusätzlich passend für den automatischen Start eingerichtet sein.
Dasselbe Prinzip passt zu einem persönlichen Synchronisierungsdienst oder einem Benutzer-Timer: Dateien sollen weiter synchronisiert oder Aufgaben nach Zeitplan ausgeführt werden, auch wenn gerade niemand interaktiv mit dem Konto arbeitet. Bei Benutzer-Timern ermöglicht Linger, dass der zuständige Dienstmanager dafür unabhängig von einer Anmeldung läuft.
Der Grundgedanke lautet also: Die Aufgabe gehört zum Benutzerkonto, aber ihre Ausführung soll nicht davon abhängen, ob dessen Besitzer gerade angemeldet ist.
### Was Linger nicht erledigt
Linger startet den Benutzer-Dienstmanager, aktiviert aber nicht automatisch jede darin vorhandene Unit. Die gewünschte Einbindung muss weiterhin eingerichtet werden, beispielsweise mit:
```
systemctl --user enable mein-hintergrunddienst.service
```
Außerdem stellt Linger keine persönliche Arbeitsumgebung bereit. Ein erst bei Anmeldung entschlüsseltes Home-Verzeichnis oder ein gesperrter Schlüsselbund kann weiterhin verhindern, dass ein Dienst auf benötigte Dateien oder Geheimnisse zugreift.
Die administrative Frage lautet deshalb nicht nur „Läuft der Dienstmanager?“, sondern auch „Sind seine benötigten Ressourcen ohne Anmeldung verfügbar?“.
Welche Verzeichnisse gehören zu welcher Ebene?
----------------------------------------------
| Verzeichnis | Verwendung |
|---|---|
| `/usr/lib/systemd/system/` | Paketgelieferte System-Units. |
| `/etc/systemd/system/` | Lokale System-Units und administrative Anpassungen. |
| `/usr/lib/systemd/user/` | Paketgelieferte Benutzer-Units. |
| `/etc/systemd/user/` | Systemweit bereitgestellte Konfiguration für Benutzer-Dienstmanager. |
| `~/.config/systemd/user/` | Persönliche Benutzer-Units und Anpassungen. |
Je nach Distribution und Umgebung kommen weitere Suchpfade hinzu.
> Eine Unit unter `/etc/systemd/user/` wird nicht zum Systemdienst. Sie wird Benutzer-Dienstmanagern bereitgestellt und kann dadurch in mehreren Benutzerinstanzen verwendet werden.
Systemdienst oder Benutzerdienst?
---------------------------------
Die Wahl sollte sich nach der betrieblichen Zuständigkeit richten – nicht allein danach, ob eine Anwendung ohne Root-Rechte laufen kann.
| Frage | Bedeutung für die Entscheidung |
|---|---|
| Gehört der Dienst zur gemeinsamen Infrastruktur? | Das spricht meist für systemweite Verwaltung. |
| Gehört er zu einer persönlichen Arbeitsumgebung? | Das spricht meist für Benutzerverwaltung. |
| Muss er ohne Anmeldung verfügbar sein? | Systemdienst oder Benutzerdienst mit passendem Linger-Konzept. |
| Wer darf Konfiguration und Programm verändern? | Bestimmt administrative Kontrolle und Vertrauensgrenzen. |
| Welche Dateien und Rechte werden benötigt? | Bestimmt Ausführungskonto und Einschränkungen. |
| Wer übernimmt Wartung und Störungsbehebung? | Sollte eindeutig festgelegt sein. |
Ein Dienst kann technisch in beiden Modellen umsetzbar sein. Organisatorisch ist es aber ein Unterschied, ob eine zentrale Anwendung unter einem verwalteten Dienstkonto oder innerhalb eines persönlichen Mitarbeiterkontos betrieben wird.
Eine hilfreiche Grundregel lautet:
> Gemeinsame Infrastruktur sollte nicht unbeabsichtigt vom Lebenszyklus eines persönlichen Benutzerkontos abhängen.
Die beiden Ebenen besitzen getrennte Abhängigkeitsmodelle
---------------------------------------------------------
Eine Benutzer-Unit kann nicht einfach mit folgendem Eintrag einen Systemdienst mitstarten:
```
Requires=datenbank.service
```
Der Benutzer-Dienstmanager sucht diese Abhängigkeit in seinem eigenen Unit-Bestand. Er spricht damit nicht automatisch die gleichnamige System-Unit an. Beide Dienstmanager verwalten ihre eigenen Unit-Hierarchien.
Das ist auch bei Netzwerk-Targets wichtig: Ein `After=network-online.target` in einer Benutzer-Unit stellt nicht automatisch eine Reihenfolge zum systemweiten Netzwerk-Target her.
Benutzerdienste sollten deshalb insbesondere mit zeitweise nicht verfügbaren Verbindungen umgehen können, statt auf eine vermeintliche managerübergreifende Startreihenfolge zu vertrauen.
Möglichst wenige Rechte vergeben
--------------------------------
Die Wahl der Verwaltungsebene ersetzt kein Sicherheitskonzept.
Ein Benutzerdienst kann auf alle Daten zugreifen, die sein Benutzerkonto lesen darf, sofern keine zusätzlichen Einschränkungen greifen. Ein kompromittierter persönlicher Dienst kann deshalb auch ohne Root-Rechte erheblichen Schaden verursachen.
Umgekehrt kann ein Systemdienst mit einem eigenen Dienstkonto und gezielten Einschränkungen betrieben werden. systemd bietet dafür unter anderem folgende Einstellungen:
| Einstellung | Zweck |
|---|---|
| `User=` und `Group=` | Ausführungskonto eines Systemdienstes festlegen. |
| `NoNewPrivileges=yes` | Zusätzliche Privilegiengewinne durch nachfolgende Programmaufrufe verhindern. |
| `ProtectSystem=strict` | Die Dateisystemhierarchie für den Dienst weitgehend schreibgeschützt bereitstellen. |
| `ProtectHome=yes` | Den Zugriff auf Home-Bereiche einschränken. |
| `PrivateTmp=yes` | Einen privaten Bereich für temporäre Dateien bereitstellen. |
| `ReadWritePaths=` | Schreibbare Ausnahmen von Dateisystembeschränkungen definieren. |
Diese Optionen müssen zur Anwendung passen. Ein Dienst, der auf Benutzerdaten unter `/home` zugreifen soll, kann beispielsweise durch `ProtectHome=yes` unbrauchbar werden.
### Dateisystemausnahmen vergeben keine zusätzlichen Dateirechte
Ein Eintrag wie:
```
ReadWritePaths=/srv/anwendungsdaten
```
kann einen Pfad innerhalb einer ansonsten schreibgeschützten Dienstumgebung beschreibbar lassen. Er umgeht aber keine normalen[ Eigentümer-, Gruppen- oder ACL-Regeln](https://andreas-moor.de/benutzer-und-gruppenmanagement-unter-linux-der-ueberblick/). Das Dienstkonto benötigt weiterhin passende Berechtigungen.
### Benutzerdienste unterstützen nicht jede Einschränkung gleich
Einige Schutzmechanismen benötigen Kernel-Funktionen oder Privilegien, die einem Benutzer-Dienstmanager nicht uneingeschränkt zur Verfügung stehen. Teilweise hängt die Nutzung von unprivilegierten User-Namespaces und der jeweiligen systemd-Version ab.
Eine für Systemdienste entwickelte Hardening-Konfiguration sollte deshalb nicht ungeprüft in eine Benutzer-Unit übernommen werden.
Beispiel: Ein eingeschränkter Systemdienst
------------------------------------------
Die folgende Unit illustriert, wie systemweite Verwaltung und eingeschränkte Ausführung zusammenpassen:
```
[Unit]
Description=Interner Verarbeitungsdienst
[Service]
Type=exec
User=verarbeitung
Group=verarbeitung
ExecStart=/usr/local/bin/verarbeitungsdienst
WorkingDirectory=/var/lib/verarbeitung
StateDirectory=verarbeitung
NoNewPrivileges=yes
ProtectSystem=strict
ProtectHome=yes
PrivateTmp=yes
Restart=on-failure
RestartSec=5s
[Install]
WantedBy=multi-user.target
```
Voraussetzungen sind ein vorhandenes Dienstkonto und ein geeignetes Programm.
`StateDirectory=verarbeitung` lässt systemd ein Zustandsverzeichnis unter `/var/lib/` vorbereiten und die Eigentumsverhältnisse für den Dienst einrichten. Das verwaltete Zustandsverzeichnis bleibt auch bei `ProtectSystem=strict` beschreibbar.
Das Beispiel ist keine universelle Sicherheitsvorlage. Benötigt die Anwendung weitere Schreibpfade, Geräte oder andere Zugriffe, muss die Konfiguration gezielt angepasst und getestet werden.
Ressourcen über cgroups steuern
-------------------------------
Ein Dienst kann nicht nur durch seine Rechte, sondern auch durch seinen Ressourcenverbrauch andere Aufgaben beeinträchtigen.
systemd verwendet Linux-cgroups, um Prozesse zu gruppieren und Ressourcen für diese Gruppen zu steuern. Grenzen können auf einzelne Dienste und auf übergeordnete Slices angewendet werden.
### Arbeitsspeicher: Schwelle und harte Grenze unterscheiden
```
[Service]
MemoryHigh=768M
MemoryMax=1G
```
Die Einstellungen haben unterschiedliche Aufgaben:
- `MemoryHigh=` ist eine Drosselungs- und Rückgewinnungsschwelle. Bei Überschreitung versucht der Kernel stärker, Speicher zurückzugewinnen, und bremst die betroffenen Prozesse.
- `MemoryMax=` ist die harte Grenze. Kann der Verbrauch nicht ausreichend begrenzt werden, kann innerhalb der cgroup der OOM-Killer Prozesse beenden.
Die Dokumentation empfiehlt ausdrücklich, `MemoryHigh=` als primären Steuerungsmechanismus und `MemoryMax=` als letzte Begrenzung einzusetzen.
Die Beispielwerte sind keine allgemeine Empfehlung. Bereits normale Lastspitzen können je nach Anwendung deutlich mehr Speicher benötigen.
### CPU: Gewichtung oder Obergrenze?
```
[Service]
CPUWeight=50
CPUQuota=150%
```
Auch hier sind zwei Konzepte zu unterscheiden:
| Einstellung | Bedeutung |
|---|---|
| `CPUWeight=` | Relative Verteilung verfügbarer CPU-Zeit zwischen konkurrierenden Gruppen derselben Ebene. |
| `CPUQuota=` | Obergrenze für die CPU-Zeit der Unit. |
`CPUQuota=150%` erlaubt insgesamt höchstens CPU-Zeit entsprechend eineinhalb vollständig ausgelasteten CPUs. Es bedeutet nicht „150 Prozent des gesamten Hosts“. `CPUWeight=50` gibt einem Dienst ein relatives Gewicht von **50** bei der Verteilung von CPU-Zeit. Der Standardwert ist **100**: Bei Konkurrenz erhält der Dienst damit ungefähr halb so viel CPU-Zeit wie ein gleichrangiger Dienst mit Standardgewicht. Es bedeutet nicht „maximal 50 Prozent CPU“.
Eine CPU-Obergrenze kann unerwünschte Last begrenzen, aber auch Antwortzeiten und Laufzeiten verschlechtern. Sie sollte deshalb aus einer konkreten Betriebsanforderung abgeleitet werden.
Ressourcenlimits wirken hierarchisch
------------------------------------
Die Grenzen einer übergeordneten Gruppe gelten auch für ihre untergeordneten Dienste.
Bei Benutzerprozessen ist beispielsweise folgende Struktur relevant:
```
user.slice
│
└── user-1000.slice
│
├── Anmeldesitzungen
│
└── user@1000.service
│
└── Benutzer-Units
```
Ein Limit für `user-1000.slice` betrifft damit die dort zusammengefassten Prozesse dieses Benutzers, einschließlich Sitzungen und Benutzer-Dienstmanager. Ein Limit ausschließlich für `user@1000.service` betrifft dagegen dessen Unterhierarchie.
Das ist administrativ wichtig: Eine Begrenzung „für den Benutzer“ kann erheblich mehr treffen als den einen Hintergrunddienst, den man ursprünglich im Blick hatte.
Welche Controller einem Benutzer-Dienstmanager zur eigenen Verwaltung zur Verfügung stehen, hängt zudem von der cgroup-Konfiguration und Delegation ab. Limits sollten deshalb nicht nur eingetragen, sondern auch auf ihre tatsächliche Wirkung geprüft werden.
Sicherheit und Limits schrittweise überprüfen
---------------------------------------------
Eine sinnvolle Vorgehensweise ist:
1. Zuständigkeit und Verwaltungsebene festlegen.
2. Benötigte Dateien, Verbindungen und Rechte erfassen.
3. Ein geeignetes Ausführungskonto wählen.
4. Den Dienst zunächst funktional testen.
5. Einschränkungen gezielt ergänzen.
6. Lastspitzen und Fehlerfälle untersuchen.
7. Wirksamkeit und Nebenwirkungen dokumentieren.
Für die Diagnose sollten immer die richtige Verwaltungsebene und die passenden Protokolle verwendet werden.
Systemdienst:
```
systemctl status verarbeitung.service
journalctl -u verarbeitung.service -b
```
Benutzerdienst:
```
systemctl --user status mein-hintergrunddienst.service
journalctl --user -u mein-hintergrunddienst.service -b
```
Bei Problemen sollte nicht sofort jede Einschränkung entfernt werden. Häufig ist eine einzelne Voraussetzung unpassend: ein Dateipfad, eine Berechtigung, eine fehlende Umgebungseinstellung oder ein zu knappes Ressourcenlimit.
Fazit
-----
Systemdienste und Benutzerdienste unterscheiden sich vor allem durch ihre Verwaltungszuständigkeit und ihren Lebenszyklus – nicht einfach durch „Root“ gegenüber „ohne Root“.
Systemdienste können unter eingeschränkten Dienstkonten laufen. Benutzerdienste können mit Linger unabhängig von einer aktiven Anmeldung betrieben werden. Beide Modelle benötigen aber passende Rechte, verfügbare Daten und eine klare betriebliche Verantwortung.
Sicherheitsvorgaben und Ressourcenlimits gehören dabei zur Dienstdefinition. Sie sollen Auswirkungen begrenzen, ersetzen jedoch weder Anwendungssicherheit noch Kapazitätsplanung. Gute Konfiguration bedeutet deshalb nicht maximale Einschränkung um jeden Preis, sondern nachvollziehbare Grenzen, unter denen der Dienst seine Aufgabe zuverlässig erfüllen kann.
Systemdienste und Benutzerdienste – Zuständigkeiten, Rechte und Ressourcen unter systemd
Submitted 2 hours ago by
blog@andreas-moor.de to random@mbin.linuxnation.social
https://andreas-moor.de/?p=78751