ഡോക്കർ രചന: വികസനം മുതൽ ഉത്പാദനം വരെ

കോഴ്‌സിന്റെ ആരംഭം പ്രതീക്ഷിച്ച് തയ്യാറാക്കിയ പോഡ്‌കാസ്റ്റ് ട്രാൻസ്‌ക്രിപ്ഷന്റെ വിവർത്തനം "ലിനക്സ് അഡ്മിനിസ്ട്രേറ്റർ"

ഒരു ജോലി സൃഷ്ടിക്കുന്നതിനുള്ള ഒരു അത്ഭുതകരമായ ഉപകരണമാണ് ഡോക്കർ കമ്പോസ്
നിങ്ങളുടെ ആപ്ലിക്കേഷനിൽ ഉപയോഗിച്ചിരിക്കുന്ന സ്റ്റാക്കിനുള്ള പരിസ്ഥിതി. ഇത് നിർവ്വചിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു
നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ ഓരോ ഘടകങ്ങളും, വ്യക്തവും ലളിതവുമായ വാക്യഘടന പിന്തുടരുന്നു YAML-
ഫയലുകൾ.

വരവോടെ ഡോക്കർ കമ്പോസ് v3 ഈ YAML ഫയലുകൾ പ്രവർത്തിക്കുമ്പോൾ ഉൽപ്പാദന പരിതസ്ഥിതിയിൽ നേരിട്ട് ഉപയോഗിക്കാനാകും
ക്ലസ്റ്റർ ഡോക്കർ കൂട്ടം.

എന്നാൽ നിങ്ങൾക്ക് ഇതേ ഡോക്കർ-കംപോസ് ഫയൽ ഉപയോഗിക്കാമെന്നാണോ ഇതിനർത്ഥം
വികസന പ്രക്രിയയിലും ഉൽപാദന അന്തരീക്ഷത്തിലും? അല്ലെങ്കിൽ അതേ ഫയൽ ഉപയോഗിക്കുക
സ്റ്റേജിംഗ്? ശരി, പൊതുവേ, അതെ, എന്നാൽ ഈ പ്രവർത്തനത്തിന് നമുക്ക് ഇനിപ്പറയുന്നവ ആവശ്യമാണ്:

• വേരിയബിൾ ഇന്റർപോളേഷൻ: ചിലർക്ക് പരിസ്ഥിതി വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു
  ഓരോ പരിതസ്ഥിതിയിലും മാറുന്ന മൂല്യങ്ങൾ.
• കോൺഫിഗറേഷൻ അസാധുവാക്കൽ: ഒരു സെക്കൻഡ് നിർവചിക്കാനുള്ള കഴിവ് (അല്ലെങ്കിൽ ഏതെങ്കിലും
  മറ്റൊരു തുടർന്നുള്ള) ഡോക്കർ-കമ്പോസ് ഫയൽ, അത് സംബന്ധിച്ച് എന്തെങ്കിലും മാറ്റം വരുത്തും
  ആദ്യം, രണ്ട് ഫയലുകളും ലയിപ്പിക്കുന്നതിന് ഡോക്കർ കമ്പോസ് ശ്രദ്ധിക്കും.

വികസനവും പ്രൊഡക്ഷൻ ഫയലുകളും തമ്മിലുള്ള വ്യത്യാസങ്ങൾ

വികസന സമയത്ത്, നിങ്ങൾ മിക്കവാറും കോഡ് മാറ്റങ്ങൾ പരിശോധിക്കാൻ ആഗ്രഹിക്കുന്നു
തൽസമയം. ഇത് ചെയ്യുന്നതിന്, സാധാരണയായി സോഴ്സ് കോഡുള്ള വോളിയം മൌണ്ട് ചെയ്യുന്നു
നിങ്ങളുടെ ആപ്ലിക്കേഷന്റെ റൺടൈം അടങ്ങുന്ന കണ്ടെയ്നർ. എന്നാൽ ഒരു ഉൽപാദന അന്തരീക്ഷത്തിന്
ഈ രീതി അനുയോജ്യമല്ല.

ഉൽപ്പാദനത്തിൽ, നിങ്ങൾക്ക് നിരവധി നോഡുകളുള്ള ഒരു ക്ലസ്റ്റർ ഉണ്ട്, വോളിയം പ്രാദേശികമാണ്
നിങ്ങളുടെ കണ്ടെയ്‌നർ (അല്ലെങ്കിൽ സേവനം) പ്രവർത്തിക്കുന്ന നോഡിന് ആപേക്ഷികമായതിനാൽ നിങ്ങൾ അങ്ങനെ ചെയ്യരുത്
സങ്കീർണ്ണമായ പ്രവർത്തനങ്ങളില്ലാതെ നിങ്ങൾക്ക് സോഴ്സ് കോഡ് മൗണ്ട് ചെയ്യാൻ കഴിയും
കോഡ് സമന്വയം, സിഗ്നലുകൾ മുതലായവ.

പകരം, നിങ്ങളുടെ കോഡിന്റെ ഒരു നിർദ്ദിഷ്‌ട പതിപ്പ് ഉപയോഗിച്ച് ഒരു ചിത്രം സൃഷ്‌ടിക്കാൻ ഞങ്ങൾ സാധാരണയായി ആഗ്രഹിക്കുന്നു.
ഉചിതമായ ടാഗ് ഉപയോഗിച്ച് ഇത് അടയാളപ്പെടുത്തുന്നത് പതിവാണ് (നിങ്ങൾക്ക് സെമാന്റിക് ഉപയോഗിക്കാം
പതിപ്പ് അല്ലെങ്കിൽ നിങ്ങളുടെ വിവേചനാധികാരത്തിൽ മറ്റൊരു സിസ്റ്റം).

കോൺഫിഗറേഷൻ അസാധുവാക്കൽ

വ്യത്യാസങ്ങളും നിങ്ങളുടെ ഡിപൻഡൻസികളും സാഹചര്യങ്ങളിൽ വ്യത്യസ്തമാകാം
വികസനവും ഉൽപ്പാദനവും, നമുക്ക് വ്യത്യസ്ത കോൺഫിഗറേഷൻ ഫയലുകൾ ആവശ്യമാണെന്ന് വ്യക്തമാണ്.

വ്യത്യസ്‌ത കംപോസ് ഫയലുകൾ ലയിപ്പിക്കുന്നതിനെ ഡോക്കർ കമ്പോസ് പിന്തുണയ്ക്കുന്നു
അന്തിമ കോൺഫിഗറേഷൻ നേടുക. ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് ഉദാഹരണത്തിൽ കാണാൻ കഴിയും:

$ cat docker-compose.yml
version: "3.2"

services:
  whale:
    image: docker/whalesay
    command: ["cowsay", "hello!"]
$ docker-compose up
Creating network "composeconfigs_default" with the default driver
Starting composeconfigs_whale_1
Attaching to composeconfigs_whale_1
whale_1  |  ________
whale_1  | < hello! >
whale_1  |  --------
whale_1  |     
whale_1  |      
whale_1  |       
whale_1  |                     ##        .
whale_1  |               ## ## ##       ==
whale_1  |            ## ## ## ##      ===
whale_1  |        /""""""""""""""""___/ ===
whale_1  |   ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
whale_1  |        ______ o          __/
whale_1  |                     __/
whale_1  |           __________/
composeconfigs_whale_1 exited with code 0

പറഞ്ഞതുപോലെ, ഡോക്കർ കമ്പോസ് ഒന്നിലധികം കമ്പോസുകൾ സംയോജിപ്പിക്കുന്നതിനെ പിന്തുണയ്ക്കുന്നു -
ഫയലുകൾ, രണ്ടാമത്തെ ഫയലിലെ വിവിധ പാരാമീറ്ററുകൾ അസാധുവാക്കാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. ഉദാഹരണത്തിന്:

$ cat docker-compose.second.yml
version: "3.2"
services:
  whale:
    command: ["cowsay", "bye!"]

$ docker-compose -f docker-compose.yml -f docker-compose.second.yml up
Creating composeconfigs_whale_1
Attaching to composeconfigs_whale_1
whale_1  |  ______
whale_1  | < bye! >
whale_1  |  ------
whale_1  |     
whale_1  |      
whale_1  |       
whale_1  |                     ##        .
whale_1  |               ## ## ##       ==
whale_1  |            ## ## ## ##      ===
whale_1  |        /""""""""""""""""___/ ===
whale_1  |   ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
whale_1  |        ______ o          __/
whale_1  |                     __/
whale_1  |           __________/
composeconfigs_whale_1 exited with code 0

കമാൻഡ് ചെയ്യുമ്പോൾ, വികസന സമയത്ത് ഈ വാക്യഘടന വളരെ സൗകര്യപ്രദമല്ല
പല പ്രാവശ്യം ചെയ്യേണ്ടിവരും.

ഭാഗ്യവശാൽ, ഡോക്കർ കമ്പോസ് സ്വയമേവ ഒരു പ്രത്യേക ഫയലിനായി തിരയുന്നു
docker-compose.override.yml മൂല്യങ്ങളെ മറികടക്കാൻ docker-compose.yml. എങ്കിൽ
രണ്ടാമത്തെ ഫയലിന്റെ പേരുമാറ്റുക, യഥാർത്ഥ കമാൻഡ് ഉപയോഗിച്ച് മാത്രം നിങ്ങൾക്ക് അതേ ഫലം ലഭിക്കും:

$ mv docker-compose.second.yml docker-compose.override.yml
$ docker-compose up
Starting composeconfigs_whale_1
Attaching to composeconfigs_whale_1
whale_1  |  ______
whale_1  | < bye! >
whale_1  |  ------
whale_1  |     
whale_1  |      
whale_1  |       
whale_1  |                     ##        .
whale_1  |               ## ## ##       ==
whale_1  |            ## ## ## ##      ===
whale_1  |        /""""""""""""""""___/ ===
whale_1  |   ~~~ {~~ ~~~~ ~~~ ~~~~ ~~ ~ /  ===- ~~~
whale_1  |        ______ o          __/
whale_1  |                     __/
whale_1  |           __________/
composeconfigs_whale_1 exited with code 0

ശരി, അത് ഓർക്കാൻ എളുപ്പമാണ്.

വേരിയബിളുകളുടെ ഇന്റർപോളേഷൻ

കോൺഫിഗറേഷൻ ഫയലുകളുടെ പിന്തുണ ഇന്റർപോളേഷൻ
വേരിയബിളുകൾ സ്ഥിര മൂല്യങ്ങളും. അതായത്, നിങ്ങൾക്ക് ഇനിപ്പറയുന്നവ ചെയ്യാൻ കഴിയും:

services:
  my-service:
    build:
      context: .
    image: private.registry.mine/my-stack/my-service:${MY_SERVICE_VERSION:-latest}
...

നിങ്ങൾ ചെയ്താൽ ഡോക്കർ-കമ്പോസ് ബിൽഡ് (അല്ലെങ്കിൽ പുഷ്) പരിസ്ഥിതി വേരിയബിൾ ഇല്ലാതെ
$MY_SERVICE_VERSION, മൂല്യം ഉപയോഗിക്കും ഏറ്റവും പുതിയഎന്നാൽ നിങ്ങൾ സജ്ജമാക്കുകയാണെങ്കിൽ
നിർമ്മാണത്തിന് മുമ്പുള്ള പരിസ്ഥിതി വേരിയബിളിന്റെ മൂല്യം, അത് നിർമ്മിക്കുമ്പോഴോ തള്ളുമ്പോഴോ ഉപയോഗിക്കും
രജിസ്റ്ററിലേക്ക് private.registry.mine.

എന്റെ തത്വങ്ങൾ

എനിക്കായി പ്രവർത്തിക്കുന്ന സമീപനങ്ങൾ നിങ്ങൾക്കും വേണ്ടി പ്രവർത്തിച്ചേക്കാം. ഞാൻ ഇവ പിന്തുടരുന്നു
ലളിതമായ നിയമങ്ങൾ:

• ഉത്പാദനം, വികസനം (അല്ലെങ്കിൽ മറ്റ് പരിതസ്ഥിതികൾ) എന്നിവയ്‌ക്കായുള്ള എന്റെ എല്ലാ സ്റ്റാക്കുകളും നിർവചിച്ചിരിക്കുന്നു
  docker-compose ഫയലുകൾ
• കോൺഫിഗറേഷൻ ഫയലുകൾ എന്റെ എല്ലാ പരിതസ്ഥിതികളും കഴിയുന്നത്ര കവർ ചെയ്യേണ്ടതുണ്ട്
  തനിപ്പകർപ്പ് ഒഴിവാക്കുക.
• ഓരോ പരിതസ്ഥിതിയിലും പ്രവർത്തിക്കാൻ എനിക്ക് ഒരു ലളിതമായ കമാൻഡ് ആവശ്യമാണ്.
• പ്രധാന കോൺഫിഗറേഷൻ ഫയലിൽ നിർവചിച്ചിരിക്കുന്നു docker-compose.yml.
• ഇമേജ് ടാഗുകളോ മറ്റുള്ളവയോ നിർവ്വചിക്കാൻ പരിസ്ഥിതി വേരിയബിളുകൾ ഉപയോഗിക്കുന്നു
  പരിസ്ഥിതിയിൽ നിന്ന് പരിസ്ഥിതിയിലേക്ക് വ്യത്യാസപ്പെടാവുന്ന വേരിയബിളുകൾ (സ്റ്റേജിംഗ്, ഇന്റഗ്രേഷൻ,
  ഉത്പാദനം).
• പ്രൊഡക്ഷൻ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ മൂല്യങ്ങളായി ഉപയോഗിക്കുന്നു
  സ്ഥിരസ്ഥിതിയായി, സ്റ്റാക്ക് ഇല്ലാതെ ഉൽപ്പാദനത്തിൽ സമാരംഭിക്കുകയാണെങ്കിൽ ഇത് അപകടസാധ്യതകൾ കുറയ്ക്കുന്നു
  പരിസ്ഥിതി വേരിയബിൾ സജ്ജമാക്കുക.
• ഒരു പ്രൊഡക്ഷൻ പരിതസ്ഥിതിയിൽ ഒരു സേവനം ആരംഭിക്കുന്നതിന്, കമാൻഡ് ഉപയോഗിക്കുക ഡോക്കർ സ്റ്റാക്ക് വിന്യാസം - രചിക്കുക-ഫയൽ docker-compose.yml -with-registry-auth my-stack-name.
• കമാൻഡ് ഉപയോഗിച്ചാണ് പ്രവർത്തന അന്തരീക്ഷം ആരംഭിക്കുന്നത് docker-compose up -d.

ഒരു ലളിതമായ ഉദാഹരണം നോക്കാം.

# docker-compose.yml
...
services:
  my-service:
    build:
      context: .
    image: private.registry.mine/my-stack/my-service:${MY_SERVICE_VERSION:-latest}
    environment:
      API_ENDPOINT: ${API_ENDPOINT:-https://production.my-api.com}
...

И

# docker-compose.override.yml
...
services:
  my-service:
    ports: # This is needed for development!
      - 80:80
    environment:
      API_ENDPOINT: https://devel.my-api.com
    volumes:
      - ./:/project/src
...

ഞാൻ ഉപയോഗിക്കാം ഡോക്കർ-കമ്പോസ് (ഡോക്കർ-കംപോസ് അപ്പ്)സ്റ്റാക്ക് പ്രവർത്തിപ്പിക്കാൻ
സോഴ്സ് കോഡ് ഘടിപ്പിച്ച വികസന മോഡ് /പ്രോജക്റ്റ്/എസ്ആർസി.

എനിക്ക് നിർമ്മാണത്തിൽ ഇതേ ഫയലുകൾ ഉപയോഗിക്കാൻ കഴിയും! എനിക്ക് തീർച്ചയായും ഉപയോഗിക്കാമായിരുന്നു
ഒരേ ഫയൽ docker-compose.yml സ്റ്റേജിനായി. ഇതിലേക്ക് വിപുലീകരിക്കാൻ
നിർമ്മാണം, എനിക്ക് ഒരു മുൻനിശ്ചയിച്ച ടാഗ് ഉപയോഗിച്ച് ചിത്രം നിർമ്മിച്ച് അയയ്ക്കേണ്ടതുണ്ട്
CI ഘട്ടത്തിൽ:

export MY_SERVICE_VERSION=1.2.3
docker-compose -f docker-compose.yml build
docker-compose -f docker-compose.yml push

നിർമ്മാണത്തിൽ, ഇനിപ്പറയുന്ന കമാൻഡുകൾ ഉപയോഗിച്ച് ഇത് പ്രവർത്തിപ്പിക്കാൻ കഴിയും:

export MY_SERVICE_VERSION=1.2.3
docker stack deploy my-stack --compose-file docker-compose.yml --with-registry-auth

നിങ്ങൾക്ക് സ്റ്റേജിൽ ഇത് ചെയ്യണമെങ്കിൽ, നിങ്ങൾ നിർവചിച്ചാൽ മതി
സ്റ്റേജിംഗ് പരിതസ്ഥിതിയിൽ പ്രവർത്തിക്കുന്നതിന് ആവശ്യമായ പരിസ്ഥിതി വേരിയബിളുകൾ:

export MY_SERVICE_VERSION=1.2.3
export API_ENDPOINT=http://staging.my-api.com
docker stack deploy my-stack --compose-file docker-compose.yml --with-registry-auth

തൽഫലമായി, ഞങ്ങൾ രണ്ട് വ്യത്യസ്ത ഡോക്കർ-കംപോസ് ഫയലുകൾ ഉപയോഗിച്ചു
നിങ്ങൾക്ക് ഉള്ള ഏത് പരിതസ്ഥിതിക്കും ഡ്യൂപ്ലിക്കേറ്റ് കോൺഫിഗറേഷനുകൾ ഉപയോഗിക്കാം!

കോഴ്സിനെക്കുറിച്ച് കൂടുതലറിയുക "ലിനക്സ് അഡ്മിനിസ്ട്രേറ്റർ"

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