Ubuntu 22.04: Docker installieren und verwenden

Ubuntu 22.04: Docker installieren und verwenden
Navigation

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 22.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 22.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 22.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:

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     │
└─────────────┴─────────────┴─────────────┘
Markdown

Der entscheidende Vorteil: Container teilen sich den Kernel des Host-Systems und benötigen dadurch deutlich weniger Ressourcen als virtuelle Maschinen. Das brauchst du später, um mehrere Services effizient auf einem Server zu betreiben.

💡 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.

🔧 Praktisches Beispiel: Stell dir vor, du betreibst einen Webshop. Ohne Docker müsstest du auf einem Server den Webserver, die Datenbank und den Cache-Service direkt installieren. Bei Konflikten zwischen den Versionen wird es kompliziert. Mit Docker läuft jeder Service in seinem eigenen Container – sauber getrennt.

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:

uname -a
Bash

Du solltest eine Ausgabe wie diese sehen:

Linux ubuntu-server 5.15.0-72-generic #79-Ubuntu SMP ... x86_64 x86_64 x86_64 GNU/Linux
Bash

Das x86_64 bestätigt die 64-Bit-Architektur. Achte darauf, weil Docker auf 32-Bit-Systemen nicht funktioniert.

Ubuntu-Version verifizieren:

lsb_release -a
Bash

Erwartete Ausgabe:

Distributor ID: Ubuntu
Description:    Ubuntu 22.04.3 LTS
Release:        22.04
Codename:       jammy
Bash
💡 Tipp: Docker funktioniert ab Ubuntu 20.04, aber für Produktionsumgebungen empfehlen wir Ubuntu 22.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:

sudo apt remove docker docker-engine docker.io containerd runc
Bash

Auch wenn eine Fehlermeldung erscheint („Paket nicht installiert“), ist das normal und kein Problem.

Pakete aktualisieren:

sudo apt update && sudo apt upgrade -y
Bash

Das dauert je nach Anzahl der Updates einige Minuten. Achte darauf, weil veraltete Systempakete später Probleme verursachen können.

Erforderliche Abhängigkeiten installieren:

sudo apt install -y \
	apt-transport-https \
	ca-certificates \
	curl \
	gnupg \
	lsb-release
Bash

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:

sudo reboot
Bash
💡 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 22.04 verwendet standardmäßig UFW (Uncomplicated Firewall). Docker erstellt automatisch eigene iptables-Regeln. Prüfe den UFW-Status:

sudo ufw status
Bash

Falls UFW aktiv ist, plane später die Docker-Ports entsprechend zu konfigurieren. Das brauchst du später, um Container von außen erreichbar zu machen.

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.

Zwischenfazit: Du hast gelernt, was Docker ist und warum es so wichtig für moderne IT-Infrastrukturen ist. Dein Ubuntu-System ist jetzt bereit für die Installation. Die Vorbereitungsschritte mögen aufwendig erscheinen, aber sie verhindern später frustrierende Fehlermeldungen und Installationsprobleme.

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:

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:

curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
Bash

Was passiert hier im Detail:

==> curl -fsSL: Lädt den GPG-Schlüssel herunter
==> gpg --dearmor: Konvertiert den Schlüssel ins richtige Format
==> Der Schlüssel wird in /usr/share/keyrings/ gespeichert
💡 Tipp: Die Option -fsSL bei curl bedeutet: fail silently, show errors, follow redirects, location header. Das ist wichtig für sichere Downloads.

Repository zur APT-Quellenliste hinzufügen:

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
Bash

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 22.04 ist das "jammy")
==> Das Repository wird in eine separate Datei geschrieben

Paketlisten aktualisieren:

sudo apt update
Bash

Du solltest eine Zeile wie diese sehen:

Get:1 https://download.docker.com/linux/ubuntu jammy InRelease [48.9 kB]
Bash

Das bestätigt, dass das Docker-Repository erfolgreich hinzugefügt wurde.

Docker Engine installieren:

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

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:

sudo docker --version
Bash

Erwartete Ausgabe (Version kann variieren):

Docker version 24.0.5, build ced0996
Bash

Docker-Service-Status überprüfen:

sudo systemctl status docker
Bash

Du solltest eine Ausgabe wie diese sehen:

● docker.service - Docker Application Container Engine
	 Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
	 Active: active (running) since Sun 2024-01-07 10:30:15 UTC; 2min ago
Zsh

Das Active: active (running) bestätigt, dass Docker läuft.

🔧 Praktischer Test: Führe den Docker-„Hello World“-Test aus:

sudo docker run hello-world
Zsh

Erwartete Ausgabe:

Hello from Docker!
This message shows that your installation appears to be working correctly.
Zsh
❗ 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:

sudo systemctl start docker
sudo systemctl enable docker
Bash

Docker Compose verifizieren:

Mit der modernen Installation ist Docker Compose als Plugin verfügbar:

docker compose version
Bash

Ausgabe:

Docker Compose version v2.21.0
Zsh
⚠️ 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:

sudo usermod -aG docker $USER
Bash

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:

newgrp docker
Bash

Test ohne sudo:

docker run hello-world
Bash

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:

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json > /dev/null <<EOF
{
  "log-driver": "json-file",
  "log-opts": {
	"max-size": "10m",
	"max-file": "3"
  },
  "storage-driver": "overlay2"
}
EOF
Bash
💡 Das brauchst du später, um zu verhindern, dass Container-Logs die Festplatte volllaufen lassen.

Docker-Service neu starten:

sudo systemctl restart docker
Bash

Konfiguration verifizieren:

docker info | grep -A 5 "Storage Driver"
Bash

Ausgabe:

 Storage Driver: overlay2
  Backing Filesystem: extfs
  Supports d_type: true
  Native Overlay Diff: true
  userxattr: false
Zsh

Netzwerk-Konfiguration verstehen:

Docker erstellt automatisch ein Standard-Netzwerk:

docker network ls
Zsh

Ausgabe:

NETWORK ID     NAME      DRIVER    SCOPE
abcd1234efgh   bridge    bridge    local
ijkl5678mnop   host      host      local
qrst9012uvwx   none      null      local
Zsh

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:

sudo du -sh /var/lib/docker
Zsh
💡 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:

docker system df
Zsh

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:

sudo systemctl enable docker
sudo systemctl enable containerd
Zsh

Firewall-Konfiguration (falls UFW aktiv):

Falls du UFW verwendest, musst du Docker-Regeln berücksichtigen:

sudo ufw status
Zsh

Falls UFW aktiv ist:

# Docker-Daemon-Port (normalerweise nicht nötig, da nur lokal)
# Container-Ports müssen je nach Anwendung konfiguriert werden
Zsh
❗ 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:

# 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
Zsh

Installation abschließend testen:

# System-Information anzeigen
docker info

# Version aller Komponenten
docker version

# Einfacher Container-Test
docker run --rm alpine echo "Docker ist einsatzbereit!"
Zsh
💡 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. Im nächsten Abschnitt lernst du, wie du Docker praktisch verwendest.

💡 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 22.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.

Schlagwörter

Ähnliche Beiträge