Docker Compose : simplifier votre travail à l'aide de Makefiles

Toutes les quelques années, le secteur du développement logiciel subit un changement de paradigme. L’un de ces phénomènes peut être reconnu comme l’intérêt croissant pour le concept de microservices. Bien que les microservices ne soient pas la technologie la plus récente, ce n’est que récemment que leur popularité a littéralement explosé.

Les grands services monolithiques sont désormais remplacés par des microservices indépendants et autonomes. Un microservice peut être considéré comme une application qui répond à 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 développer un nouveau système logiciel sans utiliser de microservices. Et cette situation, à son tour, nous amène à la plateforme Docker.

Docker

plate-forme Docker, dans le développement et le déploiement de microservices, est devenu presque un standard de l'industrie. 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 n'importe quelle application, ainsi que de la distribuer et de l'exécuter dans n'importe quel environnement, des cloud hybrides aux systèmes de périphérie.

Docker Compose

Technologie Docker Compose conçu pour configurer des applications multi-conteneurs. Un projet Docker Compose peut contenir autant de conteneurs Docker que le créateur du 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 permettant de décrire et d'exécuter des applications Docker multi-conteneurs.

Deux conteneurs exécutés sur un système hôte

Marque GNU

Programme make, est essentiellement un outil permettant d'automatiser la création de programmes et de bibliothèques à partir du code source. En général, on peut dire que make s'applique à tout processus qui implique l'exécution de commandes arbitraires pour transformer certains matériaux d'entrée en une forme de sortie, vers un objectif donné. Dans notre cas, les commandes docker-compose seront transformés en objectifs abstraits (Cibles téléphoniques).

Pour dire le programme make sur ce que nous en attendons, nous avons besoin d'un fichier Makefile.

В нашем Makefile contiendra des commandes régulières docker и docker-compose, qui sont conçus pour résoudre de nombreux problèmes. À savoir, nous parlons d'assembler un conteneur, de le démarrer, de l'arrêter, de le redémarrer, d'organiser la connexion des utilisateurs au conteneur, de travailler avec les journaux du conteneur et de résoudre d'autres problèmes similaires.

Cas d'utilisation typiques de Docker Compose

Imaginons une application Web standard comportant les composants suivants :

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

Cette application aura besoin de 3 conteneurs Docker et d'un fichier docker-compose, qui contient des instructions pour gérer ces conteneurs. Chaque conteneur aura des points de contact différents. Par exemple, avec un conteneur timescale il sera possible de travailler à peu près de la même manière qu'ils travaillent avec des bases de données. A savoir, il vous permet d'effectuer les actions suivantes :

• Connexion au shell Postgres.
• Import et export de tableaux.
• création pg_dump des tables ou des bases de données.

Conteneur d'applications Express.js, expressjs, peut avoir les capacités suivantes :

• Fournir de nouvelles données à partir du journal système.
• Connectez-vous au shell pour exécuter certaines commandes.

Interagir avec les conteneurs

Une fois que nous avons configuré la communication entre les conteneurs à l'aide de Docker Compose, il est temps de communiquer avec ces conteneurs. Dans le système Docker Compose, il existe une commande docker-compose, option de support -f, qui vous permet de transférer un fichier vers 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.

Voyons à quoi ressemblent les interactions avec les conteneurs lors de l'utilisation de commandes docker-compose. Si nous imaginons que nous devons nous connecter au shell psql, alors les commandes correspondantes pourraient ressembler à ceci :

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

La même commande qui n'est pas utilisée pour exécuter docker-composeEt docker, pourrait ressembler à ceci :

docker exec -it  edp_timescale_1 psql -Upostgres

Attention, dans de tels cas il est toujours préférable d'utiliser la commande docker, et la commande docker-compose, car cela élimine le besoin de mémoriser les noms des conteneurs.

Les deux commandes ci-dessus ne sont pas si difficiles. Mais si on utilisait un « wrapper » sous la forme Makefile, qui nous donnerait une interface sous forme de commandes simples et appellerait elle-même des commandes longues similaires, alors les mêmes résultats pourraient être obtenus comme ceci :

make db-shell

Il est bien évident que l'utilisation Makefile rend le travail avec des conteneurs beaucoup plus facile !

Exemple de travail

Sur la base du diagramme de projet ci-dessus, nous allons créer 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 de Docker Compose et interagir avec les conteneurs qu'il décrit, nous allons créer 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 en utilisant l'option c= vous permet de limiter la portée d'une commande à un seul conteneur.

Après Makefile prêt, vous pouvez l'utiliser comme ceci :

• make help — émettre une liste de toutes les commandes disponibles pour make.

Aide sur les commandes disponibles

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

Construire un conteneur Docker

• make start — lancement de tous les conteneurs. Pour lancer un seul conteneur, vous pouvez utiliser une commande comme make start c=timescale.

Exécuter le conteneur d'échelle de temps

Exécuter un conteneur ping

• make login-timescale — connectez-vous à la session bash du conteneur timescale.

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

• make db-shell - l'entrée de psql dans un conteneur timescale pour exécuter des requêtes SQL sur la base de données.

Exécuter psql dans un conteneur timescaledb

• make stop — arrêter les conteneurs.

Arrêter un conteneur d'échelle de temps

• make down — arrêter et retirer les conteneurs. Pour supprimer un conteneur spécifique, vous pouvez utiliser cette commande en spécifiant le conteneur souhaité. Par exemple - make down c=timescale ou make down c=api.

Arrêter et supprimer tous les conteneurs

Les résultats de

Bien que Docker Compose nous offre un riche ensemble de commandes pour gérer les conteneurs, ces commandes peuvent parfois devenir longues et difficiles à mémoriser.

Mode d'utilisation Makefile nous a aidé à établir une interaction rapide et facile avec les conteneurs à partir d'un fichier docker-compose.yml. A savoir, nous parlons des éléments suivants :

• Le développeur interagit uniquement avec les conteneurs de projet décrits dans docker-compose.yml, le travail n'est pas gêné par d'autres conteneurs en cours d'exécution.
• En cas d'oubli d'une certaine commande, vous pouvez exécuter la commande make help et obtenez de l'aide sur les commandes disponibles.
• Vous n'avez pas besoin de mémoriser de longues listes d'arguments pour effectuer des actions telles que l'obtention des dernières entrées de journal ou la connexion à un système. Par exemple, une commande comme docker-compose -f docker-compose.yml exec timescale psql -Upostgres se transforme en make db-shell.
• Dossier Makefile Vous pouvez vous y adapter de manière flexible à mesure que le projet se développe. Par exemple, il est facile d'ajouter une commande pour créer une sauvegarde de base de données ou effectuer toute autre action.
• Si une grande équipe de développeurs utilise le même Makefile, cela rationalise la collaboration et réduit les erreurs.

PS В нашем marché il y a une image Docker, qui peut être installé en un clic. Vous pouvez vérifier le fonctionnement des conteneurs sur VPS. Tous les nouveaux clients bénéficient de 3 jours de tests gratuits.

Chers lecteurs, Comment automatiser Docker Compose ?

Source: habr.com