Docker Compose: ເຮັດໃຫ້ວຽກຂອງທ່ານງ່າຍຂຶ້ນໂດຍໃຊ້ Makefiles

ທຸກໆສອງສາມປີ, ອຸດສາຫະກໍາການພັດທະນາຊອບແວໄດ້ຜ່ານການປ່ຽນແປງແບບແຜນ. ຫນຶ່ງໃນປະກົດການເຫຼົ່ານີ້ສາມາດຖືກຮັບຮູ້ວ່າເປັນຄວາມສົນໃຈເພີ່ມຂຶ້ນໃນແນວຄວາມຄິດຂອງການບໍລິການຈຸນລະພາກ. ເຖິງແມ່ນວ່າການບໍລິການຈຸນລະພາກບໍ່ແມ່ນເຕັກໂນໂລຊີໃຫມ່ທີ່ສຸດ, ພຽງແຕ່ບໍ່ດົນມານີ້ມີຄວາມນິຍົມຂອງຕົນ skyrockets ຮູ້ຫນັງສື.

ການບໍລິການ monolithic ຂະຫນາດໃຫຍ່ໃນປັດຈຸບັນໄດ້ຖືກທົດແທນໂດຍ microservices ເອກະລາດ, ເປັນເອກະລາດ. ການບໍລິການຈຸນລະພາກສາມາດຄິດໄດ້ວ່າເປັນແອັບພລິເຄຊັນທີ່ໃຫ້ບໍລິການຈຸດປະສົງດຽວ ແລະສະເພາະຫຼາຍ. ຕົວຢ່າງ, ມັນອາດຈະເປັນ DBMS ທີ່ກ່ຽວຂ້ອງ, ຄໍາຮ້ອງສະຫມັກ Express, ບໍລິການ Solr.

ມື້ນີ້, ມັນເປັນການຍາກທີ່ຈະຈິນຕະນາການການພັດທະນາລະບົບຊອບແວໃຫມ່ໂດຍບໍ່ຕ້ອງໃຊ້ microservices. ແລະສະຖານະການນີ້, ໃນທາງກັບກັນ, ນໍາພາພວກເຮົາໄປສູ່ເວທີ Docker.

Docker

ແພລະຕະຟອມ Docker, ໃນການພັດທະນາແລະການນໍາໃຊ້ການບໍລິການຈຸລະພາກ, ໄດ້ກາຍເປັນເກືອບມາດຕະຖານອຸດສາຫະກໍາ. ຢູ່ໃນເວັບໄຊທ໌ຂອງໂຄງການທ່ານສາມາດຄົ້ນພົບວ່າ Docker ເປັນແພລະຕະຟອມ containerization ເອກະລາດດຽວທີ່ອະນຸຍາດໃຫ້ອົງການຈັດຕັ້ງສາມາດສ້າງຄໍາຮ້ອງສະຫມັກໃດໆ, ເຊັ່ນດຽວກັນກັບການແຈກຢາຍແລະດໍາເນີນການໃນສະພາບແວດລ້ອມໃດກໍ່ຕາມ - ຈາກລູກປະສົມກັບລະບົບຂອບ.

Docker Compose

ເທກໂນໂລຍີ Docker Compose ອອກແບບມາເພື່ອກຳນົດຄ່າແອັບພລິເຄຊັນຫຼາຍຖັງ. ໂຄງການ Docker Compose ສາມາດບັນຈຸ Docker ຫຼາຍເທົ່າທີ່ຜູ້ສ້າງໂຄງການຕ້ອງການ.

ເມື່ອເຮັດວຽກກັບ Docker Compose, ໄຟລ໌ YAML ຖືກນໍາໃຊ້ເພື່ອກໍາຫນົດຄ່າບໍລິການຄໍາຮ້ອງສະຫມັກແລະຈັດລະບຽບການໂຕ້ຕອບຂອງເຂົາເຈົ້າກັບກັນແລະກັນ. ດັ່ງນັ້ນ Docker Compose ແມ່ນເຄື່ອງມືສໍາລັບການອະທິບາຍ ແລະແລ່ນແອັບພລິເຄຊັນ Docker ຫຼາຍພາຊະນະ.

ສອງຕູ້ຄອນເທນເນີທີ່ເຮັດວຽກຢູ່ໃນລະບົບໂຮດ

GNU ເຮັດ

ໂປລແກລມ make, ເປັນສິ່ງຈໍາເປັນເປັນເຄື່ອງມືສໍາລັບການອັດຕະໂນມັດການກໍ່ສ້າງໂຄງການແລະຫ້ອງສະຫມຸດຈາກລະຫັດແຫຼ່ງ. ໂດຍທົ່ວໄປ, ພວກເຮົາສາມາດເວົ້າໄດ້ make ໃຊ້ກັບຂະບວນການໃດໆທີ່ກ່ຽວຂ້ອງກັບການປະຕິບັດຄໍາສັ່ງທີ່ຕົນເອງມັກເພື່ອຫັນປ່ຽນວັດສະດຸປ້ອນເຂົ້າເປັນບາງຮູບແບບຜົນຜະລິດ, ເພື່ອເປົ້າຫມາຍບາງຢ່າງ. ໃນກໍລະນີຂອງພວກເຮົາ, ຄໍາສັ່ງ docker-compose ຈະຖືກປ່ຽນເປັນເປົ້າໝາຍທີ່ບໍ່ມີຕົວຕົນ (ເປົ້າໝາຍໂທລະສັບ).

ເພື່ອບອກໂຄງການ make ກ່ຽວກັບສິ່ງທີ່ພວກເຮົາຕ້ອງການຈາກມັນ, ພວກເຮົາຕ້ອງການໄຟລ໌ Makefile.

ໃນຂອງພວກເຮົາ Makefile ຈະມີຄໍາສັ່ງປົກກະຕິ docker и docker-compose, ເຊິ່ງຖືກອອກແບບມາເພື່ອແກ້ໄຂບັນຫາຫຼາຍຢ່າງ. ຄື, ພວກເຮົາເວົ້າກ່ຽວກັບການປະກອບຕູ້ຄອນເທນເນີ, ກ່ຽວກັບການເລີ່ມຕົ້ນມັນ, ຢຸດມັນ, ເລີ່ມຕົ້ນໃຫມ່, ກ່ຽວກັບການຈັດຕັ້ງການເຂົ້າສູ່ລະບົບຂອງຜູ້ໃຊ້ກັບພາຊະນະ, ກ່ຽວກັບການເຮັດວຽກກັບບັນທຶກບັນຈຸ, ແລະການແກ້ໄຂບັນຫາທີ່ຄ້າຍຄືກັນອື່ນໆ.

ກໍລະນີການນໍາໃຊ້ທົ່ວໄປສໍາລັບການຂຽນ Docker

ຂໍໃຫ້ຈິນຕະນາການຄໍາຮ້ອງສະຫມັກເວັບໄຊຕ໌ປົກກະຕິທີ່ມີອົງປະກອບດັ່ງຕໍ່ໄປນີ້:

• ຖານຂໍ້ມູນ TimescaleDB (Postgres).
• ຄໍາຮ້ອງສະຫມັກ Express.js.
• Ping (ພຽງແຕ່ບັນຈຸ, ບໍ່ໄດ້ເຮັດຫຍັງພິເສດ).

ແອັບພລິເຄຊັນນີ້ຈະຕ້ອງການ 3 Docker containers ແລະໄຟລ໌ docker-compose, ເຊິ່ງປະກອບດ້ວຍຄໍາແນະນໍາສໍາລັບການຄຸ້ມຄອງບັນຈຸເຫຼົ່ານີ້. ແຕ່ລະຖັງຈະມີຈຸດສໍາພັດທີ່ແຕກຕ່າງກັນ. ຕົວຢ່າງ, ມີຖັງ timescale ມັນຈະເປັນໄປໄດ້ທີ່ຈະເຮັດວຽກປະມານແບບດຽວກັນກັບພວກເຂົາເຮັດວຽກກັບຖານຂໍ້ມູນ. ຄື, ມັນອະນຸຍາດໃຫ້ທ່ານປະຕິບັດການດັ່ງຕໍ່ໄປນີ້:

• ເຂົ້າສູ່ລະບົບ Shell Postgres.
• ການນໍາເຂົ້າແລະສົ່ງອອກຕາຕະລາງ.
• ການສ້າງ pg_dump ຕາຕະລາງຫຼືຖານຂໍ້ມູນ.

ກ່ອງບັນຈຸແອັບພລິເຄຊັນ Express.js, expressjs, ອາດ​ຈະ​ມີ​ຄວາມ​ສາ​ມາດ​ດັ່ງ​ຕໍ່​ໄປ​ນີ້​:

• ການສະຫນອງຂໍ້ມູນສົດຈາກບັນທຶກຂອງລະບົບ.
• ເຂົ້າສູ່ລະບົບ shell ເພື່ອປະຕິບັດຄໍາສັ່ງທີ່ແນ່ນອນ.

ການໂຕ້ຕອບກັບເຄື່ອງບັນຈຸ

ເມື່ອພວກເຮົາໄດ້ຕັ້ງຄ່າການສື່ສານລະຫວ່າງ containers ໂດຍໃຊ້ Docker Compose, ມັນເຖິງເວລາທີ່ຈະຕິດຕໍ່ສື່ສານກັບ containers ເຫຼົ່ານັ້ນ. ພາຍໃນລະບົບ Docker Compose ມີຄໍາສັ່ງ docker-compose, ສະຫນັບສະຫນູນທາງເລືອກ -f, ເຊິ່ງອະນຸຍາດໃຫ້ທ່ານສາມາດໂອນໄຟລ໌ໄປຫາລະບົບ docker-compose.yml.

ການນໍາໃຊ້ຄວາມສາມາດຂອງທາງເລືອກນີ້, ທ່ານສາມາດຈໍາກັດການໂຕ້ຕອບກັບລະບົບພຽງແຕ່ກັບບັນຈຸເຫຼົ່ານັ້ນທີ່ໄດ້ກ່າວມາໃນໄຟລ໌ docker-compose.yml.

ລອງເບິ່ງວ່າການໂຕ້ຕອບກັບ containers ມີລັກສະນະແນວໃດເມື່ອໃຊ້ຄໍາສັ່ງ 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, ເນື່ອງຈາກວ່ານີ້ລົບລ້າງຄວາມຕ້ອງການທີ່ຈະຈື່ຈໍາຊື່ບັນຈຸ.

ທັງສອງຄໍາສັ່ງຂ້າງເທິງນີ້ບໍ່ຍາກຫຼາຍ. ແຕ່ຖ້າພວກເຮົາໃຊ້ "wrapper" ໃນຮູບແບບ Makefile, ເຊິ່ງຈະເຮັດໃຫ້ພວກເຮົາມີການໂຕ້ຕອບໃນຮູບແບບຂອງຄໍາສັ່ງທີ່ງ່າຍດາຍແລະຕົວມັນເອງຈະເອີ້ນຄໍາສັ່ງຍາວທີ່ຄ້າຍຄືກັນ, ຫຼັງຈາກນັ້ນຜົນໄດ້ຮັບດຽວກັນສາມາດບັນລຸໄດ້ເຊັ່ນນີ້:

make db-shell

ມັນຂ້ອນຂ້າງຈະແຈ້ງວ່າການນໍາໃຊ້ Makefile ເຮັດໃຫ້ການເຮັດວຽກກັບ containers ງ່າຍຂຶ້ນຫຼາຍ!

ຕົວຢ່າງການເຮັດວຽກ

ອີງໃສ່ແຜນວາດໂຄງການຂ້າງເທິງ, ພວກເຮົາຈະສ້າງໄຟລ໌ຕໍ່ໄປນີ້ 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 ແລະພົວພັນກັບ containers ທີ່ມັນອະທິບາຍ, ພວກເຮົາຈະສ້າງໄຟລ໌ຕໍ່ໄປນີ້. 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= ອະນຸຍາດໃຫ້ທ່ານຈໍາກັດຂອບເຂດຂອງຄໍາສັ່ງກັບຫນຶ່ງ container.

ຫລັງຈາກ Makefile ພ້ອມ​ແລ້ວ​, ທ່ານ​ສາ​ມາດ​ນໍາ​ໃຊ້​ມັນ​ເຊັ່ນ​ນີ້​:

• make help — ອອກ​ບັນ​ຊີ​ລາຍ​ການ​ຂອງ​ຄໍາ​ສັ່ງ​ທັງ​ຫມົດ​ທີ່​ມີ​ສໍາ​ລັບ​ການ​ make.

ຊ່ວຍເຫຼືອກ່ຽວກັບຄໍາສັ່ງທີ່ມີຢູ່

• make build - ການ​ປະ​ກອບ​ຮູບ​ພາບ​ຈາກ​ Dockerfile. ໃນຕົວຢ່າງຂອງພວກເຮົາພວກເຮົາໄດ້ນໍາໃຊ້ຮູບພາບທີ່ມີຢູ່ timescale и ping. ແຕ່ຮູບພາບ api ພວກເຮົາຕ້ອງການເກັບກໍາໃນທ້ອງຖິ່ນ. ນີ້ແມ່ນສິ່ງທີ່ຕ້ອງເຮັດຫຼັງຈາກປະຕິບັດຄໍາສັ່ງນີ້.

ການສ້າງ Docker container

• make start — ເປີດ​ຕົວ​ບັນ​ຈຸ​ທັງ​ຫມົດ​. ເພື່ອເປີດຕົວພຽງແຕ່ຫນຶ່ງ container, ທ່ານສາມາດນໍາໃຊ້ຄໍາສັ່ງເຊັ່ນ: 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 ຊ່ວຍພວກເຮົາສ້າງປະຕິສໍາພັນໄວແລະງ່າຍດາຍກັບ containers ຈາກໄຟລ໌ docker-compose.yml. ນັ້ນແມ່ນ, ພວກເຮົາເວົ້າກ່ຽວກັບສິ່ງຕໍ່ໄປນີ້:

• ນັກພັດທະນາຕິດຕໍ່ພົວພັນກັບຕົວບັນຈຸໂຄງການທີ່ອະທິບາຍໄວ້ໃນ docker-compose.yml, ການເຮັດວຽກບໍ່ໄດ້ຖືກແຊກແຊງໂດຍຖັງແລ່ນອື່ນໆ.
• ໃນກໍລະນີທີ່ຄໍາສັ່ງທີ່ແນ່ນອນຖືກລືມ, ທ່ານສາມາດປະຕິບັດຄໍາສັ່ງໄດ້ make help ແລະໄດ້ຮັບການຊ່ວຍເຫຼືອກ່ຽວກັບຄໍາສັ່ງທີ່ມີຢູ່.
• ທ່ານບໍ່ຈໍາເປັນຕ້ອງຈື່ຈໍາບັນຊີລາຍຊື່ຍາວຂອງ argument ເພື່ອປະຕິບັດການດໍາເນີນການເຊັ່ນ: ການໄດ້ຮັບຂໍ້ມູນບັນທຶກຫລ້າສຸດຫຼືເຂົ້າສູ່ລະບົບເຂົ້າໄປໃນລະບົບ. ຕົວຢ່າງເຊັ່ນຄໍາສັ່ງເຊັ່ນ docker-compose -f docker-compose.yml exec timescale psql -Upostgres ກາຍເປັນ make db-shell.
• ເອກະສານ Makefile ເຈົ້າສາມາດປັບຕົວເຂົ້າກັບມັນໄດ້ເມື່ອໂຄງການເຕີບໃຫຍ່. ຕົວຢ່າງ, ມັນງ່າຍທີ່ຈະເພີ່ມຄໍາສັ່ງເພື່ອສ້າງການສໍາຮອງຂໍ້ມູນຖານຂໍ້ມູນຫຼືປະຕິບັດການອື່ນໆ.
• ຖ້າທີມງານໃຫຍ່ຂອງນັກພັດທະນາໃຊ້ດຽວກັນ Makefile, ນີ້ປັບປຸງການຮ່ວມມືແລະຫຼຸດຜ່ອນຄວາມຜິດພາດ.

PS ໃນຂອງພວກເຮົາ ຕະຫຼາດ ມີຮູບພາບ Docker, ເຊິ່ງສາມາດໄດ້ຮັບການຕິດຕັ້ງໃນຫນຶ່ງຄລິກ. ທ່ານ​ສາ​ມາດ​ກວດ​ສອບ​ການ​ດໍາ​ເນີນ​ງານ​ຂອງ​ພາ​ຊະ​ນະ​ທີ່​ VPS. ລູກຄ້າໃຫມ່ທັງຫມົດແມ່ນໃຫ້ 3 ມື້ຂອງການທົດສອບຟຣີ.

ທ່ານຜູ້ອ່ານທີ່ຮັກແພງ! ເຈົ້າເຮັດໃຫ້ Docker Compose ອັດຕະໂນມັດໄດ້ແນວໃດ?

ແຫຼ່ງຂໍ້ມູນ: www.habr.com