🥇Docker Compose: Forenkle arbeidet ditt ved å bruke Makefiles

Hvert par år gjennomgår programvareutviklingsindustrien et paradigmeskifte. Et av disse fenomenene kan gjenkjennes som den økende interessen for konseptet mikrotjenester. Selv om mikrotjenester ikke er den nyeste teknologien, har populariteten bokstavelig talt skutt i været først nylig.

Store monolittiske tjenester blir nå erstattet av uavhengige, autonome mikrotjenester. En mikrotjeneste kan betraktes som en applikasjon som tjener et enkelt og veldig spesifikt formål. Det kan for eksempel være en relasjonell DBMS, en Express-applikasjon, en Solr-tjeneste.

I disse dager er det vanskelig å forestille seg å utvikle et nytt programvaresystem uten å bruke mikrotjenester. Og denne situasjonen fører oss til Docker-plattformen.

Docker

plattform Docker, i utvikling og distribusjon av mikrotjenester, har blitt nesten en industristandard. På prosjektets nettside kan du finne ut at Docker er den eneste uavhengige containeriseringsplattformen som lar organisasjoner enkelt lage hvilken som helst applikasjon, samt distribuere og kjøre dem i ethvert miljø – fra hybridskyer til kantsystemer.

Docker komponere

Технология Docker komponere designet for å konfigurere multi-container-applikasjoner. Et Docker Compose-prosjekt kan inneholde så mange Docker-beholdere som prosjektets skaper trenger.

Når du arbeider med Docker Compose, brukes en YAML-fil til å konfigurere applikasjonstjenester og organisere deres interaksjon med hverandre. Docker Compose er derfor et verktøy for å beskrive og kjøre Docker-applikasjoner med flere beholdere.

To containere som kjører på et vertssystem

GNU-fabrikat

Program make, er i hovedsak et verktøy for å automatisere bygging av programmer og biblioteker fra kildekoden. Generelt kan vi si det make gjelder for enhver prosess som involverer utføring av vilkårlige kommandoer for å transformere noen inndatamaterialer til en eller annen utdataform, til et eller annet mål. I vårt tilfelle, kommandoene docker-compose vil bli forvandlet til abstrakte mål (Telefonmål).

For å fortelle programmet make om hva vi vil ha fra det, trenger vi en fil Makefile.

I vår Makefile vil inneholde vanlige kommandoer docker и docker-compose, som er designet for å løse mange problemer. Vi snakker nemlig om å sette sammen en container, om å starte den, stoppe den, starte den på nytt, om å organisere brukerinnlogging til containeren, om å jobbe med containerlogger og om å løse andre lignende problemer.

Typiske brukstilfeller for Docker Compose

La oss forestille oss en vanlig nettapplikasjon som har følgende komponenter:

TimescaleDB database (Postgres).
Express.js-applikasjonen.
Ping (bare en beholder, gjør ikke noe spesielt).

Denne applikasjonen trenger 3 Docker-beholdere og en fil docker-compose, som inneholder instruksjoner for håndtering av disse beholderne. Hver beholder vil ha forskjellige berøringspunkter. For eksempel med en beholder timescale det vil være mulig å jobbe omtrent på samme måte som de jobber med databaser. Det lar deg nemlig utføre følgende handlinger:

Logger inn på Postgres-skallet.
Import og eksport av tabeller.
opprettelse pg_dump tabeller eller databaser.

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

Oppgi ferske data fra systemloggen.
Logg på skallet for å utføre bestemte kommandoer.

Samhandling med containere

Når vi har satt opp kommunikasjon mellom containere ved hjelp av Docker Compose, er det på tide å kommunisere med disse containerne. Innenfor Docker Compose-systemet er det en kommando docker-compose, støttealternativ -f, som lar deg overføre en fil til systemet docker-compose.yml.

Ved å bruke mulighetene til dette alternativet kan du begrense interaksjon med systemet til de beholderne som er nevnt i filen docker-compose.yml.

La oss ta en titt på hvordan interaksjoner med containere ser ut når du bruker kommandoer docker-compose. Hvis vi forestiller oss at vi trenger å logge inn i skallet psql, så kan de tilsvarende kommandoene se slik ut:

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

Den samme kommandoen som ikke brukes til å utføre docker-composeOg docker, kan se slik ut:

docker exec -it  edp_timescale_1 psql -Upostgres

Vær oppmerksom på at i slike tilfeller er det alltid å foretrekke å bruke kommandoen docker, og kommandoen docker-compose, da dette eliminerer behovet for å huske beholdernavn.

Begge kommandoene ovenfor er ikke så vanskelige. Men hvis vi brukte en "wrapper" i skjemaet Makefile, som ville gi oss et grensesnitt i form av enkle kommandoer og selv ville kalle lignende lange kommandoer, da kan de samme resultatene oppnås slik:

make db-shell

Det er helt åpenbart at bruken Makefile gjør arbeidet med containere mye enklere!

Arbeidseksempel

Basert på prosjektdiagrammet ovenfor, 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 samhandle med beholderne den beskriver, vil vi opprette 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 av kommandoene som er beskrevet her gjelder for alle beholdere, men ved å bruke alternativet c= lar deg begrense omfanget av en kommando til én beholder.

Etter Makefile klar, du kan bruke den slik:

make help — utstede en liste over alle kommandoer tilgjengelig for make.

Hjelp til tilgjengelige kommandoer

make build - sette sammen et bilde fra Dockerfile. I vårt eksempel brukte vi eksisterende bilder timescale и ping. Men bildet api vi ønsker å samle inn lokalt. Dette er nøyaktig hva som vil bli gjort etter å ha utført denne kommandoen.

Bygge en Docker-container

make start — utsetting av alle containere. For å starte bare én beholder, kan du bruke en kommando som make start c=timescale.

Kjøre tidsskalabeholderen

Kjøre en ping-container

make login-timescale — logg inn på bash-økten til containeren timescale.

Kjører bash i en tidsskalabeholder

make db-shell - inngang til psql i en beholder timescale for å utføre SQL-spørringer mot databasen.

Kjører psql i en timescaledb-beholder

make stop — stoppe containere.

Stoppe en tidsskalabeholder

make down — stoppe og fjerne beholdere. For å fjerne en spesifikk beholder, kan du bruke denne kommandoen og spesifisere ønsket beholder. For eksempel - make down c=timescale eller make down c=api.

Stoppe og slette alle beholdere

Resultater av

Selv om Docker Compose gir oss et rikt sett med kommandoer for å administrere containere, kan disse kommandoene noen ganger bli lange og vanskelige å huske.

Bruksmåte Makefile hjalp oss med å etablere rask og enkel interaksjon med containere fra en fil docker-compose.yml. Vi snakker nemlig om følgende:

Utvikleren samhandler kun med prosjektbeholderne beskrevet i docker-compose.yml, arbeid blir ikke forstyrret av andre kjørende containere.
I tilfelle at en bestemt kommando er glemt, kan du utføre kommandoen make help og få hjelp til tilgjengelige kommandoer.
Du trenger ikke å huske lange lister med argumenter for å utføre handlinger som å hente de siste loggoppføringene eller logge på et system. For eksempel en kommando som docker-compose -f docker-compose.yml exec timescale psql -Upostgres blir til make db-shell.
fil Makefile Du kan fleksibelt tilpasse deg det etter hvert som prosjektet vokser. For eksempel er det enkelt å legge til en kommando for å lage en databasesikkerhetskopi eller utføre en annen handling.
Hvis et stort team av utviklere bruker det samme Makefile, dette effektiviserer samarbeid og reduserer feil.

PS I vår markedsplass det er et bilde Docker, som kan installeres med ett klikk. Du kan sjekke driften av containere på VPS. Alle nye kunder får 3 dagers testing gratis.

Kjære lesere! Hvordan automatiserer du Docker Compose?

Kilde: www.habr.com

Docker Compose: Forenkle arbeidet ditt ved å bruke Makefiles