โปรโฮสต์ > บล็อก > การบริหาร > Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles

ทุกๆ สองสามปี อุตสาหกรรมการพัฒนาซอฟต์แวร์จะมีการเปลี่ยนแปลงกระบวนทัศน์ หนึ่งในปรากฏการณ์เหล่านี้สามารถรับรู้ได้ว่าเป็นความสนใจที่เพิ่มขึ้นในแนวคิดของไมโครเซอร์วิส แม้ว่าไมโครเซอร์วิสจะไม่ใช่เทคโนโลยีใหม่ล่าสุด แต่เมื่อไม่นานมานี้ความนิยมก็พุ่งสูงขึ้นอย่างแท้จริง

บริการแบบเสาหินขนาดใหญ่กำลังถูกแทนที่ด้วยไมโครเซอร์วิสอิสระและเป็นอิสระ ไมโครเซอร์วิสถือได้ว่าเป็นแอปพลิเคชันที่ให้บริการเพื่อวัตถุประสงค์เดียวและเฉพาะเจาะจงมาก ตัวอย่างเช่น อาจเป็น DBMS เชิงสัมพันธ์, แอปพลิเคชัน Express, บริการ Solr

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles

ทุกวันนี้ เป็นเรื่องยากที่จะจินตนาการถึงการพัฒนาระบบซอฟต์แวร์ใหม่โดยไม่ใช้ไมโครเซอร์วิส และสถานการณ์นี้ก็นำเราไปสู่แพลตฟอร์ม Docker

นักเทียบท่า

เวที นักเทียบท่าในการพัฒนาและการปรับใช้ไมโครเซอร์วิสนั้นแทบจะกลายเป็นมาตรฐานอุตสาหกรรมไปแล้ว บนเว็บไซต์ของโครงการ คุณจะพบว่า Docker เป็นแพลตฟอร์มคอนเทนเนอร์อิสระเพียงแพลตฟอร์มเดียวที่ช่วยให้องค์กรต่างๆ สามารถสร้างแอปพลิเคชันใดๆ ได้อย่างง่ายดาย รวมทั้งแจกจ่ายและรันแอปพลิเคชันในสภาพแวดล้อมต่างๆ ตั้งแต่ระบบคลาวด์แบบไฮบริดไปจนถึงระบบ Edge

Docker Compose

เทคโนโลยี Docker Compose ออกแบบมาสำหรับการกำหนดค่าแอปพลิเคชันหลายคอนเทนเนอร์ โปรเจ็กต์ Docker Compose สามารถมีคอนเทนเนอร์ Docker ได้มากเท่าที่ผู้สร้างโปรเจ็กต์ต้องการ

เมื่อทำงานกับ Docker Compose ไฟล์ YAML จะใช้เพื่อกำหนดค่าบริการแอปพลิเคชันและจัดระเบียบการโต้ตอบระหว่างกัน Docker Compose จึงเป็นเครื่องมือสำหรับอธิบายและเรียกใช้แอปพลิเคชัน Docker แบบหลายคอนเทนเนอร์

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
คอนเทนเนอร์สองตัวที่ทำงานบนระบบโฮสต์

GNU ทำ

โครงการ 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.

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
ความช่วยเหลือเกี่ยวกับคำสั่งที่มีอยู่

  • make build - การประกอบภาพจาก Dockerfile. ในตัวอย่างของเรา เราใช้รูปภาพที่มีอยู่ timescale и ping. แต่ภาพลักษณ์ api เราต้องการรวบรวมในประเทศ นี่คือสิ่งที่จะทำหลังจากรันคำสั่งนี้

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
การสร้างคอนเทนเนอร์นักเทียบท่า

  • make start — เปิดตัวคอนเทนเนอร์ทั้งหมด หากต้องการเปิดใช้คอนเทนเนอร์เดียว คุณสามารถใช้คำสั่งเช่น make start c=timescale.

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
เรียกใช้คอนเทนเนอร์มาตราส่วนเวลา

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
ใช้งานคอนเทนเนอร์ปิง

  • make login-timescale — เข้าสู่เซสชั่นทุบตีของคอนเทนเนอร์ timescale.

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
การรัน bash ในคอนเทนเนอร์มาตราส่วนเวลา

  • make db-shell - ทางเข้า psql ในภาชนะ timescale เพื่อดำเนินการค้นหา SQL กับฐานข้อมูล

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
กำลังรัน psql ในคอนเทนเนอร์ timescaledb

  • make stop – การหยุดภาชนะ

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
การหยุดคอนเทนเนอร์มาตราส่วนเวลา

  • make down – การหยุดและนำภาชนะออก หากต้องการลบคอนเทนเนอร์ใดคอนเทนเนอร์หนึ่งออก คุณสามารถใช้คำสั่งนี้เพื่อระบุคอนเทนเนอร์ที่ต้องการได้ ตัวอย่างเช่น - make down c=timescale หรือ make down c=api.

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles
การหยุดและการลบคอนเทนเนอร์ทั้งหมด

ผลของการ

แม้ว่า 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 Внашем ตลาด มีรูปภาพอยู่ นักเทียบท่าซึ่งสามารถติดตั้งได้ในคลิกเดียว สามารถตรวจสอบการทำงานของตู้คอนเทนเนอร์ได้ที่ VPS. ลูกค้าใหม่ทุกคนจะได้รับการทดสอบฟรี 3 วัน

เรียนผู้อ่าน! คุณจะทำให้ Docker Compose เป็นอัตโนมัติได้อย่างไร

Docker Compose: ทำให้งานของคุณง่ายขึ้นโดยใช้ Makefiles

ที่มา: will.com

เพิ่มความคิดเห็น