Docker Compose: forenkling av arbeidet ved bruk av Makefile

Hver few år skjer det et paradigmeskifte i programvareutviklingsindustrien. En slik utvikling kan sies å være den økende interessen for mikroservicer. Selv om mikroservicer ikke er en helt ny teknologi, har populariteten deres bokstavelig talt skutt i været den siste tiden.

Store monolitte tjenester blir i dag erstattet av uavhengige, autonome mikroservicer. En mikroservice kan betraktes som en applikasjon som har et spesifikt og klart definert formål. For eksempel kan dette være en relasjonsdatabase, en Express-applikasjon, eller en Solr-tjeneste.

I dag er det vanskelig å forestille seg utviklingen av et nytt programvaresystem uten mikroservicer. Denne situasjonen fører oss videre til Docker-plattformen.

Docker

Plattform Docker, i utviklingen og distribusjonen av mikroservicer, har blitt praktisk talt en industristandard. På prosjektets nettside kan man finne ut at Docker er den eneste uavhengige plattformen for containerisering som lar organisasjoner enkelt opprette, distribuere og kjøre applikasjoner i ulike miljøer - fra hybride skyer til edge-systemer.

Docker Compose

Teknologi Docker Compose er ment for konfigurasjon av flerkontainerapplikasjoner. I et Docker Compose-prosjekt kan det være så mange Docker-containere som prosjektets utvikler måtte ønske.

Når det gjelder Docker Compose, brukes en YAML-fil for å konfigurere appens tjenester og organisere hvordan de interagerer med hverandre. Docker Compose er dermed et verktøy for å beskrive og starte flerkontainer Docker-applikasjoner.

To containere som kjører på vertssystemet

GNU Make

Program lag, er essensielt et verktøy for å automatisere bygging av programmer og biblioteker fra kildekode. Generelt kan man si at lag er anvendelig for enhver prosess som innebærer utføring av vilkårlige kommandoer for å transformere visse råmaterialer til en bestemt form, til et bestemt mål. I vårt tilfelle vil kommandoene docker-compose bli omformet til abstrakte mål (Fiktive mål).

For å informere programmet lag om hva vi ønsker fra det, trenger vi en fil Makefile.

markedsplass Makefile som vil inneholde vanlige kommandoer docker og docker-compose, som er ment for å løse mange oppgaver. Det handler om å bygge en container, starte den, stoppe den, restart den, organisere brukerens tilgang til containeren, jobbe med containerens logger og løse andre lignende oppgaver.

Typiske bruksområder for Docker Compose

La oss tenke oss en vanlig webapplikasjon som har følgende komponenter:

• TimescaleDB (Postgres) database.
• Express.js-applikasjon.
• Ping (bare en container som ikke gjør noe spesielt).

Dette programmet trenger 3 Docker-containere og en fil docker-compose, som inneholder instruksjoner for å administrere disse containerne. Hver av containerne vil ha forskjellige grensesnitt. For eksempel kan man jobbe med containeren timescale på omtrent samme måte som man jobber med databaser. Det vil si at den tillater følgende handlinger:

• Tilgang til Postgres-skallet.
• Import og eksport av tabeller.
• Opprette pg_dump tabeller eller databaser.

Express.js-applikasjonscontaineren, expressjs, kan ha følgende funksjoner:

• Uttak av ferske data fra systemloggen.
• Tilgang til skallet for å utføre spesifikke kommandoer.

Interaksjon med containerne

Etter at vi har konfigurert forbindelsen mellom containerne ved hjelp av Docker Compose, er det på tide å etablere interaksjonen med disse containerne. I Docker Compose-systemet er det en kommando docker-compose, som støtter alternativet for streaming av logger) og, som lar deg sende systemet en fil docker-compose.yml.

Ved å bruke mulighetene til dette alternativet kan man begrense interaksjonen med systemet til bare de containerne som er nevnt i filen docker-compose.yml.

La oss se på hvordan interaksjonene med containerne ser ut når man bruker kommandoen docker-compose. Hvis vi antar at vi må gå inn i skallet psql, kan de tilsvarende kommandoene se slik ut:

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

Den samme kommandoen, men der man ikke bruker docker-compose, men docker, kan se slik ut:

docker exec -it edp_timescale_1 psql -Upostgres

Merk at det i slike tilfeller alltid er å foretrekke å bruke kommandoen docker, ikke kommandoen docker-compose, ettersom det eliminerer behovet for å huske containerne sine navn.

Begge de ovennevnte kommandoene er ikke så kompliserte. Men hvis vi hadde brukt en 'wrapper' i form av Makefile, som gir oss et grensesnitt i form av enkle kommandoer, og som selv ville kalle lignende lange kommandoer, ville samme resultat kunne oppnås slik:

make db-shell

Det er helt åpenbart at bruken av Makefile signifikant forenkler arbeidet med containere!

Arbeids eksempel

Basert på den ovenfor beskrevne prosjektplanen, vil vi lage 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 å administrere Docker Compose-konfigurasjonen og for å samhandle med containerne den beskriver, vil vi lage 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 kommandoene som er beskrevet her, gjelder for alle containere, men bruk av alternativet c= begrenset omfanget av kommandoen til én enkelt container.

Etter at Makefile klar, kan den brukes slik:

• make help — visning av listen over alle tilgjengelige kommandoer for lag.

Hjelp om tilgjengelige kommandoer

• make build — bygging av bildet fra Dockerfile. I vårt eksempel har vi brukt eksisterende bilder timescale og ping. Men bildet api vi ønsker å samle lokalt. Det er nettopp det som vil bli gjort etter at denne kommandoen er utført.

Bygging av Docker-container

• make start — starter alle containere. For å starte bare én container kan man bruke en kommando som make start c=timescale.

Starter timescale-containeren

Starter ping-containeren

• make login-timescale — logger inn i bash-økten til containeren timescale.

Starter bash i timescale-containeren

• make db-shell — logger inn i psql i en container timescale for å utføre SQL-spørringer mot databasen.

Starter psql i timescaledb-containeren

• make stop — stopper containerne.

Stopper timescale-containeren

• make down — stopper og fjerner containerne. For å fjerne en spesifikk container kan man bruke denne kommandoen med angivelse av den nødvendige containeren. For eksempel — make down c=timescale eller make down c=api.

Stopper og fjerner alle containere

Resultater

Selv om Docker Compose-systemet gir oss en omfattende sett med kommandoer for administrasjon av containere, blir noen av disse kommandoene lange, noe som gjør dem vanskelige å huske.

Bruksmåte Makefile har hjulpet oss med å etablere rask og enkel interaksjon med containere fra filen docker-compose.yml. Det handler spesifikt om følgende:

• Utvikleren interagerer kun med prosjektcontainerne som er beskrevet i docker-compose.yml, andre kjørende containere forstyrrer ikke arbeidet.
• I tilfelle man glemmer en kommando, kan man utføre kommandoen make help og få hjelp om tilgjengelige kommandoer.
• Det er ikke nødvendig å huske lange lister med argumenter for å utføre handlinger som å hente friske logger eller logge inn. For eksempel, kommandoen docker-compose -f docker-compose.yml exec timescale psql -Upostgres blir til make db-shell.
• Fil Makefile kan, ettersom prosjektet vokser, tilpasses fleksibelt. For eksempel kan man lett legge til en kommando for å ta sikkerhetskopi av databasen eller for å utføre enhver annen handling.
• Hvis en stor gruppe utviklere bruker den samme Makefile, organiserer det samarbeidet og reduserer antall feil.

P.S. markedsplass har vi et bilde , som installeres med ett klikk. Du kan sjekke hvordan containerne fungerer på Docker. Alle nye kunder får 3 dager gratis for testing. VPSBruker du CI/CD-teknologier i prosjektene dine?

Kjære lesere! Hvordan automatiserer du arbeidet med Docker Compose?

Kilde: habr.com