Anmelden
Anmelden

Docker Compose installieren auf Ubuntu: vollständige Anleitung

Docker Compose installieren auf Ubuntu: vollständige Anleitung
Emmanuel Oyibo
Technical writer
Docker-Plattform Ubuntu-System
14.01.2026
Reading time: 6 min

Docker Compose hat grundlegend verändert, wie Entwickler containerisierte Anwendungen erstellen und betreiben, insbesondere wenn mehrere voneinander abhängige Services koordiniert werden müssen. Dieses Tool ersetzt die manuelle Verwaltung einzelner Container durch einen strukturierten, YAML-basierten Workflow und ermöglicht es Teams, komplette Anwendungsarchitekturen in einer einzigen Konfigurationsdatei zu definieren.

Für Ubuntu-Umgebungen bedeutet dies reproduzierbare Deployments, vereinfachtes Skalieren und geringeren Betriebsaufwand. Diese Anleitung bietet eine neue Perspektive auf die Installation und Nutzung von Docker Compose und liefert tiefere Einblicke in die praktische Umsetzung.

Voraussetzungen

Bevor du mit diesem Tutorial beginnst, stelle sicher, dass Folgendes erfüllt ist:

  • Stelle eine Ubuntu-Cloud-Server-Instanz bei Hostman bereit.

  • Verfüge über ein Benutzerkonto mit sudo-Rechten oder Root-Zugriff, um Pakete zu installieren und Docker zu verwalten.

  • Docker muss installiert sein und auf dem Server laufen, da Docker Compose auf der Docker Engine aufsetzt.

Warum Docker Compose wichtig ist

Moderne Anwendungen bestehen häufig aus miteinander verbundenen Komponenten wie APIs, Datenbanken und Caching-Schichten. Diese Elemente einzeln mit Docker-Befehlen zu verwalten, wird mit zunehmender Komplexität schnell unübersichtlich. Docker Compose löst dieses Problem, indem alle Services, Netzwerke und Speicheranforderungen in einer docker-compose.yml-Datei definiert werden können. Dieser Ansatz sorgt für Konsistenz über alle Umgebungen hinweg – egal ob lokal auf einer Ubuntu-Maschine oder auf einem Cloud-Server.

Ein Beispiel: Eine Webanwendung besteht aus einem Node.js-Backend, einer PostgreSQL-Datenbank und einem Redis-Cache. Ohne Docker Compose müsste jede Komponente mit separaten docker run-Befehlen und präzisen Netzwerkparametern gestartet werden. Mit Compose werden diese Abhängigkeiten einmal definiert und können anschließend mit einem einzigen Befehl gestartet oder beendet werden.

Installation von Docker Compose

Folge diesen Schritten, um Docker Compose auf deinem Ubuntu-System zu installieren.

Schritt 1: Überprüfen, ob Docker installiert und aktiv ist

Docker Compose ist eine Erweiterung von Docker. Überprüfe daher zuerst den Status des Docker-Dienstes:

sudo systemctl status docker

Wenn der Dienst nicht aktiv ist, starte ihn mit:

sudo systemctl start docker

Schritt 2: Systempakete aktualisieren

Aktualisiere die Paketlisten, um Zugriff auf aktuelle Softwareversionen zu haben:

sudo apt-get update

Schritt 3: Grundlegende Hilfsprogramme installieren

Für eine sichere Kommunikation mit den Docker-Repositories werden folgende Pakete benötigt:

sudo apt-get install ca-certificates curl

Schritt 4: Docker-GPG-Schlüssel konfigurieren

Authentifiziere Docker-Pakete, indem du den kryptografischen Schlüssel hinzufügst:

sudo install -m 0755 -d /etc/apt/keyrings

sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc

sudo chmod a+r /etc/apt/keyrings/docker.asc

Dieser Schritt stellt sicher, dass die Pakete während der Übertragung nicht manipuliert wurden.

Schritt 5: Docker-Repository hinzufügen

Füge das Docker-Repository passend zu deiner Ubuntu-Version hinzu:

echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Der Befehl erkennt die Ubuntu-Version automatisch über VERSION_CODENAME.

Schritt 6: Docker-Compose-Plugin installieren

Aktualisiere die Paketlisten und installiere das Compose-Plugin:

sudo apt update

sudo apt-get install docker-compose-plugin

Schritt 7: Installation überprüfen

Überprüfe die erfolgreiche Installation mit:

docker compose version

Beispielausgabe:

Docker Compose version v2.33.0

Ein praktisches Docker-Compose-Projekt erstellen

Zur Demonstration der Docker-Compose-Funktionen stellen wir einen Webserver mit Nginx bereit.

1. Projektverzeichnis initialisieren

Erstelle ein Arbeitsverzeichnis:

mkdir ~/compose-demo && cd ~/compose-demo

2. Services in docker-compose.yml definieren

Erstelle die Konfigurationsdatei:

nano docker-compose.yml

Füge folgenden Inhalt ein:

services:

  web:

    image: nginx:alpine

    ports:

      - "8080:80"

    volumes:

      - ./app:/usr/share/nginx/html

Erklärung:

  • services: Wurzelelement zur Definition der Container

  • web: Benutzerdefinierter Servicename

  • image: Alpine-basiertes Nginx-Image mit geringem Ressourcenverbrauch

  • ports: Zuordnung von Port 8080 (Host) zu Port 80 (Container)

  • volumes: Synchronisiert das lokale app-Verzeichnis mit dem Web-Root des Containers

3. Webinhalt erstellen

Lege die HTML-Struktur an:

mkdir app

nano app/index.html

Füge den folgenden HTML-Code ein:

<!DOCTYPE html>

<html lang="en">

<head>

  <meta charset="UTF-8">

  <title>Docker Compose Test</title>

</head>

<body>

  <h1>Hello from Docker Compose!</h1>

</body>

</html>

Container orchestrieren: Start bis Shutdown

1. Services im Hintergrund starten

docker compose up -d

Docker Compose lädt das Nginx-Image automatisch herunter und konfiguriert das Netzwerk.

2. Container-Status überprüfen

docker compose ps -a

3. Webanwendung aufrufen

Rufe lokal http://localhost:8080 oder auf einem Remote-Server http://<SERVER_IP>:8080 auf. Die Testseite sollte angezeigt werden.

4. Fehlerdiagnose über Logs

Bei Problemen kannst du die Container-Logs prüfen:

docker compose logs web

5. Sauberes Stoppen und Aufräumen

Container stoppen:

docker compose stop

Alle Projektressourcen entfernen:

docker compose down

Befehlsübersicht: Über die Grundlagen hinaus

Diese Befehle erweitern das Container-Management:

  • docker compose up --build – Images vor dem Start neu erstellen

  • docker compose pause – Container anhalten, ohne sie zu beenden

  • docker compose top – Laufende Prozesse in Containern anzeigen

  • docker compose config – Konfiguration prüfen und anzeigen

  • docker compose exec – Befehle in laufenden Containern ausführen
    (z. B. docker compose exec web nginx -t zum Testen der Nginx-Konfiguration)

Fazit

Docker Compose verwandelt die Orchestrierung mehrerer Container von einer manuellen, fehleranfälligen Aufgabe in einen strukturierten und wiederholbaren Prozess. Durch die Installation von Docker Compose, das Definieren von Services in YAML und die Nutzung zentraler Befehle kannst du selbst komplexe Anwendungen zuverlässig verwalten.

Docker-Plattform Ubuntu-System
14.01.2026
Reading time: 6 min

Ähnlich

Docker-Plattform

Nextcloud mit Docker installieren

Für alle, die vollständige Kontrolle über ihre Daten behalten möchten, bietet Nextcloud eine leistungsstarke Open-Source-Lösung für den Aufbau eines privaten Cloud-Speichersystems. Die Plattform ermöglicht nicht nur eine sichere Dateisynchronisierung über verschiedene Geräte hinweg, sondern auch das Hosten des Speichers auf einem eigenen Server, ohne auf Drittanbieter angewiesen zu sein. In dieser Anleitung führen wir dich durch die Installation von Nextcloud mithilfe isolierter Docker-Container, was die Bereitstellung und Verwaltung erheblich vereinfacht. Außerdem richten wir eine automatische Verschlüsselung des Datenverkehrs mit SSL-Zertifikaten von Let’s Encrypt ein, um eine sichere Übertragung zu gewährleisten. Voraussetzungen Du benötigst: Einen Hostman-Cloud-Server mit vorinstalliertem Linux Ubuntu 24.04. Einen Domainnamen. Installiertes Docker und Docker Compose. Für den Server empfiehlt sich eine Konfiguration mit 1 CPU-Kern, 2 GB RAM und einer öffentlichen IPv4-Adresse, die du bei der Erstellung oder später im Bereich „Network“ anfordern kannst. Der Server wird innerhalb weniger Minuten bereitgestellt. Die IPv4-Adresse sowie Login-Daten für den SSH-Zugang findest du im Dashboard. Nextcloud installieren und ausführen Nextcloud benötigt mehrere wichtige Komponenten: Datenbank: in diesem Fall MariaDB, ein performantes und zuverlässiges Datenbanksystem. SSL-Zertifikat: wir verwenden kostenlose SSL-Zertifikate der Non-Profit-Zertifizierungsstelle Let’s Encrypt. Reverse Proxy: wir setzen Nginx Proxy Manager ein, der eingehende HTTP- und HTTPS-Anfragen an die entsprechenden Container weiterleitet und verwaltet. Schritt 1: Konfigurationsverzeichnis erstellen Zuerst erstellen wir ein Verzeichnis für die Konfigurationsdateien und wechseln hinein: mkdir nextcloud && cd nextcloud Schritt 2: Eine .env-Datei anlegen Diese versteckte Datei speichert Variablen mit Passwörtern: nano .env Inhalt der Datei: NEXTCLOUD_ROOT_PASSWORD=secure_root_password_123 NEXTCLOUD_DB_PASSWORD=secure_nextcloud_db_password_456 NPM_ROOT_PASSWORD=secure_npm_root_password_789 NPM_DB_PASSWORD=secure_npm_db_password_012 Vergiss nicht, die Werte durch deine eigenen Passwörter zu ersetzen. Schritt 3: Die docker-compose.yml-Datei erstellen Öffne sie mit: nano docker-compose.yml Füge folgende Konfiguration ein: (Codeblöcke nicht übersetzt gemäß deinem) volumes:   nextcloud-data:   nextcloud-db:   npm-data:   npm-ssl:   npm-db:   networks:   frontend:   backend:   services:   nextcloud-app:     image: nextcloud:31.0.8     restart: always     volumes:       - nextcloud-data:/var/www/html     environment:       - MYSQL_PASSWORD=${NEXTCLOUD_DB_PASSWORD}       - MYSQL_DATABASE=nextcloud       - MYSQL_USER=nextcloud       - MYSQL_HOST=nextcloud-db       - MYSQL_PORT=3306     networks:       - frontend       - backend     nextcloud-db:     image: mariadb:12.0.2     restart: always     command: --transaction-isolation=READ-COMMITTED --binlog-format=ROW     volumes:       - nextcloud-db:/var/lib/mysql     environment:       - MYSQL_ROOT_PASSWORD=${NEXTCLOUD_ROOT_PASSWORD}       - MYSQL_PASSWORD=${NEXTCLOUD_DB_PASSWORD}       - MYSQL_DATABASE=nextcloud       - MYSQL_USER=nextcloud     networks:       - backend     npm-app:     image: jc21/nginx-proxy-manager:2.12.6     restart: always     ports:       - "80:80"       - "81:81"       - "443:443"     environment:       - DB_MYSQL_HOST=npm-db       - DB_MYSQL_PORT=3306       - DB_MYSQL_USER=npm       - DB_MYSQL_PASSWORD=${NPM_DB_PASSWORD}       - DB_MYSQL_NAME=npm     volumes:       - npm-data:/data       - npm-ssl:/etc/letsencrypt     networks:       - frontend       - backend     npm-db:     image: jc21/mariadb-aria:10.11.5     restart: always     environment:       - MYSQL_ROOT_PASSWORD=${NPM_ROOT_PASSWORD}       - MYSQL_DATABASE=npm       - MYSQL_USER=npm       - MYSQL_PASSWORD=${NPM_DB_PASSWORD}     volumes:       - npm-db:/var/lib/mysql     networks:       - backend Schritt 4: Container starten Starte die Container: docker compose up -d Bei docker compose up -d kann ein Fehler aufgrund der Pull-Limits von Docker Hub auftreten. In diesem Fall: Melde dich bei deinem Docker-Hub-Konto an oder erstelle ein neues Konto. Gehe zu Account settings → Personal access tokens. Klicke auf Generate new token. Füge eine Beschreibung hinzu, wähle ein Ablaufdatum und erteile Berechtigungen: Read, Write, Delete. Klicke Generate. Kopiere den Token (er wird nur einmal angezeigt). Logge dich auf dem Server ein mit: docker login -u dockeruser Ersetze dockeruser durch deinen Benutzernamen und gib den Token als Passwort ein. Starte danach die Container erneut: docker compose up -d Prüfe den Status: docker ps Alle Container sollten den Status Up haben. Schritt 5: HTTPS mit Let’s Encrypt konfigurieren Öffne im Browser: http://<server-IP>:81 Melde dich mit den Standardzugangsdaten an: Login: admin@example.com Passwort: changeme Beim ersten Login: Vollständigen Namen, Spitznamen und E-Mail aktualisieren. Passwort ändern. Schritt 6: Proxy Host hinzufügen Gehe zu Hosts → Proxy Hosts. Klicke Add Proxy Host und fülle aus: Domain Names: deine Domain für Nextcloud Scheme: http Forward Hostname/IP: nextcloud-app Forward Port: 80 Im Tab SSL: Wähle Request a new SSL Certificate Aktiviere: Force SSL HTTP/2 Support HSTS Enabled Gib deine E-Mail für Let’s Encrypt an und akzeptiere die Bedingungen. Speichern. Schritt 7: In Nextcloud einloggen Öffne nun deine Domain. Wenn alles korrekt eingerichtet ist, erscheint die Nextcloud-Weboberfläche und das SSL-Zertifikat wird automatisch von Let’s Encrypt ausgestellt. Erstelle ein neues Administratorkonto. Installiere optional empfohlene Apps oder überspringe diesen Schritt. Damit ist die Installation und Basiskonfiguration abgeschlossen. Fazit In diesem Artikel haben wir gezeigt, wie man Nextcloud mit Docker bereitstellt und ein kostenloses Let’s-Encrypt-Zertifikat einrichtet. Diese Methode gehört zu den zuverlässigsten, sichersten und am einfachsten skalierbaren Ansätzen. Docker sorgt für saubere Isolation, erleichtert Updates und macht Migrationen unkompliziert. Ein SSL-Zertifikat ist unerlässlich zum Schutz sensibler Daten und zur Gewährleistung verschlüsselten Datenverkehrs.
25 November 2025 · 7 min to read
Docker-Plattform

Bitwarden in Docker installieren

Bitwarden ist ein kostenloser, quelloffener Passwortmanager, der vertrauliche Informationen in einem verschlüsselten Tresor speichert. Er ist in C# geschrieben und nutzt .NET Core sowie ASP.NET Core. Die zugrunde liegende Datenbank basiert auf T-SQL/SQL Server. Bitwarden ist ein Cloud-Dienst, der über verschiedene Client-Anwendungen zugänglich ist und daher plattformübergreifend funktioniert: über das Web, Desktop-Apps (Windows, macOS, Linux), mobile Anwendungen, Browser-Erweiterungen (Chrome, Firefox, Safari, Edge, Opera, Vivaldi, Brave, Tor) oder über die Befehlszeile. Ein wesentlicher Grund für die Nutzung von Bitwarden besteht darin, keine Drittanbieter-Passwortmanager zu verwenden, bei denen vertrauliche Daten auf externen Servern gespeichert werden. Stattdessen kann Bitwarden auf einem eigenen, sicheren Server betrieben werden. Bitwarden besteht aus einer Gruppe von Containern, von denen jeder eine separate Funktion des Managers enthält — beispielsweise die Datenbank oder den Webserver. Daher ist für die Installation und den Betrieb von Bitwarden ein Containerisierungssystem erforderlich — und dieses ist Docker. Hauptfunktionen von Bitwarden Open Source 256-Bit-AES-Verschlüsselung zum Schutz von Benutzerdaten Unterstützung für Zwei-Faktor-Authentifizierung Passwort-Auditierung und -Verifizierung Unterstützung biometrischer Authentifizierung Möglichkeit, den Server lokal zu hosten Cross-Platform-Clients für alle gängigen Systeme Voraussetzungen Diese Anleitung verwendet Befehle für UNIX-ähnliche Systeme, insbesondere Debian/Ubuntu, die häufig für Serverbereitstellungen eingesetzt werden. Bevor Sie Bitwarden installieren und konfigurieren, stellen Sie sicher, dass alle erforderlichen Systempakete installiert und aktuell sind: sudo apt update sudo apt upgrade Wenn Ihr Server neu ist, empfiehlt es sich, einige grundlegende Tools zu installieren: sudo apt-get install apt-transport-https ca-certificates curl gnupg-agent software-properties-common Als Nächstes stellen Sie sicher, dass Docker und Docker Compose installiert sind, um die Bitwarden-Container zu verwalten. Schritt 1: Docker und seine Komponenten installieren Zuerst fügen Sie den GPG-Schlüssel von Docker hinzu, der zum Signieren von Paketen verwendet wird: curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add - Dann fügen Sie das Docker-Repository hinzu, um die neueste Version zu beziehen: sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" Aktualisieren Sie das System erneut: sudo apt update Schließlich installieren Sie Docker und Docker Compose: sudo apt install docker-ce docker-ce-cli containerd.io docker-compose Schritt 2: Bitwarden-Setup absichern Zur Erhöhung der Sicherheit erstellen Sie einen dedizierten Benutzer mit eingeschränkten Berechtigungen. Erstellen Sie ein Verzeichnis für Bitwarden: sudo mkdir /opt/bitwarden Erstellen Sie den Benutzer: sudo adduser bitwarden Weisen Sie dem Benutzer Besitzrechte zu: sudo chmod -R 700 /opt/bitwarden sudo chown -R bitwarden:bitwarden /opt/bitwarden Erlauben Sie dem Benutzer, Docker-Befehle auszuführen: sudo usermod -aG docker bitwarden Wechseln Sie danach zum Bitwarden-Benutzer: su bitwarden cd /opt/bitwarden Schritt 3: Bitwarden in Docker installieren und starten Selbst wenn Sie Docker nicht gut kennen, stellen die Entwickler von Bitwarden ein Installationsskript bereit, das den Prozess automatisiert.Laden Sie es herunter und machen Sie es ausführbar: curl -Lso bitwarden.sh https://go.btwrdn.co/bw-sh && chmod 700 bitwarden.sh Starten Sie anschließend das Skript: ./bitwarden.sh install Das Skript fragt Sie nach mehreren Konfigurationsparametern, darunter: Domainname für Bitwarden Datenbankname Ob Let’s Encrypt für ein kostenloses SSL-Zertifikat verwendet werden soll Sie benötigen außerdem eine Installations-ID und einen Schlüssel, die Sie auf der offiziellen Bitwarden-Seite generieren können. Schritt 4: SMTP-Mailserver konfigurieren Die Einrichtung eines SMTP-Servers ist optional, wird aber empfohlen, um Administrator-Anmeldungen und Benachrichtigungen zu ermöglichen. Bearbeiten Sie die Datei ./bwdata/env/global.override.env und fügen Sie die SMTP-Parameter hinzu, z. B.: globalSettings__mail__smtp__host=smtp.gmail.com globalSettings__mail__smtp__port=587 globalSettings__mail__smtp__ssl=true globalSettings__mail__smtp__username=your_email@gmail.com globalSettings__mail__smtp__password=your_password adminSettings__admins=your_email@gmail.com Wenn Sie mit Docker vertraut sind, können Sie auch einen eigenen Mailserver verwenden, z. B. docker-mailserver, der gut mit Bitwarden funktioniert. Alternativ können Sie öffentliche Mailserver wie Gmail verwenden (weniger sicher, aber einfacher). In diesem Fall: globalSettings__mail__replyToEmail=your_email@gmail.com globalSettings__mail__smtp__host=smtp.gmail.com globalSettings__mail__smtp__username=your_email globalSettings__mail__smtp__password=your_password globalSettings__mail__smtp__ssl=true globalSettings__mail__smtp__port=587 globalSettings__mail__smtp__useDefaultCredentials=false globalSettings__disableUserRegistration=true Bitwarden sendet dann Benachrichtigungen über Gmail. Achten Sie darauf, in Ihrem Gmail-Konto den Zugriff für weniger sichere Apps zu aktivieren, sonst blockiert Google den Zugriff. Wenn Sie einen anderen E-Mail-Dienst verwenden, tragen Sie dessen SMTP-Daten entsprechend in global.override.env ein. Bei Problemen können Sie ein Online-SMTP-Testtool nutzen, um die Konfiguration zu prüfen. Schritt 5: Server starten und Funktion prüfen Starten Sie den Server mit demselben Skript: ./bitwarden.sh start Öffnen Sie im Browser die IP-Adresse oder Domain Ihres Servers. Für den Adminbereich hängen Sie /admin an die URL an. Die Seite fordert Sie auf, die E-Mail-Adresse anzugeben, die in der global.override.env-Datei konfiguriert ist. Der Mailserver sendet einen Link, über den Sie sich ohne Passwort im Adminbereich anmelden können. Ab diesem Punkt können Sie jeden Bitwarden-Client verwenden — z. B. die Desktop-App, um sich mit Ihrem Server zu verbinden und Passwörter sicher zu speichern. Server stoppen und entfernen Falls es zu Problemen kommt oder Sie eine Neuinstallation durchführen möchten, stoppen Sie Bitwarden vollständig: ./bitwarden.sh stop Löschen Sie das Datenverzeichnis: rm -r ~/bwdata Und installieren Sie Bitwarden bei Bedarf erneut: ./bitwarden.sh install Fazit Die Installation von Bitwarden ist unkompliziert, da die Entwickler den größten Teil des Prozesses automatisiert haben. Nach der Einrichtung können Sie Ihre sensiblen Daten sicher verwalten und dabei DNS, SSL und SMTP verwenden. Weitere nützliche Hinweise zur praktischen Nutzung finden Sie in der offiziellen Bitwarden-Dokumentation.
07 November 2025 · 6 min to read
Docker-Plattform

Externe Docker-Registrys konfigurieren

Externe Docker-Registrys konfigurieren Bei der Arbeit mit Docker werden sogenannte Images verwendet – ausführbare Dateien, die alles enthalten, was zum Ausführen einer Anwendung erforderlich ist, einschließlich Quellcode, Bibliotheken und Abhängigkeiten. Diese Images werden in speziellen Repositories gespeichert, den sogenannten Registrys, die entweder privat oder öffentlich sein können. Die bekannteste öffentliche Registry ist Docker Hub, wo viele offizielle Images wie Nginx, PostgreSQL, Alpine, Ubuntu, Node und MongoDB zu finden sind. Benutzer können sich bei Docker Hub registrieren und dort eigene Images speichern – standardmäßig mit einem öffentlichen und drei privaten Repositories. Docker Hub ist die Standard-Registry, die Docker zum Herunterladen (Pull) von Images verwendet. Dieser Leitfaden zeigt, wie man die Standard-Registry in Docker auf eine andere umstellt. Verwendung externer Docker-Registrys Eine einfache Möglichkeit, externe Registrys zu nutzen, besteht darin, Drittanbieter-Registrys zu verwenden, die von Unternehmen wie Google oder Amazon bereitgestellt werden. Hier eine Liste öffentlicher Registrys, die verwendet werden können: Registry-URL Anbieter https://mirror.gcr.io Google https://public.ecr.aws Amazon https://quay.io Red Hat https://registry.access.redhat.com Red Hat https://registry.redhat.io Red Hat ⚠️ Hinweis: Die Nutzung externer Docker-Registrys kann Sicherheitsrisiken bergen – gehe daher vorsichtig vor. Im Folgenden wird beschrieben, wie du die Standard-Registry (Docker Hub) auf eine andere umstellst. Linux-Konfiguration Öffne die Datei daemon.json mit einem beliebigen Texteditor. Wenn Docker nicht im Rootless-Modus installiert wurde, befindet sich die Datei unter: /etc/docker/daemon.json Falls sie nicht existiert, wird sie mit diesem Befehl erstellt: nano /etc/docker/daemon.json Für Rootless Docker liegt die Datei im Benutzerverzeichnis unter: ~/.config/docker/daemon.json Erstelle sie ggf. mit: nano ~/.config/docker/daemon.json Füge den folgenden Parameter hinzu, um eine neue Standard-Registry festzulegen (im Beispiel: Google Mirror Registry): {   "registry-mirrors": ["https://mirror.gcr.io"] } Speichere und schließe die Datei. Starte anschließend den Docker-Dienst neu, um die Änderungen zu übernehmen: systemctl reload docker Nun verwendet Docker beim Herunterladen von Images die neue Registry. Beispiel: Ziehe das Alpine-Image aus der Google-Registry: docker pull mirror.gcr.io/alpine Du kannst auch eine bestimmte Version angeben, z. B.: docker pull mirror.gcr.io/nginx:1.25.2 Windows-Konfiguration (Docker Desktop) Öffne die Datei daemon.json, die sich hier befindet: C:\Users\<dein_benutzername>\.docker\daemon.json Füge den Registry-Mirror-Parameter hinzu: {   "registry-mirrors": ["https://mirror.gcr.io"] } Speichere die Datei und starte Docker neu. Klicke dazu mit der rechten Maustaste auf das Docker-Symbol in der Taskleiste und wähle "Restart". Alternativ kannst du die Einstellung direkt über die Docker Desktop-Oberfläche vornehmen - Navigiere zu Settings → Docker Engine und füge Folgendes hinzu: {   "registry-mirrors": ["https://mirror.gcr.io"] }   Klicke anschließend auf Apply & Restart, um die Änderungen zu übernehmen. Nach dem Neustart wird Docker die neue Registry für Image-Pulls verwenden.Beispiel: Lade ein curl-Image herunter: docker pull mirror.gcr.io/curlimages/curl Oder ziehe eine bestimmte Version: docker pull mirror.gcr.io/node:21-alpine Verwendung von Nexus als Docker-Registry Alternativ kannst du Nexus verwenden, um Docker-Images zu verwalten. Nexus unterstützt sogenannte Proxy-Repositories, die Images aus externen Registrys wie Docker Hub zwischenspeichern (cachen). So kann Nexus als Caching-Proxy fungieren, falls externe Registrys vorübergehend nicht erreichbar sind. Einrichten eines Proxy-Repositories in Nexus Melde dich in Nexus mit einem Administrator oder einem Benutzer mit Repository-Verwaltungsrechten an. Gehe zu Server Administration and Configuration → Repositories. Klicke auf Create repository und wähle den Typ docker (proxy). Fülle die erforderlichen Felder aus: Name: Vergib einen eindeutigen Namen für das Repository. Online: Aktivieren, damit das Repository Anfragen annehmen kann. Proxy-Server: Wenn Nexus hinter einem Proxy (z. B. Nginx) läuft, sind keine Ports für Authentifizierung erforderlich.Ohne Proxy sollte ein eindeutiger Port für HTTP oder HTTPS zugewiesen werden. Allow anonymous docker pull: Aktivieren, um Images ohne Anmeldung zu ziehen.Falls deaktiviert, ist ein Login erforderlich. Remote storage: Gib die URL der externen Registry an (z. B. https://registry-1.docker.io für Docker Hub). Nach dem Erstellen des Repositories kannst du dich – falls erforderlich – bei Nexus anmelden: docker login <nexus_registry_address> Ein Image wird dann wie folgt heruntergeladen: docker pull <nexus_registry_address>/image_name:tag Beispiel: Ziehe ein Python-Image mit Tag 3.8.19-alpine: docker pull nexus-repo.com/python:3.8.19-alpine ⚠️ Sicherheits-Tipp: Verwende nicht den Tag latest, da er potenziell instabile oder unsichere Versionen enthalten kann. Fazit Dieser Artikel hat verschiedene Methoden gezeigt, um Docker-Images herunterzuladen und zu speichern. Externe Registrys können nützlich sein, wenn die Standard-Registry (Docker Hub) nicht verfügbar ist. Wenn du externen Anbietern nicht vertraust, kannst du jederzeit deine eigene private oder öffentliche Docker-Registry einrichten – etwa über Nexus oder Harbor.
05 November 2025 · 5 min to read

Haben Sie Fragen,
Anmerkungen oder Bedenken?

Unsere Fachleute stehen Ihnen jederzeit zur Verfügung,
egal ob Sie Hilfe benötigen oder nicht wissen, wo Sie anfangen sollen.
E-Mail an uns
Hostman's Support