Docker Compose Tutorial

Docker Compose Tutorial
Dockers Popularität als Entwicklungsinstrument ist auf dem Vormarsch. Docker hat der Containerbewegung neues Leben eingeatmet. Entwickler mögen es, es zu verwenden, weil es schnell und leicht zu lern ist. Es hilft Entwicklungsteams, Standardumgebungen auszutauschen, ohne sich um Zeit und Ressourcen zu kümmern,.

Entwickler können die gewünschte Umgebung in einem Docker -Container einrichten, den Container als Bild speichern und sie einfach mit ihren Entwicklungsteams teilen. Der Prozess eignet sich hervorragend für einen einzelnen Behälter. Multi-Container-Umgebungen sind jedoch schwerer zu pflegen. Docker Compose bietet die Lösung.

Mit Docker Compose können Entwickler eine YAML -Datei definieren, um die Konfiguration für mehrere Dienste einzurichten. Dann können sie die Multi-Container-Dienste mit einem einzigen Befehl starten. Es vereinfacht den Prozess der Arbeit mit Multicontainer-Anwendungen.

Voraussetzung

Wir gehen davon aus, Sie haben ein grundlegendes Verständnis von Docker. Ansonsten schauen Sie sich an So installieren und verwenden Sie Docker auf Ubuntu. Die Beispiele verwenden WordPress, MySQL, Flask und Python. Es ist jedoch keine Vorkenntnisse dieser Tools erforderlich.

Docker komponieren Prozess: auf einen Blick

  1. Anwendungsumgebung definieren: Verwenden Sie Dockerfile, um die App -Umgebung zu definieren, um sie leicht reproduzierbar zu machen.
  2. Definieren Sie die Docker -Kompose -Umgebung: Verwenden Sie Docker-Compose.YML, um die Dienste in der Anwendung zu definieren.
  3. Anwendung ausführen: Verwenden Sie Docker-Compose, um die Multi-Container-Anwendung auszuführen.

Beispiel Docker Compose -Datei

Version: '3'
Dienstleistungen:
DB:
Bild: Mysql: 5.7
Bände:
- db_data:/var/lib/mysql
Neustart: Immer
Umfeld:
Mysql_root_password: rootPassword123
MySQL_Database: WordPress
MySQL_USER: WordPress_User
MySQL_Password: WordPress_Password
WordPress:
kommt drauf an:
- db
Bild: WordPress: Neueste
Häfen:
- "8000: 80"
Neustart: Immer
Umfeld:
WordPress_DB_HOST: DB: 3306
WordPress_DB_USER: WordPress_User
WordPress_DB_Password: WordPress_Password
Bände:
db_data:

Wenn der oben genannte Docker-Compose.Die YML -Datei wird mit Docker Up aufgerufen. Sie erstellt einen WordPress -Dienst, der eine Verbindung zu einem MySQL -Datenbankdienst herstellt.

Docker Compose -Befehle

Sie können verwenden Docker -Compose -Help Um den Befehl Docker Compose zu finden

Wann ist Docker Compose zu verwenden?

Derzeit wird Docker hauptsächlich in Entwicklungsumgebungen verwendet. Einige der beliebten Verwendungen von Docker Compose sind:

1. Prototyping und Entwicklung

Anwendungsprototyping und Entwicklungsprozess werden aufgrund des Mangels an Standardumgebungen verlangsamt. Entwickler müssen oft mehrmals Zeit damit verschwenden. Auch das Lesen von Leitfäden zum Einrichten von Umgebungsparametern ist zeitaufwändig.

Docker Compose vereinfacht den Prozess. Sobald eine Umgebung konfiguriert ist, können Entwicklungsteams die Docker -Dateien in der Organisation freigeben. Es kann eine enorme Zeitspanne sparen, die bei Konfigurationsmanagementproblemen verschwendet wird.

2. Prozesse testen und automatisieren

Kontinuierliche Integration und kontinuierliche Lieferung (CI/CD) werden zu Standardprozessen in den heutigen agilen Entwicklungsumgebungen werden. Automatisierte Tests sind ein wichtiger Bestandteil von CI/CD. Docker Compose hilft dabei, den automatisierten Testprozess zu definieren. Alle Komplikationen beim Starten neuer Dienste können genau in Docker -Konfigurationsdateien eingerichtet werden. Tester können diese Dateien verwenden, um temporäre Dienste zu starten, Textskripte auszuführen und die Dienste zu zerstören, nachdem die Testergebnisse gesammelt wurden. Es spart Zeit, weil manuelles Startdienste zeitaufwändig und fehleranfällig ist.

3. Zukünftige Produktionseinsatz

Docker wird hauptsächlich in Entwicklungsumgebungen verwendet. Wenn Docker-Funktionen jedoch robuster werden, wird Docker für mehr Arbeiten auf Produktionsebene verwendet. Docker Compose kann ein wertvolles Tool für einzelne Hostbereitstellungen sein.

Übung: Eine einfache Webanwendung

Versuchen wir uns in einer einfachen Python -basierten Webanwendung, um Docker Compose auszuprobieren. Wir werden das Flask-Web-Framework verwenden, um eine Anwendung zu erstellen, die mit einer In-Memory-Datenbank-Redis kommuniziert, um zu verfolgen, wie oft die Webanwendung besucht wurde.

Die Verzeichnisstruktur wird so aussehen:

Simple_App
├── Inhalt
│ ├── Dockerfile
│ └ºC
│ ├── Simple_App.py
│ └── Anforderungen.txt
└── Docker-Compose.YML

Die obige Verzeichnisstruktur ist für eine grundlegende Anwendung nicht erforderlich. Es zeigt jedoch, wie die Organisation von Informationen für eine effizientere Implementierung von Docker Compose hilfreich sein kann.

Schritt 1: Erstellen Sie Verzeichnisstruktur und Dateien

Erstellen wir die Verzeichnisstruktur und die erforderlichen Dateien:

$ mkdir Simple_App
$ mkdir Simple_App/Inhalt
$ mkdir Simple_App/Inhalt/Code
$ touch Simple_App/Docker-compose.YML
$ touch Simple_App/Inhalt/Dockerfile
$ touch Simple_App/Inhalt/Code/Simple_App.py
$ touch Simple_App/Inhalt/Code/Anforderungen.txt

Der Befehl touch besteht darin, nur leere Dateien zu erstellen. Sie können manuell in die Ordner gehen und die Dateien erstellen.

Schritt 2: Webanwendungscode

Der Codeordner enthält den Webanwendungscode. Verfolgen Simple_App.py Datei:

aus Flask -Importkolben
von Redis Import Redis
app = Flask (__ Name__)
Redis = Redis (Host = 'Redis', Port = 6379)
@app.Route('/')
Def hello ():
count = Redis.inkret ('Hits')
zurückkehren 'Willkommen bei Docker Compose Lektionen!

Sie haben diese Seite mal besucht.\N'.Format (Graf)
Wenn __name__ == "__main__":
App.run (host = "0.0.0.0 ", debug = true)

Die obige Anwendung erstellt eine willkommene Seite, auf der die Häufigkeit der Seite besucht wird. Der Besuchschalter wird in einer Redis -Datenbank gepflegt. Redis verwendet Port 6379 als Standard -Höranschluss. Füllen Sie als nächstes die aus Anforderungen.txt Datei:

Flasche
Redis

Dadurch können PIP Python -Abhängigkeiten im Webbehälter installieren. Wir werden PIP im Rahmen der Initialisierung unseres Dienstes durchführen.

Schritt 3: Dockerfile

Füll das Simple_App/Inhalt/Dockerfile mit dem folgenden Code:

Von Python: 3.6.3-Jessie
HINZUFÜGEN ./Code /Code
WorkDir /Code
PIP -Installationsanforderungen ausführen.txt
CMD ["Python", "Simple_App.py "]

Obenstehendes Dockerfile erreicht Folgendes:

  1. Erstellt ein Bild von Python: 3.6.3-Jessie. Wenn es vor Ort nicht verfügbar ist, wird es von Docker Hub heruntergeladen.
  2. Kopiert Elemente in Simple_App/Inhalt/Code hinein /Code auf dem Behälter
  3. Satz /Code als Arbeitsverzeichnis am Container
  4. Verwendet PIP, um die Python -Abhängigkeiten zu installieren
  5. Legt den Standard -Startpunkt für den Ausführen des Containers fest Python Simple_App.py.

Schritt 4: Docker Compose

Füll das Simple_App/Docker-Compose.YML Datei mit dem folgenden Code:

Version: '3'
Dienstleistungen:
Netz:
bauen: ./Inhalt
Häfen:
- "5000: 5000"
Bände:
- ./Inhalt/Code:/Code
Redis:
Bild: "Redis: Alpine"

Der Docker-Compose.YML Datei definiert zwei Container: Web und Redis. Es verwendet Docker Compose Version 3 -Format.

Für den Webdienst:

  • Erstellt den Webdienst mithilfe Simple_App/Inhalt/Dockerfile
  • Leiten Sie Port 5000 vom Webbehälter zum Port 5000 des Hosts weiter. Port 5000 ist der Standardport für Flask -Anwendungen.
  • Volumen Simple_App/Inhalt/Code ist montiert wie /Code auf dem Behälter. Es bedeutet, dass, wenn Sie etwas in der ändern Simple_App/Inhalt/Code, es wird sich reflektiert in /Code Ordner im Webbehälter.

Für den Redis -Service:

  • Verwendet das Redis: Alpine -Bild von Docker Hub, um den Redis -Dienst zu erstellen.

Schritt 5: Ausführen von Anwendungen mit Docker Compose

Die Anwendung ist zur Bereitstellung bereit. Von dem Simple_App Ordner, führen Sie den folgenden Befehl aus:

$ docker-compose up

Die Ausgabe sollte so beginnen:

$ docker-compose up
Bauen von Web
Schritt 1/5: Von Python: 3.6.3-Jessie
3.6.3-Jessie: Aus der Bibliothek/Python ziehen
85b1f47fba49: Herunterladen [===========>] 12.43 MB/52.6mb
5409E9A7FA9E: Download Complete
661393707836: Herunterladen [===============>] 13.71 MB/43.23 MB
1BB98C08D57E: Herunterladen [>] 1.081MB/134.7mb

Sobald alle Bilder erstellt wurden, sollten Sie Folgendes sehen:

Status: Neueres Bild für Redis: Alpine heruntergeladen
Erstellen von simpleApp_redis_1…
Erstellen von simpleApp_web_1…
Erstellen von simpleApp_redis_1
Erstellen von simpleApp_web_1… erledigt
Anhängen an simpleApp_redis_1, simimapp_web_1
Redis_1 | 1: M 21. Oktober 02:06:33.639 * Bereit, Verbindungen zu akzeptieren
Web_1 | * Ausführen auf http: // 0.0.0.0: 5000/ (drücken Sie Strg+C, um aufzuhören)
Web_1 | * Neustart mit STAT
Web_1 | * Debugger ist aktiv!
Web_1 | * Debugger Pin: 237-189-083

Sie können die Anwendung testen, indem Sie zu http: // localhost: 5000 gehen:. Wenn Sie die Seite einige Male aktualisieren, sollte sie die Anzahl der Besuche widerspiegeln. Sie können den Status von Diensten oder Containern überprüfen, die ausgeführt werden:

$ docker ps
Befehl container -ID -Bild erstellt Statusports Namen Namen
22852e0Ad98a Redis: Alpine "Docker-Eintragung ..." Vor 5 Minuten up 5 Minuten 6379/TCP Simplyapp_redis_1
D51739D0A3AC SimpleApp_Web "Python Simple_App.py "vor 5 Minuten hoch 5 Minuten 0.0.0.0: 5000-> 5000/TCP Simplyapp_Web_1

Wenn Sie eine Bash -Shell in SimpleApp_Web_1 starten (Ihr Containername kann sich unterscheiden), werden Sie in das Arbeitsverzeichnis /Code angemeldet:

$ docker exec -it simpleApp_web_1 bash
root@d51739d0a3ac:/code# ls
Anforderungen.txt Simple_App.py
root@d51739d0a3ac:/code#

Der /Code Verzeichnis sollte den Inhalt von widerspiegeln Simple_App/Inhalt/Code darin, wie oben gesehen (sieheSimple_App.py Und Anforderungen.txt).

Wenn Sie Ihre aktualisieren Simple_App.pyZeile von:

zurückkehren 'Willkommen bei Docker Compose Lektionen!

Sie haben diese Seite mal besucht.\N'.Format (Graf)

Zu:

zurückkehren 'Willkommen bei Docker Compose Lektionen!

Sind Sie fasziniert?

Sie haben diese Seite mal besucht.\N'.Format (Graf)

Es sollte über http: // localhost: 5000 nachdenken:

Schritt 6: Dienste herunterschalten

Sie können die Anwendung mit:

$ docker-compose stop
Simplyapp_redis_1 stoppen…
Simplyapp_Web_1 stoppen…

Die montierten Bände bleiben bestehen. Sie können die Container vollständig entfernen, einschließlich der Volumina mit dem folgenden Befehl.

$ docker-compose down-volume
Entfernen von simpleApp_redis_1… fertig
Entfernen von simpleApp_web_1… fertig
Entfernen von Netzwerken SimpleApp_Default

Glückwunsch! Sie haben die Grundlagen von Docker Compose gemeistert.

Weiteres Studium

Weitere Untersuchungen finden Sie in der folgenden Dokumentation:

  • Docker -Dokumentation
  • Docker Compose Datei Referenz
  • Docker Compose Networking

Verweise:

  • https: // docs.Docker.com/compose/Übersicht/#Development-Incironments
  • https: // docs.Docker.com/compose/GetStarted/
  • https: // blog.Codeship.com/orchestrate-container-for-entwickeln mit docker-compose/
  • https: // www.sumologisch.com/blog/devOps/how-to-build-applications-docker-compose/
  • https: // docs.Docker.com/compose/wordpress/#Define-the-Project