Debian und Ubuntu im Produktivbetrieb: Paketmanagement, Sicherheit und Betriebsoptimierung für DevOps

Einleitung

Dieses Tutorial richtet sich an erfahrene Entwickler und DevOps-Profis, die Debian- oder Ubuntu-Server in produktiven Umgebungen betreiben und langfristig stabil, sicher und effizient halten möchten.

Wir behandeln fortgeschrittene Aspekte der Paketverwaltung, Sicherheit, Systemd- und Logging-Konfiguration, verteilte Update-Strategien und praktische Automatisierungsschritte. Ziel ist, konkrete Rezepte zu liefern, die Sie direkt in Ihren Pipelines oder Betriebshandbüchern verwenden können.

Keywords für SEO: Debian, Ubuntu, APT, unattended-upgrades, sysadmin, DevOps, systemd, AppArmor, Livepatch, apt-cacher-ng.

Hintergrund: Warum Unterschiede und Gemeinsamkeiten relevant sind

Debian und Ubuntu teilen denselben Paketmanager (APT) und das Deb-Paketformat. Ubuntu basiert auf Debian, ergänzt aber eigenständige Policies, zusätzliche Repositories (z. B. Canonical Livepatch, Ubuntu Pro) und Snap-Pakete.

Für Betreiber bedeutet das: Viele Konzepte sind identisch, doch Details wie Kernel-Lifecycle, Canonical-Dienste und Snap-Verhalten unterscheiden sich. Dieses Tutorial behandelt beide Distributionen, mit Hinweisen zu spezifischen Ubuntu-Features.

Übersicht: Was Sie nach dem Durcharbeiten können

Sie lernen:

– APT-Quellen sicher und reproduzierbar zu verwalten

– Updates automatisch und kontrolliert auszurollen (Unattended-Upgrades, Staged Rollouts)

– Paket-Pinning, Holds und lokale Apt-Repos einzusetzen

– Systemd- und journald-Tuning für stabile Dienste

– SSH-, Firewall- und AppArmor-Härtungen durchzuführen

– Monitoring-, Backup- und Snapshot-Workflows zu integrieren

Vertrauenswürdige Quellen

Sie werden immer wieder auf die offiziellen Dokumentationen zurückgreifen wollen. Empfehlenswerte Referenzen:

– Debian APT Wiki: https://wiki.debian.org/Apt

– Ubuntu Security Notices und Livepatch: https://ubuntu.com/security und https://ubuntu.com/linux-livepatch

– systemd Dokumentation: https://www.freedesktop.org/wiki/Software/systemd/

– AppArmor: https://gitlab.com/apparmor/apparmor/-/wikis/home

1) Sicheres und reproduzierbares APT-Management

APT ist mächtig, aber Fehlkonfigurationen lassen Sie schnell zwischen stabilen und unstabilen Paketen pendeln. Halten Sie eine klare Quellen-Strategie und signierte Repositories ein.

Best Practices:

– Verwenden Sie /etc/apt/sources.list.d/ für dienstspezifische Repositories.

– Speichern Sie GPG-Schlüssel unter /etc/apt/keyrings/ und referenzieren Sie sie in den sources.list-Einträgen via signed-by.

– Vermeiden Sie apt-key, denn es ist veraltet.

Beispiel: sicheren Eintrag mit Keyring

echo 'deb [signed-by=/etc/apt/keyrings/myrepo.gpg] https://myrepo.example.org/ubuntu focal main' \
  | sudo tee /etc/apt/sources.list.d/myrepo.list
sudo curl -fsSL 'https://myrepo.example.org/repo.gpg' \
  -o /etc/apt/keyrings/myrepo.gpg
sudo apt update

2) Automatismen: Unattended-Upgrades und gestaffelte Rollouts

Automatische Sicherheitsupdates reduzieren Angriffsflächen, bringen aber auch Risiko inkompatibler Änderungen. Kombinieren Sie unattended-upgrades mit Canary- und Staged-Rollout-Strategien.

Installieren und konfigurieren:

sudo apt install unattended-upgrades apt-listchanges
sudo dpkg-reconfigure --priority=low unattended-upgrades

Beispielkonfiguration unter /etc/apt/apt.conf.d/50unattended-upgrades (vereinfachte Variante):

Unattended-Upgrade::Origins-Pattern {
  "o=Ubuntu,a=jammy-security";
  "o=Debian,a=stable-security";
};
Unattended-Upgrade::Automatic-Reboot "true";
Unattended-Upgrade::Mail "[email protected]";

Staged Rollout: Starten Sie mit einem kleinen Canary-Pool (z. B. 5% der Prod-Hosts). Überwachen Sie Key-Metriken (Service-Fehler, Latenz, Crashloop) bevor Sie auf 100% skalieren. Automatisieren Sie mit Ansible oder Terraform, indem Sie ein Tag-basiertes Flag für unattended-upgrades oder ein Feature-Flag verwenden.

3) Paket-Pinning und Version-Holds

Für kritische Dienste möchten Sie eventuell bestimmte Paketversionen schützen. Verwenden Sie apt-mark und /etc/apt/preferences.d/ für feinere Kontrolle.

Halten einer Version:

sudo apt-mark hold docker-ce
# Rückgängig:
sudo apt-mark unhold docker-ce

Pinning-Regel (z. B. bevorzugen Sie ein internes Repo über upstream):

# /etc/apt/preferences.d/99internal.pref
Package: *
Pin: origin "myrepo.example.org"
Pin-Priority: 700

Pin-Priorities Richtwerte:

– >1000: Erzwingt Downgrade

– 990–1000: Sehr hohe Präferenz (z. B. Release)

– 100–500: Normal bevorzugt

– <0: Verhindert Installation

4) Lokale Apt-Proxy- und Repository-Strategien

In großen Umgebungen sparen apt-cacher-ng oder squid-deb-proxy Bandbreite und beschleunigen Deployments.

Installieren apt-cacher-ng auf einer dedizierten VM:

sudo apt install apt-cacher-ng
# Standard-Config ist meist brauchbar; prüfen Sie /etc/apt-cacher-ng/acng.conf

Clientseitig konfigurieren Sie einen Proxy-Eintrag in /etc/apt/apt.conf.d/01proxy:

Acquire::http::Proxy "http://apt-cache.local:3142";

Für reproduzierbare Rollouts können Sie ein internes Repository mit reprepro oder apt-ftparchive betreiben. Tools wie reprepro erlauben signierte Repositorys mit gpg und einfachen Package-Promotions.

5) Systemd-Feinheiten: Overrides, Metriken, Startverhalten

Systemd ist der Dreh- und Angelpunkt im modernen Systembetrieb. Verwenden Sie systemctl edit, um Service-Overrides anzulegen, statt die Unit-Datei direkt zu ändern.

Beispiel: Override einsetzen, um Restart-Verhalten zu fixieren:

sudo systemctl edit myservice.service
# Fügt eine Datei /etc/systemd/system/myservice.service.d/override.conf mit:
[Service]
Restart=on-failure
RestartSec=5s
LimitNOFILE=65536

Verhalten der Logs kontrollieren: journald ist praktisch, benötigt aber Limits und Rotationseinstellungen, um Disk-Fill zu vermeiden.

Wichtige journald-Einstellungen (in /etc/systemd/journald.conf):

SystemMaxUse=500M
SystemKeepFree=100M
RuntimeMaxUse=200M
ForwardToSyslog=yes

Setzen Sie systemd-notify in Services ein, damit Healthchecks schneller reagieren beim Deploy.

6) Logging, Rotation und zentrale Speicherung

Setzen Sie auf zentrale Log-Architektur: forwarding mit rsyslog/Fluentd/Vector zu ElasticSearch oder Loki. Lokale Rotation bleibt aber wichtig.

rsyslog Beispiel für TCP-Forwarding:

# /etc/rsyslog.d/60-remote.conf
module(load="omfwd")
*.* action(type="omfwd" target="logs.example.org" port="514" protocol="tcp")

Nutzen Sie logrotate für traditionelle Datei-Logs. Journald kann exportiert werden mit journalctl –since / –until.

7) Sicherheit: SSH, Firewall, Fail2Ban

SSH-Härtung ist unverzichtbar. Minimale Maßnahmen:

– Root-Login deaktivieren

– Passwort-Authentifizierung deaktivieren, nur Key-Based

– SSH über non-standard Port optional; Rate-Limiting mit fail2ban

sshd_config Beispiele:

PermitRootLogin no
PasswordAuthentication no
PermitEmptyPasswords no
ChallengeResponseAuthentication no
UsePAM yes
AllowUsers [email protected]

Fail2Ban Basisregel für SSH:

sudo apt install fail2ban
# /etc/fail2ban/jail.d/ssh.local
[sshd]
enabled = true
port = ssh
maxretry = 5
bantime = 3600

Firewall: Verwenden Sie nftables (oder UFW als einfacher Wrapper). Beispiel UFW-Regelset:

sudo apt install ufw
sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw allow 9090/tcp # Cockpit
sudo ufw enable

8) AppArmor: Profile und Troubleshooting

Debian und Ubuntu nutzen AppArmor als Mandatory Access Control. Pflegen Sie Profile für kritische Dienste (z. B. Nginx, PostgreSQL, Docker).

Tools:

– aa-status zur Übersicht

– aa-logprof zum interaktiven Anreichern von Profilen

Profil aktualisieren:

sudo aa-status
sudo aa-logprof

Beim Einsatz von Containern müssen Sie Profile bewusst gestalten, da Container Prozesse isolieren, aber selbige Profile auf Host-Ebene verletzen können.

9) Kernel-Updates und Livepatch (Ubuntu)

Kernel-Updates erfordern oft einen Neustart. Ubuntu bietet den Livepatch-Service, um einige kritische Kernel-Patches ohne Reboot anzuwenden. Für Produktionsumgebungen ist Livepatch ein weiteres Werkzeug, ersetzt aber kein orchestriertes Reboot-Management.

Ubuntu Livepatch aktivieren (Ubuntu Pro oder mit Token):

sudo snap install canonical-livepatch
sudo canonical-livepatch enable 
canonical-livepatch status --verbose

Beachten Sie die Notwendigkeit von Image- und Kernelkompatibilität; Livepatch ist nicht für alle Kernel-Subsets verfügbar.

10) Backup- und Snapshot-Strategien

Für schnelle Rollbacks eignen sich LVM- oder BTRFS-Snapshots. Für langfristige Backups sind borgbackup und restic etabliert.

BTRFS Snapshot Beispiel (für Host mit BTRFS):

# create snapshot of subvolume
sudo btrfs subvolume snapshot /srv/data /srv/snapshots/data-$(date +%F)
# send to remote
sudo btrfs send /srv/snapshots/data-2025-01-01 \
  | ssh [email protected] 'btrfs receive /backups/host'

Für LVM:

sudo lvcreate -L1G -s -n root-snap /dev/vg0/root
# Mount, copy data, then lvremove root-snap

11) Monitoring und Observability

Basismetriken: CPU, Memory, Disk, FS-Inodes, Network, Service-Health. Tools: Prometheus + node_exporter, Grafana, and optional APM agents.

Installations-Schnipsel für node_exporter:

wget https://github.com/prometheus/node_exporter/releases/download/v*/node_exporter-*.*-amd64.tar.gz
sudo useradd -M -r -s /bin/false node_exporter
# unpack, create systemd unit, enable service

Für UI-gesteuertes Management eignet sich Cockpit als leichtes Web-Frontend:

sudo apt install cockpit
sudo systemctl enable --now cockpit.socket
# Zugriff über https://host:9090

In Cockpit finden Sie Bereiche für Software-Updates, Storage, Services und Logs. Das ist besonders nützlich für Operatoren, die rasch visuell agieren wollen.

12) Desktop-/GUI-Hinweise

Auf Desktop-Installationen verwenden Admins Synaptic, GNOME Software oder gdebi, um Pakete visuell zu managen. Gdebi ist praktisch, um lokale .deb-Dateien inkl. Abhängigkeiten zu installieren.

sudo apt install gdebi
sudo gdebi mypackage.deb

GNOME Software zeigt Update-Benachrichtigungen und Snap-Management; beachten Sie, dass Snaps eigene Updates haben, die unabhängig von APT laufen.

13) Paket-Erstellung und CI-Integration

In CI/CD-Pipelines bauen Sie eigene .deb-Pakete, signieren sie und verteilen sie in Ihrem privaten Repository. Tools: dpkg-buildpackage, debhelper, sbuild oder pbuilder.

Minimaler Aufbau einer CI-Job-Pipeline:

– Build Stage: compile, unit-tests, dpkg-buildpackage

– Sign Stage: gpg –sign, upload to artifact repo

– Publish Stage: reprepro include

Beispiel GitLab-CI Job-Snippet (konzeptionell):

build_deb:
  image: debian:bookworm
  script:
    - apt update && apt install -y dpkg-dev devscripts
    - debuild -us -uc
  artifacts:
    paths:
      - ../*.deb

14) Troubleshooting-Quicktips

– Paketabhängigkeitskonflikte: apt –fix-broken install, dpkg -C, dpkg –configure -a

– Systemd-Service hängt: journalctl -u myservice -b –no-pager

– Disk-Full: du -hs /var/log/* | sort -h

– Paketquelle nicht erreichbar: curl -v https://repo.example.org/

Praxisbeispiel: Vollständiges Setup für einen Production Node

Schritt 1: Basis-Härtung und Updates

sudo apt update && sudo apt upgrade -y
sudo apt install unattended-upgrades fail2ban ufw apt-cacher-ng

Schritt 2: Unattended-Upgrades konfigurieren und E-Mail Alerts

sudo dpkg-reconfigure unattended-upgrades
# prüfen Sie /etc/apt/apt.conf.d/50unattended-upgrades und passen Mail, Origins an

Schritt 3: Systemd-Overrides für Ihre kritischen Dienste

sudo systemctl edit myservice
# set Restart und Limits wie oben

Schritt 4: Logging und Monitoring an zentrale Stelle anbinden (rsyslog / Prometheus)

sudo apt install prometheus-node-exporter
sudo systemctl enable --now node-exporter

Schritt 5: Backup konfigurieren (borg/restic) und Snapshot-Policy implementieren

GUI: Wie es in Cockpit aussieht

Nach Installation öffnen Sie https://host:9090, melden sich mit Linux-Credentials an und navigieren zu ‚Software Updates‘ um verfügbare Updates anzuzeigen, ‚Services‘ um Systemd-Units zu managen, und ‚Logs‘ um Journal- und Syslog-Meldungen einzusehen.

Fazit und nächste Schritte

Debian und Ubuntu bieten eine solide Basis für produktive Systeme. Das Zusammenspiel aus sauberer APT-Konfiguration, kontrollierten Updates, systemd-Feinjustierung, Logging-Infrastruktur und Security-Härtungen bildet die Grundlage für einen robusten Betrieb.

Als nächste Schritte empfehle ich:

– Eine Canary-Strategie für Updates und automatische Rollbacks mittels Snapshots oder VM-Image-Rollback implementieren.

– CI/CD um DEB-Build- und Sign-Schritte erweitern, inkl. automatischem Upload in ein internes reprepro.

– Observability vertiefen: End-to-End-Alerting mit Prometheus-Alertmanager und Runbooks für häufige Vorfälle.

Vertrauenswürdige weiterführende Lektüre: Debian APT Wiki (https://wiki.debian.org/Apt), Ubuntu Security (https://ubuntu.com/security), systemd (https://www.freedesktop.org/wiki/Software/systemd/), AppArmor (https://gitlab.com/apparmor/apparmor/-/wikis/home).

Wenn Sie wollen, kann ich Ihnen eine exemplarische Ansible-Rolle erstellen, die die beschriebenen Schritte automatisiert (Unattended-Upgrades, fail2ban, ufw, systemd-overrides, apt-cacher-ng-Client-Konfiguration).

Viel Erfolg beim Aufbau stabiler Debian-/Ubuntu-Infrastrukturen.