Lors de la conférence FOSDEM 2020, le projet a été présenté

Tous les quelques années, l'industrie du développement logiciel connaît un changement de paradigme. L'un de ces phénomènes peut être reconnu par l'augmentation de l'intérêt pour le concept de microservices. Bien que les microservices ne soient pas une technologie nouvelle, leur popularité a littéralement explosé ces dernières années.

De nos jours, de grands services monolithiques sont remplacés par des microservices autonomes et indépendants. Un microservice peut être considéré comme une application qui sert un but unique et très spécifique. Par exemple, cela peut être une base de données relationnelle, une application Express, ou un service Solr.

De nos jours, il est difficile d'imaginer le développement d'un nouveau système logiciel sans utiliser des microservices. Cette situation nous conduit à la plateforme Docker.

Docker

Plateforme Docker, dans le domaine du développement et du déploiement de microservices, est devenue pratiquement un standard industriel. Sur le site du projet, on peut apprendre que Docker est la seule plateforme de conteneurisation autonome qui permet aux organisations de créer facilement n'importe quelle application, ainsi que de les distribuer et de les exécuter dans n'importe quel environnement — des nuages hybrides aux systèmes en périphérie.

Docker Compose

Technologie Docker Compose destinée à la configuration d'applications multi-conteneurs. Dans un projet Docker Compose, autant de conteneurs Docker que nécessaire peuvent être inclus par le créateur du projet.

Lorsqu'on travaille avec Docker Compose, un fichier YAML est utilisé pour configurer les services de l'application et organiser leur interaction. Docker Compose est donc un outil pour décrire et exécuter des applications Docker multi-conteneurs.

Deux conteneurs fonctionnant sur un système hôte

GNU Make

Programme make, en essence, est un outil pour automatiser la construction de programmes et de bibliothèques à partir du code source. En général, on peut dire que make s'applique à tout processus impliquant l'exécution de commandes arbitraires pour transformer certains matériaux d'entrée en un certain résultat, en un certain objectif. Dans notre cas, les commandes docker-compose seront transformées en objectifs abstraits (Cibles fictives).

Pour indiquer à l'application make ce que nous voulons d'elle, nous aurons besoin d'un fichier Makefile.

Dans notre Makefile contiendra des commandes ordinaires. docker et docker-compose, qui sont destinées à résoudre de nombreuses tâches. En effet, il s'agit de l'assemblage du conteneur, de son démarrage, de son arrêt, de son redémarrage, de l'organisation de l'accès de l'utilisateur au conteneur, de la gestion des journaux du conteneur et de la résolution d'autres tâches similaires.

Cas d'utilisation typiques de Docker Compose

Imaginons une application web standard, qui comporte les composants suivants :

• Base de données TimescaleDB (Postgres).
• Application Express.js.
• Ping (simple conteneur, ne faisant rien de particulier).

Cette application nécessitera 3 conteneurs Docker et un fichier docker-compose, contenant des instructions pour gérer ces conteneurs. Chacun des conteneurs aura des points d'interaction différents. Par exemple, avec le conteneur timescale , on pourra interagir de la même manière qu'avec des bases de données. En effet, il permet d'effectuer les actions suivantes :

• Accès au shell Postgres.
• Importation et exportation de tables.
• Création pg_dump de tables ou de bases de données.

Le conteneur de l'application Express.js, expressjs, peut avoir les fonctionnalités suivantes :

• Fourniture de données récentes à partir du journal système.
• Accès au shell pour exécuter certaines commandes.

Interaction avec les conteneurs

Après avoir configuré la connectivité entre les conteneurs à l'aide de Docker Compose, il est temps de mettre en place l'interaction avec ces conteneurs. Au sein du système Docker Compose, il existe une commande docker-compose, qui prend en charge l'option -f, permettant de transmettre au système un fichier docker-compose.yml.

En utilisant cette option, il est possible de restreindre l'interaction avec le système uniquement aux conteneurs mentionnés dans le fichier. docker-compose.yml.

Regardons à quoi ressemblent les interactions avec les conteneurs lors de l'utilisation des commandes docker-compose. Si l'on suppose que nous devons accéder au shell psql, alors les commandes correspondantes peuvent ressembler à ceci :

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

La même commande, quand elle est utilisée sans docker-compose, et docker, peut se formuler comme suit :

docker exec -it edp_timescale_1 psql -Upostgres

Notez qu'il est toujours préférable d'utiliser la commande docker, plutôt que la commande docker-compose, car cela permet d'éviter d'avoir à se souvenir des noms des conteneurs.

Les deux commandes ci-dessus ne sont pas si compliquées. Mais si nous avions utilisé un « wrapper » sous forme de Makefile, qui nous donnerait une interface sous forme de commandes simples et invoquerait elle-même de telles longues commandes, des résultats similaires pourraient être obtenus comme suit :

make db-shell

Il est tout à fait évident que l'utilisation de Makefile simplifie considérablement le travail avec les conteneurs !

Exemple de travail

Sur la base du schéma de projet examiné ci-dessus, nous créerons 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 pour interagir avec les conteneurs qu'elle décrit, créons 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= permet de limiter la portée de la commande à un seul conteneur.

Après que Makefile soit prêt, vous pouvez l'utiliser comme suit :

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

Aide sur les commandes disponibles

• make build — construction de l'image à partir de Dockerfile. Dans notre exemple, nous avons utilisé des images existantes timescale et ping. Mais l'image api que nous voulons assembler localement. C'est précisément ce qui sera réalisé après l'exécution de cette commande.

Assemblage d'un conteneur Docker

• make start — démarrage de tous les conteneurs. Pour démarrer un seul conteneur, vous pouvez utiliser une commande comme make start c=timescale.

Démarrage du conteneur timescale

Démarrage du conteneur ping

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

Démarrage de bash dans le conteneur timescale

• make db-shell — connexion dans psql le conteneur timescale pour exécuter des requêtes SQL sur la base de données.

Démarrer psql dans le conteneur timescaledb

• make stop — arrêt des conteneurs.

Arrêt du conteneur timescale

• make down — arrêt et suppression des conteneurs. Pour supprimer un conteneur spécifique, cette commande peut être utilisée en indiquant le conteneur souhaité. Par exemple — make down c=timescale ou make down c=api.

Arrêt et suppression de tous les conteneurs

Résultats

Bien que le système Docker Compose nous donne un large ensemble de commandes destinées à gérer les conteneurs, parfois ces commandes deviennent longues, ce qui les rend difficiles à mémoriser.

La méthodologie d'utilisation Makefile nous a aidés à établir une interaction rapide et simple avec les conteneurs à partir du fichier docker-compose.yml. En d'autres termes, il s'agit de ce qui suit :

• Le développeur n'interagit qu'avec les conteneurs du projet, décrits dans docker-compose.yml, le travail n'est pas gêné par d'autres conteneurs en cours d'exécution.
• Dans le cas où une certaine commande est oubliée, vous pouvez exécuter la commande make help et obtenir de l'aide sur les commandes disponibles.
• Il n'est pas nécessaire de mémoriser de longues listes d'arguments pour effectuer des actions telles que récupérer des entrées récentes du journal ou se connecter. Par exemple, une commande comme docker-compose -f docker-compose.yml exec timescale psql -Upostgres se transforme en make db-shell.
• Le fichier Makefile peut, au fur et à mesure que le projet grandit, être flexible pour s'adapter à lui. Par exemple, il est facile d'ajouter une commande pour créer une sauvegarde de la base de données ou pour effectuer toute autre action.
• Si une grande équipe de développeurs utilise le même Makefile, cela organise le travail collaboratif et réduit le nombre d'erreurs.

P.S. Dans notre sur le marketplace il y a une image Docker, qui s'installe en un clic. Vous pouvez vérifier le fonctionnement des conteneurs sur VPS. Tous les nouveaux clients se voient offrir 3 jours gratuits pour des tests.

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

Source : habr.com