# systemctl — systemd-Dienste und Units steuern

> Praxis-Guide zu systemctl: Dienste starten, stoppen, aktivieren und überwachen, Units und Targets verwalten und den Systemzustand steuern.

Source: https://www.jpkc.com/db/cheatsheets/shell-system/systemctl/

<!-- PROSE:intro -->
systemctl ist das zentrale Werkzeug, um den systemd-Init- und Service-Manager zu steuern – von einzelnen Diensten bis zum gesamten Systemzustand. Du startest, stoppst und lädst Dienste neu, aktivierst sie für den Autostart, prüfst ihren Status und arbeitest mit Units, Targets, Timern und Logs. Dieser Guide führt dich durch die Befehle, die du im Server-Alltag wirklich brauchst – vom schnellen `restart` bis zur Boot-Analyse mit `systemd-analyze`.
<!-- PROSE:intro:end -->

## Dienste steuern

`systemctl start <service>` — Startet einen Dienst sofort.

```bash
systemctl start nginx
```

`systemctl stop <service>` — Stoppt einen laufenden Dienst.

```bash
systemctl stop nginx
```

`systemctl restart <service>` — Stoppt und startet einen Dienst neu. Verursacht eine kurze Ausfallzeit.

```bash
systemctl restart nginx
```

`systemctl reload <service>` — Lädt die Konfiguration neu, ohne den Dienst zu stoppen (keine Ausfallzeit, sofern unterstützt).

```bash
systemctl reload nginx
```

`systemctl reload-or-restart <service>` — Lädt neu, wenn der Dienst es unterstützt, andernfalls Neustart.

```bash
systemctl reload-or-restart php-fpm
```

`systemctl try-restart <service>` — Startet einen Dienst nur neu, wenn er gerade läuft.

```bash
systemctl try-restart nginx
```

`systemctl kill <service>` — Sendet ein Signal an die Prozesse eines Dienstes. Standardsignal ist SIGTERM.

```bash
systemctl kill nginx
```

`systemctl kill -s SIGKILL <service>` — Erzwingt das Beenden eines Dienstes, indem SIGKILL an alle seine Prozesse gesendet wird.

```bash
systemctl kill -s SIGKILL stuck-service
```

## Aktivieren & Deaktivieren (Autostart)

`systemctl enable <service>` — Aktiviert einen Dienst, sodass er automatisch beim Booten startet.

```bash
systemctl enable nginx
```

`systemctl disable <service>` — Deaktiviert den automatischen Start eines Dienstes beim Booten.

```bash
systemctl disable nginx
```

`systemctl enable --now <service>` — Aktiviert beim Booten und startet sofort in einem Befehl.

```bash
systemctl enable --now nginx
```

`systemctl disable --now <service>` — Deaktiviert beim Booten und stoppt sofort in einem Befehl.

```bash
systemctl disable --now nginx
```

`systemctl is-enabled <service>` — Prüft, ob ein Dienst für den automatischen Start beim Booten aktiviert ist.

```bash
systemctl is-enabled nginx
```

`systemctl reenable <service>` — Deaktiviert und aktiviert einen Dienst neu. Nützlich nach Änderungen am [Install]-Abschnitt.

```bash
systemctl reenable nginx
```

`systemctl mask <service>` — Verhindert vollständig, dass ein Dienst gestartet wird (auch manuell). Verlinkt die Unit nach /dev/null.

```bash
systemctl mask bluetooth
```

`systemctl unmask <service>` — Hebt die Maskierung auf und erlaubt wieder den Start des Dienstes.

```bash
systemctl unmask bluetooth
```

## Status & Inspektion

`systemctl status <service>` — Zeigt detaillierten Status inklusive Zustand, PID, Speicherverbrauch und letzten Log-Zeilen.

```bash
systemctl status nginx
```

`systemctl is-active <service>` — Prüft, ob ein Dienst gerade läuft. Gibt active oder inactive zurück.

```bash
systemctl is-active nginx
```

`systemctl is-failed <service>` — Prüft, ob ein Dienst fehlgeschlagen ist.

```bash
systemctl is-failed nginx
```

`systemctl show <service>` — Zeigt alle Eigenschaften eines Dienstes im Format key=value.

```bash
systemctl show nginx
```

`systemctl show <service> -p <property>` — Zeigt eine bestimmte Eigenschaft eines Dienstes.

```bash
systemctl show nginx -p MainPID
```

`systemctl show <service> -p ActiveState,SubState` — Zeigt mehrere bestimmte Eigenschaften auf einmal.

```bash
systemctl show nginx -p ActiveState,SubState,MainPID
```

`systemctl cat <service>` — Zeigt den vollständigen Inhalt der Unit-Datei eines Dienstes an.

```bash
systemctl cat nginx
```

`systemctl help <service>` — Öffnet die zu einem Dienst gehörende Man-Page (falls verfügbar).

```bash
systemctl help sshd
```

## Units auflisten

`systemctl list-units` — Listet alle geladenen und aktiven Units auf.

```bash
systemctl list-units
```

`systemctl list-units --type=service` — Listet nur Service-Units auf.

```bash
systemctl list-units --type=service
```

`systemctl list-units --state=running` — Listet nur derzeit laufende Units auf.

```bash
systemctl list-units --state=running
```

`systemctl list-units --state=failed` — Listet alle fehlgeschlagenen Units auf.

```bash
systemctl list-units --state=failed
```

`systemctl list-units --all` — Listet alle Units auf, auch inaktive.

```bash
systemctl list-units --all
```

`systemctl list-unit-files` — Listet alle installierten Unit-Dateien mit ihrem Aktiviert/Deaktiviert-Zustand auf.

```bash
systemctl list-unit-files
```

`systemctl list-unit-files --type=service` — Listet nur Service-Unit-Dateien mit ihrem Zustand auf.

```bash
systemctl list-unit-files --type=service
```

`systemctl list-unit-files --state=enabled` — Listet nur aktivierte Unit-Dateien auf.

```bash
systemctl list-unit-files --state=enabled
```

## Abhängigkeiten & Reihenfolge

`systemctl list-dependencies <service>` — Zeigt einen Baum der Units, von denen ein Dienst abhängt.

```bash
systemctl list-dependencies nginx
```

`systemctl list-dependencies <service> --reverse` — Zeigt, welche Units von diesem Dienst abhängen (ihn benötigen).

```bash
systemctl list-dependencies nginx --reverse
```

`systemctl list-dependencies <service> --before` — Zeigt Units, vor denen dieser Dienst startet.

```bash
systemctl list-dependencies nginx --before
```

`systemctl list-dependencies <service> --after` — Zeigt Units, nach denen dieser Dienst startet.

```bash
systemctl list-dependencies nginx --after
```

## Unit-Dateien verwalten

`systemctl edit <service>` — Erstellt eine Drop-in-Override-Datei für einen Dienst (öffnet den Editor). Änderungen überstehen Paket-Updates.

```bash
systemctl edit nginx
```

`systemctl edit --full <service>` — Bearbeitet die vollständige Unit-Datei direkt (kein Drop-in). Overrides überstehen Paket-Updates NICHT.

```bash
systemctl edit --full nginx
```

`systemctl daemon-reload` — Lädt die systemd-Manager-Konfiguration neu, nachdem Unit-Dateien geändert wurden. Nach jeder manuellen Änderung erforderlich.

```bash
systemctl daemon-reload
```

`systemctl revert <service>` — Entfernt alle lokalen Anpassungen (Drop-ins) und stellt die Hersteller-Unit-Datei wieder her.

```bash
systemctl revert nginx
```

`systemd-analyze verify <unit_file>` — Prüft eine Unit-Datei auf Syntaxfehler und häufige Probleme.

```bash
systemd-analyze verify /etc/systemd/system/my-app.service
```

## Timer (Cron-Ersatz)

`systemctl list-timers` — Listet alle aktiven Timer mit ihren nächsten und letzten Auslösezeiten auf.

```bash
systemctl list-timers
```

`systemctl list-timers --all` — Listet alle Timer auf, auch inaktive.

```bash
systemctl list-timers --all
```

`systemctl start <timer>` — Startet einen Timer sofort.

```bash
systemctl start backup.timer
```

`systemctl enable --now <timer>` — Aktiviert einen Timer dauerhaft über Neustarts hinweg und startet ihn jetzt.

```bash
systemctl enable --now backup.timer
```

`systemctl status <timer>` — Zeigt den Timer-Status inklusive des nächsten geplanten Laufs.

```bash
systemctl status backup.timer
```

`systemd-analyze calendar '<expression>'` — Testet und parst einen Kalenderausdruck, um zu sehen, wann er auslösen würde.

```bash
systemd-analyze calendar 'Mon..Fri *-*-* 06:00:00'
```

`systemd-run --on-calendar='<expression>' <command>` — Erstellt einen transienten Timer, der einen Befehl nach Zeitplan ausführt.

```bash
systemd-run --on-calendar='*-*-* 02:00:00' /usr/local/bin/backup.sh
```

`systemd-run --on-active=<time> <command>` — Erstellt einen transienten Timer, der einmalig nach einer Verzögerung läuft.

```bash
systemd-run --on-active=30m /usr/local/bin/cleanup.sh
```

## Journalctl (Logs)

`journalctl -u <service>` — Zeigt alle Log-Einträge für einen bestimmten Dienst.

```bash
journalctl -u nginx
```

`journalctl -u <service> -f` — Folgt der Live-Log-Ausgabe eines Dienstes (tail).

```bash
journalctl -u nginx -f
```

`journalctl -u <service> -n <lines>` — Zeigt nur die letzten N Log-Zeilen eines Dienstes.

```bash
journalctl -u nginx -n 50
```

`journalctl -u <service> --since '<time>'` — Zeigt Logs seit einem bestimmten Zeitpunkt.

```bash
journalctl -u nginx --since '1 hour ago'
```

`journalctl -u <service> --since '<start>' --until '<end>'` — Zeigt Logs innerhalb eines Zeitraums.

```bash
journalctl -u nginx --since '2024-01-01' --until '2024-01-02'
```

`journalctl -u <service> -p <priority>` — Filtert Logs nach Priorität: emerg, alert, crit, err, warning, notice, info, debug.

```bash
journalctl -u nginx -p err
```

`journalctl -u <service> -o json-pretty` — Gibt Logs im hübsch formatierten JSON-Format aus.

```bash
journalctl -u nginx -o json-pretty
```

`journalctl -u <service> --no-pager` — Gibt Logs ohne Pager aus (nützlich zum Weiterleiten in Pipes).

```bash
journalctl -u nginx --no-pager | grep error
```

`journalctl -b` — Zeigt alle Logs des aktuellen Boots.

```bash
journalctl -b
```

`journalctl -b -1` — Zeigt Logs des vorherigen Boots.

```bash
journalctl -b -1
```

`journalctl --list-boots` — Listet alle aufgezeichneten Boot-Sitzungen auf.

```bash
journalctl --list-boots
```

`journalctl --disk-usage` — Zeigt, wie viel Speicherplatz die Journal-Logs belegen.

```bash
journalctl --disk-usage
```

`journalctl --vacuum-size=<size>` — Reduziert den Journal-Log-Speicher auf eine maximale Größe.

```bash
journalctl --vacuum-size=500M
```

`journalctl --vacuum-time=<time>` — Entfernt Journal-Einträge, die älter als die angegebene Zeit sind.

```bash
journalctl --vacuum-time=30d
```

## Systemzustand & Targets

`systemctl get-default` — Zeigt das Standard-Boot-Target (z. B. graphical.target, multi-user.target).

```bash
systemctl get-default
```

`systemctl set-default <target>` — Legt das Standard-Boot-Target fest.

```bash
systemctl set-default multi-user.target
```

`systemctl isolate <target>` — Wechselt sofort zu einem anderen Target (wie ein Runlevel-Wechsel).

```bash
systemctl isolate multi-user.target
```

`systemctl list-units --type=target` — Listet alle aktiven Targets auf.

```bash
systemctl list-units --type=target
```

`systemctl reboot` — Startet das System neu.

```bash
systemctl reboot
```

`systemctl poweroff` — Fährt das System herunter und schaltet es aus.

```bash
systemctl poweroff
```

`systemctl suspend` — Versetzt das System in den Bereitschaftsmodus (Suspend-to-RAM).

```bash
systemctl suspend
```

`systemctl hibernate` — Versetzt das System in den Ruhezustand (Suspend-to-Disk).

```bash
systemctl hibernate
```

## Analyse & Performance

`systemd-analyze` — Zeigt, wie lange der Systemstart gedauert hat (Kernel + Userspace).

```bash
systemd-analyze
```

`systemd-analyze blame` — Listet alle Dienste nach Startzeit auf, langsamste zuerst.

```bash
systemd-analyze blame
```

`systemd-analyze critical-chain` — Zeigt die kritische Kette der Units, die den Boot am stärksten verzögert haben.

```bash
systemd-analyze critical-chain
```

`systemd-analyze critical-chain <service>` — Zeigt die kritische Kette für einen bestimmten Dienst.

```bash
systemd-analyze critical-chain nginx.service
```

`systemd-analyze plot > boot.svg` — Erzeugt eine SVG-Grafik des Boot-Vorgangs zur visuellen Analyse.

```bash
systemd-analyze plot > boot.svg
```

`systemd-analyze security <service>` — Analysiert die Sicherheits- und Sandboxing-Einstellungen eines Dienstes.

```bash
systemd-analyze security nginx
```

## Nutzerdienste

`systemctl --user start <service>` — Startet einen Dienst auf Nutzerebene (kein root erforderlich).

```bash
systemctl --user start my-app
```

`systemctl --user enable --now <service>` — Aktiviert und startet einen Dienst auf Nutzerebene.

```bash
systemctl --user enable --now my-app
```

`systemctl --user status <service>` — Zeigt den Status eines Dienstes auf Nutzerebene.

```bash
systemctl --user status my-app
```

`systemctl --user list-units --type=service` — Listet alle Dienste auf Nutzerebene auf.

```bash
systemctl --user list-units --type=service
```

`systemctl --user daemon-reload` — Lädt die systemd-Konfiguration auf Nutzerebene neu, nachdem Unit-Dateien bearbeitet wurden.

```bash
systemctl --user daemon-reload
```

`loginctl enable-linger <user>` — Erlaubt, dass Nutzerdienste auch laufen, wenn der Nutzer nicht angemeldet ist.

```bash
loginctl enable-linger deploy
```

<!-- PROSE:outro -->
## Fazit

systemctl bündelt die komplette Dienststeuerung unter systemd in einem konsistenten Kommando – im Alltag kommst du mit `start`, `stop`, `restart`, `reload` und `status` schon sehr weit. Wichtig ist der Unterschied zwischen `enable`/`disable` (Autostart beim Booten) und `start`/`stop` (sofortige Wirkung jetzt); `enable --now` kombiniert beides in einem Schritt. Nach jeder Änderung an Unit-Dateien gehört ein `systemctl daemon-reload` dazu, und `list-units --failed` zeigt dir schnell, was hakt. Sei vorsichtig bei kritischen Diensten: Ein `stop`, `disable` oder `mask` an `sshd` oder am Netzwerk kann auf einem entfernten Server den Zugang oder den nächsten Boot kappen. Auch `reboot`, `poweroff` und `isolate` greifen tief ins System ein – und die meisten Schreibaktionen brauchen `sudo`. Eigene Nutzerdienste verwaltest du ganz ohne root mit `systemctl --user`.

## Weiterführende Links

- [ubuntuusers-Wiki: systemd](https://wiki.ubuntuusers.de/systemd/) – ausführliche deutschsprachige Dokumentation zu systemd und seinen Werkzeugen
- [Arch-Wiki: systemd (Deutsch)](https://wiki.archlinux.org/title/Systemd_(Deutsch)) – tiefgehender deutschsprachiger Artikel zu systemd, Units und Timern
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [journalctl](https://www.jpkc.com/db/cheatsheets/shell-system/journalctl/) – Logs von systemd-Diensten und dem Journal abfragen
- [loginctl](https://www.jpkc.com/db/cheatsheets/shell-system/loginctl/) – Nutzer-Sitzungen und Logins von systemd-logind verwalten
- [hostnamectl](https://www.jpkc.com/db/cheatsheets/shell-system/hostnamectl/) – Hostnamen und Systeminformationen über systemd abfragen und setzen

