Docker Compose: förenkla arbetet med att använda Makefile

Varje par år sker det en förändring av paradigmer inom programvaruutvecklingsindustrin. En av dessa fenomen kan betraktas som det växande intresset för konceptet mikrotjänster. Även om mikrotjänster inte är en helt ny teknologi har dess popularitet på senare tid verkligen skjutit i höjden.

Stora monolitiska tjänster ersätts nu för tiden av oberoende, autonomiska mikrotjänster. En mikrotjänst kan ses som en applikation som har ett mycket specifikt syfte. Till exempel kan det vara en relationsdatabas, en Express-applikation eller en Solr-tjänst.

Idag är det svårt att föreställa sig utvecklingen av ett nytt programvarusystem utan att använda mikrotjänster. Denna situation leder oss till plattformen Docker.

Docker

Plattform Docker, i utveckling och distribution av mikrotjänster, har blivit praktiskt taget en branschstandard. På projektets webbplats kan man läsa att Docker är den enda oberoende containerplattformen som gör det möjligt för organisationer att skapa, distribuera och köra applikationer i olika miljöer — från hybridmoln till edge-system, utan större ansträngning.

Docker Compose

Tekniken Docker Compose är avsedd för konfiguration av flercontainerapplikationer. I ett Docker Compose-projekt kan det ingå så många Docker-containrar som skaparen av projektet behöver.

Vid arbete med Docker Compose används en YAML-fil för att konfigurera apptjänster och organisera deras interaktion med varandra. Docker Compose är således ett verktyg för att beskriva och köra flercontainerapplikationer i Docker.

Två containrar som arbetar på värdsystemet

GNU Make

Programmet make, är i grunden ett verktyg för att automatisera byggandet av program och bibliotek från källkod. Generellt kan man säga att make är tillämpligt på alla processer som involverar utförande av godtyckliga kommandon för att omvandla vissa ingångsmaterial till ett visst resulterande tillstånd, till ett visst mål. I vårt fall kommer kommandona docker-compose att omvandlas till abstrakta mål (Phony targets).

För att informera programmet make om vad vi vill ha från det, behöver vi en fil Makefile.

I vår Makefile som kommer att innehålla vanliga kommandon docker och docker-compose, som är avsedda för att lösa många uppgifter. Det handlar om att bygga containrar, om att starta, stoppa och återstarta dem, om att organisera användarinloggning i containrar, om att arbeta med loggar av containrar samt om att lösa andra liknande uppgifter.

Typiska användningsområden för Docker Compose

Låt oss föreställa oss en vanlig webbapplikation som har följande komponenter:

• TimescaleDB-databasen (Postgres).
• Ett Express.js-program.
• Ping (en enkel container som inte gör något särskilt).

Denna applikation kommer att behöva 3 Docker-containrar och en fil docker-compose, som innehåller instruktioner för hantering av dessa containrar. Varje container kommer att ha olika interaktionspunkter. Till exempel kan man arbeta med containern timescale på ett liknande sätt som man arbetar med databaser. Det vill säga, den tillåter följande åtgärder:

• Inloggning i Postgres-skalet.
• Import och export av tabeller.
• Skapande pg_dump tabeller eller databaser.

Containern för Express.js-programmet, expressjs, kan ha följande möjligheter:

• Leverera färska data från systemloggen.
• Inloggning i skalet för att köra vissa kommandon.

Interaktion med containrar

När vi har konfigurerat kopplingen mellan containrarna med hjälp av Docker Compose, är det dags att etablera interaktionen med dessa containrar. Inom Docker Compose-systemet finns det en kommando docker-compose, som stöder alternativet -f, vilket gör att man kan överföra en fil till systemet. docker-compose.yml.

Genom att använda detta alternativ kan man begränsa interaktionen med systemet till endast de containrar som nämns i filen. docker-compose.yml.

Låt oss titta på hur interaktionerna med containrarna ser ut när vi använder kommandon docker-compose. Om vi föreställer oss att vi behöver logga in i skalet psql, kan de relevanta kommandona se ut så här:

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

Samma kommando, för vilket man inte använder docker-compose, och docker, kan se ut så här:

docker exec -it edp_timescale_1 psql -Upostgres

Observera att det alltid är att föredra att använda kommandot docker, och inte kommandot docker-compose, eftersom detta gör att man slipper komma ihåg containerns namn.

Båda ovanstående kommandon är inte så svåra. Men om vi använde en "inpackning" i form av Makefile, som skulle ge oss ett gränssnitt i form av enkla kommandon och själv skulle anropa sådana långa kommandon, kan vi uppnå samma resultat så här:

make db-shell

Det är helt uppenbart att användningen av Makefile avsevärt förenklar arbetet med containrar!

Praktiskt exempel

Baserat på den ovan diskuterade projektschemat kommer vi att skapa följande fil 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

För att hantera Docker Compose-konfigurationen och interagera med de containrar den beskriver, ska vi skapa följande fil 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 flesta av de kommandon som beskrivs här tillämpas på alla containrar, men användningen av alternativet c= tillåter att begränsa kommandots räckvidd till en enskild container.

Efter att Makefile klar, du kan använda den så här:

• make help — ger en lista över alla kommandon som är tillgängliga för make.

Hjälp om tillgängliga kommandon

• make build — bygga en bild från DockerfileI vårt exempel har vi använt befintliga bilder timescale och pingMen bilden api som vi vill samla lokalt. Det är just detta som kommer att göras efter att kommandot har körts.

Byggnation av en Docker-behållare

• make start — startar alla behållare. För att starta bara en behållare kan man använda ett kommando som make start c=timescale.

Startar timescale-behållaren

Startar ping-behållaren

• make login-timescale — loggar in i bash-sessionen för behållaren timescale.

Starta bash i timescale-behållaren

• make db-shell — loggar in i psql i en container timescale för att köra SQL-frågor mot databasen.

Startar psql i timescaledb-behållaren

• make stop — stoppar behållarna.

Stoppar timescale-behållaren

• make down — stoppar och tar bort behållarna. För att ta bort en specifik behållare kan man använda detta kommando med den specifika behållaren angiven. Till exempel — make down c=timescale eller make down c=api.

Stoppar och tar bort alla behållare

Sammanfattning

Trots att Docker Compose ger oss en omfattande uppsättning kommandon för att hantera behållare, kan dessa kommandon ibland bli långa och svåra att komma ihåg.

Användningsmetodiken Makefile har hjälpt oss att hantera snabb och enkel interaktion med behållarna från filen docker-compose.yml. Det handlar om följande:

• Utvecklaren interagerar endast med projektets behållare som beskrivs i docker-compose.yml, andra körda behållare stör inte arbetet.
• Om något kommando har glömts kan man köra kommandot make help och få hjälp med tillgängliga kommandon.
• Det är inte nödvändigt att komma ihåg långa listor med argument för att utföra åtgärder som att hämta färska loggar eller logga in. Till exempel, ett kommando som docker-compose -f docker-compose.yml exec timescale psql -Upostgres blir make db-shell.
• Fil Makefile kan, när projektet växer, anpassas flexibelt efter det. Till exempel är det inte svårt att lägga till ett kommando för att skapa en databasbackup eller utföra någon annan åtgärd.
• Om ett stort team av utvecklare använder samma Makefile, organiserar det det gemensamma arbetet och minskar antalet fel.

P.S. I vår marknadsplats finns en bild Docker, som installeras med ett klick. Du kan kontrollera hur containrarna fungerar på VPS. Alla nya kunder får 3 dagar gratis för testning.

Kära läsare! Hur automatiserar du arbetet med Docker Compose?

Källa: habr.com