Docker auf Debian 13 installieren: Die vollständige Anleitung

0

Docker auf Debian zu installieren dauert fünf Minuten – wenn man den richtigen Weg nimmt. Genau da liegt das Problem: Debian hat ein eigenes Docker-Paket in den Quellen, das meist veraltet ist, und die verbreiteten Anleitungen im Netz zeigen ein Repository-Format, das Docker inzwischen abgelöst hat.

Diese Anleitung nimmt den offiziellen Weg und ist auf einem echten System nachgeprüft: Debian 13 „Trixie“, Kernel 6.12, installiert wurden Docker 29.8.0 und Docker Compose v5.5.1 (Stand September 2026). Alle Ausgaben in diesem Artikel stammen aus diesem Durchlauf.

Das Wichtigste in Kürze

• Nimm Dockers eigenes Repository, nicht das Paket docker.io aus Debian.
• Die Paketquelle wird heute im deb822-Format als /etc/apt/sources.list.d/docker.sources angelegt – nicht mehr als einzeilige docker.list.
• Der Dienst startet auf Debian nach der Installation von allein.
• Für Docker ohne sudo musst du dich neu anmelden – die Gruppenmitgliedschaft greift in der laufenden Sitzung nicht.
• Veröffentlichte Container-Ports umgehen deine Firewall. Der wichtigste Abschnitt dieses Artikels.

Voraussetzungen

Du brauchst ein 64-Bit-Debian und einen Benutzer mit sudo-Rechten. Offiziell unterstützt Docker:

Ältere Versionen bekommen keine Pakete mehr. Architekturen: x86_64, arm64, armhf, ppc64le, s390x.

Ein Hinweis zu sudo: Wenn du bei der Debian-Installation ein Root-Passwort gesetzt hast, ist sudo gar nicht installiert und dein Benutzer steht in keiner sudo-Gruppe. Das fällt genau hier zum ersten Mal auf. Nachholen als root:

su -
apt update && apt install -y sudo
usermod -aG sudo DEIN_BENUTZER
exit

Danach einmal ab- und wieder anmelden.

Schritt 1: Alte Pakete entfernen

Bevor Dockers Pakete kommen, müssen konkurrierende Versionen weg. Debian bringt unter anderem docker.io, containerd und runc mit, die sich mit den offiziellen Paketen ins Gehege kommen.

sudo apt remove $(dpkg --get-selections docker.io docker-compose docker-doc docker-buildx podman-docker containerd runc | cut -f1)

Wundere dich nicht über die Ausgabe. Auf einem frisch installierten System sieht sie so aus:

dpkg: Kein Paket gefunden, das auf docker.io passt
dpkg: Kein Paket gefunden, das auf docker-compose passt
dpkg: Kein Paket gefunden, das auf docker-doc passt
dpkg: Kein Paket gefunden, das auf docker-buildx passt
dpkg: Kein Paket gefunden, das auf podman-docker passt
dpkg: Kein Paket gefunden, das auf containerd passt
dpkg: Kein Paket gefunden, das auf runc passt

Das sind keine Fehler. Es bedeutet schlicht: Es war nichts zu entfernen. Der Befehl ist trotzdem sinnvoll, weil auf gewachsenen Systemen sehr wohl etwas davon liegt.

Schritt 2: Paketquelle einrichten

Zuerst die beiden Werkzeuge, die für den Rest gebraucht werden:

sudo apt update
sudo apt install ca-certificates curl

Dann Dockers Signaturschlüssel holen:

sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/debian/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

Den Schlüssel überprüfen – der Schritt, den alle auslassen

Du lädst gerade einen Schlüssel, mit dem dein System künftig Software vertraut. Es lohnt, seinen Fingerabdruck zu kontrollieren:

gpg --show-keys --with-fingerprint /etc/apt/keyrings/docker.asc

Erwartet wird:

9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88

Kleiner Haken: Auf einer minimalen Debian-Installation ist gpg gar nicht vorhanden – der Befehl läuft ins Nichts. Dann erst sudo apt install gnupg, danach prüfen.

Die Paketquelle im deb822-Format

Hier weichen die meisten Anleitungen ab. Docker nutzt heute das mehrzeilige deb822-Format:

sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/debian
Suites: $(. /etc/os-release && echo "$VERSION_CODENAME")
Components: stable
Architectures: $(dpkg --print-architecture)
Signed-By: /etc/apt/keyrings/docker.asc
EOF

Kontrolliere das Ergebnis – die beiden eingesetzten Werte müssen zu deinem System passen:

Types: deb
URIs: https://download.docker.com/linux/debian
Suites: trixie
Components: stable
Architectures: amd64
Signed-By: /etc/apt/keyrings/docker.asc

Steht bei Suites nichts oder etwas Falsches, hat die Einsetzung von $VERSION_CODENAME nicht funktioniert – dann trage trixie oder bookworm von Hand ein.

Wenn du eine Anleitung mit einer Zeile wie echo "deb [arch=... signed-by=...] ... stable" | sudo tee /etc/apt/sources.list.d/docker.list findest: Das ist das alte Format. Es funktioniert noch, aber Docker dokumentiert es nicht mehr. Beides gleichzeitig anzulegen führt zu doppelten Quellen und Warnungen bei jedem apt update.

Jetzt die Paketlisten einlesen:

sudo apt update

In der Ausgabe muss Dockers Server auftauchen:

Holen:5 https://download.docker.com/linux/debian trixie/stable amd64 Packages [45,7 kB]

Schritt 3: Docker installieren

sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

Fünf Pakete, und jedes hat eine Aufgabe:

Am Ende der Installation erscheinen diese beiden Zeilen – sie sind der Grund, warum du auf Debian nichts weiter starten musst:

Created symlink '/etc/systemd/system/multi-user.target.wants/docker.service' → '/usr/lib/systemd/system/docker.service'.
Created symlink '/etc/systemd/system/sockets.target.wants/docker.socket' → '/usr/lib/systemd/system/docker.socket'.

Prüfe die Versionen:

docker --version
docker compose version

Im Test ergab das:

Docker version 29.8.0, build 88096ef
Docker Compose version v5.5.1

Wichtig: Es heißt docker compose mit Leerzeichen, nicht docker-compose mit Bindestrich. Der alte Befehl war ein eigenes Python-Programm und ist abgekündigt. Anleitungen, die docker-compose verwenden, sind älter als 2022.

Schritt 4: Läuft der Dienst?

systemctl status docker

Erwartet:

● docker.service - Docker Application Container Engine
     Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; preset: enabled)
     Active: active (running)

Entscheidend sind zwei Wörter: enabled heißt, der Dienst startet beim Booten mit. active (running) heißt, er läuft jetzt. Beides richtet das Debian-Paket automatisch ein – auf Arch Linux und in der RHEL-Familie ist das anders, dort musst du selbst systemctl enable --now docker ausführen.

Beenden der Statusanzeige mit q.

Schritt 5: Der Funktionstest

sudo docker run hello-world

Docker findet das Abbild nicht lokal, holt es und startet einen Container, der eine Meldung ausgibt und sich beendet:

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
4f55086f7dd0: Pull complete
Digest: sha256:5e23090353324d887c48ad5e5c56d294eab81588df9605b07d1afe895f9cc8f8
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

Wenn du das siehst, ist die Installation fertig. Alles Weitere ist Komfort und Sicherheit – aber genau das macht den Unterschied im Alltag.

Schritt 6: Docker ohne sudo benutzen

Versuchst du jetzt einen Befehl ohne sudo, kommt die häufigste Docker-Fehlermeldung überhaupt:

$ docker ps
permission denied while trying to connect to the docker API at unix:///var/run/docker.sock

Der Grund ist kein Rechtefehler in deiner Installation, sondern Absicht: Der Docker-Dienst wird über einen Socket angesprochen, der nur root und der Gruppe docker gehört. Nimm deinen Benutzer in diese Gruppe auf:

sudo usermod -aG docker $USER

Und jetzt kommt die Stelle, an der die meisten stolpern. Prüfe direkt danach deine Gruppen:

$ id -nG
dr cdrom floppy sudo audio dip video plugdev users netdev

docker fehlt. Das ist kein Fehler – Gruppenmitgliedschaften werden bei der Anmeldung gesetzt, nicht rückwirkend in laufende Sitzungen. Melde dich ab und wieder an, dann stimmt es:

$ id -nG
dr cdrom floppy sudo audio dip video plugdev users netdev docker

$ docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

Wer nicht abmelden will, bekommt mit newgrp docker eine neue Shell mit der Gruppe – das gilt aber nur für dieses eine Terminal.

Was die docker-Gruppe wirklich bedeutet

Diesen Satz sollte jeder einmal gelesen haben: Wer in der Gruppe docker ist, hat faktisch Root-Rechte auf dem gesamten System. Ein einziger Befehl genügt, um das gesamte Dateisystem des Wirts in einen Container einzuhängen und dort als root zu schreiben.

Auf deinem eigenen Rechner oder Heimserver ist das in Ordnung – du bist ja ohnehin der Administrator. Auf einem Mehrbenutzersystem solltest du sehr genau überlegen, wen du in diese Gruppe aufnimmst. Die Alternative heißt Rootless-Modus, in dem Docker vollständig unter deinem Benutzer läuft; er kostet allerdings ein paar Fähigkeiten und lohnt sich vor allem in geteilten Umgebungen.

Schritt 7: Der erste echte Container mit Compose

Ein einzelner Container über die Kommandozeile ist selten das Ziel. Im Alltag beschreibst du Dienste in einer Datei. Lege ein Verzeichnis an und darin compose.yaml:

mkdir ~/mein-dienst && cd ~/mein-dienst
nano compose.yaml

services:
  web:
    image: nginx:alpine
    ports:
      - "127.0.0.1:8080:80"
    restart: unless-stopped

Starten:

docker compose up -d

Network mein-dienst_default  Created
Container mein-dienst-web-1  Started

Nachsehen, was läuft:

$ docker compose ps
NAME                IMAGE          SERVICE   STATUS    PORTS
mein-dienst-web-1   nginx:alpine   web       Up        127.0.0.1:8080->80/tcp

Und testen:

curl -I http://localhost:8080

Drei Dinge an dieser Datei verdienen Beachtung. Der Dateiname ist heute compose.yaml; das alte docker-compose.yml funktioniert weiter. Die Zeile version: ganz oben, die in älteren Anleitungen steht, ist überflüssig und erzeugt inzwischen eine Warnung. Und die Portangabe beginnt mit 127.0.0.1: – warum das so wichtig ist, steht im nächsten Abschnitt.

Beenden und aufräumen:

docker compose down

Docker und deine Firewall – bitte lesen

Das ist der Abschnitt, den kaum eine deutsche Anleitung enthält, und der wichtigste des ganzen Artikels.

Veröffentlichte Container-Ports umgehen deine Firewall. Nicht wegen eines Fehlers, sondern weil Docker seine eigenen Regeln in die Paketfilter-Ketten schreibt – und zwar vor denen deiner Firewall. Schreibst du in der Compose-Datei

    ports:
      - "8080:80"

dann ist dieser Dienst für das gesamte Netzwerk erreichbar, auch wenn deine Firewall eingehende Verbindungen verbietet. Im Test war genau das nachweisbar: Firewall aktiv, Port 8080 in keiner Regel freigegeben – und von einem anderen Rechner im Netz antwortete der Container mit HTTP 200.

Sichtbar wird die Ursache in der Regelkette:

$ sudo iptables -L FORWARD -n --line-numbers
Chain FORWARD (policy DROP)
num  target
1    DOCKER-USER
2    DOCKER-FORWARD
3    ufw-before-logging-forward
4    ufw-before-forward

Dockers Ketten stehen auf Position 1 und 2. Die Firewall kommt erst auf Platz 3 und 4 – wenn die Entscheidung längst gefallen ist.

Lösung 1: An localhost binden

Der einfachste und für Heimserver beste Weg. Statt "8080:80" schreibst du:

    ports:
      - "127.0.0.1:8080:80"

Damit horcht der Port nur auf dem Rechner selbst. Von außen ist nichts erreichbar – im Test lokal HTTP 200, von einem anderen Rechner keine Antwort. Wenn du den Dienst im Netz brauchst, stellst du einen Reverse Proxy davor, etwa den vorgeschalteten Router oder einen Proxy-Container, und veröffentlichst nur dessen Port.

Lösung 2: Regeln in der DOCKER-USER-Kette

Die Kette DOCKER-USER ist ausdrücklich für dich gedacht – Docker rührt sie nicht an. Dort kannst du den Zugriff einschränken, ohne auf veröffentlichte Ports zu verzichten:

sudo iptables -I DOCKER-USER -i eth0 ! -s 192.168.1.0/24 -j DROP

Das verwirft alles, was über eth0 kommt und nicht aus dem eigenen Netz stammt. Ersetze Interface und Netz durch deine Werte; den Namen des Interfaces zeigt ip route show default. Im Test blockierte eine solche Regel den Zugriff von außen sofort (HTTP 000), während der Dienst lokal weiter antwortete – und nach dem Entfernen der Regel war er umgehend wieder offen.

Zum Merken: Solche Regeln sind nach einem Neustart weg. Dauerhaft machst du das mit iptables-persistent oder einer systemd-Unit.

Wichtige Dateien und Verzeichnisse

Der Blick in die Kennzahlen mit docker info zeigt auf einem aktuellen Debian:

Storage Driver: overlayfs
Cgroup Driver:  systemd (v2)
Logging:        json-file
Docker Root Dir: /var/lib/docker

Der Speichertreiber heißt inzwischen overlayfs – ältere Anleitungen nennen overlay2. Beides bezeichnet dasselbe Verfahren.

Ein Tipp zum Platz: /var/lib/docker läuft auf Servern gern voll, weil ungenutzte Abbilder und Volumes liegen bleiben. docker system df zeigt den Verbrauch, docker system prune räumt auf. Wie du einem vollen Datenträger auf die Spur kommst, steht in Linux-Befehle für den Alltag.

Häufige Fragen

Warum nicht einfach apt install docker.io?

Das geht und ist für einen schnellen Test in Ordnung. Das Debian-Paket hinkt aber Versionen hinterher, enthält kein docker compose als Plugin und bekommt Sicherheitsaktualisierungen nach Debians Zeitplan statt nach Dockers. Für einen Server, auf dem Dienste dauerhaft laufen, ist das offizielle Repository die bessere Wahl.

Was ist mit dem Installationsskript von get.docker.com?

curl -fsSL https://get.docker.com | sh funktioniert und ist bequem. Docker selbst empfiehlt es aber ausdrücklich nicht für Produktionssysteme: Es erkennt die Umgebung automatisch, überschreibt dabei Einstellungen ohne Rückfrage und lässt sich nicht sauber aktualisieren. Für eine Wegwerf-VM in Ordnung, für deinen Heimserver nicht.

Wie aktualisiere ich Docker später?

Wie jedes andere Paket: sudo apt update && sudo apt upgrade. Weil die Quelle eingerichtet ist, kommen neue Versionen automatisch mit. Laufende Container werden beim Neustart des Dienstes kurz unterbrochen – bei restart: unless-stopped starten sie danach von allein wieder.

Der Dienst startet nicht. Was nun?

sudo journalctl -u docker -n 50 --no-pager zeigt die Ursache. Häufigste Gründe: ein Tippfehler in /etc/docker/daemon.json (die Datei muss gültiges JSON sein), ein belegter Port oder ein Konflikt mit einer alten containerd-Installation.

Brauche ich Docker Desktop?

Auf einem Server nein. Docker Desktop ist eine grafische Oberfläche mit eigener virtueller Maschine, gedacht für Arbeitsplätze unter Windows und macOS. Auf Linux willst du die Engine direkt. Wenn du eine Weboberfläche zur Verwaltung suchst, ist Portainer der passende Weg.

Läuft Docker in einer virtuellen Maschine?

Ja, ohne Einschränkung – diese Anleitung wurde in einer VM geprüft. Nur verschachtelte Virtualisierung kann Ärger machen, wenn du in einem Container wiederum VMs starten willst.

Wie entferne ich Docker wieder vollständig?

sudo apt purge docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo rm -rf /var/lib/docker /var/lib/containerd

Der zweite Befehl löscht alle Abbilder, Container und Volumes. Vorher prüfen, ob dort noch Daten liegen, die du brauchst.

Fazit

Der offizielle Weg ist kaum aufwendiger als die Abkürzung über docker.io und liefert dir aktuelle Versionen, docker compose als Plugin und Aktualisierungen über den normalen Paketmanager. Fünf Befehle für die Paketquelle, einer für die Installation – das ist alles.

Was danach über Erfolg oder Ärger entscheidet, sind zwei Dinge, die keine Installationsanleitung erzwingt: Ports an 127.0.0.1 binden statt ans ganze Netz, und sich darüber im Klaren sein, dass die Gruppe docker Root-Rechten gleichkommt.

Andere Systeme laufen anders – auf Arch startet der Dienst nicht von allein, in der RHEL-Familie kollidiert Podman. Die Anleitungen dazu findest du in unserer Übersicht: Docker auf jedem System installieren. Und wenn Docker läuft, ist Portainer ein guter erster Dienst.