Docker Compose: Jo wurk ferienfâldigje mei Make-bestannen

Elke pear jier ûndergiet de softwareûntwikkelingssektor in paradigmaferskowing. Ien fan dizze ferskynsels kin erkend wurde as de groeiende belangstelling foar it konsept fan mikrotsjinsten. Hoewol mikrotsjinsten net de nijste technology binne, is syn populariteit allinich letterlik skyrocket.

Grutte monolityske tsjinsten wurde no ferfongen troch ûnôfhinklike, autonome mikrotsjinsten. In mikrotsjinst kin beskôge wurde as in applikaasje dy't ien en heul spesifyk doel tsjinnet. It kin bygelyks in relaasje DBMS, in Express-applikaasje, in Solr-tsjinst wêze.

Dizze dagen is it lestich foar te stellen dat jo in nij softwaresysteem ûntwikkelje sûnder mikrotsjinsten te brûken. En dizze situaasje liedt ús op syn beurt nei it Docker-platfoarm.

Havenarbeider

Platfoarm Havenarbeider, yn 'e ûntwikkeling en ynset fan mikrotsjinsten, is hast in yndustrystandert wurden. Op 'e projektwebside kinne jo útfine dat Docker it ienige ûnôfhinklike kontenerisaasjeplatfoarm is wêrmei organisaasjes maklik elke applikaasje kinne oanmeitsje, en ek fersprieden en útfiere yn elke omjouwing - fan hybride wolken oant rânesystemen.

Docker Compose

Technology Docker Compose ûntwurpen foar it konfigurearjen fan multi-container applikaasjes. In Docker Compose-projekt kin safolle Docker-konteners befetsje as de skepper fan it projekt nedich is.

As jo ​​wurkje mei Docker Compose, wurdt in YAML-bestân brûkt om applikaasjetsjinsten te konfigurearjen en har ynteraksje mei elkoar te organisearjen. Docker Compose is dêrom in ark foar it beskriuwen en útfieren fan Docker-applikaasjes mei meardere konteners.

Twa konteners rinne op in hostsysteem

GNU meitsje

It programma make, is yn wêzen in ark foar it automatisearjen fan it bouwen fan programma's en bibleteken út boarnekoade. Yn 't algemien kinne wy ​​dat sizze make jildt foar elk proses dat it útfieren fan willekeurige kommando's omfettet om guon ynfiermaterialen te transformearjen yn guon útfierfoarm foar ien of oare doel. Yn ús gefal, de kommando's docker-compose sil wurde omfoarme ta abstrakte doelen (Phone doelen).

Om it programma te fertellen make oer wat wy wolle fan it, wy moatte in triem Makefile.

Yn ús Makefile sil reguliere kommando's befetsje docker и docker-compose, dy't ûntwurpen binne om in protte problemen op te lossen. Wy hawwe it nammentlik oer it gearstallen fan in kontener, oer it opstarten, stopjen, opnij starte, oer it organisearjen fan brûkersoanmelding by de kontener, oer wurkjen mei kontenerlogboeken en oer it oplossen fan oare ferlykbere problemen.

Typyske gebrûksgefallen foar Docker Compose

Litte wy ús in gewoane webapplikaasje foarstelle dy't de folgjende komponinten hat:

• TimescaleDB database (Postgres).
• Express.js applikaasje.
• Ping (gewoan in kontener, docht neat spesjaal).

Dizze applikaasje sil 3 Docker-containers en in bestân nedich wêze docker-compose, dy't ynstruksjes befettet foar it behearen fan dizze konteners. Elke kontener sil ferskate kontaktpunten hawwe. Bygelyks mei in kontener timescale it sil mooglik wêze om sawat deselde manier te wurkjen as se wurkje mei databases. It lit jo nammentlik de folgjende aksjes útfiere:

• Oanmelde yn 'e Postgres-shell.
• Ymportearje en eksportearje fan tabellen.
• skepping pg_dump tabellen of databases.

Express.js applikaasje container, expressjs, kin de folgjende mooglikheden hawwe:

• It leverjen fan frisse gegevens út it systeemlogboek.
• Oanmelde by de shell om bepaalde kommando's út te fieren.

Ynteraksje mei konteners

Sadree't wy kommunikaasje hawwe ynsteld tusken konteners mei Docker Compose, is it tiid om te kommunisearjen mei dy konteners. Binnen it Docker Compose-systeem is d'r in kommando docker-compose, stypjende opsje -f, wêrmei jo in bestân nei it systeem kinne oerdrage docker-compose.yml.

Mei de mooglikheden fan dizze opsje kinne jo ynteraksje mei it systeem allinich beheine ta de konteners dy't yn it bestân neamd binne docker-compose.yml.

Litte wy ris sjen hoe ynteraksjes mei konteners der útsjen by it brûken fan kommando's docker-compose. As wy ús yntinke dat wy moatte ynlogge yn 'e shell psql, dan kinne de oerienkommende kommando's der sa útsjen:

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

Itselde kommando dat net brûkt wurdt om út te fieren docker-composeen docker, kin der sa útsjen:

docker exec -it  edp_timescale_1 psql -Upostgres

Tink derom dat it yn sokke gefallen altyd de foarkar is om it kommando te brûken docker, en it kommando docker-compose, om't dit de needsaak elimineert om kontenernammen te ûnthâlden.

Beide boppesteande kommando's binne net sa dreech. Mar as wy brûkten in "wrapper" yn 'e foarm Makefile, dy't ús in ynterface soe jaan yn 'e foarm fan ienfâldige kommando's en sels ferlykbere lange kommando's neame, dan kinne deselde resultaten as dit berikt wurde:

make db-shell

It is dúdlik dat it gebrûk Makefile makket it wurkjen mei konteners folle makliker!

Wurk foarbyld

Op grûn fan it boppesteande projektdiagram sille wy it folgjende bestân oanmeitsje 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

Om de Docker Compose-konfiguraasje te behearjen en te ynteraksje mei de konteners dy't it beskriuwt, sille wy it folgjende bestân oanmeitsje 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 measte fan 'e hjir beskreaune kommando's jilde foar alle konteners, mar mei de opsje c= lit jo de omfang fan in kommando beheine ta ien kontener.

nei de Makefile klear, jo kinne it sa brûke:

• make help - it útjaan fan in list mei alle kommando's beskikber foar make.

Help by beskikbere kommando's

• make build - gearstalling fan in ôfbylding fan Dockerfile. Yn ús foarbyld hawwe wy besteande ôfbyldings brûkt timescale и ping. Mar it byld api wy wolle lokaal sammelje. Dit is krekt wat sil dien wurde nei it útfieren fan dit kommando.

Bouwe in Docker-kontener

• make start - alle konteners lansearje. Om mar ien kontener te starten, kinne jo in kommando brûke lykas make start c=timescale.

It útfieren fan de tiidskaalkontainer

It útfieren fan in ping-kontener

• make login-timescale - oanmelde by de bash-sesje fan 'e kontener timescale.

Running bash yn in tiidskaal kontener

• make db-shell - yngong nei psql yn in kontener timescale om SQL-fragen út te fieren tsjin de databank.

Psql útfiere yn in timescaledb-container

• make stop - stoppe konteners.

Stopje in tiidskaal container

• make down - it stopjen en fuortheljen fan konteners. Om in spesifike kontener te ferwiderjen, kinne jo dit kommando brûke om de winske kontener oan te jaan. Bygelyks - make down c=timescale of make down c=api.

Stopje en wiskje alle konteners

Resultaten

Hoewol Docker Compose ús in rike set fan kommando's jout foar it behearen fan konteners, kinne dizze kommando's soms lang wurde en dreech te ûnthâlden.

Metoade fan gebrûk Makefile holp ús in flugge en maklike ynteraksje mei konteners út in bestân docker-compose.yml. Wy hawwe it nammentlik oer it folgjende:

• De ûntwikkelder ynteraksje allinich mei de projektkonteners beskreaun yn docker-compose.yml, wurk wurdt net hindere troch oare rinnende konteners.
• Yn it gefal dat in bepaald kommando fergetten is, kinne jo it kommando útfiere make help en krije help by beskikbere kommando's.
• Jo hoege gjin lange listen mei arguminten te ûnthâlden om aksjes út te fieren, lykas it krijen fan de lêste log-yngongen of ynlogge op in systeem. Bygelyks, in kommando lykas docker-compose -f docker-compose.yml exec timescale psql -Upostgres feroaret yn make db-shell.
• file Makefile Jo kinne der fleksibel oan oanpasse as it projekt groeit. It is bygelyks maklik om in kommando ta te foegjen om in database-backup te meitsjen of in oare aksje út te fieren.
• As in grut team fan ûntwikkelders itselde brûkt Makefile, dit streamlines gearwurking en ferminderet flaters.

PS Yn ús marketplace der is in byld Havenarbeider, dy't yn ien klik ynstallearre wurde kin. Jo kinne kontrolearje de wurking fan konteners by VPS. Alle nije kliïnten krije 3 dagen fan testen fergees.

Dear readers! Hoe automatisearje jo Docker Compose?

Boarne: www.habr.com