Docker Compose: Arbeitserleichterung mit Makefile

Alle paar Jahre kommt es in der Softwareentwicklungsbranche zu einem Paradigmenwechsel. Ein solches Phänomen ist das wachsende Interesse an der Mikroservice-Architektur. Obwohl Mikroservices nicht die neueste Technologie sind, hat ihre Popularität in letzter Zeit sprunghaft zugenommen.

Große monolithische Anwendungen werden heutzutage durch unabhängige, autonome Mikroservices ersetzt. Ein Mikroservice kann als eine Anwendung betrachtet werden, die einem einzigen, sehr spezifischen Zweck dient. Zum Beispiel könnte dies eine relationale Datenbank, eine Express-Anwendung oder ein Solr-Service sein.

Heutzutage ist es schwer vorstellbar, ein neues Softwaresystem ohne den Einsatz von Mikroservices zu entwickeln. Diese Situation führt uns wiederum zur Plattform Docker.

Docker

Plattform Docker, in der Entwicklung und Bereitstellung von Mikrodiensten hat sich praktisch zum Industriestandard entwickelt. Auf der Projektseite erfahren Sie, dass Docker die einzige unabhängige Containerisierungsplattform ist, die es Organisationen ermöglicht, mit Leichtigkeit beliebige Anwendungen zu erstellen und diese in jeder Umgebung zu verteilen und auszuführen – von hybriden Clouds bis hin zu Edge-Systemen.

Docker Compose

Technologie Docker Compose ist zur Konfiguration von Multicontainer-Anwendungen gedacht. In ein Docker Compose-Projekt können so viele Docker-Container integriert werden, wie der Ersteller dieses Projekts benötigt.

Bei der Arbeit mit Docker Compose wird zur Konfiguration der Anwendungsdienste und zur Organisation ihrer Interaktion untereinander eine YAML-Datei verwendet. Docker Compose ist somit ein Werkzeug zur Beschreibung und Ausführung von Multicontainer-Docker-Anwendungen.

Zwei Container, die auf dem Host-System laufen

GNU Make

Das Programm make, ist im Wesentlichen ein Werkzeug zur Automatisierung des Builds von Programmen und Bibliotheken aus Quellcode. Insgesamt kann man sagen, dass make gilt für jeden Prozess, der die Ausführung willkürlicher Befehle umfasst, um bestimmte Ausgangsmaterialien in eine bestimmte Form, auf ein bestimmtes Ziel zu verwandeln. In unserem Fall werden die Befehle version: '1' services: simplesample-sonar: image: sonarqube:lts ports: - 9001:9000 - 9092:9092 network_mode: bridge in abstrakte Ziele umgewandelt (Phony targets).

Um der Anwendung mitzuteilen, make was wir von ihr erwarten, benötigen wir eine Datei Makefile.

In unserem Makefile , die gängige Befehle enthält, docker und version: '1' services: simplesample-sonar: image: sonarqube:lts ports: - 9001:9000 - 9092:9092 network_mode: bridgedie für eine Vielzahl von Aufgaben gedacht sind. Insbesondere geht es um den Bau des Containers, dessen Start, Stop, Neustart, die Organisation des Benutzerzugangs zum Container, die Arbeit mit den Container-Logs und die Lösung ähnlicher Aufgaben.

Typische Anwendungsfälle für Docker Compose

Stellen wir uns eine typische Webanwendung vor, die folgende Komponenten enthält:

• Eine TimescaleDB-Datenbank (Postgres).
• Eine Express.js-Anwendung.
• Ein Ping (einfach ein Container, der nichts Besonderes macht).

Diese Anwendung benötigt 3 Docker-Container und eine Datei version: '1' services: simplesample-sonar: image: sonarqube:lts ports: - 9001:9000 - 9092:9092 network_mode: bridge, die Anweisungen zur Verwaltung dieser Container enthält. Jeder Container wird unterschiedliche Schnittstellen haben. Zum Beispiel mit dem Container timescale Es wird ähnlich funktionieren wie der Umgang mit Datenbanken. Genauer gesagt, es ermöglicht die folgenden Aktionen:

• Zugang zur Postgres-Shell.
• Import und Export von Tabellen.
• Erstellung pg_dump von Tabellen oder Datenbanken.

Der Container der Express.js-Anwendung, expressjs, kann folgende Funktionen bieten:

• Aussortieren frischer Daten aus dem Systemprotokoll.
• Zugang zur Shell zur Ausführung bestimmter Befehle.

Interaktion mit Containern

Nachdem wir die Verbindung zwischen den Containern mit Docker Compose eingerichtet haben, ist es an der Zeit, die Interaktion mit diesen Containern zu optimieren. Im Rahmen des Docker Compose-Systems gibt es den Befehl version: '1' services: simplesample-sonar: image: sonarqube:lts ports: - 9001:9000 - 9092:9092 network_mode: bridge, der die Option -funterstützt, docker-compose.yml.

die es ermöglicht, der Systemumgebung eine Datei zu übergeben. docker-compose.yml.

Mit den Möglichkeiten dieser Option kann die Interaktion mit dem System auf die Container beschränkt werden, die in der Datei erwähnt werden. version: '1' services: simplesample-sonar: image: sonarqube:lts ports: - 9001:9000 - 9092:9092 network_mode: bridgeLassen Sie uns anschauen, wie die Interaktionen mit Containern bei Verwendung der Befehle . Angenommen, wir müssen in die Shell vonpsql

, dann könnten die entsprechenden Befehle folgendermaßen aussehen:

docker-compose -f docker-compose.yml exec timescale psql -Upostgres version: '1' services: simplesample-sonar: image: sonarqube:lts ports: - 9001:9000 - 9092:9092 network_mode: bridge, und dockerDer gleiche Befehl, der nicht verwendet wird, kann so aussehen:

docker exec -it edp_timescale_1 psql -Upostgres

Bitte beachten Sie, dass in solchen Fällen immer die Verwendung von nicht der Kommando docker, sondern der Kommando version: '1' services: simplesample-sonar: image: sonarqube:lts ports: - 9001:9000 - 9092:9092 network_mode: bridge, da dies die Notwendigkeit beseitigt, sich die Namen der Container zu merken.

Beide oben genannten Befehle sind nicht besonders kompliziert. Aber wenn wir eine "Wrapper"-Lösung verwendet hätten, Makefile, die uns eine Schnittstelle in Form von einfachen Befehlen bieten würde und selbst solche langen Befehle aufruft, könnten wir die gleichen Ergebnisse so erzielen:

make db-shell

Es ist offensichtlich, dass die Verwendung von Makefile die Arbeit mit Containern erheblich vereinfacht!

Ein praktisches Beispiel

Basierend auf dem zuvor besprochenen Projektschema erstellen wir die folgende Datei docker-compose.yml:

version: '3.3'
services:
    api:
        build: .
        image: mywebimage:0.0.1
        ports:
            - 8080:8080
        volumes:
            - /app/node_modules/
        depends_on:
            - timescale
        command: npm run dev
        networks:
            - webappnetwork
    timescale:
        image: timescale/timescaledb-postgis:latest-pg11
        environment:
          - POSTGRES_USER=postgres
          - POSTGRES_PASSWORD=postgres
        command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"]
        volumes:
          - ./create_schema.sql:/docker-entrypoint-initdb.d/create_schema.sql
        networks:
           - webappnetwork
    ping:
       image: willfarrell/ping
       environment:
           HOSTNAME: "localhost"
           TIMEOUT: 300
networks:
   webappnetwork:
       driver: bridge

Um die Docker Compose-Konfiguration zu verwalten und mit den beschriebenen Containern zu interagieren, erstellen wir die folgende Datei. Makefile:

THIS_FILE := $(lastword $(MAKEFILE_LIST))
.PHONY: help build up start down destroy stop restart logs logs-api ps login-timescale login-api db-shell
help:
        make -pRrq  -f $(THIS_FILE) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$'
build:
        docker-compose -f docker-compose.yml build $(c)
up:
        docker-compose -f docker-compose.yml up -d $(c)
start:
        docker-compose -f docker-compose.yml start $(c)
down:
        docker-compose -f docker-compose.yml down $(c)
destroy:
        docker-compose -f docker-compose.yml down -v $(c)
stop:
        docker-compose -f docker-compose.yml stop $(c)
restart:
        docker-compose -f docker-compose.yml stop $(c)
        docker-compose -f docker-compose.yml up -d $(c)
logs:
        docker-compose -f docker-compose.yml logs --tail=100 -f $(c)
logs-api:
        docker-compose -f docker-compose.yml logs --tail=100 -f api
ps:
        docker-compose -f docker-compose.yml ps
login-timescale:
        docker-compose -f docker-compose.yml exec timescale /bin/bash
login-api:
        docker-compose -f docker-compose.yml exec api /bin/bash
db-shell:
        docker-compose -f docker-compose.yml exec timescale psql -Upostgres

Die meisten der hier beschriebenen Befehle gelten für alle Container, aber die Verwendung der Option c= beschränkt den Geltungsbereich des Befehls auf einen einzelnen Container.

Sobald Makefile bereit ist, kann es so verwendet werden:

• make help — gibt eine Liste aller verfügbaren Befehle aus, die für make.

Hilfe zu den verfügbaren Befehlen

• make build — Erstellung des Images aus Dockerfile. In unserem Beispiel haben wir vorhandene Images verwendet timescale und ping. Aber das Image api möchten wir lokal erstellen. Genau das wird nach Ausführung dieses Befehls geschehen.

Erstellung des Docker-Containers

• make start — Start aller Container. Um nur einen einzelnen Container zu starten, kann man einen Befehl wie diesen verwenden make start c=timescale.

Start des timescale-Containers

Start des ping-Containers

• make login-timescale — Einstieg in die Bash-Session des Containers timescale.

Bash im timescale-Container starten

• make db-shell — Zugang zu . Angenommen, wir müssen in die Shell von im Container timescale um SQL-Abfragen an die Datenbank auszuführen.

psql im timescaledb-Container starten

• make stop — Stoppen der Container.

Stoppen des timescale-Containers

• make down — Stoppen und Entfernen der Container. Um einen bestimmten Container zu löschen, kann dieser Befehl mit Angabe des gewünschten Containers verwendet werden. Zum Beispiel — make down c=timescale oder make down c=api.

Stoppen und Entfernen aller Container

Ergebnisse

Obwohl das Docker Compose-System uns eine umfangreiche Menge an Befehlen zur Verwaltung von Containern zur Verfügung stellt, werden diese Befehle manchmal lang und sind daher schwer zu merken.

Verfahren zur Nutzung Makefile hat uns geholfen, eine schnelle und einfache Interaktion mit Containern aus der Datei einzurichten docker-compose.yml. Genauer gesagt, es geht um Folgendes:

• Der Entwickler interagiert ausschließlich mit den im Projekt beschriebenen Containern, docker-compose.yml, andere laufende Container stören dabei nicht.
• Falls ein Befehl vergessen wurde, kann der Befehl make help ausgeführt werden, um Hilfe zu den verfügbaren Befehlen zu erhalten.
• Es ist nicht nötig, sich lange Listen von Argumenten für Aktionen wie das Abrufen neuer Protokolle oder das Anmelden zu merken. Zum Beispiel wird ein Befehl wie , dann könnten die entsprechenden Befehle folgendermaßen aussehen: zu make db-shell.
• Die Datei Makefile kann flexibel an die wachsenden Projektanforderungen angepasst werden. Zum Beispiel lässt sich leicht ein Befehl zum Erstellen eines Datenbank-Backups oder für andere Aktionen hinzufügen.
• Wenn ein großes Entwicklerteam dasselbe nutzt, Makefile, organisiert dies die Zusammenarbeit und reduziert die Anzahl der Fehler.

P.S. In unserem Marktplatz gibt es ein Image Docker, das mit einem Klick installiert wird. Sie können die Funktionalität der Container auf VPSüberprüfen. Allen neuen Kunden stehen 3 Tage kostenlos zur Verfügung, um zu testen.

Sehr geehrte Leser! Wie automatisieren Sie die Arbeit mit Docker Compose?

Quelle: habr.com