- Docker Compose ermöglicht es Ihnen, Multi-Container-Anwendungen mithilfe einer YAML-Datei zu definieren und zu orchestrieren, wodurch komplexe Bereitstellungen vereinfacht werden.
- Dienste, Netzwerke und Datenmengen werden deklarativ beschrieben, was die Datenpersistenz und eine sichere interne Kommunikation ermöglicht.
- Befehle wie oben, unten, ProtokolleDie Funktionen `exec` und `build` decken den gesamten Lebenszyklus von Projekten ab, die mit Compose verwaltet werden.
- Eine einzige docker-compose.yml-Datei ermöglicht die Reproduzierbarkeit der Bereitstellung sowohl lokal als auch auf Cloud-Servern oder VPS, die über die Konsole oder Portainer verwaltet werden.

Die Arbeit mit Containern ist für fast jedes Entwicklerteam mittlerweile Standard. Sobald eine Anwendung jedoch über einen einfachen Dienst hinausgeht und Datenbank, Cache, Frontend und weitere Microservices integriert, wird die manuelle Verwaltung schnell zur Qual. Hier kommt Docker Compose ins Spiel: Ein Tool, das genau dafür entwickelt wurde, dass Sie nicht jeden Container einzeln starten, Netzwerke manuell konfigurieren oder sich jeden einzelnen Befehl merken müssen.
Ziel dieses Artikels ist es, Ihnen zu zeigen, wie Sie mit Docker Compose vollständige Anwendungen lokal und auf Servern bereitstellen. Dazu lernen Sie die Funktion jedes einzelnen Teils der docker-compose.yml-Datei, die Funktionsweise von Diensten, Volumes und Netzwerken, die benötigten Befehle für Ihre tägliche Arbeit und wie all dies in einem realen Kontext mit einer Node.js-Anwendung und einer Datenbank funktioniert. Falls Sie aus der reinen Entwicklung (Frontend, Mobile, Backend) kommen und Ihnen Begriffe wie Orchestrierung oder Operationen zunächst fremd erscheinen, keine Sorge: Wir gehen Schritt für Schritt vor, ohne dabei auf Details zu verzichten.
Grundlegende Umgebungsanforderungen
Bevor wir mit der Bereitstellung beginnen, benötigen Sie ein minimal vorbereitetes Basissystem . Eine typische Umgebung, die häufig für Übungszwecke und kleinere Produktionsprojekte verwendet wird, könnte etwa so aussehen:
- Ubuntu 20.04 als Serverbetriebssystem oder lokaler Rechner.
- Docker 20.10.x installiert und funktionsfähig (Daemon aktiv).
- Docker Compose 1.29.x oder höher zur Verwaltung von Projekten mit mehreren Containern.
- Node.js 18.x. y NPM 8.x wenn Sie Images aus einer Node-Anwendung erstellen möchten.
Es ist nicht zwingend erforderlich, genau diese Versionen zu verwenden , jedoch wird eine ähnliche und relativ aktuelle Version empfohlen. Auf Cloud-Servern wie VPS ( Google Cloud, AWS, Arsys usw.) ist es üblich, eine Linux- VM einzurichten , Docker zu installieren und anschließend Docker Compose hinzuzufügen.
Was ist Docker und welches Problem löst Docker Compose?

Docker ist eine Plattform zum Verpacken und Ausführen von Anwendungen in isolierten Containern . Jeder Container enthält nur die zum Ausführen Ihres Prozesses benötigten Komponenten (Binärdateien, Bibliotheken, Laufzeitumgebung usw.). Er teilt sich den Kernel mit dem Hostsystem, ohne jedoch andere Dienste zu beeinträchtigen. Dadurch wird das klassische Dilemma „Es funktioniert auf meinem Rechner“ beseitigt und Sie können Ihre Anwendung nahtlos zwischen verschiedenen Rechnern verschieben.
Docker Compose hingegen ist das Tool, das mehrere Container so orchestriert, als wären sie eine einzige Anwendung . Bei einem einfachen Dienst reicht docker run aus, aber sobald Sie mehr benötigen:
- Un Frontend (Angular, React, Vue…)
- Un Backend (Node.js, Java, Python…)
- Eine Datenbank (MySQL, PostgreSQL, MongoDB…)
- Vielleicht ein Cache-System Redis-Typ
Die Verwaltung all dieser Container einzeln ist unpraktisch . Mit Compose können Sie den gesamten „Stack“ in einer einzigen YAML-Datei definieren und darin festlegen, welche Dienste existieren, wie sie sich verbinden, welche Ports sie freigeben, welche Volumes sie verwenden und welche Umgebungsvariablen sie benötigen.
Diese Datei heißt üblicherweise docker-compose.yml , kann aber auch anders benannt werden, wenn beim Ausführen der Befehle die Option `-f` angegeben wird. Sie funktioniert wie ein Rezept: Jeder, der Docker und Docker Compose verwendet, kann dieselbe Container-Infrastruktur auf seinem Rechner oder Server nachbilden.
Installation von Docker Compose auf verschiedenen Systemen

Die einzige Voraussetzung für die Installation von Docker Compose ist, dass Docker ausgeführt wird . Der weitere Ablauf variiert je nach Betriebssystem geringfügig:
Installation unter Linux (Beispiel Ubuntu)
Bei Distributionen wie Ubuntu können Sie Docker Compose installieren, indem Sie die offizielle Binärdatei herunterladen und ihr Ausführungsrechte erteilen. Ein typisches Vorgehen ist:
sudo curl -L "https://github.com/docker/compose/releases/download/1.29.2/docker-compose-$(uname -s)-$(uname -m)" \
-o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
Sobald dies erledigt ist, führen Sie docker-compose --version aus, um zu überprüfen, ob der Befehl verfügbar ist und mit der richtigen Version antwortet.
Installation auf macOS
Auf dem Mac ist die einfachste Methode in der Regel die Installation von Docker Desktop , da dieses bereits Docker Engine und Docker Compose enthält. Alternativ verwenden viele Entwickler Homebrew.
brew install docker-compose
Mit Docker Desktop müssen Sie sich normalerweise keine Gedanken mehr über die Kompositionen machen , da das Paket selbst dafür sorgt, dass es zusammen mit der Docker-Engine auf dem neuesten Stand bleibt.
Installation unter Windows
Unter Windows ist die praktischste Option die Verwendung von Docker Desktop für Windows . Laden Sie das Installationsprogramm von der offiziellen Docker-Website herunter, führen Sie es aus und folgen Sie den Anweisungen des Installationsassistenten. Dadurch werden Docker und Compose in PowerShell oder WSL2 eingerichtet.
Obwohl Docker nativ unter Windows verwendet werden kann , wird für anspruchsvollere Entwicklungsumgebungen in der Regel die Verwendung von WSL2 mit einer Linux-Distribution oder direkt einer Remote-Linux-VM empfohlen, da Docker und Compose dort produktionsnäher arbeiten.
Grundstruktur einer docker-compose.yml-Datei

In der docker-compose.yml-Datei lassen sich verschiedene Hauptblöcke definieren : Formatversion, Dienste, Volumes, Netzwerke und in manchen Fällen zusätzliche Konfigurationen. Dienste sind für die Bereitstellung einer typischen Anwendung unerlässlich, während Volumes und Netzwerke entscheidend sind, wenn Persistenz erforderlich ist.
Dienste: das Herzstück der App
Jeder Dienst in der Compose-Datei entspricht typischerweise einem Container (oder einer Gruppe von Containern), der einen Teil der Anwendung bereitstellt . Beispiele hierfür sind ein Webdienst, ein Datenbankdienst, ein Caching-Dienst usw. Die Definition jedes Dienstes unterstützt eine Reihe von Eigenschaften, darunter:
- Image: Docker-Image, das für den Container verwendet wird (z. B. nginx:latest, postgres:15, node:18…).
- Containername: Expliziter Containername (optional; falls nicht definiert, generiert Compose einen).
- bauen: Pfad zu dem Verzeichnis, in dem sich die Dockerfile befindet, um das Image zu erstellen, falls diese nicht existiert oder wir eine benutzerdefinierte Dockerfile wünschen.
- Befehl: Befehl, der beim Start des Containers ausgeführt wird (überschreibt den vorherigen Befehl) CMD (aus dem Bild).
- Häfen: Portzuordnung im Host:Container-Format, zum Beispiel "80:80" oder "3030:3030".
- Volumen: Volume-Mounts (benannte Volumes, Bind-Mounts usw.).
- Umwelt: Umgebungsvariablen, die in den Container injiziert werden.
- kommt drauf anDas Doppelpunkt-Zeichen (:) kennzeichnet Abhängigkeiten zwischen Diensten, sodass einige vor anderen gestartet werden.
- NetzwerkeDocker-Netzwerke, mit denen der Dienst Verbindungen herstellt.
- WiederaufnahmeNeustartrichtlinie (nein, immer, bei Fehler, außer wenn gestoppt).
Das Interessante daran ist, dass viele dieser Eigenschaften optional sind . Man könnte einen Dienst beispielsweise nur mit `image` definieren, und Compose könnte den Container bereits mit Standardwerten starten. Anschließend lassen sich Ports, Netzwerke, Variablen usw. bei Bedarf feinabstimmen.
Datenvolumen: Datenspeicherung und -weitergabe
Volumes in Docker sind der Standardmechanismus zum Speichern und Teilen von Daten zwischen Containern oder mit dem Host . In Compose werden sie typischerweise im Abschnitt „volumes“ auf der obersten Ebene deklariert und dann von Diensten referenziert.
Ein Volumen kann mehrere relevante Eigenschaften haben :
- Fahrer: Datenträgertreibertyp (Standard, lokal).
- Treiberoptionen: spezifische Treiberoptionen, in denen Sie Folgendes angeben können:
- tippe: Volumentyp ("Volume", "Bind", "NFS", usw.).
- Gerät: Pfad auf dem Host, den Sie einbinden möchten, im Falle einer Bind-Mount-Verbindung.
- o: Montageoptionen (rw, ro usw.).
- extern: wenn das Volume extern verwaltet wird (nicht von Compose erstellt wurde).
- Etiketten: beliebige Bezeichnungen.
- Name: Volumenname, falls Sie ihn anpassen möchten.
- kann: Volumenbereich (üblicherweise lokal).
Obwohl sich viele Details konfigurieren lassen, genügt es in vielen Fällen, den Volume-Namen anzugeben und ihn im Dienst zu verwenden. Beispielsweise ist es bei einer MySQL- oder PostgreSQL-Datenbank üblich, ein Datenvolume und gegebenenfalls eine Bind-Mount-Verbindung für Initialisierungsskripte zu haben.
Netzwerke: Kommunikation zwischen Containern
Bei Anwendungen mit mehreren Modulen ist es üblich, deren Datenverkehr in einem internen Netzwerk zu isolieren, sodass Frontend und Backend bzw. Backend und Datenbank nur einander sehen können und nicht unkontrolliert dem Host ausgesetzt sind.
Docker implementiert Netzwerke mit einem dreischichtigen, an ein klassisches Modell angelehnten Ansatz :
- Endpunkt: die virtuelle Schnittstelle, die den Container mit dem Netzwerk verbindet.
- Sandkasten: der isolierte Netzwerkbereich des Containers (sein eigener TCP/IP-Stack).
- Netzwerk: das Netzwerk, das die verschiedenen Sandboxes über die Endpunkte miteinander verbindet.
Zu den am häufigsten verwendeten Netzwerktreibern in Docker gehören :
| LED Treiber | Bereich | Beschreibung |
|---|---|---|
| Brücke | Local | Es handelt sich um das Standardnetzwerk auf vielen Docker-Hosts, das eine virtuelle Brücke auf dem Host erstellt und Container miteinander verbindet. |
| Gastgeber | Local | Netzwerkisolation deaktivieren: Der Container nutzt das Netzwerk des Hosts direkt. |
| Auflage | Globalen | Es ermöglicht Ihnen, Container, die auf verschiedenen Docker-Hosts laufen, innerhalb eines Swarms zu verbinden. |
| Macvlan | Globalen | Weisen Sie dem Container eine MAC-Adresse zu, als wäre er ein physisches Gerät im Netzwerk. |
| keine | Local | Ohne Docker-verwaltete Netzwerkverbindung, für ganz bestimmte Fälle. |
In Compose werden Netzwerke im Abschnitt „Netzwerke“ definiert , wo Sie den Treiber und die Optionen auswählen. Wenn Sie nichts definieren, wird standardmäßig ein Bridge-Netzwerk verwendet. Dienste verbinden sich mit diesen Netzwerken, indem sie einfach den Namen in ihrer Definition angeben.
Einfaches Beispiel: nginx und PostgreSQL mit Docker Compose

Um diese Konzepte zu veranschaulichen, stellen Sie sich vor, Sie möchten eine einfache Website mit Nginx und einer PostgreSQL-Datenbank einrichten . Ein minimalistisches Beispiel für eine docker-compose.yml-Datei könnte zwei Dienste, ein internes Netzwerk und einige Volumes enthalten:
version: '3.8'
services:
web:
image: nginx:latest
container_name: mi_nginx
ports:
- "80:80"
depends_on:
- db
networks:
- app_net
db:
image: postgres:latest
container_name: mi_postgres
environment:
POSTGRES_PASSWORD: ejemplo_password
volumes:
- datos_db:/var/lib/postgresql/data
networks:
- app_net
volumes:
datos_db:
networks:
app_net:
driver: bridge
Hier sehen wir zwei sehr wichtige Dinge : Erstens, dass Nginx Port 80 für den Host freigibt, während die Datenbank nur innerhalb des app_net-Netzwerks erreichbar ist, und zweitens, dass die PostgreSQL-Daten auf einem Volume namens datos_db gespeichert werden. Da die Webanwendung von der Datenbank abhängt, versucht Compose, diese zuerst zu starten.
Abhängigkeiten zwischen Diensten mit depends_on
In realen Anwendungen gibt es oft Beziehungen, bei denen „dieser Dienst ohne jenen sinnlos ist “. Zum Beispiel eine REST-API, die benötigt, dass die Datenbank läuft, um Verbindungen herzustellen, oder ein Frontend, das erst startet, wenn das Backend antwortet.
In Docker Compose können Sie diese Beziehungen mit dem Schlüssel `depends_on` ausdrücken , indem Sie die Dienste auflisten, von denen der aktuelle Dienst abhängt:
services:
api:
image: mi_usuario/mi_api:latest
depends_on:
- db
db:
image: postgres:15
Mit dieser Konfiguration startet Compose beim Ausführen von `docker-compose up` ohne Angabe von Diensten zuerst die Datenbank und anschließend die API. Beachten Sie jedoch, dass `depends_on` die Startreihenfolge steuert , aber nicht garantiert, dass der abhängige Dienst bereits bereit ist (z. B. dass die Datenbank Verbindungen annimmt). In kritischen Fällen werden üblicherweise Warteskripte oder Integritätsprüfungen verwendet.
Wichtige Docker Compose-Befehle
Sobald Ihre docker-compose.yml-Datei vorhanden ist , beschränkt sich die tägliche Verwendung von Compose auf einige wenige grundlegende Befehle. Wir gehen stets davon aus, dass Sie sich im Verzeichnis der Datei befinden oder die Option `-f` verwenden, um dies anzugeben.
Starten Sie die Anwendung: docker-compose up
Der Hauptbefehl zum Bereitstellen von Containern lautet `docker-compose up` . Wenn Sie ihn ohne weitere Parameter ausführen, versucht er, die benötigten Images zu erstellen (sofern diese einen `build`-Abschnitt enthalten) und alle definierten Dienste zu starten.
docker-compose up
Wenn die Container im Hintergrund laufen sollen , wie es auf Servern üblich ist, fügen Sie -d hinzu:
docker-compose up -d
Container stoppen: docker-compose down
Zum Stoppen und Löschen von Projektcontainern (jedoch nicht unbedingt Images oder Volumes) verwenden Sie:
docker-compose down
Sie können diesen Befehl mit zusätzlichen Optionen kombinieren, wenn Sie auch Volumes, benutzerdefinierte Netzwerke usw. löschen möchten. In den meisten Fällen reicht jedoch die Verwendung von `down` aus, um das Projekt ordnungsgemäß zu beenden.
Dienststatus anzeigen: docker-compose ps
Um zu überprüfen, welche Dienste aktiv sind, welchen Ports sie zugeordnet sind und welchen Status sie haben , verwenden Sie folgenden Befehl:
docker-compose ps
Dadurch wird Ihnen eine Tabelle mit den von diesem Compose verwalteten Containern angezeigt , einschließlich Spalten für Name, Image, Ports und aktuellen Status. Dies ist sehr nützlich, um zu überprüfen, ob alles wie erwartet funktioniert.
Abfrageprotokolle: docker-compose logs
Um zu sehen, was in Ihren Diensten vor sich geht, können Sie `docker-compose logs` verwenden . Sie können die Protokolle für alle Dienste oder für einen bestimmten Dienst anzeigen.
docker-compose logs
# Sólo los logs del servicio "api"
docker-compose logs api
Wenn Sie die Option -f hinzufügen , wird die Verfolgung in Echtzeit durchgeführt (ähnlich wie bei tail -f):
docker-compose logs -f api
Betreten eines Containers: docker-compose exec
Wenn Sie in einen Container „hinein“ müssen, um zu debuggen oder Befehle auszuführen , verwenden Sie `docker-compose exec`. Zum Beispiel, um eine Shell in einem Dienst namens `api` zu öffnen:
docker-compose exec api sh
In Containern, die auf Bash-Distributionen basieren, können Sie Bash anstelle von Sh verwenden, je nachdem, was je nach Basis-Image praktischer ist.
Images erstellen oder neu erstellen: docker-compose build und docker-compose pull
Wenn Sie Dockerfiles oder Teile des Build-Kontexts geändert haben , müssen Sie die zugehörigen Images neu erstellen:
docker-compose build
# O bien para un servicio concreto
docker-compose build api
Wenn Images von einer entfernten Registry (Docker Hub, private Registry usw.) stammen und Sie einfach die neueste in der YAML-Datei angegebene Version herunterladen möchten, verwenden Sie Folgendes:
docker-compose pull
Denken Sie daran, dass Sie jederzeit die "normalen" Docker-Befehle (docker ps, docker images, docker volume ls, docker network ls usw.) verwenden können. Um jedoch die Konsistenz des Projekts zu gewährleisten, ist es am besten, alles, was die in docker-compose.yml definierten Dienste betrifft, über Compose abzuwickeln.
Vollständiges Beispiel: Node.js + MySQL-Anwendung mit Docker und Docker Compose
Betrachten wir ein realistischeres Beispiel : eine REST-API in Node.js, die MySQL zur Speicherung von Informationen (z. B. Fahrzeugdaten) verwendet. Der typische Ablauf wäre:
- API entwickeln Konfiguration mithilfe von Umgebungsvariablen.
- Erstelle eine Dockerfile für die API.
- Erstellen Sie das Image und laden Sie es bei Bedarf auf Docker Hub hoch..
- Definiere eine docker-compose.yml-Datei. mit der API und der Datenbank.
- Mit docker-compose up können Sie alles zum Laufen bringen. und probiere die App aus.
1. Node.js-API für Umgebungsvariablen vorbereitet
Angenommen, Sie haben ein Node-Projekt mit Express, das Endpunkte zum Abfragen, Erstellen und Auflisten von Autos bereitstellt. Der entscheidende Punkt ist hier nicht der Code selbst, sondern die Konfiguration der Datenbankverbindung über Umgebungsvariablen wie DB_HOST, DB_USER, DB_PASSWORD, DB_NAME usw.
Dies ist grundlegend für die erfolgreiche Arbeit mit Docker : Man möchte keine Zugangsdaten oder URLs im Code festschreiben, sondern diese erst zum Zeitpunkt der Bereitstellung parametrisieren, egal ob lokal oder in der Cloud.
2. Dockerfile für die Webanwendung
Im Anwendungsverzeichnis erstellen Sie eine Dockerfile-Datei, die für die Erstellung des Images zuständig ist . Ein einfaches Beispiel könnte so aussehen:
FROM node:18-alpine
WORKDIR /usr/src/app
COPY package*.json ./
RUN npm install --only=production
COPY . .
EXPOSE 3000
CMD ["node", "index.js"]
Dieses Dockerfile verwendet ein offizielles Node-Image , installiert Abhängigkeiten, kopiert den Code, legt den Port der Anwendung fest (in diesem Fall 3000) und definiert den Startbefehl. Von hier aus können Sie das Image lokal erstellen:
docker build -t mi_usuario/mi-api-coches:latest .
Überprüfen Sie mit `docker images` , ob das Image existiert. Wenn alles korrekt funktioniert, können Sie die API sogar in einem separaten Container mit `docker run` ausführen. Richtig interessant wird es aber erst, wenn wir sie mit der Datenbank mithilfe von Compose orchestrieren.
3. Laden Sie das Bild in einen Datensatz hoch (optional, aber sehr nützlich).
Wenn Sie Ihre Anwendung auf einem anderen Rechner (z. B. einer Cloud-VM) bereitstellen möchten , ist es sehr praktisch, das Image in Docker Hub oder eine andere Registry hochzuladen. So geht's:
docker login
# te pedirá usuario y contraseña
docker push mi_usuario/mi-api-coches:latest
Wenn Sie eine explizite Versionierung wünschen , können Sie mehrere Versionen kennzeichnen:
docker tag mi_usuario/mi-api-coches:latest mi_usuario/mi-api-coches:v1
docker push mi_usuario/mi-api-coches:v1
Auf dem Server, auf dem Sie die Anwendung bereitstellen möchten , müssen Sie lediglich ein docker pull des Images durchführen und es in der docker-compose.yml verwenden, ohne es dort neu erstellen zu müssen.
4. Definieren Sie die docker-compose.yml-Datei mit API und MySQL.
Der nächste Schritt besteht darin , eine docker-compose.yml-Datei zu erstellen, die die API und die Datenbank kombiniert , außerdem ein Volume für die MySQL-Daten und gegebenenfalls ein Initialisierungsskript hinzuzufügen:
version: '3.8'
services:
web:
image: mi_usuario/mi-api-coches:latest
container_name: api_coches
ports:
- "3000:3000"
environment:
DB_HOST: db
DB_USER: coches_user
DB_PASSWORD: coches_pass
DB_NAME: coches_db
depends_on:
- db
networks:
- coches_net
db:
image: mysql:8
container_name: mysql_coches
environment:
MYSQL_ROOT_PASSWORD: root_pass
MYSQL_DATABASE: coches_db
MYSQL_USER: coches_user
MYSQL_PASSWORD: coches_pass
volumes:
- datos_mysql:/var/lib/mysql
- ./initdb:/docker-entrypoint-initdb.d
ports:
- "3306:3306"
networks:
- coches_net
volumes:
datos_mysql:
networks:
coches_net:
driver: bridge
Diese Konfiguration enthält mehrere interessante Details :
- Die API verweist mit DB_HOST=db auf die Datenbank.Der Name entspricht dem MySQL-Dienstnamen. Docker Compose stellt einen internen DNS-Server bereit, daher müssen Sie sich keine Gedanken über IP-Adressen machen; verwenden Sie einfach den Dienstnamen.
- Der Ordner ./initdb ist im MySQL-Container unter /docker-entrypoint-initdb.d eingebunden.Dies ermöglicht es Ihnen, .sql- oder .sh-Skripte einzubinden, die beim ersten Start automatisch ausgeführt werden (z. B. zum Erstellen von Tabellen, Einfügen von Beispieldaten usw.).
- Die MySQL-Daten werden im Volume data_mysql gespeichert.Wenn Sie also die Container mit docker-compose down löschen, bleiben die Datenbankinformationen erhalten.
- Beide Dienste nutzen das Netzwerk coches_net.Das Netzwerk fungiert als isoliertes internes Netzwerk. Nach außen werden nur die benötigten Ports freigegeben (3000 für die API, 3306, falls ein Zugriff auf die Datenbank von extern erforderlich ist, was manchmal gar nicht nötig ist).
5. Anwendung bereitstellen und testen
Sobald die docker-compose.yml-Datei fertig ist, ist die Bereitstellung so einfach wie das Starten der Anwendung aus dem Verzeichnis der Datei:
docker-compose up -d
Beim ersten Mal dauert es etwas länger, da die MySQL-Images (und die API, falls diese nicht lokal installiert ist) heruntergeladen, das Volume erstellt und die Initialisierungsskripte ausgeführt werden müssen. Anschließend kann der Status wie folgt überprüft werden:
docker-compose ps
Wenn alles „Aktiv“ ist, können Sie API-Anfragen mit curl oder Postman senden . Zum Beispiel:
# Listar todos los coches
curl http://localhost:3000/coches
# Obtener un coche concreto
curl http://localhost:3000/coches/1
# Crear un coche vía POST
curl -X POST http://localhost:3000/coches \
-H "Content-Type: application/json" \
-d '{"marca": "Seat", "modelo": "León"}'
Um die Bereitstellung zu beenden, führen Sie einfach `docker-compose down` aus . Wenn Sie das Volume nicht löschen, bleiben die Daten für den nächsten Neustart erhalten.
Docker Compose auf Cloud-Servern und Portainer bereitstellen
Alles, was wir bisher gesehen haben, gilt gleichermaßen für die Bereitstellung auf dem eigenen Laptop wie auf einem Cloud-Server . Der Unterschied besteht im Wesentlichen darin, wo Sie die `docker-compose up`-Befehle ausführen und wie Sie die Ports nach außen öffnen.
Ein sehr einfacher Ansatz für persönliche Projekte oder Nebenprojekte ist die Erstellung einer kleinen VM (zum Beispiel einer kostenlosen e2-micro auf Google Cloud), die Installation von Docker und Docker Compose, das Klonen Ihres Repositorys mit dem Code und der docker-compose.yml und das Starten der Anwendung dort.
Sie müssen lediglich die Firewall-Richtlinien Ihres Anbieters beachten : Wenn Ihre Anwendung auf Port 3000 lauscht, müssen Sie diesen Port in den Netzwerkeinstellungen Ihres Anbieters öffnen (oder einen Reverse-Proxy auf den Ports 80/443 verwenden, um mit HTTPS zusätzliche Sicherheit zu gewährleisten). Sobald der Port geöffnet ist, können Sie über http://SERVER_IP:3000 von jedem Browser aus darauf zugreifen.
Falls Ihnen die Containerverwaltung über die Kommandozeile zu umständlich erscheint, können Sie Portainer verwenden . Dieses Tool läuft ebenfalls in einem Container und bietet eine Weboberfläche zur Verwaltung von Docker (und Docker Compose). Um Portainer auf einem Server einzurichten, gehen Sie beispielsweise wie folgt vor:
docker volume create portainer_data
docker run -d \
-p 8000:8000 -p 9000:9000 \
--name=portainer \
--restart=always \
-v /var/run/docker.sock:/var/run/docker.sock \
-v portainer_data:/data \
portainer/portainer
Dann würden Sie über http://SERVER_IP:9000 auf Portainer zugreifen , einen Administratorbenutzer erstellen und von dort aus könnten Sie Container, Compose-Stacks, Netzwerke, Volumes usw. alles über den Browser einsehen.
Mit Docker Compose lässt sich die gesamte Architektur einer Anwendung in einer einzigen Datei kapseln . So kann jeder Entwickler, egal ob vom Laptop oder einer Remote-VM, denselben Stack mit einem einzigen Befehl starten. Durch die Anwendung bewährter Methoden wie Umgebungsvariablen, interne Netzwerke, persistente Volumes und gegebenenfalls Tools wie Portainer schaffen Sie eine solide Grundlage für die Bereitstellung von kleinen persönlichen Projekten bis hin zu komplexen Umgebungen – ohne dabei den Überblick zu verlieren.
Index
- 1 Grundlegende Umgebungsanforderungen
- 2 Was ist Docker und welches Problem löst Docker Compose?
- 3 Installation von Docker Compose auf verschiedenen Systemen
- 4 Grundstruktur einer docker-compose.yml-Datei
- 5 Einfaches Beispiel: nginx und PostgreSQL mit Docker Compose
- 6 Abhängigkeiten zwischen Diensten mit depends_on
- 7 Wichtige Docker Compose-Befehle
- 7.1 Starten Sie die Anwendung: docker-compose up
- 7.2 Container stoppen: docker-compose down
- 7.3 Dienststatus anzeigen: docker-compose ps
- 7.4 Abfrageprotokolle: docker-compose logs
- 7.5 Betreten eines Containers: docker-compose exec
- 7.6 Images erstellen oder neu erstellen: docker-compose build und docker-compose pull
- 8 Vollständiges Beispiel: Node.js + MySQL-Anwendung mit Docker und Docker Compose
- 9 Docker Compose auf Cloud-Servern und Portainer bereitstellen