Docker Compose: Vereinfachung der Arbeit mit Makefile.

Alle paar Jahre findet in der Softwareentwicklungsbranche ein Paradigmenwechsel statt. Ein solches Phänomen ist das wachsende Interesse an der Konzept der Mikrodienste. Obwohl Mikrodienste keine ganz neue Technologie sind, hat ihre Popularität in letzter Zeit sprunghaft zugenommen.

In der heutigen Zeit werden große monolithische Dienste durch unabhängige, autonome Mikrodienste ersetzt. Ein Mikrodienst kann als Anwendung betrachtet werden, die einem einzigen und sehr spezifischen Zweck dient. Zum Beispiel kann dies eine relationale Datenbank, eine Express-Anwendung oder ein Solr-Dienst sein.

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

Docker

Plattform Docker, die beim Entwickeln und Bereitstellen von Mikrodiensten praktisch zum Industriestandard geworden ist. Auf der Projektwebsite kann man erfahren, dass Docker die einzige unabhängige Containerisierungsplattform ist, die es Organisationen ermöglicht, ohne großen Aufwand beliebige Anwendungen zu erstellen sowie diese in verschiedenen Umgebungen von hybriden Clouds bis hin zu Edge-Systemen zu verteilen und auszuführen.

Docker Compose

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

Beim Arbeiten mit Docker Compose wird zur Konfiguration der Anwendungsdienste und zur Organisation ihrer Interaktionen untereinander eine YAML-Datei verwendet. Docker Compose ist somit ein Werkzeug zur Beschreibung und Ausführung von Docker-Multi-Container-Anwendungen.

Zwei Container, die auf einem Host-System

GNU Make

Programm make, stellt im Wesentlichen ein Werkzeug zur Automatisierung des Bauprozesses von Programmen und Bibliotheken aus Quellcode dar. Im Allgemeinen kann man sagen, dass make auf jeden Prozess anwendbar ist, der die Ausführung beliebiger Befehle zur Umwandlung gewisser Rohmaterialien in eine bestimmte Resultatsform, ein gewisses Ziel, umfasst. In unserem Fall werden die Befehle docker-compose in abstrakte Ziele umgewandelt (Phony targets).

Um dem Programm zu sagen, was wir von ihm wollen, benötigen wir eine Datei make In unserem Makefile.

wird es gewöhnliche Befehle enthalten. Makefile In unserem docker und docker-compose, die zur Lösung einer Vielzahl von Aufgaben bestimmt sind. Genauer gesagt, es geht um den Aufbau des Containers, um dessen Start, Stopp, Neustart, um die Organisation des Benutzerzugangs zum Container, um die Arbeit mit den Logs des Containers und um die Lösung anderer ähnlicher Aufgaben.

Typische Anwendungsfälle für Docker Compose

Stellen wir uns eine gewöhnliche Webanwendung vor, die die folgenden Komponenten umfasst:

• Datenbank TimescaleDB (Postgres).
• Express.js-Anwendung.
• Ping (einfacher Container, der nichts Besonderes macht).

Diese Anwendung benötigt 3 Docker-Container und eine Datei docker-compose, die Anweisungen zur Verwaltung dieser Container enthält. Jeder Container wird unterschiedliche Schnittstellen haben. Zum Beispiel kann man mit dem Container timescale ungefähr so arbeiten, wie man mit Datenbanken arbeitet. Genauer gesagt, er ermöglicht die folgenden Aktionen:

• Zugriff auf die Postgres-Shell.
• Import und Export von Tabellen.
• Erstellen pg_dump von Tabellen oder Datenbanken.

Der Container der Express.js-Anwendung, expressjs, kann die folgenden Funktionen haben:

• Bereitstellung frischer Daten aus dem Systemprotokoll.
• Zugriff auf die Shell zur Ausführung bestimmter Befehle.

Interaktion mit Containern

Nachdem wir die Verbindung zwischen den Containern mithilfe von Docker Compose eingerichtet haben, ist es an der Zeit, die Interaktion mit diesen Containern zu etablieren. Innerhalb des Docker Compose-Systems gibt es einen Befehl docker-compose, der die Option -funterstützt, die es ermöglicht, der Software eine Datei zu übergeben, docker-compose.yml.

Durch die Nutzung dieser Option kann die Interaktion mit dem System auf nur die Container beschränkt werden, die in der Datei erwähnt werden. docker-compose.yml.

Schauen wir uns an, wie die Interaktionen mit Containern bei Verwendung der Befehle aussehen. docker-compose. Wenn wir uns vorstellen, dass wir in die Shell von psql, gelangen wollen, könnten die entsprechenden Befehle so aussehen:

docker-compose -f docker-compose.yml exec timescale psql -Upostgres

Der gleiche Befehl, für dessen Ausführung nicht docker-compose, und docker, könnte so aussehen:

docker exec -it edp_timescale_1 psql -Upostgres

Beachten Sie, dass es in solchen Fällen immer vorzuziehen ist, nicht den Befehl docker, sondern den Befehl docker-compose, zu verwenden, da dies es erleichtert, sich die Container-Namen nicht merken zu müssen.

Beide oben genannten Befehle sind nicht besonders kompliziert. Aber hätten wir in Form einer „Wrapper“-Lösung genutzt Makefile, die uns eine Schnittstelle in Form einfacher Befehle bieten würde und ähnliche lange Befehle selbst aufrufen würde, könnten die gleichen Ergebnisse so erzielt werden:

make db-shell

Es ist völlig offensichtlich, dass die Verwendung Makefile die Arbeit mit Containern erheblich vereinfacht!

Arbeitsbeispiel

Basierend auf dem oben beschriebenen 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 Konfiguration von Docker Compose zu verwalten und mit den Containern zu interagieren, die sie beschreibt, 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 hier beschriebenen Befehle gelten für alle Container, aber die Verwendung der Option c= ermöglicht es, den Anwendungsbereich des Befehls auf einen einzelnen Container zu beschränken.

Nachdem Makefile es fertig ist, kann man es so verwenden:

• make help — Ausgabe einer Liste aller verfügbaren Befehle für make.

Hilfe zu den verfügbaren Befehlen

• make build — Erstellung des Images aus Dockerfile. In unserem Beispiel haben wir bestehende Images verwendet timescale und ping. Aber das Image API wollen wir lokal sammeln. Genau das wird nach der Ausführung dieses Befehls getan.

Build des Docker-Containers

• make start — starten aller Container. Um nur einen bestimmten Container zu starten, kann man einen Befehl in der Art verwenden von make start c=timescale.

Start des Containers timescale

Start des Containers ping

• make login-timescale — Zugang zur bash-Session des Containers timescale.

Zugriff auf bash im Container timescale

• make db-shell — Zugang zu psql in einem Container timescale um SQL-Abfragen zur Datenbank auszuführen.

Start von psql im Container timescaledb

• make stop — Stoppen der Container.

Stoppen des Containers timescale

• make down — Stoppen und Entfernen der Container. Um einen bestimmten Container zu entfernen, kann man diesen Befehl mit Angabe des erforderlichen Containers verwenden. Zum Beispiel — make down c=timescale oder make down c=api.

Stoppen und Entfernen aller Container

Ergebnisse

Trotz der Tatsache, dass das Docker Compose-System uns eine umfangreiche Sammlung von Befehlen zur Verfügung stellt, die zur Verwaltung von Containern gedacht sind, werden diese Befehle manchmal lang, wodurch sie schwer zu merken sind.

Die Methode der Verwendung Makefile hat uns geholfen, eine schnelle und einfache Interaktion mit den Containern aus der Datei docker-compose.ymleinzurichten. Genauer gesagt geht es um Folgendes:

• Der Entwickler interagiert ausschließlich mit den im docker-compose.ymlbeschriebenen Containern des Projekts, ohne dass andere gestartete Container stören.
• Falls ein gewisser Befehl vergessen wird, kann man den Befehl make help ausführen und sich Hilfe zu den verfügbaren Befehlen holen.
• Es ist nicht notwendig, lange Listen von Argumenten zum Ausführen solcher Aktionen zu merken, wie das Abrufen frischer Protokolle oder das Einloggen. Zum Beispiel wird ein Befehl in der Art von docker-compose -f docker-compose.yml exec timescale psql -Upostgres zu make db-shell.
• Die Datei Makefile kann, je nach Wachstum des Projekts, flexibel darauf angepasst werden. Zum Beispiel kann man leicht einen Befehl zum Erstellen einer Datenbanksicherung oder zum Ausführen einer anderen Aktion hinzufügen.
• Wenn ein großes Entwicklerteam dasselbe verwendet Makefile, erleichtert das die Zusammenarbeit und verringert die Anzahl der Fehler.

P.S. wird es gewöhnliche Befehle enthalten. 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 zur kostenlosen Testung zur Verfügung.

Liebe Leser! Wie automatisieren Sie die Arbeit mit Docker Compose?

Quelle: habr.com