ડોકર કંપોઝ: મેકફાઇલ્સનો ઉપયોગ કરીને તમારા કાર્યને સરળ બનાવવું

દર થોડા વર્ષોમાં, સોફ્ટવેર ડેવલપમેન્ટ ઈન્ડસ્ટ્રીમાં પેરાડાઈમ શિફ્ટ થાય છે. આમાંની એક ઘટનાને માઇક્રોસર્વિસિસની વિભાવનામાં વધતી જતી રસ તરીકે ઓળખી શકાય છે. જોકે માઇક્રોસર્વિસિસ એ સૌથી નવી તકનીક નથી, તાજેતરમાં જ તેની લોકપ્રિયતા શાબ્દિક રીતે આસમાને પહોંચી છે.

મોટી મોનોલિથિક સેવાઓ હવે સ્વતંત્ર, સ્વાયત્ત માઇક્રોસર્વિસિસ દ્વારા બદલવામાં આવી રહી છે. માઇક્રોસર્વિસને એક એપ્લિકેશન તરીકે વિચારી શકાય છે જે એક જ અને ખૂબ જ ચોક્કસ હેતુને પૂર્ણ કરે છે. ઉદાહરણ તરીકે, તે રિલેશનલ ડીબીએમએસ, એક્સપ્રેસ એપ્લિકેશન, સોલર સેવા હોઈ શકે છે.

આ દિવસોમાં, માઇક્રોસર્વિસિસનો ઉપયોગ કર્યા વિના નવી સોફ્ટવેર સિસ્ટમ વિકસાવવાની કલ્પના કરવી મુશ્કેલ છે. અને આ પરિસ્થિતિ, બદલામાં, અમને ડોકર પ્લેટફોર્મ તરફ દોરી જાય છે.

Docker

પ્લેટફોર્મ Docker, માઇક્રોસર્વિસિસના વિકાસ અને જમાવટમાં, લગભગ એક ઉદ્યોગ ધોરણ બની ગયું છે. પ્રોજેક્ટ વેબસાઈટ પર તમે શોધી શકો છો કે ડોકર એકમાત્ર સ્વતંત્ર કન્ટેનરાઈઝેશન પ્લેટફોર્મ છે જે સંસ્થાઓને કોઈપણ એપ્લિકેશનને વિના પ્રયાસે બનાવી શકે છે, તેમજ તેને કોઈપણ વાતાવરણમાં વિતરિત અને ચલાવવાની મંજૂરી આપે છે - હાઇબ્રિડ ક્લાઉડ્સથી એજ સિસ્ટમ્સ સુધી.

ડોકર કંપોઝ

ટેકનોલોજી ડોકર કંપોઝ મલ્ટિ-કન્ટેનર એપ્લિકેશનને ગોઠવવા માટે રચાયેલ છે. ડોકર કંપોઝ પ્રોજેક્ટમાં પ્રોજેક્ટના નિર્માતાની જરૂરિયાત જેટલા ડોકર કન્ટેનર હોઈ શકે છે.

ડોકર કમ્પોઝ સાથે કામ કરતી વખતે, 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 અમારામાં બજાર એક છબી છે Docker, જે એક ક્લિકમાં ઇન્સ્ટોલ કરી શકાય છે. પર તમે કન્ટેનરની કામગીરી તપાસી શકો છો VPS. તમામ નવા ગ્રાહકોને 3 દિવસનું પરીક્ષણ મફત આપવામાં આવે છે.

પ્રિય વાચકો! તમે ડોકર કંપોઝ કેવી રીતે સ્વચાલિત કરશો?

સોર્સ: www.habr.com