Linux, DevOps und KI: Warum Grundlagen im Jahr 2026 wichtiger sind als je zuvor

Im Eifer, KI und cloud-native Tools zu adoptieren, werden oft die Grundlagen vernachlässigt. Dieser Artikel erklärt, warum die Beherrschung der Linux-Kommandozeile, Container-Grundlagen und Basiswissen über Infrastruktur das Fundament für jeden modernen DevOps- und KI-Workload bilden. KI generiert Code – sie ersetzt nicht das Verständnis.

systemctl — Service-Management

# Start, stop, restart a service
sudo systemctl start nginx
sudo systemctl stop nginx
sudo systemctl restart nginx

# Reload configuration (graceful, no downtime — service must support SIGHUP)
sudo systemctl reload nginx

# Conditionally restart only if the service is running
sudo systemctl try-restart nginx

# Enable/disable a service (start/stop at boot)
sudo systemctl enable nginx
sudo systemctl disable nginx

# Enable and start immediately
sudo systemctl enable --now nginx
# Disable and stop immediately
sudo systemctl disable --now nginx

# Check service status
sudo systemctl status nginx

# Check whether a service is active/enabled
systemctl is-active nginx        # prints: active / inactive / failed
systemctl is-enabled nginx       # prints: enabled / disabled / static / masked
systemctl is-failed nginx        # prints: failed / active / inactive

# Mask a service (makes it impossible to start, even manually)
sudo systemctl mask sleep.target
# Unmask
sudo systemctl unmask sleep.target

systemctl — Units auflisten

# List all units (services, sockets, timers, targets, etc.)
systemctl list-units

# List only active units
systemctl list-units --state=active

# List failed units
systemctl list-units --state=failed

# List all unit files on disk (including inactive)
systemctl list-unit-files

# List services specifically
systemctl list-units --type=service

# List timers
systemctl list-timers --all

# List sockets
systemctl list-sockets

# Show dependencies of a unit
systemctl list-dependencies nginx
systemctl list-dependencies --reverse nginx   # reverse (what depends on it)

# Show a unit's full configuration (resolved, with drop-ins merged)
systemctl cat nginx

systemctl — Systemzustand

# Check overall system state
systemctl status                   # summary of system
systemctl is-system-running        # prints: running / degraded / maintenance

# Halt, power-off, reboot
sudo systemctl halt
sudo systemctl poweroff
sudo systemctl reboot

# Suspend / hibernate
sudo systemctl suspend
sudo systemctl hibernate
sudo systemctl hybrid-sleep        # suspend + hibernate

# Enter rescue / emergency mode
sudo systemctl rescue
sudo systemctl emergency

# Change default target (runlevel)
sudo systemctl set-default multi-user.target
sudo systemctl set-default graphical.target

# Get current default target
systemctl get-default

Struktur der Unit-Datei

Alle Unit-Dateien befinden sich unter /etc/systemd/system/ (Administrator-verwaltet) oder /lib/systemd/system/ (Paket-verwaltet). Dateiname = Unit-Name, z. B. myapp.service.

[Unit]
# Beschreibung, die in Logs und Statusausgaben angezeigt wird
Description=My Application Service
Documentation=https://docs.example.com/myapp

# --- Abhängigkeitsreihenfolge ---
# After: starte diese Unit NACHDEM die aufgelisteten Units gestartet wurden
After=network-online.target docker.service
# Before: starte diese Unit VOR den aufgelisteten Units
Before=nginx.service
# Requires: harte Abhängigkeit — wenn die aufgelistete Unit fehlschlägt, schlägt auch diese Unit fehl
Requires=docker.service
# Wants: weiche Abhängigkeit — starte die aufgelistete Unit, wenn möglich, aber schlage nicht fehl, wenn dies nicht möglich ist
Wants=redis.service
# PartOf: starte diese Unit neu, wenn die übergeordnete Unit neu startet
PartOf=docker.service

Conflicts: diese Unit kann nicht zusammen mit der aufgelisteten Unit ausgeführt werden

Conflicts=shutdown.target

[Service]

--- Ausführung ---

ExecStart: der Befehl für den Hauptprozess (erforderlich für Type=simple)

ExecStart=/usr/bin/myapp --config /etc/myapp/config.toml

ExecStartPre: wird vor ExecStart ausgeführt (muss erfolgreich sein, sonst schlägt der Dienst fehl)

ExecStartPre=/usr/bin/myapp --validate-config

ExecStartPost: wird ausgeführt, nachdem der Hauptprozess gestartet wurde

ExecStartPost=/usr/bin/myapp --notify-master

ExecReload: Befehl zum Neuladen der Konfiguration (ausgelöst durch systemctl reload)

ExecReload=/bin/kill -HUP $MAINPID

ExecStop: Befehl zum Stoppen des Dienstes (Standard: SIGTERM)

ExecStop=/usr/bin/myapp --shutdown

ExecStopPost: Bereinigung, nachdem der Dienst gestoppt wurde

ExecStopPost=/usr/bin/rm -f /run/myapp.pid

--- Service-Typ ---

Type=simple # Standard: Dienst gilt als gestartet, sobald ExecStart einen Fork ausführt Type=forking # Dienst forkt in den Hintergrund; systemd verfolgt die PID via PIDFile Type=notify # Dienst sendet sd_notify(), wenn er bereit ist Type=oneshot # Dienst wird einmal ausgeführt und beendet sich; RemainAfterExit=yes verwenden Type=dbus # Dienst ist bereit, wenn ein spezifizierter Bus-Name erscheint Type=idle # wie simple, verzögert den Start jedoch, bis alle Jobs verteilt sind

PIDFile=/run/myapp.pid # erforderlich für Type=forking

--- Neustart-Richtlinie ---

Restart=on-failure # Neustart bei Exit-Code ungleich Null oder Signal Restart=always # immer Neustart (auch bei sauberem Beenden) Restart=on-abnormal # bei Signal, Timeout oder Watchdog Restart=no # niemals Neustart (Standard)

Verzögerung zwischen Neustart-Versuchen (Standard: 100ms)

RestartSec=5s

Anzahl der Neustart-Versuche innerhalb eines Zeitfensters

StartLimitBurst=5 # max. Versuche StartLimitIntervalSec=60 # innerhalb dieses Fensters

--- Benutzer und Berechtigungen ---

User=myapp Group=myapp WorkingDirectory=/opt/myapp

SupplementaryGroups=docker # zusätzliche Gruppen

--- Umgebung ---

Environment="NODE_ENV=production" Environment="DB_HOST=localhost" Environment="DB_PORT=5432" EnvironmentFile=/etc/myapp/env # KEY=VALUE Zeilen aus einer Datei laden EnvironmentFile=-/etc/myapp/env.local # Präfix-Bindestrich = kein Fehler, falls Datei fehlt

--- Ressourcenlimits ---

LimitNOFILE=65536 # max. offene Dateideskriptoren LimitNPROC=4096 # max. Prozesse MemoryMax=512M # Speicherlimit (Kill, wenn überschritten) MemoryHigh=384M # Soft-Speicherlimit (Drosselung) CPUQuota=50% # CPU-Limit (Prozentanteil eines einzelnen Kerns) TasksMax=100 # max. Anzahl an Threads/Prozessen TimeoutStartSec=30 # max. Startzeit, bevor systemd den Prozess beendet TimeoutStopSec=10 # max. Stoppzeit TimeoutSec=60 # Kurzform für Start und Stopp

--- Security Hardening ---

Sandboxing

ProtectSystem=strict # /usr und /boot schreibgeschützt machen ProtectHome=true # /home, /root, /run/user unzugänglich machen PrivateTmp=yes # privates /tmp mounten PrivateDevices=yes # privates /dev mounten (keine physischen Geräte) PrivateNetwork=yes # Netzwerk-Namespace isolieren (kein Netzwerkzugriff) NoNewPrivileges=yes # setuid/setgid Privilegienerweiterung verhindern ReadOnlyPaths=/etc/myapp # explizit schreibgeschützte Pfade erlauben ReadWritePaths=/var/lib/myapp # explizit beschreibbare Pfade erlauben ProtectKernelTunables=yes # Modifikation von Kernel-Tunables verhindern ProtectControlGroups=yes # Modifikation von cgroups verhindern ProtectKernelModules=yes # Laden/Entladen von Kernel-Modulen verhindern SystemCallFilter=@system-service # Whitelist erlaubter Syscalls CapabilityBoundingSet=CAP_NET_BIND_SERVICE # Linux-Capabilities einschränken AmbientCapabilities=CAP_NET_BIND_SERVICE # Capabilities ohne vollen Root-Zugriff gewähren

--- Logging ---

StandardOutput=journal # stdout an journald loggen (Standard) StandardError=journal # stderr an journald loggen (Standard) SyslogIdentifier=myapp # Identifikator für syslog/journal Filterung

--- systemd benachrichtigen, wenn bereit ---

NotifyAccess=all # allen Prozessen erlauben, Bereitschaftsbenachrichtigungen zu senden WatchdogSec=30 # erwartet einen Keepalive-Ping alle 30s

--- Verschiedenes ---

RemainAfterExit=yes # Dienst nach Beendigung als aktiv markieren (für Type=oneshot)

[Install]

WantedBy: das Target, das diese Unit beim Aktivieren einbindet

WantedBy=multi-user.target

Also= diese Units ebenfalls aktivieren, wenn diese Unit aktiviert wird

Also=myapp-logrotate.timer

Alias= Symlinks mit diesen Namen erstellen

Alias=myapp.service

### Real-World Service Unit File

```ini
# /etc/systemd/system/myapp.service
[Unit]
Description=MyApp Web Server
After=network-online.target postgresql.service
Wants=postgresql.service
StartLimitIntervalSec=300
StartLimitBurst=5

[Service]
Type=simple
User=myapp
Group=myapp
WorkingDirectory=/opt/myapp
ExecStartPre=/usr/bin/myapp migrate --config /etc/myapp/config.toml
ExecStart=/usr/bin/myapp serve --config /etc/myapp/config.toml --port 8080
ExecReload=/bin/kill -HUP $MAINPID
Restart=on-failure
RestartSec=5s
TimeoutStartSec=30
TimeoutStopSec=10

EnvironmentFile=/etc/myapp/environment
Environment="RUST_LOG=info"

LimitNOFILE=65536
MemoryMax=1G
TasksMax=512

ProtectSystem=strict
ProtectHome=true
PrivateTmp=yes
NoNewPrivileges=yes
ReadOnlyPaths=/etc/myapp
ReadWritePaths=/var/lib/myapp /var/log/myapp

StandardOutput=journal
StandardError=journal
SyslogIdentifier=myapp

[Install]
WantedBy=multi-user.target

Drop-In Directories

Drop-ins let you override or extend a unit's settings without modifying the original file. Useful for vendor units you don't control.

# Erstellen eines Drop-ins für nginx
sudo systemctl edit nginx
# Dies erstellt: /etc/systemd/system/nginx.service.d/override.conf

# Erstellen eines Drop-ins mit benutzerdefiniertem Namen
sudo systemctl edit nginx --force --full

# Verzeichnisstruktur
/etc/systemd/system/
  nginx.service             # Ihre benutzerdefinierte Unit (hat Priorität)
  nginx.service.d/          # Drop-in-Verzeichnis
    override.conf           # wird über die Vendor-Unit gemergt
    custom-limits.conf      # zusätzliche Drop-in-Datei
/lib/systemd/system/
  nginx.service             # Vendor/Package-Unit

# /etc/systemd/system/nginx.service.d/custom-limits.conf
[Service]
LimitNOFILE=100000
MemoryMax=2G
Environment="NGINX_WORKER_PROCESSES=auto"

# Anzeigen der vollständig aufgelösten (gemergten) Unit-Konfiguration
systemctl cat nginx

# Aktive Drop-in-Verzeichnisse auflisten
systemctl show nginx | grep DropInPaths

Timer Units

Systemd timers replace cron for most scheduling use cases. They support monotonic timers (relative to boot, not wall clock).

# Alle Timer auflisten
systemctl list-timers --all

# Status eines Timers anzeigen
systemctl status myapp-backup.timer

# /etc/systemd/system/myapp-backup.timer
[Unit]
Description=Run MyApp backup daily

[Timer]
# Wall clock: Ausführung zu einer bestimmten Zeit
OnCalendar=daily
OnCalendar=*-*-* 03:00:00         # jeden Tag um 3 Uhr morgens
OnCalendar=Mon *-*-* 02:30:00     # jeden Montag um 2:30 Uhr morgens
OnCalendar=hourly                 # jede Stunde
OnCalendar=*:0/15                 # alle 15 Minuten
OnCalendar=Mon,Fri *-*-* 01,13:00 # Mo und Fr um 1 Uhr und 13 Uhr
OnCalendar=monthly                # am 1. jedes Monats um Mitternacht
OnCalendar=quarterly              # 1. Jan, 1. Apr, 1. Jul, 1. Okt um Mitternacht
OnCalendar=2026-12-25 00:00:00    # einmalig an einem bestimmten Datum

# Monotone Timer (relativ zu einem Ereignis)
OnBootSec=5min                    # 5 Minuten nach dem Booten
OnStartupSec=10min                # 10 Minuten nach dem Start von systemd
OnUnitActiveSec=1d                # 1 Tag nach der letzten Aktivierung des Timers
OnUnitActiveSec=1h                # 1 Stunde nach der letzten Aktivierung

# Timer-Verhalten
Persistent=true     # falls das System zum geplanten Zeitpunkt aus war, beim nächsten Boot ausführen
AccuracySec=1min    # bis zu 1 Minute Abweichung zulassen (reduziert Wake-ups, spart Strom)
RandomizedDelaySec=5m  # zufällige Verzögerung bis zu 5 Minuten (vermeidet Thundering Herd)
WakeSystem=false     # System nicht aus dem Standby wecken

# Nur nützlich für One-Shot-Timer:
Unit=myapp-backup.service

[Install]
WantedBy=timers.target

# Timer aktivieren/starten (nicht den Service — der Timer aktiviert diesen)
sudo systemctl enable --now myapp-backup.timer
# Prüfen, wann ein Timer das nächste Mal ausgelöst wird
systemctl list-timers myapp-backup.timer

Timers vs Cron

Rule of thumb: Use systemd timers for anything running on a systemd-based system. Use cron only for compatibility with non-systemd environments.

Target Units (Runlevels)

Targets group units together, similar to traditional SysV runlevels.

# Aktuelles Target anzeigen
systemctl get-default

# Standard-Target ändern
sudo systemctl set-default multi-user.target

# Alle verfügbaren Targets auflisten
systemctl list-unit-files --type=target

# Ein Target isolieren (zu diesem wechseln und alles stoppen, was nicht in dessen Abhängigkeitsbaum liegt)
sudo systemctl isolate rescue.target

# Wichtige Targets, die man kennen sollte
systemctl list-dependencies multi-user.target   # zeigt an, was im Multi-User-Modus startet
systemctl list-dependencies graphical.target

Socket Units

Socket activation lets systemd listen on a port/socket and start the service on-demand when a connection arrives.

# /etc/systemd/system/myapp.socket
[Unit]
Description=MyApp Socket

[Socket]
ListenStream=8080
Accept=no              # no = der Listening-Socket wird an den Service übergeben
                        # yes = systemd akzeptiert die Verbindung und startet pro Verbindung einen Service
Service=myapp.service

[Install]
WantedBy=sockets.target

# Den Socket aktivieren (nicht den Service)
sudo systemctl enable --now myapp.socket

# Prüfen, welche Sockets aktiv sind
systemctl list-sockets

# Verifizieren, ob systemd zuhört
ss -tlnp | grep 8080

Mount Units

Systemd can manage mount points, including automount (lazy mounting on first access).

# /etc/systemd/system/mnt-backup.mount
[Unit]
Description=Mount backup drive
Requires=network-online.target
After=network-online.target

[Mount]
What=192.168.1.100:/backups
Where=/mnt/backups
Type=nfs
Options=ro,noauto,_netdev

[Install]
WantedBy=multi-user.target

# /etc/systemd/system/mnt-backup.automount
[Unit]
Description=Automount backup drive

[Automount]
Where=/mnt/backups
TimeoutIdleSec=300    # nach 5 Minuten Inaktivität unmounten
[Install]
WantedBy=multi-user.target

# Automount aktivieren
sudo systemctl enable --now mnt-backup.automount

# Mount-Units auflisten
systemctl list-units --type=mount

journalctl — Log Querying

# Alle Logs anzeigen (neueste zuerst)
journalctl

# Logs in Echtzeit verfolgen (wie tail -f)
journalctl -f

# Logs für einen spezifischen Service anzeigen
journalctl -u nginx
journalctl -u nginx -f          # nginx-Logs verfolgen

# Logs für eine spezifische PID anzeigen
journalctl _PID=1234

# Logs für einen spezifischen Benutzer anzeigen
journalctl _UID=1000

# Zeitbasierte Filterung
journalctl --since "2026-04-20"
journalctl --since "2026-04-20 09:00:00"
journalctl --since "1 hour ago"
journalctl --since "yesterday"
journalctl --until "2026-04-20 18:00:00"
journalctl --since "2026-04-19" --until "2026-04-20"

# Filter kombinieren
journalctl -u nginx --since "2026-04-20 09:00" --until "2026-04-20 12:00"

# Nur Logs vom aktuellen Bootvorgang anzeigen
journalctl -b

# Logs von einem spezifischen Bootvorgang anzeigen
journalctl -b -1          # vorheriger Boot
journalctl -b -2          # vorletzter Boot
journalctl --list-boots   # alle aufgezeichneten Boots mit Zeitstempeln auflisten

# Prioritätsfilterung (0=emerg, 1=alert, 2=crit, 3=err, 4=warning, 5=notice, 6=info, 7=debug)
journalctl -p err         # Fehler und höher
journalctl -p warning     # Warnungen und höher
journalctl -p 3           # identisch mit err

# Nur Kernel-Meldungen anzeigen
journalctl -k

# Ausgabeformat
journalctl -o json        # strukturiertes JSON (ein Objekt pro Zeile)
journalctl -o json-pretty # formatiertes JSON
journalctl -o verbose     # alle Felder sichtbar
journalctl -o short-precise  # inklusive Mikrosekunden-Zeitstempel
journalctl -o short-iso   # ISO 8601 Zeitstempel

# Nur die letzten N Einträge anzeigen
journalctl -n 50
journalctl -n 100 --no-pager   # erste 100 Zeilen, ohne Pager

# Filterung nach Executable oder systemd-Unit
journalctl /usr/sbin/sshd
journalctl _SYSTEMD_UNIT=ssh.service

# Log-Meldungen mit grep durchsuchen
journalctl -u nginx | grep "error"
journalctl -u nginx -g "connection.*refused"   # integriertes grep des Journals nutzen

# Festplattenbelegung
journalctl --disk-usage

# Alte Logs bereinigen (letzte 500 MB behalten)
sudo journalctl --vacuum-size=500M

# Bereinigung nach Zeit
sudo journalctl --vacuum-time=2weeks
sudo journalctl --vacuum-time=1month

# Bereinigung nach Anzahl der Dateien
sudo journalctl --vacuum-files=10

Troubleshooting

# Prüfen, warum ein Service fehlgeschlagen ist
systemctl status nginx
journalctl -u nginx -n 50 --no-pager

# Prüfen, ob die Unit-Datei eines Services Syntaxfehler enthält
systemd-analyze verify /etc/systemd/system/myapp.service

# Bootzeit analysieren
systemd-analyze
systemd-analyze blame          # Bootzeit pro Unit
systemd-analyze critical-chain   # Abhängigkeitskette mit der längsten Dauer
systemd-analyze critical-chain nginx.service

# Prüfen, welche Prozesse ein Service ausführt
systemctl show nginx --property=MainPID --property=ControlPID

# Alle Eigenschaften einer Unit anzeigen
systemctl show nginx
systemctl show nginx --property=ExecStart --property=Restart

# Lade-Reihenfolge und Abhängigkeiten der Unit-Datei prüfen
systemd-analyze dump | grep -A 5 "nginx.service"

# Die effektive (zusammengeführte) Konfiguration anzeigen
systemctl cat nginx
# Überprüfung auf Override-/Drop-in-Dateien
systemd show nginx -p DropInPaths

# Anzeige der cgroup-Ressourcenauslastung für einen Dienst
systemd-cgtop

# Anzeige der Ressourcenauslastung für einen spezifischen Service-Slice
systemctl show myapp.service -p MemoryCurrent -p CPUUsageNSec

# Zurücksetzen eines fehlgeschlagenen Zustands (muss vor dem Neustart erfolgen)
sudo systemctl reset-failed

# Auflistung aller aktuell fehlgeschlagenen Units
systemctl --failed

Service Hardening Reference

The most impactful hardening options ranked by security value:

[Service]
# === Essenziell (auf jeden Dienst anwenden) ===
NoNewPrivileges=yes
ProtectSystem=strict
PrivateTmp=yes

# === Dringend empfohlen ===
ProtectHome=true
PrivateDevices=yes
ProtectKernelTunables=yes
ProtectControlGroups=yes
ReadWritePaths=/var/lib/myapp     # nur wenn der Dienst Schreibzugriff benötigt

# === Hohe Sicherheit ===
ProtectKernelModules=yes
SystemCallFilter=@system-service
SystemCallErrorNumber=EPERM       # blockierte Syscalls ablehnen statt den Prozess zu beenden
MemoryDenyWriteExecute=yes
CapabilityBoundingSet=CAP_NET_BIND_SERVICE  # nur das Gewähren, was benötigt wird

# === Maximale Isolation ===
PrivateNetwork=yes               # gar kein Netzwerk (gut für cron-ähnliche Aufgaben)
PrivateUsers=yes                 # separater UID-Namespace
LockPersonality=yes
RemoveIPC=yes
RestrictAddressFamilies=AF_INET AF_INET6  # Socket-Familien einschränken
RestrictRealtime=yes
DynamicUser=yes                  # temporären Benutzer zuweisen (kein statisches User= erforderlich)

Environment Files

# /etc/myapp/environment — systemd Environment-Datei Format
# Zeilen sind KEY=VALUE Paare
# Leere Zeilen und Zeilen, die mit # oder ; beginnen, werden ignoriert
# Keine Anführungszeichen nötig — Werte werden wörtlich übernommen (inklusive Leerzeichen)

NODE_ENV=production
DATABASE_URL=postgres://user:pass@localhost:5432/mydb
LOG_LEVEL=info
CACHE_SIZE=1024

# In der Service-Unit auf die Datei verweisen:
EnvironmentFile=/etc/myapp/environment

# Mehrere Dateien — spätere Dateien überschreiben frühere:
EnvironmentFile=/etc/myapp/environment
EnvironmentFile=/etc/myapp/environment.local

# Präfix mit Bindestrich bedeutet "nicht fehlschlagen, wenn Datei fehlt" (für optionale lokale Overrides):
EnvironmentFile=-/etc/myapp/environment.local

# Einzelne Environment= Direktiven haben Vorrang vor EnvironmentFile
Environment="NODE_ENV=staging"  # dies überschreibt NODE_ENV aus der Datei

ExecStart Pre/Post Scripts

[Service]
Type=oneshot
RemainAfterExit=yes

# Vor dem Hauptbefehl ausführen — alle müssen erfolgreich sein
ExecStartPre=/bin/mkdir -p /var/lib/myapp
ExecStartPre=/usr/bin/chown -R myapp:myapp /var/lib/myapp
ExecStartPre=/usr/bin/myapp --validate-config

# Der Hauptbefehl
ExecStart=/usr/bin/myapp --init

# Nach dem Start des Hauptbefehls ausführen (läuft parallel zum Hauptprozess)
ExecStartPost=/usr/bin/myapp --register-health-check

# Ausführen, wenn der Dienst gestoppt wird
ExecStop=/usr/bin/myapp --graceful-shutdown

# Nach dem Stoppen des Dienstes ausführen (Cleanup)
ExecStopPost=/usr/bin/rm -f /run/myapp.pid

# Befehl mit - (Bindestrich) präfixen, damit Fehler nicht zum Abbruch führen
ExecStartPre=-/usr/bin/touch /var/log/myapp/boot.log

Resource Limits Reference

[Service]
# CPU
CPUQuota=200%                  # max. 2 CPU-Kerne
CPUQuota=50%                   # ein halber Kern
CPUWeight=100                  # relativer CPU-Anteil (Standard 100)
CPUStartupWeight=200           # höherer Anteil während des Starts
# Speicher
MemoryMax=1G                   # hartes Limit — OOM, wenn überschritten
MemoryHigh=768M                # weiches Limit — gedrosselt, aber nicht beendet
MemoryMin=64M                  # garantiertes Minimum
MemorySwapMax=512M             # Swap-Limit
MemoryZSwapMax=256M            # komprimiertes Swap-Limit

# Dateideskriptoren
LimitNOFILE=65536              # offene Dateien (soft = hard = 65536)
# Feingranular: LimitNOFILE=1024:65536  (soft:hard)

# Prozesse und Threads
LimitNPROC=4096                # max. Prozesse pro Benutzer
TasksMax=512                   # max. Threads in der cgroup

# Dateigröße
LimitFSIZE=100M                # max. Dateigröße, die der Prozess erstellen kann

# Locks
LimitLOCKS=infinity            # max. Dateisperren (Locks)

# Stack-Größe
LimitSTACK=8M                  # max. Stack-Größe pro Thread

# Wall clock time
LimitCPU=2h                    # max. CPU-Zeit (Prozess wird beendet, wenn überschritten)

# Anzahl der Dateisperren
LimitLOCK=1024

Quick Reference Card

# === Service-Lebenszyklus ===
systemctl start|stop|restart|reload SERVICE
systemctl enable|disable|is-enabled SERVICE
systemctl enable --now SERVICE       # aktivieren + starten
systemctl disable --now SERVICE      # deaktivieren + stoppen
systemctl status SERVICE
systemctl mask|unmask SERVICE

# === Auflistungen ===
systemctl list-units --type=service
systemctl list-unit-files --type=service
systemctl list-timers --all
systemctl list-dependencies SERVICE
systemctl --failed

# === Bearbeitung ===
systemctl edit SERVICE              # Drop-in-Override erstellen
systemctl cat SERVICE               # aufgelöste Unit-Datei anzeigen
systemctl daemon-reload             # neu laden nach Bearbeitung der Unit-Dateien

# === Targets (Runlevels) ===
systemctl get-default
systemctl set-default TARGET
systemctl isolate TARGET

# === journalctl ===
journalctl -u SERVICE               # Logs für einen Service
journalctl -b                       # aktueller Bootvorgang
journalctl -b -1                    # vorheriger Bootvorgang
journalctl --since "1 hour ago"
journalctl -p err                   # Fehler und höhere Prioritäten
journalctl -f                       # follow (Echtzeit)
journalctl -g "pattern"             # grep (Suche)
journalctl --disk-usage
journalctl --vacuum-size=500M
journalctl --vacuum-time=2weeks

# === Fehlerbehebung ===
systemd-analyze verify UNIT_FILE
systemd-analyze blame
systemd-analyze critical-chain SERVICE
systemctl reset-failed

Ressourcen & Verwandte Plattformen

• tobias-weiss.org - Weitere Cheat Sheets, Artikel und Shop-Produkte
• graphwiz.ai - KI, Knowledge Graphs und agentische Entwicklung
• courses.graphwiz.ai - Interaktive Übungsprüfungen und Lernleitfäden
• ki-kompetenz-training.org - EU AI Act konforme KI-Kompetenztrainings

Verwandte Cheat Sheets

• Ansible Cheat Sheet - Konfigurationsautomatisierung
• Nginx Cheat Sheet - Reverse Proxy Services