Docker Compose: Förenkla ditt arbete med Makefiles

Med några års mellanrum genomgår mjukvaruutvecklingsbranschen ett paradigmskifte. Ett av dessa fenomen kan erkännas som det växande intresset för konceptet mikrotjänster. Även om mikrotjänster inte är den senaste tekniken, har dess popularitet bokstavligen skjutit i höjden först nyligen.

Stora monolitiska tjänster ersätts nu av oberoende, autonoma mikrotjänster. En mikrotjänst kan ses som en applikation som tjänar ett enda och mycket specifikt syfte. Det kan till exempel vara en relations-DBMS, en Express-applikation, en Solr-tjänst.

Idag är det svårt att föreställa sig att utveckla ett nytt mjukvarusystem utan att använda mikrotjänster. Och denna situation leder oss i sin tur till Docker-plattformen.

Hamnarbetare

Plattform Hamnarbetare, i utvecklingen och distributionen av mikrotjänster, har blivit nästan en industristandard. På projektwebbplatsen kan du ta reda på att Docker är den enda oberoende containeriseringsplattformen som tillåter organisationer att utan ansträngning skapa vilken applikation som helst, samt distribuera och köra dem i vilken miljö som helst – från hybridmoln till kantsystem.

Docker komponera

Технология Docker komponera designad för att konfigurera applikationer med flera behållare. Ett Docker Compose-projekt kan innehålla så många Docker-behållare som projektets skapare behöver.

När du arbetar med Docker Compose används en YAML-fil för att konfigurera applikationstjänster och organisera deras interaktion med varandra. Docker Compose är därför ett verktyg för att beskriva och köra Docker-applikationer med flera behållare.

Två behållare som körs på ett värdsystem

GNU -märke

Program make, är i huvudsak ett verktyg för att automatisera byggandet av program och bibliotek från källkod. Generellt kan vi säga det make gäller alla processer som involverar exekvering av godtyckliga kommandon för att omvandla vissa inmatningsmaterial till någon utdataform, till något mål. I vårt fall, kommandona docker-compose kommer att förvandlas till abstrakta mål (Telefonmål).

För att berätta för programmet make om vad vi vill ha av det behöver vi en fil Makefile.

I vår Makefile kommer att innehålla vanliga kommandon docker и docker-compose, som är utformade för att lösa många problem. Vi pratar nämligen om att montera en container, om att starta den, stoppa den, starta om den, om att organisera användarinloggning till containern, om att arbeta med containerloggar och om att lösa andra liknande problem.

Typiska användningsfall för Docker Compose

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

• TimescaleDB databas (Postgres).
• Express.js-applikation.
• Ping (bara en behållare, gör inget speciellt).

Denna applikation kommer att behöva 3 Docker-behållare och en fil docker-compose, som innehåller instruktioner för hantering av dessa behållare. Varje behållare kommer att ha olika kontaktpunkter. Till exempel med en behållare timescale det kommer att vara möjligt att arbeta ungefär på samma sätt som de arbetar med databaser. Det låter dig nämligen utföra följande åtgärder:

• Loggar in på Postgres-skalet.
• Import och export av tabeller.
• skapande pg_dump tabeller eller databaser.

Express.js-applikationsbehållare, expressjs, kan ha följande funktioner:

• Tillhandahåller färska data från systemloggen.
• Logga in på skalet för att utföra vissa kommandon.

Interagera med behållare

När vi har ställt in kommunikation mellan behållare med Docker Compose, är det dags att kommunicera med dessa behållare. Inom Docker Compose-systemet finns ett kommando docker-compose, stödalternativ -f, som låter dig överföra en fil till systemet docker-compose.yml.

Genom att använda funktionerna i detta alternativ kan du begränsa interaktionen med systemet endast till de behållare som nämns i filen docker-compose.yml.

Låt oss ta en titt på hur interaktioner med behållare ser ut när du använder kommandon docker-compose. Om vi ​​föreställer oss att vi behöver logga in i skalet psql, då kan motsvarande kommandon se ut så här:

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

Samma kommando som inte används för att köra docker-composeOch docker, kan se ut så här:

docker exec -it  edp_timescale_1 psql -Upostgres

Observera att i sådana fall är det alltid att föredra att använda kommandot docker, och laget docker-compose, eftersom detta eliminerar behovet av att komma ihåg behållarnamn.

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

make db-shell

Det är ganska uppenbart att användningen Makefile gör arbetet med containrar mycket enklare!

Arbetsexempel

Baserat på ovanstående projektdiagram 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 behållarna den beskriver, kommer vi att 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 kommandona som beskrivs här gäller för alla behållare, men med alternativet c= låter dig begränsa omfattningen av ett kommando till en behållare.

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

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

Hjälp om tillgängliga kommandon

• make build - sätta ihop en bild från Dockerfile. I vårt exempel använde vi befintliga bilder timescale и ping. Men bilden api vi vill samla lokalt. Detta är exakt vad som kommer att göras efter att du har kört detta kommando.

Att bygga en Docker-container

• make start — sjösättning av alla containrar. För att starta bara en behållare kan du använda ett kommando som make start c=timescale.

Köra tidsskalebehållaren

Kör en pingcontainer

• make login-timescale — logga in på bash-sessionen för containern timescale.

Kör bash i en tidsskala behållare

• make db-shell - ingång till psql i en behållare timescale för att köra SQL-frågor mot databasen.

Kör psql i en timescaledb-behållare

• make stop — stoppa containrar.

Stoppa en tidsskala container

• make down — stoppa och ta bort behållare. För att ta bort en specifik behållare kan du använda det här kommandot och specificera önskad behållare. Till exempel - make down c=timescale eller make down c=api.

Stoppa och ta bort alla behållare

Resultat av

Även om Docker Compose ger oss en rik uppsättning kommandon för att hantera containrar, kan dessa kommandon ibland bli långa och svåra att komma ihåg.

Användningsmetod Makefile hjälpte oss att skapa snabb och enkel interaktion med behållare från en fil docker-compose.yml. Vi pratar nämligen om följande:

• Utvecklaren interagerar endast med projektbehållare som beskrivs i docker-compose.yml, arbetet störs inte av andra körande containrar.
• I händelse av att ett visst kommando glöms bort, kan du utföra kommandot make help och få hjälp med tillgängliga kommandon.
• Du behöver inte komma ihåg långa listor med argument för att utföra åtgärder som att hämta de senaste loggposterna eller logga in i ett system. Till exempel ett kommando som docker-compose -f docker-compose.yml exec timescale psql -Upostgres förvandlas till make db-shell.
• fil Makefile Du kan flexibelt anpassa dig till det när projektet växer. Det är till exempel lätt att lägga till ett kommando för att skapa en databassäkerhetskopiering eller utföra någon annan åtgärd.
• Om ett stort team av utvecklare använder samma Makefile, detta effektiviserar samarbetet och minskar antalet fel.

PS I vår marknad det finns en bild Hamnarbetare, som kan installeras med ett klick. Du kan kontrollera hanteringen av containrar på VPS. Alla nya kunder får 3 dagars testning utan kostnad.

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

Källa: will.com