డాకర్ కంపోజ్: మేక్‌ఫైల్‌లను ఉపయోగించి మీ పనిని సరళీకృతం చేయడం

ప్రతి కొన్ని సంవత్సరాలకు, సాఫ్ట్‌వేర్ డెవలప్‌మెంట్ పరిశ్రమ ఒక నమూనా మార్పుకు లోనవుతుంది. ఈ దృగ్విషయాలలో ఒకటి మైక్రోసర్వీసెస్ భావనపై పెరుగుతున్న ఆసక్తిగా గుర్తించబడుతుంది. మైక్రోసర్వీస్ సరికొత్త సాంకేతికత కానప్పటికీ, ఇటీవలే దాని ప్రజాదరణ అక్షరాలా ఆకాశాన్ని తాకింది.

పెద్ద ఏకశిలా సేవలు ఇప్పుడు స్వతంత్ర, స్వయంప్రతిపత్త మైక్రోసర్వీస్‌లచే భర్తీ చేయబడుతున్నాయి. మైక్రోసర్వీస్‌ను ఒకే మరియు చాలా నిర్దిష్టమైన ప్రయోజనాన్ని అందించే అప్లికేషన్‌గా భావించవచ్చు. ఉదాహరణకు, ఇది రిలేషనల్ DBMS, ఎక్స్‌ప్రెస్ అప్లికేషన్, సోల్ర్ సర్వీస్ కావచ్చు.

ఈ రోజుల్లో, మైక్రోసర్వీస్‌లను ఉపయోగించకుండా కొత్త సాఫ్ట్‌వేర్ సిస్టమ్‌ను అభివృద్ధి చేయడాన్ని ఊహించడం కష్టం. మరియు ఈ పరిస్థితి, క్రమంగా, డాకర్ ప్లాట్‌ఫారమ్‌కు దారి తీస్తుంది.

డాకర్

వేదిక డాకర్, మైక్రోసర్వీస్‌ల అభివృద్ధి మరియు విస్తరణలో, దాదాపు పరిశ్రమ ప్రమాణంగా మారింది. ప్రాజెక్ట్ వెబ్‌సైట్‌లో మీరు డాకర్ అనేది స్వతంత్ర కంటెయినరైజేషన్ ప్లాట్‌ఫారమ్ అని తెలుసుకోవచ్చు, ఇది సంస్థలను అప్రయత్నంగా ఏదైనా అప్లికేషన్‌ను సృష్టించడానికి, అలాగే వాటిని ఏ వాతావరణంలోనైనా పంపిణీ చేయడానికి మరియు అమలు చేయడానికి అనుమతిస్తుంది - హైబ్రిడ్ క్లౌడ్స్ నుండి ఎడ్జ్ సిస్టమ్‌ల వరకు.

డాకర్ కంపోజ్

టెక్నాలజీ డాకర్ కంపోజ్ బహుళ-కంటైనర్ అప్లికేషన్‌లను కాన్ఫిగర్ చేయడానికి రూపొందించబడింది. డాకర్ కంపోజ్ ప్రాజెక్ట్ ప్రాజెక్ట్ సృష్టికర్తకు అవసరమైనన్ని డాకర్ కంటైనర్‌లను కలిగి ఉంటుంది.

డాకర్ కంపోజ్‌తో పని చేస్తున్నప్పుడు, అప్లికేషన్ సేవలను కాన్ఫిగర్ చేయడానికి మరియు వాటి పరస్పర చర్యను నిర్వహించడానికి YAML ఫైల్ ఉపయోగించబడుతుంది. డాకర్ కంపోజ్ అనేది బహుళ-కంటైనర్ డాకర్ అప్లికేషన్‌లను వివరించడానికి మరియు అమలు చేయడానికి ఒక సాధనం.

హోస్ట్ సిస్టమ్‌పై రెండు కంటైనర్‌లు నడుస్తున్నాయి

గ్నూ మేక్

కార్యక్రమం make, సోర్స్ కోడ్ నుండి ప్రోగ్రామ్‌లు మరియు లైబ్రరీల బిల్డింగ్‌ను ఆటోమేట్ చేయడానికి తప్పనిసరిగా ఒక సాధనం. సాధారణంగా, మనం చెప్పగలం make కొన్ని ఇన్‌పుట్ మెటీరియల్‌లను కొన్ని అవుట్‌పుట్ రూపంలోకి, కొంత లక్ష్యానికి మార్చడానికి ఏకపక్ష ఆదేశాలను అమలు చేయడంతో కూడిన ఏదైనా ప్రక్రియకు వర్తిస్తుంది. మా విషయంలో, ఆదేశాలు docker-compose నైరూప్య లక్ష్యాలుగా రూపాంతరం చెందుతాయి (ఫోన్ లక్ష్యాలు).

కార్యక్రమం చెప్పడానికి make దాని నుండి మనకు ఏమి కావాలో, మనకు ఒక ఫైల్ అవసరం Makefile.

మా లో Makefile సాధారణ ఆదేశాలను కలిగి ఉంటుంది docker и docker-compose, ఇది అనేక సమస్యలను పరిష్కరించడానికి రూపొందించబడింది. అవి, మేము కంటైనర్‌ను సమీకరించడం, దాన్ని ప్రారంభించడం, ఆపడం, పునఃప్రారంభించడం, కంటైనర్‌కు వినియోగదారు లాగిన్‌ను నిర్వహించడం, కంటైనర్ లాగ్‌లతో పని చేయడం మరియు ఇతర సారూప్య సమస్యలను పరిష్కరించడం గురించి మాట్లాడుతున్నాము.

డాకర్ కంపోజ్ కోసం సాధారణ వినియోగ సందర్భాలు

కింది భాగాలను కలిగి ఉన్న సాధారణ వెబ్ అప్లికేషన్‌ను ఊహించుకుందాం:

• టైమ్‌స్కేల్‌డిబి డేటాబేస్ (పోస్ట్‌గ్రెస్).
• Express.js అప్లికేషన్.
• పింగ్ (కేవలం ఒక కంటైనర్, ప్రత్యేకంగా ఏమీ చేయదు).

ఈ అనువర్తనానికి 3 డాకర్ కంటైనర్‌లు మరియు ఫైల్ అవసరం docker-compose, ఈ కంటైనర్లను నిర్వహించడానికి సూచనలను కలిగి ఉంటుంది. ప్రతి కంటైనర్‌కు వేర్వేరు టచ్ పాయింట్‌లు ఉంటాయి. ఉదాహరణకు, ఒక కంటైనర్తో timescale వారు డేటాబేస్‌లతో పని చేసే విధంగానే దాదాపుగా పని చేయడం సాధ్యమవుతుంది. అవి, ఇది క్రింది చర్యలను నిర్వహించడానికి మిమ్మల్ని అనుమతిస్తుంది:

• పోస్ట్‌గ్రెస్ షెల్‌లోకి లాగిన్ అవుతోంది.
• పట్టికల దిగుమతి మరియు ఎగుమతి.
• సృష్టి pg_dump పట్టికలు లేదా డేటాబేస్లు.

Express.js అప్లికేషన్ కంటైనర్, expressjs, కింది సామర్థ్యాలను కలిగి ఉండవచ్చు:

• సిస్టమ్ లాగ్ నుండి తాజా డేటాను అందిస్తోంది.
• నిర్దిష్ట ఆదేశాలను అమలు చేయడానికి షెల్‌కు లాగిన్ చేయండి.

కంటైనర్‌లతో పరస్పర చర్య చేయడం

మేము డాకర్ కంపోజ్‌ని ఉపయోగించి కంటైనర్‌ల మధ్య కమ్యూనికేషన్‌ని సెటప్ చేసిన తర్వాత, ఆ కంటైనర్‌లతో కమ్యూనికేట్ చేయడానికి ఇది సమయం. డాకర్ కంపోజ్ సిస్టమ్‌లో ఒక కమాండ్ ఉంది 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

డాకర్ కంపోజ్ కాన్ఫిగరేషన్‌ను నిర్వహించడానికి మరియు అది వివరించే కంటైనర్‌లతో పరస్పర చర్య చేయడానికి, మేము ఈ క్రింది ఫైల్‌ని సృష్టిస్తాము 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 మేము స్థానికంగా సేకరించాలనుకుంటున్నాము. ఈ ఆదేశాన్ని అమలు చేసిన తర్వాత ఇది ఖచ్చితంగా జరుగుతుంది.

డాకర్ కంటైనర్‌ను నిర్మించడం

• make start - అన్ని కంటైనర్లను ప్రారంభించడం. కేవలం ఒక కంటైనర్‌ను ప్రారంభించేందుకు, మీరు వంటి ఆదేశాన్ని ఉపయోగించవచ్చు make start c=timescale.

టైమ్‌స్కేల్ కంటైనర్‌ను రన్ చేస్తోంది

పింగ్ కంటైనర్‌ను నడుపుతోంది

• make login-timescale - కంటైనర్ యొక్క బాష్ సెషన్‌కు లాగిన్ చేయండి timescale.

టైమ్‌స్కేల్ కంటైనర్‌లో బాష్ రన్ అవుతోంది

• make db-shell - ప్రవేశం psql ఒక కంటైనర్లో timescale డేటాబేస్కు వ్యతిరేకంగా SQL ప్రశ్నలను అమలు చేయడానికి.

టైమ్‌స్కేల్‌బి కంటైనర్‌లో psqlని అమలు చేస్తోంది

• make stop - కంటైనర్లను ఆపడం.

టైమ్‌స్కేల్ కంటైనర్‌ను ఆపడం

• make down - కంటైనర్లను ఆపడం మరియు తొలగించడం. నిర్దిష్ట కంటైనర్‌ను తీసివేయడానికి, మీరు కోరుకున్న కంటైనర్‌ను పేర్కొనడానికి ఈ ఆదేశాన్ని ఉపయోగించవచ్చు. ఉదాహరణకి - make down c=timescale లేదా make down c=api.

అన్ని కంటైనర్‌లను ఆపడం మరియు తొలగించడం

ఫలితాలు

డాకర్ కంపోజ్ కంటైనర్‌లను నిర్వహించడానికి మాకు గొప్ప ఆదేశాలను ఇచ్చినప్పటికీ, కొన్నిసార్లు ఈ ఆదేశాలు చాలా పొడవుగా మరియు గుర్తుంచుకోవడం కష్టంగా మారవచ్చు.

ఉపయోగ విధానం 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 మా లో మార్కెట్ ఒక చిత్రం ఉంది డాకర్, ఇది ఒక క్లిక్‌లో ఇన్‌స్టాల్ చేయబడుతుంది. మీరు కంటైనర్ల ఆపరేషన్‌ను ఇక్కడ తనిఖీ చేయవచ్చు VP లను. కొత్త క్లయింట్‌లందరికీ 3 రోజుల పరీక్ష ఉచితంగా ఇవ్వబడుతుంది.

ప్రియమైన పాఠకులారా! మీరు డాకర్ కంపోజ్‌ని ఎలా ఆటోమేట్ చేస్తారు?

మూలం: www.habr.com