Docker Compose: Vereenvoudig jou werk met Makefile

Elke paar jaar beleef die sagteware-ontwikkelingsbedryf 'n paradigmaskuif. Een van hierdie verskynsels kan erken word as die groeiende belangstelling in die konsep van mikrodienste. Alhoewel mikrodienste nie die nuutste tegnologie is nie, het die gewildheid daarvan eers onlangs letterlik die hoogte ingeskiet.

Groot monolitiese dienste word nou vervang deur onafhanklike selfstandige mikrodienste. 'n Mikrodiens kan beskou word as 'n toepassing wat 'n enkele en baie spesifieke doel dien. Dit kan byvoorbeeld 'n relasionele DBBS, 'n Express-toepassing, 'n Solr-diens wees.

Deesdae is dit moeilik om die ontwikkeling van 'n nuwe sagtewarestelsel sonder die gebruik van mikrodienste voor te stel. En hierdie situasie lei ons op sy beurt na die Docker-platform.

Docker

Platform Docker, in die ontwikkeling en ontplooiing van mikrodienste, het amper die industriestandaard geword. Op die projekwebwerf kan jy leer dat Docker die enigste onafhanklike houerplatform is wat organisasies in staat stel om moeiteloos enige toepassings te skep, asook om dit in enige omgewing te versprei en te laat loop – van hibriede wolke tot randstelsels.

Docker Komponeer

Технология Docker Komponeer ontwerp vir die opstel van multi-houer toepassings. 'n Docker Compose-projek kan soveel Docker-houers hê as wat die skepper van daardie projek benodig.

Wanneer u met Docker Compose werk, word 'n YAML-lêer gebruik om toepassingsdienste op te stel en hul interaksie met mekaar te organiseer. Docker Compose is dus 'n instrument om multi-houer Docker-toepassings te beskryf en uit te voer.

Twee houers wat op 'n gasheerstelsel loop

GNU Maak

Program make, in wese, is 'n instrument vir die outomatisering van die samestelling van programme en biblioteke vanaf bronkode. Oor die algemeen kan dit gesê word make van toepassing op enige proses wat die uitvoering van arbitrêre opdragte behels om sommige bronmateriaal te transformeer na een of ander eindresultaat, tot een of ander doel. In ons geval, die bevele docker-compose sal omgeskakel word na abstrakte teikens (Valse teikens).

Om die program te vertel make oor wat ons van haar wil hê, het ons 'n lêer nodig Makefile.

In ons Makefile sal die gewone opdragte bevat docker и docker-compose, wat ontwerp is om 'n verskeidenheid probleme op te los. Ons praat naamlik van die samestelling van 'n houer, begin dit, stop dit, herbegin dit, organisering van 'n gebruikerinskrywing in die houer, werk met houerlogboeke en die oplossing van ander soortgelyke take.

Tipiese gebruiksgevalle vir Docker Compose

Stel jou 'n tipiese webtoepassing voor wat die volgende komponente het:

• TimescaleDB databasis (Postgres).
• Express.js-toepassing.
• Ping (net 'n houer wat niks spesiaals doen nie).

Hierdie toepassing sal 3 Docker-houers en 'n lêer benodig docker-compose'n Bevat instruksies vir die bestuur van hierdie houers. Elkeen van die houers sal verskillende interaksiepunte hê. Byvoorbeeld, met 'n houer timescale dit sal moontlik wees om ongeveer dieselfde te werk as om met databasisse te werk. Dit laat jou naamlik die volgende doen:

• Meld aan by die Postgres-dop.
• Invoer en uitvoer van tafels.
• skepping pg_dump tabelle of databasisse.

Express.js aansoekhouer, expressjs, kan die volgende kenmerke hê:

• Uitreiking van vars data uit die stelsellogboek.
• Voer 'n dop in om sekere opdragte uit te voer.

Interaksie met houers

Noudat ons kommunikasie tussen houers opgestel het deur Docker Compose te gebruik, is dit tyd om met hierdie houers te kommunikeer. Binne die Docker Compose-stelsel is daar 'n opdrag docker-compose, wat die opsie ondersteun -f, wat jou toelaat om die lêer na die stelsel oor te dra docker-compose.yml.

Deur die vermoëns van hierdie opsie te gebruik, kan u interaksie met die stelsel slegs beperk tot die houers wat in die lêer genoem word docker-compose.yml.

Kom ons kyk na hoe interaksies met houers lyk wanneer opdragte gebruik word docker-compose. As ons ons verbeel dat ons die dop moet betree psql, dan kan die ooreenstemmende opdragte soos volg lyk:

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

Dieselfde opdrag, wat nie gebruik word om uit te voer nie docker-composeEn docker, kan so lyk:

docker exec -it  edp_timescale_1 psql -Upostgres

Let daarop dat dit in sulke gevalle altyd verkieslik is om nie die opdrag te gebruik nie docker, en die bevel docker-compose, aangesien dit die behoefte uitskakel om houername te onthou.

Albei bogenoemde opdragte is nie so ingewikkeld nie. Maar as ons die "wrapper" in die vorm gebruik het Makefile, wat vir ons 'n koppelvlak in die vorm van eenvoudige opdragte sou gee en self sulke lang opdragte sou noem, dan kan dieselfde resultate soos volg behaal word:

make db-shell

Dit is duidelik dat die gebruik Makefile vergemaklik die werk met houers baie!

Werkende voorbeeld

Gebaseer op die bogenoemde projekskema, sal ons die volgende lêer skep 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 die Docker Compose-konfigurasie te bestuur en om met die houers wat dit beskryf te kommunikeer, kom ons skep die volgende lêer 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

Die meeste van die opdragte wat hier beskryf word, is van toepassing op alle houers, maar die gebruik van die c= laat jou toe om die omvang van die opdrag tot 'n enkele houer te beperk.

Na Makefile gereed, jy kan dit so gebruik:

• make help - die uitreiking van 'n lys van alle opdragte beskikbaar vir make.

Hulp vir beskikbare opdragte

• make build - bou van 'n beeld Dockerfile. In ons voorbeeld het ons bestaande beelde gebruik timescale и ping. Maar die beeld api ons wil plaaslik bou. Dit is presies wat gedoen sal word nadat hierdie opdrag uitgevoer is.

Bou 'n Docker-houer

• make start - begin alle houers. Om slegs een houer te laat loop, kan jy 'n opdrag soos make start c=timescale.

Begin die tydskaalhouer

Bestuur 'n ping-houer

• make login-timescale - Teken in op die bash-sessie van die houer timescale.

Hardloop bash in 'n tydskaalhouer

• make db-shell - ingang na psql in 'n houer timescale om SQL-navrae teen die databasis uit te voer.

Begin psql in 'n timescaledb-houer

• make stop - stop houers.

Stop die tydskaalhouer

• make down - houers stop en uitvee. Om 'n spesifieke houer te verwyder, kan jy hierdie opdrag gebruik, wat die verlangde houer spesifiseer. Byvoorbeeld - make down c=timescale of make down c=api.

Stop en vee alle houers uit

Resultate van

Alhoewel die Docker Compose-stelsel ons 'n ryk stel opdragte gee om houers te bestuur, word hierdie opdragte soms lank en moeilik om te onthou as gevolg daarvan.

Metode van gebruik Makefile het ons gehelp om 'n vinnige en maklike interaksie met houers uit 'n lêer te vestig docker-compose.yml. Ons praat naamlik van die volgende:

• Die ontwikkelaar het slegs interaksie met die projekhouers wat in beskryf word docker-compose.yml, ander lopende houers belemmer nie werk nie.
• In die geval dat 'n sekere opdrag vergeet word, kan jy die opdrag uitvoer make help en kry hulp oor beskikbare opdragte.
• Jy hoef nie lang lyste argumente te onthou om dinge uit te voer soos om nuwe loginskrywings te kry of om aan te meld nie. Byvoorbeeld, 'n opdrag soos docker-compose -f docker-compose.yml exec timescale psql -Upostgres draai in make db-shell.
• lêer Makefile Jy kan, soos die projek groei, buigsaam daarby aanpas. Dit is byvoorbeeld maklik om 'n opdrag daarby te voeg om 'n databasisrugsteun te skep of om enige ander aksie uit te voer.
• As 'n groot ontwikkelingspan dieselfde gebruik Makefile, dit stroomlyn samewerking en verminder foute.

PS In ons markplek daar is 'n beeld Docker, wat met een klik geïnstalleer word. Jy kan kyk of die houers werk VPS. Alle nuwe kliënte kry 3 dae se toetsing gratis.

Beste lesers! Hoe outomatiseer u werk met Docker Compose?

Bron: will.com