Docker-Tutorial: Eine vollständige Anleitung zum Ausführen von Containern

Docker ist eine offene Plattform, die entwickelt wurde, um die Entwicklung, Bereitstellung und Ausführung von Anwendungen zu vereinfachen. Die Softwarebereitstellung wird dabei durch Containerisierung standardisiert – eine Technologie, bei der Anwendungen gemeinsam mit ihren Abhängigkeiten in isolierte, lauffähige Einheiten, sogenannte Container, verpackt werden. Dadurch wird sichergestellt, dass Anwendungen unabhängig von der zugrunde liegenden Umgebung konsistent funktionieren.

Im Kern basiert Docker auf mehreren zentralen Konzepten, darunter Docker Engine, Docker Hub, Images, Container, Dockerfiles und Docker Compose. Ein grundlegendes Verständnis dieser Komponenten ist erforderlich, um containerisierte Anwendungen zu erstellen, bereitzustellen und effizient zu verwalten.

Die Interaktion mit Docker erfolgt in der Regel über die Kommandozeile, Docker stellt jedoch zusätzlich eine Desktop-Version mit grafischer Benutzeroberfläche bereit. Der Einrichtungsprozess unterscheidet sich entsprechend: Während Docker Desktop wie eine herkömmliche Anwendung über eine .dmg– oder .exe-Datei installiert wird, erfolgt die Installation der Docker CLI typischerweise über einen Paketmanager wie APT oder Homebrew.

Beim Arbeiten mit dem Docker-Ökosystem können auf unterschiedlichen Ebenen Fehler auftreten – etwa auf Image-Ebene, innerhalb eines Dockerfiles oder beim Ausführen von Containern. Da solche Probleme die Funktionalität der gesamten Container-Umgebung beeinträchtigen können, ist es wichtig, die häufigsten Fehlerbilder, ihre Ursachen und geeignete Lösungsansätze zu kennen. Auf diese Aspekte wird im weiteren Verlauf detaillierter eingegangen, nachdem zunächst die grundlegenden Docker-Konzepte erläutert wurden.

Was ist Containerisierung?

Containerisierung ist eine Form der Virtualisierung auf Betriebssystemebene, bei der Softwareanwendungen so verpackt werden, dass sie in isolierten Benutzerbereichen ausgeführt werden. Diese isolierten Einheiten werden als Container bezeichnet.

Ein Container bündelt eine Anwendung mit allen erforderlichen Komponenten – darunter Code, Systembibliotheken, Abhängigkeiten und Konfigurationsdateien – und stellt damit eine abgeschlossene Laufzeitumgebung bereit.

Im Gegensatz zu virtuellen Maschinen (VMs) sind Container deutlich leichtergewichtig, da sie sich den Betriebssystemkernel des Hostsystems teilen. Durch diese Entkopplung von der zugrunde liegenden Infrastruktur wird eine konsistente Ausführung von Anwendungen über verschiedene Umgebungen hinweg ermöglicht.

Zu den zentralen Vorteilen der Containerisierung gehören:

• Portabilität: Container lassen sich konsistent in nahezu jeder Umgebung ausführen – von lokalen Entwicklungsrechnern bis hin zu Remote-Servern bei Anbietern wie Hostinger. Dadurch wird ein häufiges Problem beseitigt, bei dem Anwendungen beim Wechsel zwischen Systemen während der Bereitstellung oder Zusammenarbeit auf Kompatibilitätsprobleme stoßen.
• Effizienz: Während virtuelle Maschinen ein vollständiges Gastbetriebssystem sowie einen Hypervisor erfordern, entfällt dieser Overhead bei Containern. Dadurch stellt Containerisierung eine ressourcenschonendere und effizientere Form der Virtualisierung dar.
• Isolation: Jeder Container führt Prozesse isoliert aus und verfügt über eigene Software, Konfigurationen, einen separaten Netzwerk-Stack sowie eigene Umgebungsvariablen. Dies erhöht die Sicherheit und verhindert Konflikte zwischen parallel betriebenen Anwendungen.

Warum Docker verwenden?

Docker bietet eine zuverlässige, effiziente und standardisierte Möglichkeit zum Erstellen, Verteilen und Ausführen von Anwendungen. Die Plattform adressiert mehrere praxisrelevante Herausforderungen in der Softwareentwicklung und -bereitstellung:

• Das Problem „Auf meinem Rechner funktioniert es“. Docker stellt sicher, dass eine Anwendung für alle Entwickler und über sämtliche Phasen der Bereitstellung hinweg identisch ausgeführt wird. Dadurch werden umgebungsbedingte Fehler effektiv eliminiert.
• Schnelle Entwicklung und Bereitstellung. Docker vereinfacht die Erstellung reproduzierbarer Umgebungen erheblich. Bestehende Komponenten wie Caching-Systeme oder Zahlungsgateways lassen sich integrieren, ohne diese von Grund auf neu implementieren zu müssen, was Entwicklungszeit spart.
• Skalierbarkeit und Portabilität. Mithilfe von Tools wie Docker Compose können komplexe Multi-Container-Anwendungsstacks in einer einzigen Konfigurationsdatei definiert und weitergegeben werden. Dies erleichtert die Zusammenarbeit in Teams, stellt Konsistenz sicher und ermöglicht das bedarfsgerechte Skalieren einzelner Dienste.
• Ressourceneffizienz. Da Container leichtgewichtig sind und den Kernel des Host-Betriebssystems gemeinsam nutzen, benötigen sie deutlich weniger Systemressourcen als klassische virtuelle Maschinen.

Was sind die Kernkonzepte von Docker?

Docker strukturiert das Prinzip der Containerisierung in eine Reihe zentraler, voneinander abhängiger Komponenten. Diese Elemente arbeiten gemeinsam als Plattform, um den gesamten Lebenszyklus einer containerisierten Anwendung zu verwalten – von der Erstellung des ersten Entwurfs bis zur Ausführung einer produktiven Multi-Service-Anwendung.

Docker-Engine

Die Docker Engine ist die zentrale Open-Source-Komponente zum Erstellen, Bereitstellen und Ausführen containerisierter Anwendungen. Sie basiert auf einer Client-Server-Architektur und verwaltet Docker-Objekte wie Images, Container, Netzwerke und Volumes.

Die Docker Engine besteht aus drei Hauptkomponenten:

1. Der Server: Ein dauerhaft laufender Daemon-Prozess (dockerd), der zentrale Aufgaben wie das Erstellen, Starten, Stoppen und Entfernen von Containern übernimmt.
2. APIs: Programmierschnittstellen, über die Clients – einschließlich der Docker CLI – mit dem Daemon kommunizieren und Aktionen auslösen können.
3. Der CLI-Client: Das Docker-Kommandozeilenwerkzeug, das die primäre Schnittstelle zur Interaktion mit der Docker-Plattform darstellt.

Zur besseren Veranschaulichung lässt sich die Docker Engine mit einem Restaurantbetrieb vergleichen:

• Der Server (dockerd) fungiert als Küche, die die eigentliche Ausführung der Arbeitsschritte übernimmt – vergleichbar mit der Zubereitung eines Gerichts.
• Die APIs entsprechen der Speisekarte, die definiert, welche Aktionen möglich sind und wie diese angefordert werden können.
• Die Docker CLI dient als Kellner (Schnittstelle), über den Befehle entgegengenommen und an den Daemon weitergeleitet werden.

Um zu überprüfen, ob die Docker Engine aktiv ist und korrekt mit dem Client kommuniziert, kann ein einfacher Befehl ausgeführt werden, der eine Antwort vom Daemon erwartet, zum Beispiel:

docker ps

Dieser Befehl fordert den Docker-Daemon auf, alle aktuell laufenden Container aufzulisten. Funktioniert die Docker Engine ordnungsgemäß, wird eine entsprechende Ausgabe angezeigt.

Docker Hub

Docker Hub ist die standardmäßige öffentliche Registry für Docker-Images und dient als zentraler Speicher- und Verteilungsdienst. Die Plattform stellt offizielle Images für weit verbreitete Software wie nginx, Node.js oder Python bereit und ermöglicht es Nutzern, eigene öffentliche oder private Repositories zu verwalten.

Beim Erstellen eines Containers werden benötigte Softwarepakete in Form von Images eingebunden. Docker Hub vereinfacht diesen Prozess, indem Images aus einem zentralen Repository heruntergeladen werden können.

Zur Versionsverwaltung verwendet Docker Hub sogenannte Tags, mit denen Images eindeutig gekennzeichnet werden, etwa latest. Dadurch wird sichergestellt, dass Container in verschiedenen Umgebungen konsistent und reproduzierbar ausgeführt werden.

Funktional lässt sich Docker Hub mit einer gemeinschaftlich genutzten Rezeptsammlung vergleichen: Vorgefertigte Vorlagen stehen zur Verfügung und können direkt verwendet oder an eigene Anforderungen angepasst werden. Eigene Images lassen sich ebenfalls hochladen – entweder zur Weitergabe oder zur internen Nutzung.

Die Interaktion mit Docker Hub erfolgt über die Docker CLI. Um beispielsweise ein Image aus der Registry herunterzuladen, wird folgender Befehl verwendet:

docker pull <name>:<tag>

Um das neueste offizielle Ubuntu-Image herunterzuladen:

docker pull ubuntu:latest

Docker-Images

Ein Docker-Image ist eine schreibgeschützte Vorlage, die alle Anweisungen und Dateien enthält, die zur Erstellung eines Containers erforderlich sind. Dazu zählen Anwendungscode, Konfigurationsdateien, Systembibliotheken sowie Bestandteile des Basisbetriebssystems.

Images werden mithilfe eines Dockerfiles erstellt. Jede Anweisung erzeugt dabei eine eigene, unveränderliche Schicht (Layer), die festlegt, welche Inhalte das Image enthält und welche Aktionen ausgeführt werden.

Vereinfacht betrachtet dient ein Image als Bauplan für einen Container. Es definiert exakt, wie das spätere Laufzeitsystem aufgebaut ist, kann nach der Erstellung jedoch nicht mehr verändert werden. Auf Basis dieses Bauplans wird anschließend ein Container instanziiert.

Um lokal verfügbare Images aufzulisten, verwenden Sie folgenden Befehl:

docker images

Mit dem nächsten Befehl wird ein neues Image aus dem aktuellen Verzeichnis erstellt. Ist das verwendete Basis-Image noch nicht vorhanden, wird es automatisch aus der Registry heruntergeladen:

docker build -t your-image-name:latest .

Als bewährte Vorgehensweise gilt die Verwendung möglichst schlanker Basis-Images. Dies reduziert die Image-Größe und minimiert die potenzielle Angriffsfläche, die häufig durch unnötige Pakete oder zusätzliche Komponenten entsteht.

Docker-Container

Ein Container ist eine lauffähige Instanz eines Docker-Images. Er stellt die isolierte Laufzeitumgebung dar, in der eine Anwendung gemeinsam mit ihrer Konfiguration, ihren Abhängigkeiten und den erforderlichen Softwarepaketen ausgeführt wird.

Beim Erstellen eines Docker-Containers wird über den schreibgeschützten Ebenen des Images eine beschreibbare Schicht hinzugefügt. Diese ermöglicht es, Änderungen am Dateisystem vorzunehmen, ohne das zugrunde liegende Image zu verändern.

Container sind darauf ausgelegt, kurzlebig und zustandslos zu sein. Das bedeutet, dass sie jederzeit gestoppt, entfernt, neu erstellt und mit minimalem Konfigurationsaufwand ersetzt werden können. Einzelne Container werden in der Regel direkt über die Docker CLI verwaltet, während mehrere Container mithilfe von Docker Compose oder Orchestrierungswerkzeugen wie Kubernetes gesteuert werden.

In Anlehnung an die zuvor verwendete Analogie entspricht ein Container dem tatsächlich laufenden System, das auf Basis eines Bauplans erstellt wurde. Beim Erstellen eines Docker-Containers wird dieses System instanziiert und gestartet, um die im Image definierten Prozesse auszuführen.

Um einen Docker-Container zu erstellen und einen Befehl darin auszuführen, verwenden Sie den Befehl run, zum Beispiel:

docker run -it ubuntu /bin/bash

Dieser Befehl startet einen interaktiven Container auf Basis des Ubuntu-Images und öffnet eine /bin/bash-Shell innerhalb des Containers.

Dockerfiles

Ein Dockerfile ist eine reine Textdatei, die eine Abfolge klar definierter Anweisungen zum Erstellen eines Docker-Images enthält. Darin wird festgelegt, wie das Image aufgebaut ist – vom Basisbetriebssystem über Umgebungsvariablen bis hin zum Anwendungscode.

Zu den häufigsten Anweisungen in einem Dockerfile gehören:

• FROM: Gibt das Basis-Image für eine neue Build-Phase an.
• RUN: Führt Befehle während des Image-Erstellungsprozesses aus.
• COPY oder ADD: Kopiert Dateien aus dem Build-Kontext in das Image.
• CMD oder ENTRYPOINT: Definiert den Befehl, der beim Start des Containers ausgeführt wird.
• ENV: Legt Umgebungsvariablen fest, die während des Builds und zur Laufzeit verfügbar sind.
• WORKDIR: Definiert das Arbeitsverzeichnis für nachfolgende RUN-, CMD-, ENTRYPOINT-, COPY- und ADD-Anweisungen.

Bestimmte Dockerfile-Anweisungen erzeugen jeweils eine eigene Image-Schicht und stellen damit einen einzelnen Schritt im Build-Prozess dar. Anweisungen, die lediglich Konfigurations- oder Metadaten definieren, wie etwa WORKDIR, erzeugen hingegen keine zusätzliche Schicht.

Ein vereinfachtes Beispiel für ein Dockerfile sieht wie folgt aus:

FROM python:3.9-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["python", "app.py"]

Docker Compose

Docker Compose ist ein Tool zur Definition und Verwaltung von Multi-Container-Anwendungen mithilfe einer einzigen Konfigurationsdatei, in der Regel docker-compose.yml.

Innerhalb dieser Datei werden alle Container, Netzwerke und Volumes definiert, die für einen komplexen Anwendungsstack erforderlich sind. Diese Container werden im Kontext von Docker Compose als Services bezeichnet und lassen sich gemeinsam mit einem einzigen Befehl starten und verwalten.

Ohne Docker Compose müssten Container einzeln konfiguriert und separat über die Docker CLI verwaltet werden. Bei Anwendungen, die aus mehreren miteinander verbundenen Diensten bestehen, ist dieser Ansatz fehleranfällig und zeitaufwendig.

Bleibt man bei der Analogie einzelner Geräte, entspricht ein Container einer einzelnen Maschine, während Docker Compose als Orchestrierungswerkzeug den Schaltplan für ein komplettes System vorgibt und das Zusammenspiel mehrerer Komponenten steuert.

Ein Beispiel für eine Docker-Compose-Datei:

services:
  web:
    build: ./web  # Build the image from Dockerfile in the ./web directory
    ports:
      - "8000:8000"  # Map host port 8000 to container port 8000
    depends_on:
      - db     # Wait for the db service to be started
      - redis  # Wait for the redis service to be started

  db:
    image: postgres:15  # Use the official PostgreSQL 15 image
    environment:
      POSTGRES_USER: myuser       # Set database username
      POSTGRES_PASSWORD: mypassword  # Set database password
      POSTGRES_DB: mydb           # Set initial database name
    volumes:
      - db-data:/var/lib/postgresql/data  # Persist database data using a named volume

  redis:
    image: redis:alpine  # Use a lightweight Redis image for caching

volumes:
  db-data:  # Define a named volume to store database data

Um alle in der Datei docker-compose.yml definierten Dienste im Hintergrund zu erstellen und zu starten, führen Sie folgenden Befehl mit dem -d-Flag (detached mode) aus:

docker compose up -d

Darüber hinaus stehen weitere Docker-Compose-Befehle zur Verfügung, mit denen sich Container während des gesamten Anwendungslebenszyklus zentral verwalten lassen.

Installation von Docker

Der Installationsprozess von Docker unterscheidet sich je nach verwendeter Variante. Bei der Nutzung von Docker Desktop kann das Installationspaket direkt von der offiziellen Docker-Website heruntergeladen und wie eine herkömmliche Anwendung installiert werden.

Die Docker CLI hingegen wird in der Regel über den Paketmanager des jeweiligen Betriebssystems installiert, beispielsweise über APT unter Ubuntu oder Homebrew unter macOS. Detaillierte, distributionsabhängige Installationsbefehle und Konfigurationshinweise finden Sie in der offiziellen Docker-Dokumentation.

Beachten Sie, dass die Docker CLI nicht automatisch den gesamten Funktionsumfang abdeckt. Komponenten wie Docker Compose müssen je nach Installation separat eingerichtet werden. Bei der Nutzung der Docker-Hosting-Lösung von Hostinger entfällt dieser Schritt, da Docker Compose bereits über die integrierte Docker-Manager-Funktion verfügbar ist.

Grundlegende Docker-Befehle

Die Docker CLI dient als primäre Schnittstelle zur Interaktion mit der Docker Engine und zur Verwaltung von Containern. Im Folgenden finden Sie einige der wichtigsten Docker-Befehle für häufige Aufgaben:

• docker ps -a. Listet alle Container auf, einschließlich gestoppter Container.
• docker pull <name>:<tag>. Lädt ein Image aus einer Registry auf das lokale System herunter.
• docker rmi <image>. Entfernt ein lokales Image.
• docker stop <container>. Beendet einen laufenden Container kontrolliert.
• docker rm <container>. Löscht einen Container.

Eine umfassende Übersicht über weitere häufig verwendete Befehle für Images, Container, Volumes und Netzwerke finden Sie in unserem ausführlichen Docker-Spickzettel.

Verwaltung von Docker-Volumes

Volumes sind der empfohlene Mechanismus zur Persistenz von Daten in Docker. Sie stellen sicher, dass Daten auch dann erhalten bleiben, wenn ein Container gestoppt, neu erstellt oder entfernt wird.

Dies ist insbesondere wichtig, da Container während ihres Lebenszyklus häufig neu gestartet oder ersetzt werden, etwa im Rahmen von Updates oder Wartungsarbeiten. Führt ein Container zustandsbehaftete Anwendungen wie Datenbanken aus, bei denen die Datenintegrität entscheidend ist, sind korrekt konfigurierte Volumes unerlässlich.

Docker unterstützt drei grundlegende Speichermechanismen:

• Volumes: Persistente Daten werden im von Docker verwalteten Speicherbereich abgelegt, der sich standardmäßig unter /var/lib/docker/volumes/ auf dem Host befindet.
• Bind Mounts: Dateien oder Verzeichnisse des Hostsystems werden direkt in den Container gemountet.
• tmpfs-Mounts: Daten werden im Arbeitsspeicher des Hosts gespeichert und beim Stoppen des Containers verworfen.

Gehen Sie wie folgt vor, um ein Volume für persistente Daten zu erstellen und zu verwalten:

1. Erstellen Sie ein benanntes Volume. Der folgende Befehl legt beispielsweise ein Volume mit dem Namen my-database-data an:

docker volume create my-database-data

2. Starten Sie den Datenbankcontainer und binden Sie das Volume mithilfe des -v-Flags in das interne Datenverzeichnis des Containers ein:

docker run -d \
  --name my-database \
  -e MYSQL_ROOT_PASSWORD=securepassword \
  -v my-database-data:/var/lib/mysql \
  mysql:latest

3. Überprüfen Sie Details und Speicherort des Volumes auf dem Hostsystem mit folgendem Befehl:

docker volume inspect my-database-data

4. Um nicht verwendete Volumes zu entfernen und Speicherplatz freizugeben, können Sie folgenden Befehl ausführen:

docker volume prune -a

Alternativ zur Verwendung einzelner Befehle können Volumes direkt in einer Docker-Compose-Konfigurationsdatei deklariert und eingebunden werden. Dies erleichtert die Übersicht und Verwaltung, insbesondere bei Anwendungen mit mehreren Diensten.

Die folgende YAML-Konfiguration zeigt ein Beispiel für die Definition eines Volumes und dessen Einbindung in einen Container:

services:

  my-database:

    image: mysql:latest

    container_name: my-database

    environment:
      MYSQL_ROOT_PASSWORD: securepassword

    volumes:
      - my-database-data:/var/lib/mysql

volumes:
  my-database-data:

Erstellen eines Docker-Netzwerks

Docker-Netzwerke sorgen für Isolation und ermöglichen gleichzeitig die Kommunikation zwischen Containern sowie mit externen Systemen. Standardmäßig werden Container mit einem Bridge-Netzwerk verbunden. Für Multi-Service-Anwendungen empfiehlt es sich jedoch, ein benutzerdefiniertes Bridge-Netzwerk zu erstellen.

Docker-Netzwerke ermöglichen die Kommunikation zwischen Containern untereinander sowie mit externen Diensten und Systemen.

Standardmäßig verbindet Docker einen Container mit dem sogenannten Standard-Bridge-Netzwerk. Dieses ermöglicht die grundlegende Kommunikation mit dem Hostsystem, ist jedoch für komplexere Multi-Container-Setups nur eingeschränkt geeignet, da es begrenzte Funktionen für die strukturierte Verbindung mehrerer Dienste bietet.

Für Multi-Service-Anwendungen gilt es daher als Best Practice, ein benutzerdefiniertes Bridge-Netzwerk zu verwenden. In einem solchen Netzwerk können Container über ihre Dienstnamen miteinander kommunizieren. Dies vereinfacht die Serviceerkennung, verbessert die Kontrolle über die Interaktion zwischen Containern und verhindert ungewollte Wechselwirkungen zwischen einzelnen Diensten.

Container lassen sich mit einem benutzerdefinierten Bridge-Netzwerk verbinden, indem die Netzwerkkonfiguration in der Docker-Compose-YAML-Datei definiert wird. Ein Beispiel:

services:

  my-database:

    image: mysql:latest

    container_name: my-database

    environment:
      MYSQL_ROOT_PASSWORD: securepassword

    volumes:
      - my-database-data:/var/lib/mysql

    networks:
      - my-app-network #create a network

Alternativ kann ein benutzerdefiniertes Bridge-Netzwerk direkt über die Docker CLI erstellt werden. Dabei ist my-app-network der frei wählbare Name des Netzwerks:

docker network create my-app-network

Anschließend kann ein Container mit dem entsprechenden Netzwerk verbunden werden. Mit dem Flag –name wird der Dienstname definiert, während –network angibt, mit welchem Netzwerk der Container verbunden wird:

docker run -d \
  --name my-database \
  --network my-app-network \
  -e MYSQL_ROOT_PASSWORD=securepassword \
  -v my-database-data:/var/lib/mysql \
  mysql:latest

Um einen weiteren Container mit demselben Netzwerk zu verbinden, wird der Befehl entsprechend angepasst. Im folgenden Beispiel wird zusätzlich das -p-Flag für das Port-Mapping verwendet, um den internen Port 80 des Containers auf Port 8080 des Hostsystems zu exponieren:

docker run -d \
  --name my-webapp \
  --network my-app-network \
  -p 8080:80 \
  my-web-app-image:latest

Fehlerbehebung bei häufigen Docker-Problemen

Bei der Arbeit mit Docker treten häufig Fehler auf, die verschiedene Ebenen des Systems betreffen können, darunter Images, Container, Volumes und Netzwerke. Im Folgenden werden wiederkehrende Problemstellungen erläutert und geeignete Lösungsansätze aufgezeigt.

Container beendet sich unmittelbar nach dem Start

Container können unmittelbar nach dem Start wieder beendet werden, wenn der Hauptprozess, der über CMD oder ENTRYPOINT im Dockerfile definiert ist, abgeschlossen wird oder abstürzt. Eine häufige Ursache ist, dass der im Container definierte Vordergrundprozess beendet wird oder kein dauerhaft laufender Prozess gestartet wird.

Mögliche Lösungsansätze:

• Überprüfung der Logs. Verwenden Sie den folgenden Befehl, um die Standardausgabe (stdout) und Fehlerausgabe (stderr) des Containers einzusehen und die Ursache des Abbruchs zu identifizieren: docker logs <container_name>.
• Überprüfung des Dockerfiles. Stellen Sie sicher, dass der Container einen langlebigen Prozess ausführt. Prüfen Sie, ob im Dockerfile ein geeigneter CMD– oder ENTRYPOINT-Befehl definiert ist. Ein Webserver muss beispielsweise dauerhaft laufen, um Anfragen verarbeiten zu können.
• Ausführung im Detached Mode. Handelt es sich um einen langfristig laufenden Dienst, der im Hintergrund betrieben werden soll, stellen Sie sicher, dass Sie beim Ausführen von docker run oder docker compose run das Flag -d bzw. –detach verwenden.

Probleme mit dem Layer-Caching von Images

Wenn Änderungen am Dockerfile – etwa die Aktualisierung einer Paketversion – keine Wirkung zeigen, liegt dies häufig am Layer-Caching von Docker. Dieser Mechanismus verwendet vorhandene Image-Schichten erneut, um den Build-Prozess zu beschleunigen, anstatt alle Schritte neu auszuführen.

Obwohl dies die Effizienz erhöht, kann es zu unerwartetem Verhalten führen, wenn Änderungen an frühen Schichten vorgenommen werden, da nachfolgende Anweisungen weiterhin auf gecachten Layern basieren.

Die einfachste Lösung besteht darin, den Build-Cache zu umgehen und eine vollständige Neuerstellung zu erzwingen. Fügen Sie dazu beim Build-Vorgang die Option –no-cache hinzu, zum Beispiel:

docker build --no-cache -t my-app:latest .

Beim Installieren von Paketen über ein Dockerfile sollte außerdem sichergestellt werden, dass keine veralteten Paketlisten aus dem Cache verwendet werden. In Debian-basierten Distributionen lässt sich dies erreichen, indem apt-get update und apt-get install in einer einzigen RUN-Instruktion kombiniert werden:

RUN apt-get update && apt-get install -y --no-install-recommends

Fehler bei der Authentifizierung an einer Registry

Wenn beim Pushen eines Images in eine Registry – etwa Docker Hub – eine Fehlermeldung wie „denied: requested access to the resource is denied“ erscheint, ist der Docker-CLI-Client nicht korrekt bei der Registry authentifiziert.

Gehen Sie wie folgt vor, um das Problem zu beheben:

1. Melden Sie sich bei der gewünschten Registry an. Dabei steht my-registry.example.com für die Adresse der Registry. Für Docker Hub kann dieser Parameter weggelassen werden:

docker login my-registry.example.com

2. Geben Sie Ihren Benutzernamen und Ihr Passwort ein, sobald Sie dazu aufgefordert werden.
3. Taggen Sie das lokale Image vor dem Push mit dem korrekten Registry-Host, Repository und Tag:

docker tag my-local-image:latest my-registry.example.com/my-repo/my-local-image:latest

4. Pushen Sie das Image anschließend in die Registry:

docker push my-registry.example.com/my-repo/my-local-image:latest

Nächste Schritte zur Vertiefung Ihrer Docker-Kenntnisse

Um Docker sicher zu beherrschen und in realen Produktionsszenarien einzusetzen, reicht es nicht aus, lediglich einzelne Container zu starten oder grundlegende Befehle zu verwenden. Die nächsten Schritte umfassen das Verständnis fortgeschrittener Konzepte zur Bereitstellung, Verwaltung und Skalierung komplexer, hochverfügbarer Anwendungen.

Neben Docker Compose ist es essenziell, sich mit leistungsfähigeren Orchestrierungswerkzeugen wie Docker Swarm oder Kubernetes vertraut zu machen. Diese ermöglichen die zentrale Verwaltung, Skalierung und Überwachung mehrerer Container innerhalb eines Clusters.

Darüber hinaus sollten Sie Ihr Wissen zu Docker-Netzwerktreibern vertiefen, insbesondere zum Overlay-Netzwerktreiber, der im Docker-Swarm-Modus zur Verbindung mehrerer Hosts innerhalb eines Clusters eingesetzt wird. Während die Vernetzung mehrerer Maschinen über das Standardnetzwerk von Docker komplex und manuell ist, ermöglichen Overlay-Netzwerke eine skalierbare, zuverlässige und weitgehend automatisierte hostübergreifende Kommunikation.

Abschließend empfiehlt es sich, verschiedene Docker-Anwendungsfälle gezielt zu analysieren. Dadurch gewinnen Sie ein tieferes Verständnis dafür, wie sich Docker in unterschiedlichen Phasen der Entwicklung, des Deployments und des Betriebs effektiv einsetzen lässt.

Alle Tutorial-Inhalte auf dieser Website unterliegen Hostingers strengen redaktionellen Standards und Normen.