Vollständiger Leitfaden zum Bereitstellen von Anwendungen mit Docker Compose

Die Arbeit mit Containern ist zu einem alltäglichen Ereignis geworden. Für nahezu jedes Entwicklungsteam wird die manuelle Verwaltung einer Anwendung, die über einen einfachen Dienst hinausgeht und Datenbank, Cache, Frontend und weitere Microservices umfasst, schnell zu einer echten Herausforderung. Hier kommt Docker Compose ins Spiel: Ein Tool, das genau dafür entwickelt wurde, dass Sie Container nicht einzeln starten, Netzwerke nicht manuell konfigurieren und sich nicht jeden einzelnen, oft langen Befehl merken müssen.

Ziel dieses Artikels ist es, Ihnen zu zeigen, wie Sie mit Docker Compose vollständige Anwendungen bereitstellen.Dieser Kurs behandelt sowohl lokale als auch serverbasierte Anwendungen und stellt sicher, dass Sie die Funktion jedes einzelnen Teils der docker-compose.yml-Datei, die Funktionsweise von Diensten, Volumes und Netzwerken, die täglich benötigten Befehle sowie die praktische Anwendung in einer Node.js-Anwendung mit Datenbank vollständig verstehen. Falls Sie aus der reinen Softwareentwicklung (Frontend, Mobile, Backend) kommen und Ihnen Konzepte wie Orchestrierung und Operationen zunächst unverständlich erscheinen, keine Sorge: Wir gehen Schritt für Schritt vor, ohne dabei auf Details zu verzichten.

Grundlegende Umgebungsanforderungen

Bevor wir mit der Implementierung beginnen, benötigen Sie ein minimal vorbereitetes Basissystem.Eine typische und häufig genutzte Umgebung zum Üben und für kleinere Produktionsprojekte 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.haben aber etwas Ähnliches und relativ Aktuelles. Auf Cloud-Servern wie VPS (Google Bei Cloud-Diensten wie AWS, Arsys usw. ist es üblich, eine VM einzurichten. LinuxInstallieren Sie Docker und fügen Sie anschließend Docker Compose hinzu.

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 für die Ausführung Ihres Prozesses notwendigen Komponenten (Binärdateien, Bibliotheken, Laufzeitumgebung usw.) und 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 die Anwendung nahtlos zwischen verschiedenen Rechnern verschieben.

Docker Compose hingegen ist das Tool, das mehrere Container so orchestriert, als wären sie eine einzige Anwendung.Wenn Sie nur einen einfachen Dienst hätten, könnten Sie mit Docker Run auskommen, aber sobald Sie Folgendes 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 angeben, 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.Obwohl es durch Angabe des Parameters `-f` beim Ausführen der Befehle auch anders genannt werden kann, funktioniert es wie ein Rezept: Jeder, der Docker und Docker Compose besitzt, 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.Ab hier ändert sich der Prozess 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 ihm Ausführungsrechte zu erteilen. Ein typisches Muster 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 abgeschlossen 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

En Download Mac Am einfachsten ist es in der Regel, Docker Desktop zu installieren.welches bereits Docker Engine und Docker Compose integriert hat. Alternativ verwenden viele Entwickler Homebrew:

brew install docker-compose

Mit Docker Desktop müssen Sie sich in der Regel keine Gedanken mehr über Kompositionen machen.weil das Paket selbst dafür sorgt, dass es zusammen mit der Docker-Engine auf dem neuesten Stand bleibt.

Installation unter Windows

En Windows Die praktischste Lösung ist die Verwendung von Docker Desktop für Windows.. Downloads Führen Sie das Installationsprogramm von der offiziellen Docker-Website aus und folgen Sie den Anweisungen des Assistenten. Dadurch werden sowohl Docker als auch Compose eingerichtet. Powershell oder in WSL2.

Obwohl es möglich ist, mit Docker unter nativem Windows zu arbeitenFür anspruchsvollere Entwicklungsumgebungen empfiehlt es sich in der Regel, WSL2 mit einer Linux-Distribution oder direkt eine Remote-Linux-VM zu verwenden, wo Docker und Compose produktionsnäher arbeiten.

Grundstruktur einer docker-compose.yml-Datei

In der docker-compose.yml-Datei können wir mehrere Hauptblöcke definieren.Dies umfasst die Formatversion, Dienste, Volumes, Netzwerke und in einigen Fällen zusätzliche Konfigurationen. Dienste sind für die Bereitstellung einer typischen Anwendung unerlässlich, Volumes und Netzwerke sind für die dauerhafte Bereitstellung notwendig.

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.Beispielsweise ein Webdienst, ein Datenbankdienst, ein Caching-Dienst usw. Die Definition jedes Dienstes unterstützt eine Reihe von Eigenschaften, von denen die folgenden besonders hervorzuheben sind:

• 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.).
• -Umgebung: 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).

Interessant ist, dass viele dieser Eigenschaften optional sind.Sie könnten einen Dienst nur mit `image` definieren, und Compose könnte den Container dann mit Standardwerten starten. Anschließend können Sie bei Bedarf Ports, Netzwerke, Variablen usw. 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 üblicherweise im Abschnitt "volumes" auf der obersten Ebene deklariert und dann von den Diensten referenziert.

Ein Volumen kann mehrere relevante Eigenschaften aufweisen.:

• 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 Sie viele Details konfigurieren können, genügt es in vielen Fällen, den Datenträgernamen anzugeben. und verwenden Sie es im Dienst. Beispielsweise ist es bei einer MySQL- oder PostgreSQL-Datenbank typisch, ein Datenvolume und manchmal eine Bind-Mount-Verbindung für Initialisierungsskripte zu haben.

Netzwerke: Kommunikation zwischen Containern

Bei Anwendungen mit mehreren Modulen ist es üblicherweise sinnvoll, 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 Modell:

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

unter den Treiber Die am häufigsten verwendeten Netzwerkkomponenten in Docker sind::

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	Global	Es ermöglicht Ihnen, Container, die auf verschiedenen Docker-Hosts laufen, innerhalb eines Swarms zu verbinden.
Macvlan	Global	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.Hier wählen Sie den Treiber und die Optionen aus. Wenn Sie nichts definieren, wird standardmäßig ein Brückennetzwerk 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 all diese Konzepte in den richtigen Kontext zu setzen, stellen Sie sich vor, Sie möchten eine einfache Website mit Nginx und einer PostgreSQL-Datenbank erstellen.Ein minimalistisches Beispiel für eine docker-compose.yml-Datei könnte zwei Dienste, ein internes Netzwerk und einige Volumes umfassen:

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 DingeEinerseits stellt Nginx Port 80 für den Host bereit, während die Datenbank nur innerhalb des app_net-Netzwerks erreichbar ist. Andererseits werden die PostgreSQL-Daten auf einem Volume namens datos_db gespeichert. 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 es heißt: „Dieser Dienst macht ohne jenen keinen Sinn.“Zum Beispiel eine REST-API, die eine laufende Datenbank benötigt, 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.Auflistung der Dienste, von denen der aktuelle Dienst abhängt:

services:
  api:
    image: mi_usuario/mi_api:latest
    depends_on:
      - db

  db:
    image: postgres:15

Bei dieser Konfiguration gilt: Wenn Sie docker-compose up ausführen, ohne Dienste anzugeben,Compose lädt zuerst die Datenbank und anschließend die API. Beachten Sie jedoch, dass `depends_on` die Reihenfolge der Operationen steuert. StartenEs bietet jedoch keine hundertprozentige Garantie dafür, dass der abhängige Dienst „bereit“ ist (z. B. dass die Datenbank Verbindungen annimmt). In kritischen Fällen werden üblicherweise Warteskripte oder Integritätsprüfungen eingesetzt.

Wichtige Docker Compose-Befehle

Sobald die docker-compose.yml-Datei vorhanden istDie tägliche Arbeit mit Compose basiert auf einigen wenigen grundlegenden Befehlen. 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 der Container lautet docker-compose up.Wenn Sie es ohne weitere Parameter ausführen, versucht es, die notwendigen Images zu erstellen (sofern diese einen Build-Abschnitt haben) und alle definierten Dienste zu starten:

docker-compose up

Wenn Sie möchten, dass die Container im Hintergrund ausgeführt werden.Wie auf Servern üblich, fügen Sie -d hinzu:

docker-compose up -d

Container stoppen: docker-compose down

Um Projektcontainer zu stoppen und zu löschen (wenn auch nicht unbedingt Bilder oder Bände), die Sie verwenden:

docker-compose down

Dieser Befehl kann mit weiteren Optionen kombiniert werden. Wenn Sie Volumes, benutzerdefinierte Netzwerke usw. löschen möchten, können Sie das auch tun, aber in den meisten Fällen reicht die Verwendung von `down` aus, um das Projekt ordnungsgemäß zu beenden.

Dienststatus anzeigen: docker-compose ps

Wenn Sie überprüfen möchten, welche Dienste aktiv sind, welche Ports sie belegt haben und welchen Status sie haben,, der zu verwendende Befehl lautet:

docker-compose ps

Hier wird Ihnen eine Tabelle mit den von diesem Compose verwalteten Containern angezeigt.einschließlich Spalten für Name, Bild, Ports und aktuellen Status, sehr nützlich, um zu überprüfen, ob alles Ihren Erwartungen entspricht.

Abfrageprotokolle: docker-compose logs

Um zu sehen, was in Ihren Diensten passiert, 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ügenSie werden die Bewegungen in Echtzeit verfolgen (ä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ührenSie verwenden `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 Sie können bash anstelle von sh verwenden, je nachdem, welches der verwendeten Images Ihnen besser liegt.

Images erstellen oder neu erstellen: docker-compose build und docker-compose pull

Wenn Sie eine Dockerfile oder einen Teil des Build-Kontexts geändert habenSie müssen die zugehörigen Bilder rekonstruieren:

docker-compose build
# O bien para un servicio concreto
docker-compose build api

Wenn die Images von einer Remote-Registry stammen (Docker Hub, private Registry…). Und wenn 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 auf "normale" Docker-Befehle zurückgreifen können. (docker ps, docker images, docker volume ls, docker network ls usw.), aber um die Konsistenz des Projekts zu gewährleisten, ist es besser, alles, was die in docker-compose.yml definierten Dienste betrifft, über Compose zu handhaben.

Vollständiges Beispiel: Node.js + MySQL-Anwendung mit Docker und Docker Compose

Betrachten wir nun ein etwas realistischeres Beispiel.Eine REST-API in Node.js, die MySQL zur Speicherung von Informationen (z. B. Fahrzeugdaten) verwendet. Der typische Ablauf wäre:

1. API entwickeln Konfiguration mithilfe von Umgebungsvariablen.
2. Erstelle eine Dockerfile für die API.
3. Erstellen Sie das Image und laden Sie es bei Bedarf auf Docker Hub hoch..
4. Definiere eine docker-compose.yml-Datei. mit der API und der Datenbank.
5. 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 einige Endpunkte bereitstellt. Zum Abfragen, Erstellen und Auflisten von Autos. Der Schlüssel liegt hierbei nicht im Code selbst, sondern darin, dass die Datenbankverbindungskonfiguration über Umgebungsvariablen wie DB_HOST, DB_USER, DB_PASSWORD, DB_NAME usw. erfolgt.

Dies ist unerlässlich für ein reibungsloses Funktionieren mit Docker.Sie möchten keine Zugangsdaten oder URLs im Code festschreiben, sondern diese zum Zeitpunkt der Bereitstellung parametrisieren, egal ob lokal oder in der Cloud.

2. Dockerfile für die Webanwendung

Im Anwendungsverzeichnis erstellen Sie eine Dockerfile, die für das Erstellen des Images zuständig ist.Ein einfaches Beispiel wäre:

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 basiert auf einem offiziellen Node-Image.Installieren Sie die Abhängigkeiten, kopieren Sie den Code, legen Sie den Port der Anwendung fest (in diesem Fall 3000) und definieren Sie den Startbefehl. Anschließend können Sie das Image lokal erstellen.

docker build -t mi_usuario/mi-api-coches:latest .

Überprüfen Sie mithilfe von Docker Images, ob das Image existiert. Und wenn alles gut geht, könnten Sie diese API sogar in einem separaten Container mit Docker Run ausführen. Der interessante Teil beginnt 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 VM in der Cloud) bereitstellen möchtenEs ist 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 die Version explizit angeben möchtenSie können 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 Bereitstellung durchführen möchtenEs genügt, ein docker pull des Images durchzuführen und es in der docker-compose.yml zu 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 wird ein Volume für die MySQL-Daten hinzugefügt und, falls erforderlich, ein Skript Initialisierung:

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 birgt einige 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 von... aus dem Dateiverzeichnis:

docker-compose up -d

Das erste Mal wird etwas länger dauern Weil es die MySQL-Images (und die API, falls diese nicht lokal installiert ist) herunterladen, das Volume erstellen und die Initialisierungsskripte ausführen muss. Anschließend kann der Status überprüft werden:

docker-compose ps

Wenn alles „betrieben“ ist, können Sie Anfragen an die API senden. von curl oder Postman. 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"}'

Wenn Sie die Bereitstellung beenden möchten, führen Sie einfach `docker-compose down` aus.Wenn Sie das Volume nicht löschen, bleiben die Daten für den nächsten Systemstart erhalten.

Docker Compose auf Cloud-Servern und Portainer bereitstellen

Alles, was wir 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 man die docker-compose up-Befehle ausführt und wie man die Ports nach außen öffnet.

Ein sehr einfacher Ansatz für persönliche Projekte oder Nebenprojekte Dazu gehört das Erstellen einer kleinen VM (zum Beispiel einer kostenlosen e2-micro auf Google Cloud), das Installieren von Docker und Docker Compose, das Klonen Ihres Repositorys mit dem Code und der docker-compose.yml-Datei und das Starten der Anwendung dort.

Das Einzige, was Sie beachten müssen, ist die Firewall-Richtlinie des Anbieters.Wenn Ihre Anwendung auf Port 3000 lauscht, müssen Sie diesen Port in den Netzwerkeinstellungen Ihres Internetanbieters ö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.

Wenn Ihnen die Verwaltung von Containern über die Konsole zu umständlich ist, können Sie Portainer verwenden.Portainer ist ein Tool, das ebenfalls in einem Container läuft und eine Weboberfläche zur Verwaltung von Docker (und Docker Compose) bietet. Um Portainer auf einem Server einzurichten, müssten Sie beispielsweise Folgendes tun:

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 Portainer unter http://SERVER_IP:9000 aufrufen.Sie würden einen Administratorbenutzer erstellen und könnten von dort aus Container, Compose-Stacks, Netzwerke, Volumes usw. alles über den Browser anzeigen.

Die Arbeit mit Docker Compose ermöglicht es Ihnen, die gesamte Architektur einer Anwendung in einer einzigen Datei zu kapseln.So kann jeder Entwickler, ob vom Laptop oder einer Remote-VM, denselben Stack mit einem einzigen Befehl starten. Durch die Anwendung bewährter Methoden wie die Verwendung von Umgebungsvariablen, internen Netzwerken, persistenten 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 den Überblick zu verlieren.