Docker Compose: Forenkling af dit arbejde ved hjælp af Makefiles

Hvert par år gennemgår softwareudviklingsindustrien et paradigmeskifte. Et af disse fænomener kan genkendes som den voksende interesse for begrebet mikrotjenester. Selvom mikrotjenester ikke er den nyeste teknologi, er dens popularitet bogstaveligt talt steget i vejret først for nylig.

Store monolitiske tjenester bliver nu erstattet af uafhængige, autonome mikrotjenester. En mikroservice kan opfattes som en applikation, der tjener et enkelt og meget specifikt formål. Det kan for eksempel være et relationelt DBMS, en Express-applikation, en Solr-tjeneste.

I disse dage er det svært at forestille sig at udvikle et nyt softwaresystem uden at bruge mikrotjenester. Og denne situation fører os til gengæld til Docker-platformen.

Docker

perron Docker, i udviklingen og implementeringen af ​​mikrotjenester, er blevet næsten en industristandard. På projektets hjemmeside kan du finde ud af, at Docker er den eneste uafhængige containeriseringsplatform, der giver organisationer mulighed for ubesværet at skabe enhver applikation, samt distribuere og køre dem i ethvert miljø - fra hybridskyer til kantsystemer.

Docker komponere

Технология Docker komponere designet til konfiguration af multi-container applikationer. Et Docker Compose-projekt kan indeholde lige så mange Docker-containere, som projektets skaber har brug for.

Når du arbejder med Docker Compose, bruges en YAML-fil til at konfigurere applikationstjenester og organisere deres interaktion med hinanden. Docker Compose er derfor et værktøj til at beskrive og køre Docker-applikationer med flere beholdere.

To containere, der kører på et værtssystem

GNU Make

Program make, er i bund og grund et værktøj til at automatisere opbygningen af ​​programmer og biblioteker fra kildekode. Generelt kan vi sige det make gælder for enhver proces, der involverer udførelse af vilkårlige kommandoer for at transformere nogle inputmaterialer til en eller anden outputform, til et eller andet mål. I vores tilfælde kommandoerne docker-compose vil blive transformeret til abstrakte mål (Telefonmål).

At fortælle programmet make om, hvad vi vil have ud af det, har vi brug for en fil Makefile.

I vores Makefile vil indeholde almindelige kommandoer docker и docker-compose, som er designet til at løse mange problemer. Vi taler nemlig om at samle en container, om at starte den, stoppe den, genstarte den, om at organisere brugerlogin til containeren, om at arbejde med containerlogs og om at løse andre lignende problemer.

Typiske brugssager for Docker Compose

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

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

Denne applikation skal bruge 3 Docker-containere og en fil docker-compose, som indeholder instruktioner til håndtering af disse beholdere. Hver beholder vil have forskellige berøringspunkter. For eksempel med en beholder timescale det vil være muligt at arbejde nogenlunde på samme måde, som de arbejder med databaser. Det giver dig nemlig mulighed for at udføre følgende handlinger:

• Log ind på Postgres-skallen.
• Import og eksport af tabeller.
• skabelse pg_dump tabeller eller databaser.

Express.js-applikationscontainer, expressjs, kan have følgende egenskaber:

• Levering af friske data fra systemloggen.
• Log ind på skallen for at udføre bestemte kommandoer.

Interaktion med containere

Når vi har konfigureret kommunikation mellem containere ved hjælp af Docker Compose, er det tid til at kommunikere med disse containere. Inden for Docker Compose-systemet er der en kommando docker-compose, understøttende mulighed -f, som giver dig mulighed for at overføre en fil til systemet docker-compose.yml.

Ved at bruge denne muligheds muligheder kan du begrænse interaktion med systemet til kun de containere, der er nævnt i filen docker-compose.yml.

Lad os tage et kig på, hvordan interaktioner med containere ser ud, når du bruger kommandoer docker-compose. Hvis vi forestiller os, at vi skal logge ind på skallen psql, så kan de tilsvarende kommandoer se sådan ud:

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

Den samme kommando, som ikke bruges til at udføre docker-composeOg docker, kan se sådan ud:

docker exec -it  edp_timescale_1 psql -Upostgres

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

Begge de ovenstående kommandoer er ikke så svære. Men hvis vi brugte en "indpakning" i formularen Makefile, som ville give os en grænseflade i form af simple kommandoer og selv ville kalde lignende lange kommandoer, så kunne de samme resultater opnås som dette:

make db-shell

Det er helt indlysende, at brugen Makefile gør arbejdet med containere meget nemmere!

Arbejdseksempel

Baseret på ovenstående projektdiagram 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 interagere med de containere, den beskriver, vil vi oprette følgende 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 fleste af kommandoerne beskrevet her gælder for alle containere, men ved at bruge muligheden c= giver dig mulighed for at begrænse omfanget af en kommando til én container.

Efter Makefile klar, du kan bruge det sådan her:

• make help — udstedelse af en liste over alle tilgængelige kommandoer for make.

Hjælp til tilgængelige kommandoer

• make build - sammensætning af et billede fra Dockerfile. I vores eksempel brugte vi eksisterende billeder timescale и ping. Men billedet api vi ønsker at indsamle lokalt. Dette er præcis, hvad der vil blive gjort efter at have udført denne kommando.

Opbygning af en Docker-container

• make start — søsætning af alle containere. For at starte kun én container kan du bruge en kommando som f.eks make start c=timescale.

Kørsel af tidsskalacontaineren

Kører en ping-container

• make login-timescale — log ind på bash-sessionen for containeren timescale.

Kører bash i en tidsskala container

• make db-shell - indgang til psql i en beholder timescale at udføre SQL-forespørgsler mod databasen.

Kører psql i en timescaledb container

• make stop — stop af containere.

Stop af en tidsskalacontainer

• make down — standsning og fjernelse af beholdere. For at fjerne en bestemt beholder kan du bruge denne kommando til at angive den ønskede beholder. For eksempel - make down c=timescale eller make down c=api.

Stop og slet alle containere

Resultaterne af

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

Brugsmetode Makefile hjalp os med at etablere hurtig og nem interaktion med containere fra en fil docker-compose.yml. Vi taler nemlig om følgende:

• Udvikleren interagerer kun med projektbeholderne beskrevet i docker-compose.yml, arbejdet bliver ikke forstyrret af andre kørende containere.
• I tilfælde af at en bestemt kommando er glemt, kan du udføre kommandoen make help og få hjælp til tilgængelige kommandoer.
• Du behøver ikke at huske lange lister med argumenter for at udføre handlinger, såsom at hente de seneste logposter eller logge ind på et system. For eksempel en kommando som docker-compose -f docker-compose.yml exec timescale psql -Upostgres bliver til make db-shell.
• fil Makefile Du kan fleksibelt tilpasse dig det, efterhånden som projektet vokser. For eksempel er det nemt at tilføje en kommando for at oprette en databasesikkerhedskopi eller udføre enhver anden handling.
• Hvis et stort team af udviklere bruger det samme Makefile, dette strømliner samarbejdet og reducerer fejl.

PS I vores markedsplads der er et billede Docker, som installeres med et enkelt klik. Du kan kontrollere, at beholderne fungerer på VPS. Alle nye kunder får 3 dages test gratis.

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

Kilde: www.habr.com