Docker Compose: töö lihtsustamine Makefile'i kasutamisega

Mõned aastad tagasi toimus tarkvaraarenduse valdkonnas paradigmade vahetus. Üheks selliseks nähtuseks on huvi kasvu mikroteenuste kontseptsiooni vastu. Kuigi mikroteenused ei ole sugugi uus tehnoloogia, on nende populaarsus viimasel ajal tõusnud taevasse.

Suurte monoliitsete teenuste asemel on tänapäeval rohkem sõltumatuid ja autonoomseid mikroteenuseid. Mikroteenust võib vaadelda kui rakendust, millel on üksainus ja väga spetsiifiline eesmärk. Näiteks — see võib olla relatsiooniline andmebaas, Express-rakendus või Solr-teenus.

Tänapäeval on keeruline kujutleda uue tarkvarasüsteemi arendamist ilma mikroteenuste kasutamiseta. See olukord viib meid Docker platvormini.

Docker

Platvorm Docker, mikroteenuste arendamisel ja juurutamisel on peaaegu tööstusstandardi saavutanud. Projekti veebisaidilt saab teada, et Docker on ainus sõltumatu konteineriseerimist platvorm, mis võimaldab organisatsioonidel hõlpsasti luua igasuguseid rakendusi ning jagada ja käivitada neid erinevates keskkondades — alates hübriidpilvedest kuni servasüsteemideni.

Docker Compose

Tehnoloogia Docker Compose on mõeldud mitme konteineri rakenduste konfigureerimiseks. Docker Compose'i projekt võib sisaldada nii palju Docker konteinerite, kui projekti looja soovib.

Docker Compose'i kasutamisel rakenduste teenuste seadistamiseks ja nende omavahelise koostoime korraldamiseks kasutatakse YAML-faili. Seega on Docker Compose tööriist, mis kirjeldab ja käivitab mitme konteineri Docker rakendusi.

Kaks konteinerit, mis töötavad host-süsteemis

GNU Make

Programm make, on põhimõtteliselt tööriist programmide ja raamatukogude kokkupaneku automatiseerimiseks lähtekoodist. Üldiselt võib öelda, et make on rakendatav mis tahes protsessile, mis hõlmab meelevaldsete käskude täitmist, et muuta toormaterjalid mingiks soovitud vormiks, mingiks sihiks. Meie puhul käsud docker-compose muudetakse abstraktseteks sihtmärkideks (Phony targets).

Kuna teavitada programmi make selle kohta, mida me temalt soovime, on meil vajalik fail Makefile.

Meie Makefile sisaldavad tavapäraseid käske docker ja docker-compose, mis on mõeldud mitmete ülesannete täitmiseks. Täpsemalt, see hõlmab konteineri kokkupanekut, käivitamist, peatamist, taaskäivitamist, kasutaja sisenemist konteinerisse, konteineri logidega töötamist ning muude sarnaste ülesannete lahendamist.

Tüüpilised kasutusvariante Docker Compose'i jaoks

Kujutame ette tavalist veebirakendust, milles on järgmised komponendid:

• TimescaleDB (Postgres) andmebaas.
• Express.js rakendus.
• Ping (lihtsalt konteiner, midagi erilist ei tee).

Selle rakenduse jaoks on vaja 3 Docker konteinerit ja faili docker-compose, mis sisaldab juhiseid nende konteinerite haldamiseks. Igal konteineril on erinevad suhtluspunktid. Näiteks konteineriga timescale saab töötada nii, nagu töötatakse andmebaasidega. See võimaldab teostada järgmisi toiminguid:

• Sisenemine Postgres'i käsureale.
• Tabelite importimine ja eksportimine.
• Loomine pg_dump tabelid või andmebaasid.

Express.js rakenduse konteiner, expressjs, võib omada järgmisi funktsioone:

• Uute andmete väljastamine süsteemi logidest.
• Sisenemine käsureale teatud käskude täitmiseks.

Koostöö konteineritega

Pärast konteinerite ühendamise seadistamist Docker Compose'i abil on aeg luua nendega suhtlemine. Docker Compose'i süsteemis on käsk docker-compose, mis toetab valikut -f, mis võimaldab süsteemile edastada faili docker-compose.yml.

Selle valiku abil saab piirata suhtlemist süsteemiga ainult nende konteineritega, mis on faili sees mainitud. docker-compose.yml.

Vaatame, millised on suhtlemised konteineritega, kui kasutada käsku docker-compose. Kui eeldada, et peame sisenema kestasse psql, võivad vastavad käsud välja näha järgmiselt:

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

Sama käsk, mille täitmiseks ei kasutata docker-compose, ja docker, võib välja näha järgmine:

docker exec -it edp_timescale_1 psql -Upostgres

Pange tähele, et sarnastes olukordades on alati soovitatav kasutada käsku docker, mitte käsku docker-compose, kuna see võimaldab unustada konteinerite nimed.

Mõlemad eelnevalt mainitud käsud ei ole ülemäära keerulised. Kuid kui me kasutaksime "ümbrist" näol Makefile, mis oleks meile lihtsat käsurea liidest ja kutsuks ise välja selliseid pikki käske, siis nende samade tulemuste saavutamiseks saaks teha nii:

make db-shell

On täiesti selge, et kasutamine Makefile meenutab oluliselt meie konteineritega töötamist!

Tööproov

Eelnevalt käsitletud projektskeemi põhjal loome järgmise faili 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

Docker Compose'i konfiguratsiooni haldamiseks ja konteineritega, mille ta kirjeldab, suhtlemiseks loome järgmise faili 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

Enamik siinkohal kirjeldatud käsku rakendatakse kõigi konteinerite suhtes, kuid valiku kasutamine c= lubab piirata käsu ulatust ühe konteineriga.

Pärast seda, kui Makefile on valmis, seda saab kasutada järgmiselt:

• make help — loetelu kõigist käskudest, mis on saadaval make.

Käskudele juurdepääsu abi

• make build — pildi koostamine. Dockerfile. Meie näites kasutasime olemasolevaid pilte timescale ja ping. Kuid pilt api mida me soovime kohapeal kokku panna. Just see toimub pärast selle käsu täitmist.

Docker konteineri ehitus

• make start — kõigi konteinerite käivitamine. Ühe konteineri käivitamiseks võib kasutada sellist käsku make start c=timescale.

timescale konteineri käivitamine

ping konteineri käivitamine

• make login-timescale — sisenemine konteineri bash-seanssi timescale.

timescale konteineris bash'i käivitamine

• make db-shell — sisenemine psql konteineris timescale SQL-päringute täitmiseks andmebaasi.

psql'i käivitamine timescaledb konteineris

• make stop — konteinerite peatamine.

timescale konteineri peatamine

• make down — konteinerite peatamine ja eemaldamine. Konkreetse konteineri eemaldamiseks võib seda käsku kasutada, määrates vajadusel konteineri. Näiteks — make down c=timescale või make down c=api.

kõigi konteinerite peatamine ja eemaldamine

Kokkuvõte

Kuna Docker Compose süsteem pakub rohkesti käske, mis on mõeldud konteinerite haldamiseks, võivad need käsud mõnikord pugeda pikaks, mistõttu on neid raske meelde jätta.

Kasutamismeetod Makefile aitas meil kiiret ja lihtsat suhtlemist konteineritega failist korraldada docker-compose.yml. Nimelt on juttu järgmistest:

• Arendaja suhtleb ainult projekti konteineritega, mis on kirjeldatud docker-compose.yml, teised jooksvalt töötavad konteinerid ei sega tööd.
• Kui mõni käsk jääb unustamata, võite sisestada käsu make help ja saada teavet saadaval olevate käskude kohta.
• Ei pea mäletama pikki argumentide loendeid selliste toimingute jaoks nagu värskete logi sissekande saamine või süsteemi sisse logimine. Näiteks käsk, mis näeb välja nagu docker-compose -f docker-compose.yml exec timescale psql -Upostgres muutub make db-shell.
• File Makefile võimalik, et projekti kasvades saab teda paindlikult kohandada. Näiteks on lihtne lisada käsku, mis loob andmebaasi varukoopia või täidab mõne muu toimingu.
• Kui suur arendajate meeskond kasutab sama Makefile, siis korrastab see koostööd ja vähendab vigade arvu.

P.S. Meie turul on olemas pilt Docker, mis installitakse ühe klõpsuga. Saate kontrollida konteinerite tööd VPS. Kõigile uutele klientidele antakse tasuta 3 päeva katsetamiseks.

Lugupidamisega lugejad! Kuidas automatiseerite Docker Compose'i kasutamist?

Allikas: habr.com