👍🏿 🛁 🤚🏽 Docker Compose: simplifiez l'utilisation de Makefile 🧖 🍙 😒

Toutes les quelques années, un changement de paradigme se produit dans l'industrie du développement logiciel. L'un de ces phénomènes est l'intérêt croissant pour le concept de microservices. Bien que les microservices ne soient pas la dernière technologie, ce n'est que récemment que sa popularité a littéralement explosé.

Les grands services monolithiques sont aujourd'hui remplacés par des microservices autonomes indépendants. Un microservice peut être considéré comme une application qui sert un objectif unique et très spécifique. Par exemple, il peut s'agir d'un SGBD relationnel, d'une application Express, d'un service Solr. De nos jours, il est difficile d'imaginer le développement d'un nouveau système logiciel sans l'utilisation de microservices. Et cette situation, à son tour, nous conduit à la plate-forme Docker.

Docker

La plate - forme Docker , dans le développement et le déploiement de microservices, est devenue une norme presque industrielle. Sur le site Web du projet, vous pouvez découvrir que Docker est la seule plate-forme de conteneurisation indépendante qui permet aux organisations de créer sans effort des applications, ainsi que de les distribuer et de les exécuter dans n'importe quel environnement - des nuages hybrides aux systèmes frontaliers.

Docker compose

La technologie Docker Compose est conçue pour configurer des applications multi-conteneurs. Un projet Docker Compose peut inclure autant de conteneurs Docker que le créateur de ce projet en a besoin.

Lorsque vous travaillez avec Docker Compose, un fichier YAML est utilisé pour configurer les services d'application et organiser leur interaction les uns avec les autres. Docker Compose est donc un outil pour décrire et exécuter des applications multi-conteneurs Docker.

Deux conteneurs fonctionnant sur le système hôte

GNU Make

Un programme makeest essentiellement un outil pour automatiser l'assemblage de programmes et de bibliothèques à partir du code source. En général, nous pouvons dire qu'il est makeapplicable à tout processus qui comprend l'exécution de commandes arbitraires pour convertir certains matériaux source en une certaine forme résultante, dans un certain but. Dans notre cas, les équipes docker-composeseront converties en objectifs abstraits ( cibles bidon ).

Afin de dire au programme makece que nous en attendons, nous avons besoin d'un fichier Makefile.

La nôtre Makefilecontiendra les commandes habituelles dockeretdocker-composequi sont conçus pour résoudre de nombreux problèmes. À savoir, nous parlons d'assembler le conteneur, de le démarrer, de l'arrêter, de le redémarrer, d'organiser la connexion de l'utilisateur au conteneur, de travailler avec les journaux du conteneur et de résoudre d'autres problèmes similaires.

Utilisations typiques de Docker Compose

Imaginez une application Web standard qui comprend les composants suivants:

Base de données TimescaleDB (Postgres).
Application Express.js.
Ping (juste un conteneur qui ne fait rien de spécial).

Cette application aura besoin de 3 conteneurs Docker et d'un fichier docker-composecontenant des instructions pour gérer ces conteneurs. Chacun des conteneurs aura différents points d'interaction. Par exemple, timescalevous pouvez travailler avec un conteneur de la même manière que vous travaillez avec des bases de données. À savoir, il vous permet d'effectuer les actions suivantes:

Connectez-vous au shell Postgres.
Importer et exporter des tableaux.
Créez une pg_dumptable ou une base de données.

Le conteneur d'une application Express.js ,, expressjspeut avoir les fonctionnalités suivantes:

La sortie de nouvelles données du journal système.
Entrez dans le shell pour exécuter certaines commandes.

Interaction avec les conteneurs

Après avoir configuré la connexion entre les conteneurs à l'aide de Docker Compose, il est temps d'établir une interaction avec ces conteneurs. Dans le cadre du système Docker Compose, une commande docker-composeprend en charge une option -fqui vous permet de transférer un fichier sur le système docker-compose.yml.

En utilisant les capacités de cette option, vous pouvez limiter l'interaction avec le système uniquement aux conteneurs mentionnés dans le fichier docker-compose.yml.

Jetez un œil à l'apparence des interactions de conteneur lors de l'utilisation de commandes docker-compose. Si nous imaginons que nous devons entrer dans le shell psql, les commandes correspondantes peuvent ressembler à ceci:

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

La même commande pour laquelle non docker-compose, mais est utilisée docker, peut ressembler à ceci:

docker exec -it  edp_timescale_1 psql -Upostgres

Veuillez noter que dans de tels cas, il est toujours préférable d'utiliser non pas une commande docker, mais une commande docker-compose, car cela élimine la nécessité de se souvenir des noms de conteneurs.

Les deux commandes ci-dessus ne sont pas si compliquées. Mais si nous utilisions un «wrapper» sous une forme Makefilequi nous donnerait une interface sous forme de commandes simples et appellerait nous-mêmes de telles commandes, alors les mêmes résultats pourraient être obtenus comme ceci:

make db-shell

Il est évident que l'utilisation Makefilesimplifie grandement le travail avec des conteneurs!

Exemple de travail

Sur la base du diagramme de projet ci-dessus, créez le fichier suivant 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

Pour gérer la configuration Docker Compose et interagir avec les conteneurs qu'elle décrit, créez le fichier suivant 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

La plupart des commandes décrites ici s'appliquent à tous les conteneurs, mais l'utilisation de l'option c=vous permet de limiter la portée de la commande à un seul conteneur.

Une fois Makefileprêt, vous pouvez l'utiliser comme ceci:

make help- émission d'une liste de toutes les commandes disponibles pour make.

Aide sur les commandes disponibles

make build- assemblage de l'image à partir de Dockerfile. Dans notre exemple, nous avons utilisé des images existantes timescaleet ping. Mais apinous voulons collecter l' image localement. C'est exactement ce qui sera fait après l'exécution de cette commande.

Ensemble conteneur Docker

make start- lancement de tous les conteneurs. Pour démarrer un seul conteneur, vous pouvez utiliser la commande du formulaire make start c=timescale.

Lancer le conteneur de l'échelle de temps

Lancer le conteneur ping

make login-timescale- entrée dans la session bash du conteneur timescale.

Exécution de bash dans un conteneur d'échelle de temps

make db-shell- Connectez-vous psqlau conteneur timescalepour exécuter des requêtes SQL dans la base de données.

Exécution de psql dans le conteneur timescaledb

make stop - arrêt des conteneurs.

Arrêt du conteneur de l'échelle de temps

make down- arrêtez et retirez les conteneurs. Pour supprimer un conteneur spécifique, vous pouvez utiliser cette commande avec le conteneur spécifié. Par exemple - make down c=timescaleou make down c=api.

Arrêtez et supprimez tous les conteneurs

Sommaire

Malgré le fait que le système Docker Compose nous donne un ensemble complet de commandes conçues pour gérer les conteneurs, parfois ces commandes deviennent longues et, par conséquent, elles peuvent être difficiles à retenir.

La méthodologie d'utilisation Makefilenous a permis d'établir une interaction rapide et facile avec les conteneurs du fichier docker-compose.yml. À savoir, nous parlons de ce qui suit:

, docker-compose.yml, .
, , make help .
, . , docker-compose -f docker-compose.yml exec timescale psql -Upostgres make db-shell.
Makefile , , . , .
Makefile, .

PS Sur notre marché, il y a une image Docker , qui est installée en un clic. Vous pouvez vérifier le fonctionnement des conteneurs sur VPS . Tous les nouveaux clients bénéficient de 3 jours gratuits pour les tests.

Chers lecteurs! Comment automatisez-vous le travail avec Docker Compose?

Docker Compose: simplifiez l'utilisation de Makefile