Docker Compose: Pinapasimple ang Iyong Trabaho Gamit ang Makefiles

Bawat ilang taon, ang industriya ng software development ay sumasailalim sa isang paradigm shift. Ang isa sa mga phenomena na ito ay maaaring kilalanin bilang lumalaking interes sa konsepto ng microservices. Bagama't ang mga microservice ay hindi ang pinakabagong teknolohiya, kamakailan lamang ay literal na tumataas ang katanyagan nito.

Ang malalaking monolitikong serbisyo ay pinapalitan na ngayon ng mga independiyente, nagsasarili na mga microservice. Ang isang microservice ay maaaring isipin bilang isang application na nagsisilbi sa isang solong at napaka tiyak na layunin. Halimbawa, maaaring ito ay isang relational na DBMS, isang Express application, isang serbisyo ng Solr.

Sa mga araw na ito, mahirap isipin ang pagbuo ng isang bagong software system nang hindi gumagamit ng mga microservice. At ang sitwasyong ito, sa turn, ay humahantong sa amin sa platform ng Docker.

Manggagawa sa pantalan

Platform Manggagawa sa pantalan, sa pagbuo at pag-deploy ng mga microservice, ay naging halos isang pamantayan sa industriya. Sa website ng proyekto maaari mong malaman na ang Docker ay ang tanging independiyenteng platform ng containerization na nagbibigay-daan sa mga organisasyon na walang kahirap-hirap na lumikha ng anumang application, pati na rin ipamahagi at patakbuhin ang mga ito sa anumang kapaligiran - mula sa hybrid na ulap hanggang sa mga sistema ng gilid.

Docker Bumuo

Технология Docker Bumuo dinisenyo para sa pag-configure ng mga multi-container na application. Ang isang Docker Compose project ay maaaring maglaman ng kasing dami ng Docker container na kailangan ng gumawa ng proyekto.

Kapag nagtatrabaho sa Docker Compose, isang YAML file ang ginagamit upang i-configure ang mga serbisyo ng application at ayusin ang kanilang pakikipag-ugnayan sa isa't isa. Samakatuwid, ang Docker Compose ay isang tool para sa paglalarawan at pagpapatakbo ng mga multi-container na Docker application.

Dalawang container na tumatakbo sa isang host system

GNU Gumawa

Programa make, ay mahalagang kasangkapan para sa pag-automate ng pagbuo ng mga programa at aklatan mula sa source code. Sa pangkalahatan, masasabi natin iyan make nalalapat sa anumang proseso na nagsasangkot ng pagsasagawa ng mga arbitrary na utos upang baguhin ang ilang materyal sa pag-input sa ilang anyo ng output, sa ilang layunin. Sa aming kaso, ang mga utos docker-compose ay mababago sa abstract na mga layunin (Mga target ng telepono).

Upang sabihin sa programa make tungkol sa kung ano ang gusto namin mula dito, kailangan namin ng isang file Makefile.

Sa ating Makefile ay maglalaman ng mga regular na utos docker и docker-compose, na idinisenyo upang malutas ang maraming problema. Ibig sabihin, pinag-uusapan natin ang tungkol sa pag-assemble ng container, tungkol sa pagsisimula nito, pagpapahinto nito, pag-restart nito, tungkol sa pag-aayos ng user login sa container, tungkol sa pagtatrabaho sa mga container log, at tungkol sa paglutas ng iba pang katulad na problema.

Mga Karaniwang Use Case para sa Docker Compose

Isipin natin ang isang regular na web application na may mga sumusunod na bahagi:

• Database ng TimescaleDB (Postgres).
• Express.js application.
• Ping (isang lalagyan lang, walang ginagawang espesyal).

Ang application na ito ay mangangailangan ng 3 Docker container at isang file docker-compose, na naglalaman ng mga tagubilin para sa pamamahala ng mga container na ito. Ang bawat lalagyan ay magkakaroon ng magkakaibang mga touchpoint. Halimbawa, may lalagyan timescale magiging posible na gumana nang humigit-kumulang sa parehong paraan tulad ng pagtatrabaho nila sa mga database. Lalo na, pinapayagan ka nitong isagawa ang mga sumusunod na aksyon:

• Pag-log in sa Postgres shell.
• Pag-import at pag-export ng mga talahanayan.
• paglikha pg_dump mga talahanayan o database.

Express.js application container, expressjs, ay maaaring magkaroon ng mga sumusunod na kakayahan:

• Pagbibigay ng bagong data mula sa log ng system.
• Mag-login sa shell upang magsagawa ng ilang partikular na utos.

Pakikipag-ugnayan sa Mga Container

Kapag nakapag-set up na kami ng komunikasyon sa pagitan ng mga container gamit ang Docker Compose, oras na para makipag-ugnayan sa mga container na iyon. Sa loob ng Docker Compose system mayroong isang command docker-compose, opsyon sa pagsuporta -f, na nagpapahintulot sa iyo na maglipat ng file sa system docker-compose.yml.

Gamit ang mga kakayahan ng opsyong ito, maaari mong limitahan ang pakikipag-ugnayan sa system sa mga container lang na binanggit sa file. docker-compose.yml.

Tingnan natin kung ano ang hitsura ng mga pakikipag-ugnayan sa mga container kapag gumagamit ng mga command docker-compose. Kung iniisip natin na kailangan nating mag-log in sa shell psql, kung gayon ang kaukulang mga utos ay maaaring magmukhang ganito:

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

Ang parehong utos na hindi ginagamit upang isagawa docker-composeAt docker, maaaring ganito ang hitsura:

docker exec -it  edp_timescale_1 psql -Upostgres

Pakitandaan na sa ganitong mga kaso, mas mainam na gamitin ang command docker, at ang koponan docker-compose, dahil inaalis nito ang pangangailangang tandaan ang mga pangalan ng container.

Ang parehong mga utos sa itaas ay hindi ganoon kahirap. Ngunit kung gumamit tayo ng "wrapper" sa form Makefile, na magbibigay sa amin ng isang interface sa anyo ng mga simpleng utos at tatawag mismo ng mga katulad na mahabang utos, kung gayon ang parehong mga resulta ay maaaring makamit tulad nito:

make db-shell

Ito ay lubos na halata na ang paggamit Makefile ginagawang mas madali ang pagtatrabaho sa mga lalagyan!

Halimbawa ng paggawa

Batay sa diagram ng proyekto sa itaas, lilikha kami ng sumusunod na file 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

Upang pamahalaan ang configuration ng Docker Compose at makipag-ugnayan sa mga container na inilalarawan nito, gagawin namin ang sumusunod na file 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

Karamihan sa mga utos na inilarawan dito ay nalalapat sa lahat ng mga lalagyan, ngunit ginagamit ang opsyon c= nagbibigay-daan sa iyong limitahan ang saklaw ng isang command sa isang lalagyan.

Pagkatapos Makefile handa na, maaari mong gamitin ito tulad nito:

• make help — pagbibigay ng listahan ng lahat ng mga utos na magagamit para sa make.

Tulong sa magagamit na mga utos

• make build - assembling isang imahe mula sa Dockerfile. Sa aming halimbawa ginamit namin ang mga umiiral na larawan timescale и ping. Ngunit ang imahe api gusto naming mangolekta ng lokal. Ito ay eksakto kung ano ang gagawin pagkatapos isagawa ang utos na ito.

Pagbuo ng container ng Docker

• make start — paglulunsad ng lahat ng lalagyan. Upang ilunsad ang isang lalagyan lamang, maaari kang gumamit ng isang utos tulad ng make start c=timescale.

Pagpapatakbo ng timescale container

Pagpapatakbo ng ping container

• make login-timescale — mag-login sa session ng bash ng container timescale.

Pagpapatakbo ng bash sa isang timescale container

• make db-shell - pasukan sa psql sa isang lalagyan timescale upang magsagawa ng mga query sa SQL laban sa database.

Pagpapatakbo ng psql sa isang timescaledb container

• make stop — paghinto ng mga lalagyan.

Paghinto ng isang timescale container

• make down — paghinto at pag-alis ng mga lalagyan. Upang alisin ang isang partikular na lalagyan, maaari mong gamitin ang command na ito na tumutukoy sa gustong lalagyan. Halimbawa - make down c=timescale o make down c=api.

Paghinto at pagtanggal ng lahat ng mga lalagyan

Mga resulta ng

Bagama't ang Docker Compose ay nagbibigay sa amin ng maraming hanay ng mga command para sa pamamahala ng mga container, kung minsan ang mga command na ito ay maaaring maging mahaba at mahirap tandaan.

Paraan ng paggamit Makefile nakatulong sa amin na magtatag ng mabilis at madaling pakikipag-ugnayan sa mga container mula sa isang file docker-compose.yml. Ibig sabihin, pinag-uusapan natin ang mga sumusunod:

• Nakikipag-ugnayan lang ang developer sa mga lalagyan ng proyekto na inilarawan sa docker-compose.yml, ang trabaho ay hindi naaabala ng iba pang tumatakbong mga lalagyan.
• Sa kaganapan na ang isang tiyak na utos ay nakalimutan, maaari mong isagawa ang utos make help at humingi ng tulong sa mga available na command.
• Hindi mo kailangang tandaan ang mga mahahabang listahan ng mga argumento upang maisagawa ang mga aksyon tulad ng pagkuha ng pinakabagong mga entry sa log o pag-log in sa isang system. Halimbawa, isang utos tulad ng docker-compose -f docker-compose.yml exec timescale psql -Upostgres pagliko sa make db-shell.
• talaksan Makefile Maaari kang madaling umangkop dito habang lumalaki ang proyekto. Halimbawa, madaling magdagdag ng command upang lumikha ng backup ng database o magsagawa ng anumang iba pang aksyon.
• Kung ang isang malaking pangkat ng mga developer ay gumagamit ng pareho Makefile, pinapadali nito ang pakikipagtulungan at binabawasan ang mga error.

PS Sa ating palengke may isang imahe Manggagawa sa pantalan, na maaaring mai-install sa isang pag-click. Maaari mong suriin ang pagpapatakbo ng mga lalagyan sa VPS. Lahat ng mga bagong kliyente ay binibigyan ng 3 araw ng pagsubok nang walang bayad.

Minamahal na mambabasa! Paano mo i-automate ang Docker Compose?

Pinagmulan: www.habr.com