Docker Compose៖ សម្រួលការងាររបស់អ្នកដោយប្រើ Makefiles

រៀងរាល់ពីរបីឆ្នាំម្តង ឧស្សាហកម្មអភិវឌ្ឍន៍កម្មវិធីបានឆ្លងកាត់ការផ្លាស់ប្តូរគំរូ។ បាតុភូតមួយក្នុងចំណោមបាតុភូតទាំងនេះអាចត្រូវបានទទួលស្គាល់ថាជាចំណាប់អារម្មណ៍ដែលកំពុងកើនឡើងនៅក្នុងគំនិតនៃសេវាកម្មមីក្រូ។ ថ្វីត្បិតតែសេវាមីក្រូមិនមែនជាបច្ចេកវិទ្យាថ្មីបំផុតក៏ដោយ ក៏ទើបតែថ្មីៗនេះដែរ ដែលប្រជាប្រិយភាពរបស់វាបានកើនឡើងយ៉ាងខ្លាំង។

សេវា monolithic ដ៏ធំឥឡូវនេះត្រូវបានជំនួសដោយសេវាកម្មមីក្រូស្វយ័តឯករាជ្យ។ សេវាមីក្រូអាចត្រូវបានគេគិតថាជាកម្មវិធីដែលបម្រើគោលបំណងតែមួយ និងជាក់លាក់បំផុត។ ឧទាហរណ៍ វាអាចជា DBMS ទំនាក់ទំនង កម្មវិធី Express សេវា Solr ។

សព្វថ្ងៃនេះ វាពិបាកក្នុងការស្រមៃថានឹងបង្កើតប្រព័ន្ធសូហ្វវែរថ្មីដោយមិនប្រើសេវាមីក្រូ។ ហើយស្ថានភាពនេះនាំយើងទៅកាន់វេទិកា Docker ។

Dockers

វេទិកា Dockersនៅក្នុងការអភិវឌ្ឍន៍ និងការដាក់ឱ្យប្រើប្រាស់សេវាមីក្រូ បានក្លាយជាស្តង់ដារឧស្សាហកម្មស្ទើរតែទាំងអស់។ នៅលើគេហទំព័ររបស់គម្រោង អ្នកអាចដឹងថា Docker គឺជាវេទិកាផ្ទុកឯករាជតែមួយគត់ដែលអនុញ្ញាតឱ្យអង្គការបង្កើតកម្មវិធីណាមួយដោយមិនចាំបាច់ខិតខំប្រឹងប្រែង ក៏ដូចជាចែកចាយ និងដំណើរការពួកវានៅក្នុងបរិយាកាសណាមួយ - ពីពពកកូនកាត់ទៅប្រព័ន្ធគែម។

សរសេរ Docker

បច្ចេកវិទ្យា សរសេរ Docker រចនាឡើងសម្រាប់កំណត់រចនាសម្ព័ន្ធកម្មវិធីពហុកុងតឺន័រ។ គម្រោង Docker Compose អាចមានកុងតឺន័រ Docker ច្រើនតាមដែលអ្នកបង្កើតគម្រោងត្រូវការ។

នៅពេលធ្វើការជាមួយ Docker Compose ឯកសារ YAML ត្រូវបានប្រើដើម្បីកំណត់រចនាសម្ព័ន្ធសេវាកម្មកម្មវិធី និងរៀបចំអន្តរកម្មរបស់ពួកគេជាមួយគ្នា។ ដូច្នេះ Docker Compose គឺជាឧបករណ៍សម្រាប់ពិពណ៌នា និងដំណើរការកម្មវិធី Docker ច្រើនកុងតឺន័រ។

ធុងពីរដំណើរការលើប្រព័ន្ធម៉ាស៊ីន

ក្រុមហ៊ុន GNU Make

កម្មវិធីនេះ makeជាឧបករណ៍សំខាន់សម្រាប់បង្កើតកម្មវិធី និងបណ្ណាល័យដោយស្វ័យប្រវត្តិពីប្រភពកូដ។ ជាទូទៅយើងអាចនិយាយបាន។ make អនុវត្តចំពោះដំណើរការណាមួយដែលពាក់ព័ន្ធនឹងការប្រតិបត្តិពាក្យបញ្ជាតាមអំពើចិត្ត ដើម្បីបំប្លែងសម្ភារៈបញ្ចូលមួយចំនួនទៅជាទម្រង់លទ្ធផលមួយចំនួន ទៅកាន់គោលដៅមួយចំនួន។ ក្នុងករណីរបស់យើងពាក្យបញ្ជា docker-compose នឹងត្រូវបានបំប្លែងទៅជាគោលដៅអរូបី (គោលដៅទូរស័ព្ទ).

ដើម្បីប្រាប់កម្មវិធី make អំពីអ្វីដែលយើងចង់បានពីវា យើងត្រូវការឯកសារ Makefile.

នៅក្នុងរបស់យើង Makefile នឹងមានពាក្យបញ្ជាធម្មតា។ docker и docker-composeដែលត្រូវបានរចនាឡើងដើម្បីដោះស្រាយបញ្ហាជាច្រើន។ មានន័យថា យើងកំពុងនិយាយអំពីការផ្គុំកុងតឺន័រ អំពីការចាប់ផ្តើមវា បញ្ឈប់វា ចាប់ផ្តើមវាឡើងវិញ អំពីការរៀបចំការចូលរបស់អ្នកប្រើប្រាស់ទៅកាន់កុងតឺន័រ អំពីការធ្វើការជាមួយកំណត់ហេតុកុងតឺន័រ និងអំពីការដោះស្រាយបញ្ហាស្រដៀងគ្នាផ្សេងទៀត។

ករណីប្រើប្រាស់ធម្មតាសម្រាប់ Docker Compose

តោះស្រមៃមើលកម្មវិធីគេហទំព័រធម្មតាដែលមានធាតុផ្សំដូចខាងក្រោម៖

• មូលដ្ឋានទិន្នន័យ TimescaleDB (Postgres) ។
• កម្មវិធី Express.js ។
• ភីង (គ្រាន់តែជាធុងមួយមិនធ្វើអ្វីពិសេសទេ) ។

កម្មវិធីនេះនឹងត្រូវការធុង Docker ចំនួន 3 និងឯកសារមួយ។ docker-composeដែលមានការណែនាំសម្រាប់ការគ្រប់គ្រងធុងទាំងនេះ។ ធុងនីមួយៗនឹងមានចំណុចប៉ះខុសៗគ្នា។ ឧទាហរណ៍ជាមួយធុងមួយ។ timescale វា​នឹង​អាច​ធ្វើ​ការ​ប្រហែល​ដូច​គ្នា​នឹង​ការ​ធ្វើ​ការ​ជាមួយ​មូលដ្ឋាន​ទិន្នន័យ។ ពោលគឺវាអនុញ្ញាតឱ្យអ្នកអនុវត្តសកម្មភាពដូចខាងក្រោមៈ

• ការចូលទៅក្នុងសែល Postgres ។
• នាំចូលនិងនាំចេញតារាង។
• ការបង្កើត pg_dump តារាង ឬមូលដ្ឋានទិន្នន័យ។

ធុងកម្មវិធី Express.js, expressjsអាចមានសមត្ថភាពដូចខាងក្រោមៈ

• ការផ្តល់ទិន្នន័យថ្មីពីកំណត់ហេតុប្រព័ន្ធ។
• ចូលទៅសែល ដើម្បីប្រតិបត្តិពាក្យបញ្ជាជាក់លាក់។

អន្តរកម្មជាមួយកុងតឺន័រ

នៅពេលដែលយើងរៀបចំទំនាក់ទំនងរវាងកុងតឺន័រដោយប្រើ Docker Compose វាដល់ពេលដែលត្រូវទាក់ទងជាមួយកុងតឺន័រទាំងនោះ។ នៅក្នុងប្រព័ន្ធ Docker Compose មានពាក្យបញ្ជាមួយ។ docker-compose, ជម្រើសគាំទ្រ -fដែលអនុញ្ញាតឱ្យអ្នកផ្ទេរឯកសារទៅប្រព័ន្ធ docker-compose.yml.

ដោយប្រើសមត្ថភាពនៃជម្រើសនេះ អ្នកអាចកំណត់អន្តរកម្មជាមួយប្រព័ន្ធចំពោះតែកុងតឺន័រទាំងនោះដែលត្រូវបានលើកឡើងនៅក្នុងឯកសារប៉ុណ្ណោះ។ docker-compose.yml.

សូមក្រឡេកមើលថាតើអន្តរកម្មជាមួយកុងដង់មើលទៅដូចអ្វីនៅពេលប្រើពាក្យបញ្ជា docker-compose. ប្រសិនបើយើងស្រមៃថាយើងត្រូវចូលទៅក្នុងសែល psqlបន្ទាប់មកពាក្យបញ្ជាដែលត្រូវគ្នាអាចមើលទៅដូចនេះ៖

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

ពាក្យបញ្ជាដូចគ្នាដែលមិនត្រូវបានប្រើដើម្បីប្រតិបត្តិ docker-composeនិង docker, អាចមើលទៅដូចនេះ:

docker exec -it  edp_timescale_1 psql -Upostgres

សូមចំណាំថាក្នុងករណីបែបនេះវាតែងតែចូលចិត្តប្រើពាក្យបញ្ជា dockerនិងបញ្ជា docker-composeព្រោះវាលុបបំបាត់តម្រូវការក្នុងការចងចាំឈ្មោះធុង។

ពាក្យបញ្ជាទាំងពីរខាងលើមិនពិបាកទេ។ ប៉ុន្តែប្រសិនបើយើងប្រើ "រុំ" នៅក្នុងទម្រង់ Makefileដែលនឹងផ្តល់ឱ្យយើងនូវចំណុចប្រទាក់មួយនៅក្នុងទម្រង់នៃពាក្យបញ្ជាសាមញ្ញ ហើយខ្លួនវាផ្ទាល់នឹងហៅពាក្យបញ្ជាវែងស្រដៀងគ្នា បន្ទាប់មកលទ្ធផលដូចគ្នាអាចត្រូវបានសម្រេចដូចនេះ៖

make db-shell

វាច្បាស់ណាស់ថាការប្រើប្រាស់ Makefile ធ្វើឱ្យការធ្វើការជាមួយធុងកាន់តែងាយស្រួល!

ឧទាហរណ៍ការងារ

ដោយផ្អែកលើដ្យាក្រាមគម្រោងខាងលើ យើងនឹងបង្កើតឯកសារដូចខាងក្រោម 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 និងធ្វើអន្តរកម្មជាមួយធុងដែលវាពិពណ៌នា យើងនឹងបង្កើតឯកសារដូចខាងក្រោម 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

ពាក្យបញ្ជាភាគច្រើនដែលបានពិពណ៌នានៅទីនេះអនុវត្តចំពោះកុងតឺន័រទាំងអស់ ប៉ុន្តែដោយប្រើជម្រើស c= អនុញ្ញាតឱ្យអ្នកកំណត់វិសាលភាពនៃពាក្យបញ្ជាទៅកុងតឺន័រមួយ។

បន្ទាប់ពី Makefile រួចរាល់ហើយ អ្នកអាចប្រើវាដូចនេះ៖

• make help - ចេញបញ្ជីពាក្យបញ្ជាទាំងអស់ដែលមានសម្រាប់ make.

ជំនួយលើពាក្យបញ្ជាដែលមាន

• make build - ការប្រមូលផ្តុំរូបភាពពី Dockerfile. ក្នុងឧទាហរណ៍របស់យើង យើងបានប្រើរូបភាពដែលមានស្រាប់ timescale и ping. ប៉ុន្តែរូបភាព api យើងចង់ប្រមូលក្នុងស្រុក។ នេះគឺជាអ្វីដែលនឹងត្រូវធ្វើបន្ទាប់ពីប្រតិបត្តិពាក្យបញ្ជានេះ។

ការសាងសង់ធុង Docker

• make start - បើកដំណើរការកុងតឺន័រទាំងអស់។ ដើម្បីបើកដំណើរការកុងតឺន័រតែមួយ អ្នកអាចប្រើពាក្យបញ្ជាដូចជា make start c=timescale.

កំពុងដំណើរការកុងតឺន័រកំណត់ពេលវេលា

កំពុងដំណើរការកុងតឺន័រ ping

• make login-timescale - ចូលទៅកាន់វគ្គ bash នៃកុងតឺន័រ timescale.

កំពុងដំណើរការ bash នៅក្នុងធុងពេលវេលា

• make db-shell - ច្រកចូល psql នៅក្នុងធុងមួយ។ timescale ដើម្បីប្រតិបត្តិសំណួរ SQL ប្រឆាំងនឹងមូលដ្ឋានទិន្នន័យ។

កំពុងដំណើរការ psql នៅក្នុងធុង timescaledb

• make stop - ការបញ្ឈប់ធុង។

ការបញ្ឈប់កុងតឺន័រកំណត់ពេលវេលា

• make down - បញ្ឈប់ និងយកធុងចេញ។ ដើម្បីលុបកុងតឺន័រជាក់លាក់មួយ អ្នកអាចប្រើពាក្យបញ្ជានេះដែលបញ្ជាក់កុងតឺន័រដែលចង់បាន។ ឧទាហរណ៍ - make down c=timescale ឬ make down c=api.

ការបញ្ឈប់ និងលុបកុងតឺន័រទាំងអស់។

លទ្ធផល

ទោះបីជា Docker Compose ផ្តល់ឱ្យយើងនូវសំណុំនៃពាក្យបញ្ជាដ៏សំបូរបែបសម្រាប់ការគ្រប់គ្រងកុងតឺន័រក៏ដោយ ពេលខ្លះពាក្យបញ្ជាទាំងនេះអាចក្លាយទៅជាវែង និងពិបាកចងចាំ។

វិធីសាស្រ្តនៃការប្រើប្រាស់ Makefile បានជួយយើងបង្កើតអន្តរកម្មរហ័ស និងងាយស្រួលជាមួយកុងតឺន័រពីឯកសារមួយ។ docker-compose.yml. ពោល​គឺ​យើង​កំពុង​និយាយ​អំពី​រឿង​ខាង​ក្រោម៖

• អ្នកអភិវឌ្ឍន៍ធ្វើអន្តរកម្មតែជាមួយធុងគម្រោងដែលបានពិពណ៌នានៅក្នុង docker-compose.yml, ការងារមិនត្រូវបានរំខានដោយធុងដែលកំពុងដំណើរការផ្សេងទៀត។
• ក្នុងករណីដែលពាក្យបញ្ជាជាក់លាក់មួយត្រូវបានបំភ្លេច អ្នកអាចប្រតិបត្តិពាក្យបញ្ជា make help និងទទួលបានជំនួយលើពាក្យបញ្ជាដែលមាន។
• អ្នកមិនចាំបាច់ចាំបញ្ជីអាគុយម៉ង់យូរដើម្បីអនុវត្តសកម្មភាពដូចជាការទទួលបានធាតុកំណត់ហេតុចុងក្រោយបំផុត ឬចូលទៅក្នុងប្រព័ន្ធមួយ។ ឧទាហរណ៍ពាក្យបញ្ជាដូចជា docker-compose -f docker-compose.yml exec timescale psql -Upostgres ប្រែទៅជា make db-shell.
• ឯកសារ Makefile អ្នក​អាច​សម្រប​តាម​វា​ដោយ​ភាព​បត់បែន​នៅពេល​គម្រោង​រីកចម្រើន។ ឧទាហរណ៍ វាងាយស្រួលក្នុងការបន្ថែមពាក្យបញ្ជាដើម្បីបង្កើតការបម្រុងទុកមូលដ្ឋានទិន្នន័យ ឬធ្វើសកម្មភាពផ្សេងទៀត។
• ប្រសិនបើក្រុមអ្នកអភិវឌ្ឍន៍ធំប្រើដូចគ្នា។ Makefileនេះជួយសម្រួលដល់កិច្ចសហការ និងកាត់បន្ថយកំហុស។

PS នៅក្នុងរបស់យើង ទីផ្សារ មានរូបភាពមួយ។ Dockersដែលអាចត្រូវបានដំឡើងដោយចុចតែម្តង។ អ្នកអាចពិនិត្យមើលប្រតិបត្តិការនៃធុងនៅ ការ VPS. អតិថិជនថ្មីទាំងអស់ត្រូវបានផ្តល់ការសាកល្បងរយៈពេល 3 ថ្ងៃដោយមិនគិតថ្លៃ។

អ្នកអានជាទីស្រឡាញ់! តើអ្នកធ្វើស្វ័យប្រវត្តិកម្ម Docker Compose ដោយរបៀបណា?

ប្រភព: www.habr.com