Docker Compose: forenkling af arbejdet ved brug af Makefile

Hvert par år sker der et paradigmeskifte i softwareudviklingsindustrien. En sådan begivenhed kan betragtes som den stigende interesse for konceptet mikroservices. Selvom mikroservices ikke er en helt ny teknologi, er dens popularitet i de senere år bogstaveligt talt steget til himmels.

Store monolitiske tjenester erstattes i dag af uafhængige, autonome mikroservices. En mikroservice kan ses som en applikation, der tjener et enkelt og meget specifikt formål. For eksempel kan det være en relationsdatabase, en Express-applikation eller en Solr-tjeneste.

I dag er det svært at forestille sig udviklingen af et nyt softwaresystem uden brug af mikroservices. Denne situation fører os i sin tur til Docker-platformen.

Docker

Platformen Docker, i udviklingen og implementeringen af mikroservices, er blevet stort set en industri-standard. På projektets hjemmeside kan man læse, at Docker er den eneste uafhængige containeriseringsplatform, der gør det muligt for organisationer uden større besvær at skabe enhver applikation samt at distribuere og køre dem i enhver miljø – fra hybride skyer til edge-systemer.

Docker Compose

Technology Docker Compose er designet til at konfigurere multi-container applikationer. I et Docker Compose-projekt kan der være så mange Docker-containere, som skaberen af projektet ønsker.

Ved arbejde med Docker Compose til opsætning af applikationstjenester og organisering af deres interaktioner med hinanden bruges en YAML-fil. Docker Compose er således et værktøj til at beskrive og køre multi-container Docker-applikationer.

To containere, der kører på værtsystemet

GNU Make

Program make, er i det væsentlige et værktøj til automatisering af kompilering af programmer og biblioteker fra kildekode. Generelt kan man sige, at make er anvendeligt for enhver proces, der involverer udførelse af vilkårlige kommandoer for at omdanne nogle råmaterialer til en bestemt resultatform eller mål. I vores tilfælde vil kommandoerne docker-compose blive omdannet til abstrakte mål (Phony targets).

For at informere programmet make om hvad vi ønsker fra det, har vi brug for en fil Makefil.

I vores Makefil der vil indeholde almindelige kommandoer docker og docker-compose, der er beregnet til at løse mange opgaver. Det handler om samling af en container, dens opstart, stop, genstart, om at organisere brugerens adgang til containeren, om at arbejde med containerens logs og om at løse andre lignende opgaver.

Typiske anvendelsesmuligheder for Docker Compose

Lad os forestille os en almindelig webapplikation, der har følgende komponenter:

• TimescaleDB (Postgres) database.
• Express.js-applikation.
• Ping (bare en container, der ikke gør noget særligt).

Denne applikation vil have brug for 3 Docker-containere og en fil docker-compose, der indeholder instruktioner til at styre disse containere. Hver container vil have forskellige interaktionspunkter. For eksempel kan man arbejde med containeren timescale på en måde, der svarer til, hvordan man arbejder med databaser. Det betyder, at det muliggør følgende handlinger:

• Adgang til Postgres shell.
• Import og eksport af tabeller.
• Oprettelse pg_dump tabeller eller databaser.

Express.js-applikationscontaineren, expressjs, kan have følgende funktioner:

• Uddragning af friske data fra systemloggen.
• Adgang til shell for at udføre nogle kommandoer.

Interaktion med containere

Når vi har oprettet forbindelse mellem containerne ved hjælp af Docker Compose, er det tid til at etablere interaktion med disse containere. Inden for Docker Compose-systemet er der en kommando docker-compose, der understøtter muligheden -f, som gør det muligt at overføre en fil til systemet docker-compose.yml.

Ved at bruge funktionerne i denne mulighed kan man begrænse interaktionen med systemet til kun de containere, der er nævnt i filen docker-compose.yml.

Lad os se på, hvordan interaktionerne med containerne ser ud ved brug af kommandoerne docker-compose. Hvis vi forestiller os, at vi skal få adgang til shell'en psql, kan de relevante kommandoer se sådan ud:

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

Den samme kommando, der ikke bruger docker-compose, og docker, kan se sådan ud:

docker exec -it edp_timescale_1 psql -Upostgres

Bemærk, at det i sådanne tilfælde altid er at foretrække at bruge kommandoen docker, frem for kommandoen docker-compose, da dette eliminerer behovet for at huske containerens navne.

Begge ovenstående kommandoer er ikke så svære. Men hvis vi brugte en "wrapper" i form af Makefil, som ville give os et interface i form af enkle kommandoer og selv ville kalde sådanne lange kommandoer, kunne de samme resultater opnås således:

make db-shell

Det er helt åbenlyst, at brugen af Makefil betydeligt forenkler arbejdet med containere!

Praktisk eksempel

Baseret på den ovenfor beskrevne projektstruktur vil vi oprette følgende 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

For at administrere Docker Compose-konfigurationen og for at interagere med de containere, den beskriver, vil vi oprette følgende fil Makefil:

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 fleste af de beskrevne kommandoer gælder for alle containere, men brugen af optionen c= gør det muligt at begrænse rækkevidden af kommandoen til en enkelt container.

Efter at Makefil klar, du kan bruge den således:

• make help — viser en liste over alle kommandoer, der er tilgængelige for make.

Hjælp til tilgængelige kommandoer

• make build — bygger billedet fra Dockerfile. I vores eksempel har vi brugt eksisterende billeder timescale og ping. Men billedet api vi ønsker at samle lokalt. Det vil blive gjort, efter at denne kommando er udført.

Bygning af Docker-container

• make start — starter alle containere. For at starte kun én container kan du bruge en kommando som make start c=timescale.

Start af timescale-containeren

Start af ping-containeren

• make login-timescale — logger ind på bash-sessionen i containeren timescale.

Start af bash i timescale-containeren

• make db-shell — logger ind i psql i en container timescale for at udføre SQL-forespørgsler til databasen.

Start af psql i timescaledb-containeren

• make stop — stopper containerne.

Stop af timescale-containeren

• make down — stopper og fjerner containerne. For at fjerne en bestemt container kan denne kommando bruges med angivelse af den ønskede container. For eksempel — make down c=timescale eller make down c=api.

Stop og fjern alle containere

Resumé

Selvom Docker Compose-systemet giver os et omfattende sæt kommandoer til styring af containere, kan disse kommandoer nogle gange blive lange og dermed svære at huske.

Brugsmetode Makefil har hjulpet os med at etablere en hurtig og nem interaktion med containerne fra filen docker-compose.yml. Det handler om det følgende:

• Udvikleren interagerer kun med projektets containere, som er beskrevet i docker-compose.yml, andre kørende containere forstyrrer ikke arbejdet.
• I tilfælde af at en kommando er glemt, kan man udføre kommandoen make help for at få hjælp til de tilgængelige kommandoer.
• Det er ikke nødvendigt at huske lange lister af argumenter for at udføre handlinger som at få friske logposter eller logge ind. For eksempel, en kommando som docker-compose -f docker-compose.yml exec timescale psql -Upostgres bliver til make db-shell.
• Fil Makefil kan, når projektet vokser, tilpasses fleksibelt til det. For eksempel kan man nemt tilføje en kommando til at tage backup af databasen eller udføre enhver anden handling.
• Hvis et stort team af udviklere bruger det samme Makefil, organiserer det samarbejdet og reducerer fejl.

P.S. I vores marketplace there is an image Docker, which can be installed with one click. You can check the work of the containers on VPS. All new clients are given 3 days for free testing.

Kære læsere! Hvordan automatiserer du arbejdet med Docker Compose?

Kilde: habr.com