Detaillierte Erklärung der Docker Compose-Verwendung

Docker Compose-Nutzungsszenarien

Bei unserer Entwicklung ist eine Anwendung häufig von mehreren Diensten abhängig. Bei der herkömmlichen Docker-Run-Methode müssen Sie mehrere Dienste nacheinander starten und sogar das entsprechende Netzwerk konfigurieren. Der Vorgang ist umständlich und unbequem. Docker Compose zielt darauf ab, die Konstruktion und Abhängigkeiten mehrerer Dienste in docker-compose.yml zu schreiben und dann den gesamten Dienstcluster über den Befehl docker-compose zu starten und herunterzufahren.

Eine einfache Demo

Die Demofunktion ist ein einfaches Python-Programm, das einen Webdienst bereitstellt. Mit diesem Dienst wird gezählt, wie oft auf den aktuellen Dienst zugegriffen wird. Die Erfassung und Speicherung der Zeiten erfolgt vollständig auf Basis von Redis. Das heißt, zusätzlich zu seinen eigenen Diensten ist das Programm selbst auch auf einen Redis-Dienst angewiesen. Hier sind die detaillierten Schritte

Suchen Sie ein Verzeichnis und erstellen Sie darin eine Python-Datei app.py

Importzeit

Redis importieren
aus Flasche importieren Flasche

App = Flask(__name__)
Cache = Redis.Redis (Host = "Redis", Port = 6379)

auf Grund von get_hit_count():
 Wiederholungsversuche = 5
 während True:
  versuchen:
   returniere cache.incr('Treffer')
  außer redis.exceptions.ConnectionError als exc:
   wenn Wiederholungen == 0:
    erhöhen exc
   Wiederholungen -= 1
   Zeit.Schlaf(0,5)

@app.route('/')
def hallo():
 Anzahl = Trefferanzahl abrufen()
 return 'Hallo Welt! Ich wurde {} Mal gesehen.\n'.format(Anzahl)

Erstellen Sie im selben Ordner die Datei requirements.txt

Die Datei requirements.txt wird zum Deklarieren der abhängigen Bibliotheken verwendet, die das Python-Programm verwenden muss. Sie ähnelt ein wenig der Maven-POM-Datei in Java. Die im obigen Code verwendeten Komponenten sind Flask und Redis. Der Inhalt der Datei requirements.txt lautet also

Flasche
Redis

Erstellen Sie im selben Ordner eine Dockerfile

Dockerfile wird verwendet, um unser Programm in ein Docker-Image zu erstellen. Im Allgemeinen definiert Dockerfile die grundlegende Umgebung für die Ausführung unseres Codes, Programmstartbefehle, Ausführungsports usw. Das Dockerfile für dieses Beispiel sieht wie folgt aus

VON python:3.7-alpine
ARBEITSVERZEICHNIS /code
ENV FLASK_APP=app.py
ENV FLASK_RUN_HOST=0.0.0.0
KOPIEREN requirements.txt requirements.txt
Führen Sie den Befehl „pip install -r requirements.txt“ aus.
EXPOSE 5000
KOPIEREN . .
CMD ["Flasche", "ausführen"]

Erstellen Sie in derselben Datei eine Datei docker-compose.yml

Nach Abschluss der obigen Schritte können wir unseren Dienst im Docker-Format ausführen. Dieser Dienst ist jedoch vom Redis-Dienst abhängig. Daher organisieren wir die Abhängigkeiten der Dienste über docker-compose.yml. Der Inhalt ist wie folgt:

Version: "3.8"
Leistungen:
 Webseite:
 bauen: .
 Häfen:
  - "5000:5000"
 Redis:
 Bild: „redis:alpine“

Die Datei definiert zwei Dienste, web und redis build:. in web erstellt unseren Code in ein Image basierend auf dem zuvor definierten Dockerfile im aktuellen Verzeichnis. Wenn es als Container gestartet wird, wird Port 5000 der Außenwelt zugänglich gemacht und dem Port 5000 des aktuellen Hosts zugeordnet.

Der Redis-Dienst verwendet direkt das vorgefertigte Image redis:alpine . Es ist kein Port angegeben und der Standardport von Redis wird angezeigt.

Grundlegende Bedienung und Wartung

Alle mit Docker-Compose verbundenen Befehle müssen in dem Pfad ausgeführt werden, in dem sich docker-compose.yml befindet.

Starten Sie den Dienst basierend auf docker-compose.yml

Verwenden Sie im Verzeichnis, in dem sich docker-compose.yml befindet, den Befehl docker-compose up . Wenn jedoch die Konsole geschlossen wird, wird auch der entsprechende Docker-Dienst geschlossen. Sie können docker-compose up -d verwenden, um die Ausführung im Hintergrund-Detach-Modus durchzuführen.

docker-compose up kann einen Dienst und seine Abhängigkeiten auch separat in der Compolse-Datei starten

Zeigen Sie die Containerdienstliste an, die dem Compose-Dienst entspricht

Docker-Compose PS

Ausgabebeispiel

# Docker-Compose ps
Name Befehl Status Ports
------------------------------------------------------------------------------------------------
docker_compose_learn_redis_1 docker-entrypoint.sh redis ... Bis 6379/tcp
docker_compose_learn_web_1 Flask ausgeführt bis 0.0.0.0:5000->5000/tcp

Das Servicepräfix docker_compose_learn ist der Name des aktuellen Projekts. Der Projektname kann durch die Umgebungsvariable COMPOSE_PROJECT_NAME angegeben werden. Wenn nicht angegeben, ist der Standardprojektname der Name des Ordners, in dem sich die Compose-Datei befindet. In diesem Beispiel lautet der Ordnername docker_compose_learn

Natürlich starten eine Reihe von Diensten in Compose letztendlich eine Reihe von Containern. Sie können also auch docker container -Befehlsfamilie verwenden, um sie zu verwalten, aber das ist zu mühsam.

Beenden des Servicecontainers

Sie müssen den Befehl docker-compose stop in dem Pfad verwenden, in dem sich docker-compose.yml befindet.

Stoppen Sie den Servicecontainer und löschen Sie den entsprechenden Container

Sie müssen den Befehl im Pfad verwenden, in dem sich docker-compose.yml befindet.

Docker-Compose nach unten

Stoppen Sie den Servicecontainer und löschen Sie die entsprechenden Container- und Volumedaten.

Sie müssen den Befehl im Pfad verwenden, in dem sich docker-compose.yml befindet.

docker-compose down --volumes

Dieser Befehl löscht nicht die gemounteten Dateien des Host-Betriebssystems.

So melden Sie sich beim entsprechenden Dienst an

Um sich bei Compose anzumelden und einen bestimmten Dienst auszuführen, verwenden Sie den folgenden Befehl:

docker-compose exec ***Dienstname*** bash

So zeigen Sie die angegebene Compose-Datei an

docker-compose -f docker-compose.yml -f docker-compose.admin.yml führe Backup_db aus

Unterschied zwischen Docker-Compose Up und Docker-Compose Run

docker-compose up startet alle Dienste basierend auf der Compose-Datei und stellt die Ports der Außenwelt zur Verfügung.
docker-compose run muss einen bestimmten Dienst angeben, der gestartet werden soll. Beispielsweise startet docker-compose run web bash nur den Webdienst in der Compolse-Datei und seine abhängigen Dienste und gibt den Port nicht der Außenwelt bekannt, um Konflikte mit dem von docker-compose up gestarteten Dienstport zu vermeiden.
docker-compose run wird nur verwendet, um vorübergehend ein Service-Standortproblem zu starten.

Einige erweiterte Wissenspunkte

Umgebungsvariablen

Der Inhalt von docker-compose.yml selbst kann variable Platzhalter verwenden und seine spezifischen Variablenwerte werden in spezifischen Umgebungsvariablen definiert, sodass dieselbe Datei docker-compose.yml in verschiedenen Umgebungen unterschiedliche Ausführungsverhalten aufweisen kann. Normalerweise möchten wir, dass die Tag-Version des Images des abhängigen Dienstes von Umgebung zu Umgebung variiert.

Anschließend konfigurieren wir dessen Tag mit einem Platzhalter in der entsprechenden Servicekonfiguration von docker-compose.yml. Im Folgenden wird ${TAG} verwendet, um den Image-Tag des Webdienstes zu konfigurieren

Webseite:
 Bild: "webapp:${TAG}"

Zusätzlich zu den oben angegebenen Variablen gibt es mehrere in Docker integrierte Variablen, die festgelegt werden können. Sie werden verwendet, um das Ausführungsverhalten von Docker oder Docker Compose zu konfigurieren. Diese eingebauten Variablen sind

• COMPOSE_API_VERSION
• COMPOSE_CONVERT_WINDOWS_PATHS
• DATEI ERSTELLEN
• COMPOSE_HTTP_TIMEOUT
• COMPOSE_TLS_VERSION
• PROJEKTNAME VERFASSSEN
• DOCKER_CERT_PATH
• DOCKER_HOST
• DOCKER_TLS_VERIFY

Spezifische Bedeutungen finden Sie unter: https://docs.docker.com/compose/reference/envvars/

Am Beispiel des Platzhalters TAG gibt es mehrere Möglichkeiten, das Setzen von Variablen zu erklären:

In docker-compose.yml ausführen

Geben Sie es in der Compolse-Datei über environment an

Webseite:
 Bild: "webapp:${TAG}"
 Umfeld:
 - TAG=Entwickler

Legen Sie Shell-Umgebungsvariablen fest, bevor Sie den Befehl „Docker-Compose“ ausführen

$ export TAG=v2.0
$ Docker-Compose nach oben

Einstellung über env_file

Standardmäßig sucht docker-compose up im Befehlsausführungspfad nach der .env-Datei, um den Wert des Variablenersatzes zu finden. Die .env-Datei wird in der Form Schlüssel=Wert konfiguriert. Zum Beispiel

TAG=Entwickler

Wenn der Name der Umgebungsvariable nicht .env ist oder sich nicht im Pfad der aktuellen Befehlsausführung befindet, können Sie --env-file verwenden, um sie explizit zu laden.

docker-compose --env-file ./config/.env.dev up

Geben Sie direkt in der Compose-Datei die zu ladende Umgebungsdatei an.

Version: '3'
Leistungen:
 API:
 Bild: ‚Knoten:6-Alpine‘
 Umgebungsdatei:
  - ./Docker/api/api.env
 Umfeld:
  - NODE_ENV=Produktion

Die oben genannten Variablenwerteinstellungen haben Priorität von hoch nach niedrig

Anzeigen der endgültigen effektiven Umgebungsvariablen

Wenn Sie nicht sicher sind, welche Umgebungsvariablen letztendlich wirksam sind, können Sie den folgenden Befehl verwenden, um

Docker-Compose, Web-Umgebung ausführen

Projektnameneinstellung

Eine Gruppe von Diensten, die einer Komposition entspricht, hat einen gemeinsamen Projektnamen, der sich im Containernamenpräfix und im Netzwerkpräfix des Kompositionsdienstes widerspiegelt.
Der Projektname kann durch die Umgebungsvariable COMPOSE_PROJECT_NAME angegeben werden. Wenn nicht angegeben, ist der Standardprojektname der Name des Ordners, in dem sich die Compose-Datei befindet.

Netzwerk

Standardnetzwerk

Standardmäßig treten mehrere Dienste in Compose einem Netzwerk namens „Standard“ bei. Diese Dienste sind im Standardnetzwerk miteinander verbunden. Dem vollständigen Namen des Standardnetzwerks wird der Name des Ordners vorangestellt, in dem sich die Compose-Datei befindet. Der Ordner ist beispielsweise „Hello_World's Compose“. Der einem Satz von Diensten entsprechende Netzwerkname lautet: hello_world_default. Diese Gruppe von Diensten kommuniziert in diesem Netzwerk über die zweite Portgruppe in der Compose-Datei.

Version: "3"
Leistungen:
 Webseite:
 bauen: .
 Häfen:
  - "8000:8000"
 db:
 Bild: postgres
 Häfen:
  - „8001:5432“

Beispielsweise verwendet in der obigen Konfiguration im Netzwerk „hello_world_default“ der Webdienst Port 8000, um mit dem Datenbankdienst auf Port 5432 zu kommunizieren. Die erste Gruppe der Ports 8000 und 8001 sind die Ports, die vom Host für den Zugriff auf Web- und Datenbankdienste verwendet werden.

Selbständige Konfiguration des Standardnetzwerks

Wenn Sie die Standardnetzwerkkonfiguration ändern möchten, können Sie diese separat über das Netzwerkelement in der Erstellungsdatei ändern, z. B. indem Sie den Standardnetzwerktreiber wie folgt ändern

Netzwerke:
 Standard:
 # Verwenden Sie einen benutzerdefinierten Treiber
 Treiber: benutzerdefinierter Treiber-1

Konfigurieren und Verwenden nicht standardmäßiger Netzwerke

Definieren Sie mehrere Netzwerke und verwenden Sie

Version: "3"
Leistungen:

 Proxy:
 Erstellen: ./Proxy
 Netzwerke:
  -Frontend
 App:
 Erstellen: ./app
 Netzwerke:
  -Frontend
  - Backend
 db:
 Bild: postgres
 Netzwerke:
  - Backend

Netzwerke:
 Frontend:
 # Verwenden Sie einen benutzerdefinierten Treiber
 Treiber: benutzerdefinierter Treiber-1
 Backend:
 # Verwenden Sie einen benutzerdefinierten Treiber, der spezielle Optionen akzeptiert
 Treiber: benutzerdefinierter Treiber-2
 Treiberoptionen:
  foo: "1"
  Balken: "2"

Die obige Konfiguration definiert zwei Netzwerke, Frontend und Backend. Die App kann auf beide Netzwerke zugreifen, der Proxy-Dienst kann nur auf das Frontend-Netzwerk zugreifen und die Datenbank kann nur auf das Backend-Netzwerk zugreifen.

Ausführungsreihenfolge mehrerer Dienste

Mehrere Dienste in einer Komposition können Abhängigkeiten aufweisen. Beispielsweise ist der Webdienst vom Datenbankdienst abhängig. Wir möchten zuerst den Datenbankdienst und dann den Webdienst starten. Diese Startreihenfolge kann auch in der Compose-Datei mit depends_on angegeben werden.

Version: "2"
Leistungen:
 Webseite:
 bauen: .
 Häfen:
  - "80:8000"
 hängt ab von:
  - "db"
 Befehl: ["./wait-for-it.sh", "db:5432", "--", "python", "app.py"]
 db:
 Bild: postgres

Installation von Docker Compose

Sowohl die Mac- als auch die Windows-Version von Docker werden standardmäßig mit Docker Compose geliefert. Nur die Linux-Version muss separat installiert werden

Ähnlichkeiten und Unterschiede zwischen Docker Compose und Docker Stack

• Das Hauptziel von Docker Compose besteht darin, mehrere Dienste auf derselben Maschine zu starten und zu verwalten
• Der Docker-Stack wird hauptsächlich zum Starten und Verwalten mehrerer Dienste auf mehreren Maschinen verwendet.
• Sowohl Docker Compose als auch Docker Stack können docker-compose.yml-Dateien verwenden. Für beide Seiten nicht wirksame Konfigurationen werden automatisch ignoriert.
• Docker Compose-Dienste können mit Build dynamisch erstellt werden, während Docker Stack-Dienste nur auf Basis von Images erstellt werden können.

Verweise

https://docs.docker.com/compose/gettingstarted/
https://docs.docker.com/compose/
https://stackoverflow.com/questions/43099408/was ist der Unterschied zwischen einer Stack-Datei und einer Compose-Datei?
https://nickjanetakis.com/blog/docker-tip-23-docker-compose-vs-docker-stack
https://vsupalov.com/unterschied-docker-compose-und-docker-stack/
https://stackoverflow.com/questions/33066528/sollte ich Docker-compose-up-or-run verwenden?

Dies ist das Ende dieses Artikels über die Verwendung von Docker Compose. Weitere relevante Inhalte zur Verwendung von Docker Compose finden Sie in früheren Artikeln auf 123WORDPRESS.COM oder in den folgenden verwandten Artikeln. Ich hoffe, Sie werden 123WORDPRESS.COM auch in Zukunft unterstützen!