ഡോക്കർ കമ്പോസ്: മേക്ക് ഫയലുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ ജോലി ലളിതമാക്കുന്നു

ഏതാനും വർഷങ്ങൾ കൂടുമ്പോൾ, സോഫ്റ്റ്‌വെയർ വികസന വ്യവസായം ഒരു മാതൃകാപരമായ മാറ്റത്തിന് വിധേയമാകുന്നു. ഈ പ്രതിഭാസങ്ങളിലൊന്ന് മൈക്രോ സർവീസസ് എന്ന ആശയത്തിൽ വർദ്ധിച്ചുവരുന്ന താൽപ്പര്യമായി തിരിച്ചറിയാം. മൈക്രോസർവീസുകൾ ഏറ്റവും പുതിയ സാങ്കേതികവിദ്യയല്ലെങ്കിലും, അടുത്തിടെയാണ് അതിന്റെ ജനപ്രീതി അക്ഷരാർത്ഥത്തിൽ ഉയർന്നത്.

വലിയ മോണോലിത്തിക്ക് സേവനങ്ങൾ ഇപ്പോൾ സ്വതന്ത്രവും സ്വയംഭരണാധികാരമുള്ളതുമായ മൈക്രോ സർവീസുകൾ ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കുന്നു. ഒരു മൈക്രോസർവീസിനെ ഒരൊറ്റ പ്രത്യേക ഉദ്ദേശ്യം നിറവേറ്റുന്ന ഒരു ആപ്ലിക്കേഷനായി കണക്കാക്കാം. ഉദാഹരണത്തിന്, ഇത് ഒരു റിലേഷണൽ DBMS, ഒരു എക്സ്പ്രസ് ആപ്ലിക്കേഷൻ, ഒരു സോൾർ സേവനം എന്നിവയായിരിക്കാം.

ഈ ദിവസങ്ങളിൽ, മൈക്രോസർവീസുകൾ ഉപയോഗിക്കാതെ ഒരു പുതിയ സോഫ്റ്റ്വെയർ സിസ്റ്റം വികസിപ്പിക്കുന്നത് സങ്കൽപ്പിക്കാൻ പ്രയാസമാണ്. ഈ സാഹചര്യം, ഞങ്ങളെ ഡോക്കർ പ്ലാറ്റ്‌ഫോമിലേക്ക് നയിക്കുന്നു.

ഡോക്കർ

പ്ലാറ്റ്ഫോം ഡോക്കർ, മൈക്രോസർവീസുകളുടെ വികസനത്തിലും വിന്യാസത്തിലും, ഏതാണ്ട് ഒരു വ്യവസായ നിലവാരമായി മാറിയിരിക്കുന്നു. ഹൈബ്രിഡ് മേഘങ്ങൾ മുതൽ എഡ്ജ് സിസ്റ്റങ്ങൾ വരെ - ഏത് പരിതസ്ഥിതിയിലും അനായാസമായി ഏത് ആപ്ലിക്കേഷനും സൃഷ്ടിക്കാനും അവ വിതരണം ചെയ്യാനും പ്രവർത്തിപ്പിക്കാനും ഓർഗനൈസേഷനുകളെ അനുവദിക്കുന്ന ഒരേയൊരു സ്വതന്ത്ര കണ്ടെയ്‌നറൈസേഷൻ പ്ലാറ്റ്‌ഫോമാണ് ഡോക്കർ എന്ന് പ്രോജക്റ്റ് വെബ്‌സൈറ്റിൽ നിങ്ങൾക്ക് കണ്ടെത്താനാകും.

ഡോക്കർ രചിക്കുക

സാങ്കേതികവിദ്യ ഡോക്കർ രചിക്കുക മൾട്ടി-കണ്ടെയ്‌നർ ആപ്ലിക്കേഷനുകൾ കോൺഫിഗർ ചെയ്യുന്നതിനായി രൂപകൽപ്പന ചെയ്‌തിരിക്കുന്നു. ഒരു ഡോക്കർ കമ്പോസ് പ്രോജക്റ്റിൽ പ്രോജക്റ്റ് സ്രഷ്ടാവിന് ആവശ്യമുള്ളത്ര ഡോക്കർ കണ്ടെയ്‌നറുകൾ അടങ്ങിയിരിക്കാം.

ഡോക്കർ കമ്പോസുമായി പ്രവർത്തിക്കുമ്പോൾ, ആപ്ലിക്കേഷൻ സേവനങ്ങൾ കോൺഫിഗർ ചെയ്യുന്നതിനും പരസ്പരം ആശയവിനിമയം സംഘടിപ്പിക്കുന്നതിനും ഒരു YAML ഫയൽ ഉപയോഗിക്കുന്നു. അതിനാൽ മൾട്ടി-കണ്ടെയ്‌നർ ഡോക്കർ ആപ്ലിക്കേഷനുകൾ വിവരിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനുമുള്ള ഒരു ഉപകരണമാണ് ഡോക്കർ കമ്പോസ്.

ഒരു ഹോസ്റ്റ് സിസ്റ്റത്തിൽ പ്രവർത്തിക്കുന്ന രണ്ട് കണ്ടെയ്‌നറുകൾ

ഗ്നു മേക്ക്

പ്രോഗ്രാം make, അടിസ്ഥാനപരമായി സോഴ്സ് കോഡിൽ നിന്ന് പ്രോഗ്രാമുകളുടെയും ലൈബ്രറികളുടെയും നിർമ്മാണം ഓട്ടോമേറ്റ് ചെയ്യുന്നതിനുള്ള ഒരു ഉപകരണമാണ്. പൊതുവേ, നമുക്ക് അങ്ങനെ പറയാം make ചില ഇൻപുട്ട് മെറ്റീരിയലുകളെ ചില ഔട്ട്‌പുട്ട് ഫോമിലേക്ക്, ചില ലക്ഷ്യങ്ങളിലേക്ക് പരിവർത്തനം ചെയ്യുന്നതിന് അനിയന്ത്രിതമായ കമാൻഡുകൾ നടപ്പിലാക്കുന്നത് ഉൾപ്പെടുന്ന ഏത് പ്രക്രിയയ്ക്കും ഇത് ബാധകമാണ്. ഞങ്ങളുടെ കാര്യത്തിൽ, കമാൻഡുകൾ docker-compose അമൂർത്ത ലക്ഷ്യങ്ങളായി രൂപാന്തരപ്പെടും (ഫോൺ ലക്ഷ്യങ്ങൾ).

പരിപാടി പറയാൻ make അതിൽ നിന്ന് നമുക്ക് എന്താണ് വേണ്ടതെന്ന്, ഞങ്ങൾക്ക് ഒരു ഫയൽ ആവശ്യമാണ് Makefile.

ഞങ്ങളുടെ Makefile പതിവ് കമാൻഡുകൾ അടങ്ങിയിരിക്കും docker и docker-compose, നിരവധി പ്രശ്നങ്ങൾ പരിഹരിക്കാൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ്. അതായത്, ഞങ്ങൾ ഒരു കണ്ടെയ്നർ കൂട്ടിച്ചേർക്കുന്നതിനെക്കുറിച്ചും അത് ആരംഭിക്കുന്നതിനെക്കുറിച്ചും നിർത്തുന്നതിനെക്കുറിച്ചും പുനരാരംഭിക്കുന്നതിനെക്കുറിച്ചും കണ്ടെയ്നറിലേക്ക് ഉപയോക്തൃ ലോഗിൻ സംഘടിപ്പിക്കുന്നതിനെക്കുറിച്ചും കണ്ടെയ്നർ ലോഗുകളിൽ പ്രവർത്തിക്കുന്നതിനെക്കുറിച്ചും സമാനമായ മറ്റ് പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നതിനെക്കുറിച്ചും സംസാരിക്കുന്നു.

ഡോക്കർ കമ്പോസിനായി സാധാരണ ഉപയോഗ കേസുകൾ

ഇനിപ്പറയുന്ന ഘടകങ്ങളുള്ള ഒരു സാധാരണ വെബ് ആപ്ലിക്കേഷൻ നമുക്ക് സങ്കൽപ്പിക്കാം:

• TimescaleDB ഡാറ്റാബേസ് (Postgres).
• Express.js ആപ്ലിക്കേഷൻ.
• പിംഗ് (വെറും ഒരു കണ്ടെയ്നർ, പ്രത്യേകിച്ച് ഒന്നും ചെയ്യുന്നില്ല).

ഈ ആപ്പിന് 3 ഡോക്കർ കണ്ടെയ്‌നറുകളും ഒരു ഫയലും ആവശ്യമാണ് docker-compose, ഈ കണ്ടെയ്‌നറുകൾ കൈകാര്യം ചെയ്യുന്നതിനുള്ള നിർദ്ദേശങ്ങൾ ഇതിൽ അടങ്ങിയിരിക്കുന്നു. ഓരോ കണ്ടെയ്‌നറിനും വ്യത്യസ്ത ടച്ച് പോയിന്റുകൾ ഉണ്ടായിരിക്കും. ഉദാഹരണത്തിന്, ഒരു കണ്ടെയ്നർ ഉപയോഗിച്ച് timescale അവർ ഡാറ്റാബേസുകളിൽ പ്രവർത്തിക്കുന്ന അതേ രീതിയിൽ പ്രവർത്തിക്കാൻ സാധിക്കും. അതായത്, ഇനിപ്പറയുന്ന പ്രവർത്തനങ്ങൾ നടത്താൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു:

• Postgres ഷെല്ലിലേക്ക് ലോഗിൻ ചെയ്യുന്നു.
• പട്ടികകളുടെ ഇറക്കുമതിയും കയറ്റുമതിയും.
• സൃഷ്ടി 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, ഇത് സഹകരണം കാര്യക്ഷമമാക്കുകയും പിശകുകൾ കുറയ്ക്കുകയും ചെയ്യുന്നു.

പി.എസ് ഞങ്ങളുടെ ചന്തസ്ഥലം ഒരു ചിത്രമുണ്ട് ഡോക്കർ, ഇത് ഒറ്റ ക്ലിക്കിൽ ഇൻസ്റ്റാൾ ചെയ്യാൻ കഴിയും. നിങ്ങൾക്ക് കണ്ടെയ്‌നറുകളുടെ പ്രവർത്തനം ഇവിടെ പരിശോധിക്കാം VPS ലേക്ക്. എല്ലാ പുതിയ ക്ലയന്റുകൾക്കും 3 ദിവസത്തെ ടെസ്റ്റിംഗ് സൗജന്യമായി നൽകുന്നു.

പ്രിയ വായനക്കാർ! നിങ്ങൾ എങ്ങനെയാണ് ഡോക്കർ കമ്പോസ് ഓട്ടോമേറ്റ് ചെയ്യുന്നത്?

അവലംബം: www.habr.com