Docker Compose: het vereenvoudigen van werk met Makefile

Om de paar jaar vindt er een verschuiving in de softwareontwikkelingsindustrie plaats. Een van zulke fenomenen is de toenemende interesse in het concept van microservices. Hoewel microservices geen nieuwe technologie zijn, is de populariteit ervan de laatste tijd werkelijk explosief gestegen.

Grote monolithische services worden tegenwoordig vervangen door onafhankelijke autonome microservices. Een microservice kan worden gezien als een applicatie die een enkele en zeer specifieke doelstelling dient. Bijvoorbeeld, dit kan een relationele database zijn, een Express-applicatie, of een Solr-service.

Tegenwoordig is het moeilijk je voor te stellen dat er een nieuw softwaresysteem wordt ontwikkeld zonder het gebruik van microservices. Deze situatie leidt ons dan ook naar het platform Docker.

Docker

Platform Docker, dat in de ontwikkeling en implementatie van microservices vrijwel de industriestandaard is geworden. Op de website van het project is te lezen dat Docker het enige onafhankelijke containerisatieplatform is dat organisaties in staat stelt om met weinig moeite applicaties te bouwen, te distribueren en uit te voeren in elke omgeving, van hybride cloud tot edge-systemen.

Docker Compose

Technologie Docker Compose is bedoeld voor het configureren van multi-container applicaties. In een Docker Compose-project kunnen zoveel Docker-containers zitten als de maker van het project nodig heeft.

Bij het werken met Docker Compose wordt voor het configureren van de services van de applicatie en het organiseren van hun interactie met elkaar gebruikgemaakt van een YAML-bestand. Docker Compose is dus een hulpmiddel voor het beschrijven en uitvoeren van multi-container Docker-applicaties.

Twee containers die draaien op het host-systeem

GNU Make

zal de metadata van het bestandssysteem overschrijven. Gebruik hiervoor het volgende commando: make, is in wezen een hulpmiddel voor het automatiseren van de bouw van programma's en bibliotheken uit broncode. Over het algemeen kan men zeggen dat make toepasbaar is op elk proces dat het uitvoeren van willekeurige commando's omvat om bepaalde grondstoffen te transformeren naar een bepaald resultaat, naar een bepaald doel. In ons geval zullen de commando's docker-compose worden omgezet in abstracte doelen (Phony targets).

Om de applicatie te laten weten make wat we van haar willen, hebben we een bestand nodig Makefile.

In onze Makefile zullen de gebruikelijke commando's worden opgenomen docker en docker-compose, die bedoeld zijn om verschillende taken op te lossen. Dit omvat het opbouwen van een container, het starten, stoppen en opnieuw opstarten ervan, het organiseren van de toegang van een gebruiker tot de container, het werken met de logs van de container en het oplossen van andere soortgelijke taken.

Typische toepassingen van Docker Compose

Laten we ons een gewone webapplicatie voorstellen, die de volgende componenten bevat:

• Een TimescaleDB (Postgres) database.
• Een Express.js-applicatie.
• Ping (simply a container that doesn't do anything special).

Deze applicatie heeft 3 Docker-containers en een bestand docker-compose, dat instructies bevat voor het beheren van deze containers. Elke container zal verschillende interactiepunten hebben. Bijvoorbeeld, met de container timescale kan op een manier worden gewerkt als met databases. Hiermee kunnen de volgende acties worden uitgevoerd:

• Toegang tot de Postgres-shell.
• Importeren en exporteren van tabellen.
• Creëren pg_dump van een tabel of database.

De container van de Express.js-applicatie, expressjs, kan de volgende mogelijkheden hebben:

• Het verstrekken van actuele gegevens uit het systeemlogboek.
• Toegang tot de shell voor het uitvoeren van bepaalde commando's.

Interactie met containers

Nadat we verbinding hebben gemaakt tussen de containers met behulp van Docker Compose, is het tijd om de interactie met deze containers op te zetten. Binnen het Docker Compose-systeem is er een commando docker-compose, dat de optie ondersteunt -f, die het mogelijk maakt om het bestand docker-compose.yml.

door te geven aan het systeem. docker-compose.yml.

Met de mogelijkheden van deze optie kan de interactie met het systeem worden beperkt tot alleen die containers die in het bestand worden genoemd. docker-composeLaten we eens kijken naar hoe de interacties met containers eruitzien bij het gebruik van de commando's psql. Als we ons voorstellen dat we in de shell moeten inloggen

, kunnen de bijbehorende commando's er als volgt uitzien:

docker-compose -f docker-compose.yml exec timescale psql -Upostgres docker-compose, met behulp van 1 bit, gelijk aan 0, dockerHetzelfde commando, waarvoor geen

, kan er als volgt uitzien:

docker exec -it edp_timescale_1 psql -Upostgres dockerLet op dat het in dergelijke gevallen altijd beter is om niet het commando docker-compose, maar het commando

, te gebruiken, omdat dit de noodzaak om de namen van de containers te onthouden, verlicht. Makefile, die ons een interface zou geven in de vorm van eenvoudige commando's en zelf dergelijke lange commando's zou aanroepen, zou op dezelfde manier bereikt kunnen worden:

make db-shell

Het is volkomen duidelijk dat het gebruik van Makefile de werking met containers aanzienlijk vereenvoudigt!

Werkend voorbeeld

Op basis van het eerder besproken projectplan zullen we het volgende bestand creëren 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

Om de configuratie van Docker Compose te beheren en om interactie te hebben met de containers die het beschrijft, zullen we het volgende bestand creëren 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

De meeste hier beschreven commando's zijn van toepassing op alle containers, maar het gebruik van de optie c= staat toe de reikwijdte van het commando te beperken tot één container.

Nadat Makefile is klaar, je kunt het als volgt gebruiken:

• make help — geeft een lijst van alle beschikbare commando's voor make.

Hulp over beschikbare commando's

• make build — bouwt een afbeelding uit Dockerfile. In ons voorbeeld hebben we bestaande afbeeldingen gebruikt timescale en ping. Maar de afbeelding api die we lokaal willen samenstellen. Dit zal gebeuren na het uitvoeren van deze opdracht.

Het bouwen van een Docker-container

• make start — start alle containers. Om slechts één container te starten, kan de opdracht van de volgende vorm worden gebruikt make start c=timescale.

Start de timescale-container

Start de ping-container

• make login-timescale — toegang tot de bash-sessie van de container timescale.

Start bash in de timescale-container

• make db-shell — toegang tot psql de container timescale om SQL-query's op de database uit te voeren.

Start psql in de timescaledb-container

• make stop — stop de containers.

Stop de timescale-container

• make down — stop en verwijder de containers. Om een specifieke container te verwijderen, kan deze opdracht worden gebruikt met opgave van de benodigde container. Bijvoorbeeld — make down c=timescale of make down c=api.

Stop en verwijder alle containers

Conclusies

Hoewel het Docker Compose-systeem ons een uitgebreide set opdrachten biedt om containers te beheren, worden deze opdrachten soms lang en worden ze moeilijk te onthouden.

De gebruikte methodiek Makefile heeft ons geholpen om snel en eenvoudig met containers uit het bestand te communiceren docker-compose.yml. Dit betreft specifiek het volgende:

• De ontwikkelaar communiceert alleen met de projectcontainers die zijn beschreven in docker-compose.yml, andere draaiende containers bemoeien zich er niet mee.
• Als een bepaalde opdracht vergeten is, kan de opdracht make help worden uitgevoerd om hulp te krijgen over beschikbare opdrachten.
• Het is niet nodig om lange lijsten van argumenten te onthouden voor het uitvoeren van acties zoals het ophalen van recente logboeken of inloggen. Bijvoorbeeld, een opdracht van de vorm , kunnen de bijbehorende commando's er als volgt uitzien: verandert in make db-shell.
• Bestand Makefile kan, naarmate het project groeit, gemakkelijk aan worden gepast. Bijvoorbeeld, het is niet moeilijk om een opdracht toe te voegen voor het maken van een back-up van de database of voor het uitvoeren van elke andere actie.
• Als een groot team van ontwikkelaars hetzelfde Makefile, helpt dit de samenwerking te structureren en vermindert het aantal fouten.

P.S. In onze op de marktplaats is er een afbeelding Docker, die met één klik kan worden geïnstalleerd. U kunt de werking van de containers testen op VPS. Alle nieuwe klanten krijgen 3 dagen gratis om uit te proberen.

Geachte lezers! Hoe automatiseert u het werken met Docker Compose?

Bron: habr.com