--- id: 2026-08-20-ubuntu-26-04-docker-installieren-und-verwenden slug: ubuntu-26-04-docker-installieren-und-verwenden title: "Ubuntu 26.04: Docker installieren und verwenden" excerpt: "Schritt-für-Schritt-Anleitung zur Docker-Installation auf Ubuntu 26.04 LTS: Von den Grundlagen über die Konfiguration bis hin zu produktiven Einsatzszenarien." date: "2026-08-20T10:00:00+02:00" updated: "2026-08-20T10:00:00+02:00" author: name: "Sebastian Palencsar" handle: "spalencsar" category: "serverumgebungen" tags: ["docker", "ubuntu", "container", "linux", "server", "devops", "docker-compose"] reading_time: 60 toc: true --- Container-Technologie hat die Art, wie wir Software entwickeln und bereitstellen, grundlegend verändert. Docker steht dabei an vorderster Front dieser Revolution und ist heute aus modernen IT-Umgebungen nicht mehr wegzudenken. Ob du Webanwendungen entwickelst, komplexe Mikroservice-Architekturen aufbaust oder einfach nur eine konsistente Entwicklungsumgebung schaffen möchtest – Docker bietet dir die Werkzeuge, die du brauchst. **Warum ist Docker so wichtig geworden?** Container lösen das altbekannte Problem „Bei mir funktioniert es" elegant: Eine Anwendung läuft in ihrem Container immer gleich, egal ob auf deinem Laptop, dem Testserver oder in der Produktionsumgebung. Diese Konsistenz spart nicht nur Zeit, sondern verhindert auch kostspielige Fehler bei der Bereitstellung.
❗ **Wichtiger Hinweis:** Dieser Artikel richtet sich an **Linux-Administratoren und IT-Fachkräfte**, die bereits grundlegende Erfahrungen mit Ubuntu und der Kommandozeile haben. Du solltest dich im Terminal sicher bewegen können und verstehen, was Paketverwaltung bedeutet. Gleichzeitig ist dieser Leitfaden auch für **Einsteiger in die Container-Technologie** geeignet, die Docker von Grund auf lernen möchten.
💡 **Tipp:** Docker ist heute ein gefragtes Skill in der IT-Branche. Viele Stellenausschreibungen für Systemadministratoren und DevOps-Engineers setzen Docker-Kenntnisse voraus.
**Was erwartet dich in diesem Artikel?** Du lernst nicht nur, wie du Docker auf Ubuntu 26.04 installierst, sondern auch, wie du es effektiv einsetzt. Wir beginnen mit den Grundlagen, erklären die Installation Schritt für Schritt und führen dich bis hin zu praktischen Anwendungsbeispielen. Dabei achten wir besonders auf Stolperfallen, die Einsteigern häufig begegnen.
⚠️ **Wichtige Vorbemerkung:** Docker erfordert erweiterte Systemrechte. Alle Befehle, die wir in diesem Artikel verwenden, sind für Ubuntu 26.04 LTS getestet. Bei anderen Ubuntu-Versionen können Abweichungen auftreten.
**Was macht diesen Artikel besonders?** Wir erklären nicht nur das „Wie", sondern auch das „Warum". Jeder Befehl wird in seinem Kontext erläutert, damit du verstehst, was im Hintergrund passiert. Das ist besonders wichtig, wenn später Probleme auftreten – und die werden kommen, das ist normal. 🔧 **Praktischer Hinweis:** Plane für die komplette Durcharbeitung dieses Artikels etwa 2-3 Stunden ein. Du wirst ein voll funktionsfähiges Docker-System haben und die wichtigsten Befehle sicher beherrschen. Ubuntu 26.04 LTS (Long Term Support) ist die ideale Plattform für Docker. Das System ist stabil, gut dokumentiert und wird langfristig unterstützt. Die LTS-Version erhält fünf Jahre Security-Updates – perfekt für Produktionsumgebungen, in denen Stabilität oberste Priorität hat. **Bereit für den Einstieg?** Dann beginnen wir mit den Docker-Grundlagen und der Vorbereitung deines Ubuntu-Systems. Am Ende dieses Artikels wirst du Docker nicht nur installiert haben, sondern auch produktiv einsetzen können. ## Docker-Grundlagen ### Was ist Docker und warum brauchst du es? Docker ist eine Container-Plattform, die es dir ermöglicht, Anwendungen mit all ihren Abhängigkeiten in leichtgewichtigen, portablen Containern zu verpacken. Aber was bedeutet das konkret für dich als Administrator? **Container vs. Virtuelle Maschinen – der entscheidende Unterschied:** ```markdown Traditionelle Virtualisierung: ┌─────────────────────────────────────────┐ │ Host-Betriebssystem │ ├─────────────────────────────────────────┤ │ Hypervisor │ ├─────────────┬─────────────┬─────────────┤ │ Gast-OS │ Gast-OS │ Gast-OS │ │ App │ App │ App │ └─────────────┴─────────────┴─────────────┘ Container mit Docker: ┌─────────────────────────────────────────┐ │ Host-Betriebssystem │ ├─────────────────────────────────────────┤ │ Docker Engine │ ├─────────────┬─────────────┬─────────────┤ │ Container │ Container │ Container │ │ App │ App │ App │ └─────────────┴─────────────┴─────────────┘ ``` Der entscheidende Vorteil: Container teilen sich den Kernel des Host-Systems und benötigen dadurch deutlich weniger Ressourcen als virtuelle Maschinen.
💡 **Tipp:** Ein typischer Container benötigt nur wenige Megabyte Speicher, während eine VM mehrere Gigabyte verbraucht.
**Warum Docker in der Praxis unverzichtbar ist:** **1. Konsistente Umgebungen schaffen** Kennst du das Problem: Die Anwendung läuft auf dem Entwicklungsrechner einwandfrei, aber auf dem Produktionsserver gibt es Probleme? Docker löst dieses „Works on my machine"-Problem radikal. Ein Container verhält sich überall identisch. **2. Einfache Skalierung** Mit Docker kannst du Anwendungen horizontal skalieren, indem du einfach weitere Container-Instanzen startest. Das brauchst du später, um auf Lastspitzen zu reagieren. **3. Microservices-Architektur** Docker ist das Fundament moderner Microservices. Jeder Service läuft in seinem eigenen Container – isoliert und unabhängig deploybar. **Typische Anwendungsfälle in deinem Arbeitsalltag:** * **Entwicklungsumgebungen:** Schnell reproduzierbare Umgebungen für dein Team * **CI/CD-Pipelines:** Automatisierte Tests und Deployments * **Legacy-Anwendungen:** Alte Software in modernen Umgebungen betreiben * **Lastverteilung:** Services je nach Bedarf starten und stoppen
⚠️ **Achtung:** Docker ist kein Allheilmittel. Für sehr ressourcenintensive Anwendungen oder wenn du verschiedene Betriebssysteme brauchst, sind VMs oft die bessere Wahl.
### Systemvoraussetzungen prüfen und System vorbereiten Bevor wir Docker installieren, müssen wir sicherstellen, dass dein Ubuntu-System bereit ist. Diese Vorbereitungen sind entscheidend für eine reibungslose Installation. **Hardware-Anforderungen überprüfen:** Docker benötigt eine 64-Bit-Architektur und mindestens 2 GB RAM. Überprüfe dein System mit: ```bash uname -a ``` Du solltest eine Ausgabe wie diese sehen: ```bash Linux ubuntu-server 6.8.0-40-generic #40-Ubuntu SMP ... x86_64 x86_64 x86_64 GNU/Linux ``` Das `x86_64` bestätigt die 64-Bit-Architektur. Achte darauf, weil Docker auf 32-Bit-Systemen nicht funktioniert. **Ubuntu-Version verifizieren:** ```bash lsb_release -a ``` Erwartete Ausgabe: ```bash Distributor ID: Ubuntu Description: Ubuntu 26.04 LTS Release: 26.04 Codename: resolute ```
💡 **Tipp:** Docker funktioniert ab Ubuntu 20.04, aber für Produktionsumgebungen empfehlen wir Ubuntu 26.04 LTS wegen der längeren Support-Zeit.
**Alte Docker-Versionen vollständig entfernen:** Falls du bereits Docker installiert hattest, entferne zunächst alle alten Versionen. Das ist wichtig, um Konflikte zu vermeiden: ```bash sudo apt remove docker docker-engine docker.io containerd runc ``` Auch wenn eine Fehlermeldung erscheint („Paket nicht installiert"), ist das normal und kein Problem. **Pakete aktualisieren:** ```bash sudo apt update && sudo apt upgrade -y ``` Das dauert je nach Anzahl der Updates einige Minuten. Achte darauf, weil veraltete Systempakete später Probleme verursachen können. **Erforderliche Abhängigkeiten installieren:** ```bash sudo apt install -y \ apt-transport-https \ ca-certificates \ curl \ gnupg \ lsb-release ``` **Was passiert hier im Detail:** * `apt-transport-https`: Ermöglicht sichere HTTPS-Verbindungen für APT * `ca-certificates`: Vertrauenswürdige Zertifizierungsstellen * `curl`: Für Downloads (Docker-Installationsskript) * `gnupg`: Für die Verifikation von GPG-Signaturen * `lsb-release`: Zur Erkennung der Ubuntu-Version **Benutzerrechte vorbereiten:** Docker läuft standardmäßig als root. Für den alltäglichen Gebrauch wirst du deinen Benutzer zur docker-Gruppe hinzufügen. Das machen wir aber erst nach der Installation.
❗ **Typische Fehlerquelle:** Viele Einsteiger vergessen das System-Update vor der Docker-Installation. Das führt später zu Abhängigkeitsproblemen.
**System-Neustart empfohlen:** Nach umfangreichen Updates solltest du das System neu starten: ```bash sudo reboot ```
💡 **Das brauchst du später**, um sicherzustellen, dass alle Kernel-Updates aktiv sind. Docker nutzt moderne Kernel-Features, die nach Updates verfügbar sein müssen.
🔧 **Praktischer Hinweis:** Notiere dir die Kernel-Version vor und nach dem Neustart mit `uname -r`. Bei neueren Kernel-Versionen läuft Docker oft stabiler. **Firewall-Überlegungen:** Ubuntu 26.04 verwendet standardmäßig UFW (Uncomplicated Firewall). Docker erstellt automatisch eigene iptables-Regeln. Prüfe den UFW-Status: ```bash sudo ufw status ``` Falls UFW aktiv ist, plane später die Docker-Ports entsprechend zu konfigurieren. Dein System ist jetzt optimal für die Docker-Installation vorbereitet. Im nächsten Abschnitt installieren wir Docker Engine und konfigurieren es für den produktiven Einsatz. ## Installation und Konfiguration ### Docker Engine installieren Jetzt kommen wir zur eigentlichen Installation. Docker bietet mehrere Installationswege – wir verwenden die offizielle Methode über das Docker-Repository, da sie die aktuellsten und stabilsten Versionen liefert. **Docker's offizielles APT-Repository einrichten:** Zuerst fügen wir Docker's GPG-Schlüssel hinzu, um die Authentizität der Pakete zu gewährleisten: ```bash curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg ``` **Was passiert hier im Detail:** * `curl -fsSL`: Lädt den GPG-Schlüssel herunter (fail silently, show errors, follow redirects) * `gpg --dearmor`: Konvertiert den Schlüssel ins richtige Format * Der Schlüssel wird in `/usr/share/keyrings/` gespeichert **Repository zur APT-Quellenliste hinzufügen:** ```bash echo \ "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu \ $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null ``` **Dieser Befehl sieht komplex aus, aber er macht folgendes:** * `$(dpkg --print-architecture)`: Ermittelt automatisch deine Systemarchitektur (meist amd64) * `$(lsb_release -cs)`: Ermittelt den Ubuntu-Codenamen (bei 26.04 ist das „resolute") * Das Repository wird in eine separate Datei geschrieben **Paketlisten aktualisieren:** ```bash sudo apt update ``` Du solltest eine Zeile wie diese sehen: ```bash Get:1 https://download.docker.com/linux/ubuntu resolute InRelease [48.9 kB] ``` Das bestätigt, dass das Docker-Repository erfolgreich hinzugefügt wurde. **Docker Engine installieren:** ```bash sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin ``` **Was wird hier installiert:** * `docker-ce`: Die Docker Community Edition (Engine) * `docker-ce-cli`: Das Kommandozeilen-Interface * `containerd.io`: Die Container-Runtime * `docker-buildx-plugin`: Erweiterte Build-Funktionen * `docker-compose-plugin`: Docker Compose als Plugin Die Installation dauert wenige Minuten. Du siehst den Fortschritt in der Ausgabe. **Installation verifizieren:** Prüfe, ob Docker erfolgreich installiert wurde: ```bash sudo docker --version ``` **Erwartete Ausgabe (Version kann variieren):** ```bash Docker version 29.7.2, build afb1234 ``` **Docker-Service-Status überprüfen:** ```bash sudo systemctl status docker ``` **Du solltest eine Ausgabe wie diese sehen:** ```bash ● docker.service - Docker Application Container Engine Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled) Active: active (running) since Mon 2026-08-20 10:30:15 UTC; 2min ago ``` Das `Active: active (running)` bestätigt, dass Docker läuft. 🔧 **Praktischer Test:** Führe den Docker-"Hello World"-Test aus: ```bash sudo docker run hello-world ``` **Erwartete Ausgabe:** ```bash Hello from Docker! This message shows that your installation appears to be working correctly. ```
❗ **Typische Fehlerquelle:** Falls du die Fehlermeldung „Cannot connect to the Docker daemon socket" erhältst, ist der Docker-Service noch nicht gestartet.
**Starte ihn mit:** ```bash sudo systemctl start docker sudo systemctl enable docker ``` **Docker Compose verifizieren:** Mit der modernen Installation ist Docker Compose als Plugin verfügbar: ```bash docker compose version ``` **Ausgabe:** ```bash Docker Compose version v5.5.0 ```
⚠️ **Wichtiger Hinweis:** Das neue Docker Compose verwendet `docker compose` (mit Leerzeichen) statt `docker-compose` (mit Bindestrich). Die alte Version wird nicht mehr aktiv entwickelt.
### Docker konfigurieren und optimieren Die Grundinstallation läuft, aber für den produktiven Einsatz müssen wir Docker noch konfigurieren und optimieren. **Benutzer zur Docker-Gruppe hinzufügen:** Standardmäßig benötigt Docker root-Rechte. Für den alltäglichen Gebrauch fügst du deinen Benutzer zur docker-Gruppe hinzu: ```bash sudo usermod -aG docker $USER ``` Das brauchst du später, um Docker-Befehle ohne `sudo` ausführen zu können. Der Befehl fügt deinen aktuellen Benutzer (`$USER`) zur Gruppe `docker` hinzu. **Wichtig**: Melde dich ab und wieder an (oder starte eine neue Shell), damit die Gruppenänderung wirksam wird: ```bash newgrp docker ``` **Test ohne sudo:** ```bash docker run hello-world ``` Wenn das ohne `sudo` funktioniert, ist die Konfiguration erfolgreich.
⚠️ **Sicherheitshinweis:** Benutzer in der docker-Gruppe haben effektiv root-Zugriff auf das System. Füge nur vertrauenswürdige Benutzer hinzu.
**Docker-Daemon konfigurieren:** Erstelle eine Konfigurationsdatei für den Docker-Daemon: ```bash sudo mkdir -p /etc/docker sudo tee /etc/docker/daemon.json > /dev/null < 💡 **Das brauchst du später**, um zu verhindern, dass Container-Logs die Festplatte volllaufen lassen. **Docker-Service neu starten:** ```bash sudo systemctl restart docker ``` **Konfiguration verifizieren:** ```bash docker info | grep -A 5 "Storage Driver" ``` **Ausgabe:** ```bash Storage Driver: overlay2 Backing Filesystem: extfs Supports d_type: true Native Overlay Diff: true userxattr: false ``` **Netzwerk-Konfiguration verstehen:** Docker erstellt automatisch ein Standard-Netzwerk: ```bash docker network ls ``` **Ausgabe:** ```bash NETWORK ID NAME DRIVER SCOPE abcd1234efgh bridge bridge local ijkl5678mnop host host local qrst9012uvwx none null local ``` Das `bridge`-Netzwerk ist das Standard-Netzwerk für Container. Das brauchst du später, um Container miteinander kommunizieren zu lassen. **Storage-Speicherort prüfen:** Docker speichert standardmäßig alle Daten in `/var/lib/docker`: ```bash sudo du -sh /var/lib/docker ```
💡 **Tipp:** Stelle sicher, dass das root-Dateisystem genügend Platz hat. Für Produktionsumgebungen solltest du mindestens 20 GB frei haben.
**Docker-System-Informationen anzeigen:** ```bash docker system df ``` Diese Ausgabe zeigt dir, wie viel Speicherplatz Images verwenden, wie auch aktive und inaktive Container und Volumes und Build-Cache. 🔧 **Praktischer Hinweis:** Mit `docker system prune` kannst du ungenutzten Speicher freigeben. Das ist besonders in Entwicklungsumgebungen nützlich. **Automatischer Start konfigurieren:** Docker sollte automatisch beim Systemstart starten: ```bash sudo systemctl enable docker sudo systemctl enable containerd ``` **Firewall-Konfiguration (falls UFW aktiv):** Falls du UFW verwendest, musst du Docker-Regeln berücksichtigen: ```bash sudo ufw status ``` Falls UFW aktiv ist: ```bash # Docker-Daemon-Port (normalerweise nicht nötig, da nur lokal) # Container-Ports müssen je nach Anwendung konfiguriert werden ```
❗ **Typische Fehlerquelle:** Docker manipuliert iptables-Regeln direkt. UFW-Regeln können dadurch umgangen werden. In Produktionsumgebungen solltest du Docker-spezifische Firewall-Regeln implementieren.
**Performance-Optimierungen:** Für bessere Performance in Produktionsumgebungen: ```bash # Kernel-Parameter für Container-Performance optimieren echo 'net.bridge.bridge-nf-call-iptables = 1' | sudo tee -a /etc/sysctl.conf echo 'net.bridge.bridge-nf-call-ip6tables = 1' | sudo tee -a /etc/sysctl.conf sudo sysctl -p ``` **Installation abschließend testen:** ```bash # System-Information anzeigen docker info # Version aller Komponenten docker version # Einfacher Container-Test docker run --rm alpine echo "Docker ist einsatzbereit!" ```
💡 **Hinweis:** Die Ausgabe von `docker run --rm alpine echo "Docker ist einsatzbereit!"` bestätigt, dass Docker Images herunterladen, Container starten und wieder löschen kann.
Docker ist jetzt vollständig installiert und konfiguriert. Du kannst Docker-Befehle ohne sudo ausführen, die Logs sind begrenzt, und das System ist für den produktiven Einsatz optimiert.
💡 **Wichtiger Hinweis:** Sichere dir diese Konfiguration, indem du die Datei `/etc/docker/daemon.json` in dein Backup einbeziehst. Das brauchst du später, um die Konfiguration auf anderen Servern zu reproduzieren.
## Fazit Mit diesem umfassenden Leitfaden hast du Docker erfolgreich auf Ubuntu 26.04 LTS installiert und für den produktiven Einsatz konfiguriert. Du beherrschst jetzt nicht nur die reine Installation, sondern verstehst auch die Konzepte hinter der Container-Technologie und kennst die wichtigsten Optimierungen für Sicherheit und Performance. **Deine Erfolge im Überblick:** Du hast ein vollständig funktionsfähiges Docker-System mit optimierter Daemon-Konfiguration, automatischer Log-Rotation und den notwendigen Sicherheitseinstellungen. Die Benutzerrechte sind korrekt konfiguriert, sodass du Docker ohne sudo verwenden kannst. Gleichzeitig hast du gelernt, typische Stolperfallen zu vermeiden und Probleme selbstständig zu diagnostizieren.
💡 **Warum dieser Artikel besonders wertvoll ist:** Im Gegensatz zu Standard-Installationsanleitungen haben wir besonderen Wert auf die Systemvorbereitung, Sicherheitsaspekte und produktive Konfiguration gelegt. Du bist jetzt bereit für den professionellen Docker-Einsatz in Entwicklungs- und Produktionsumgebungen.