ആപ്ലിക്കേഷൻ ഡെവലപ്‌മെന്റും ബ്ലൂ-ഗ്രീൻ വിന്യാസവും, php, ഡോക്കർ എന്നിവയിലെ ഉദാഹരണങ്ങളുള്ള പന്ത്രണ്ട്-ഘടക ആപ്പ് രീതിശാസ്ത്രത്തെ അടിസ്ഥാനമാക്കി

ആദ്യം, ഒരു ചെറിയ സിദ്ധാന്തം. എന്താണ് സംഭവിക്കുന്നത് പന്ത്രണ്ട് ഫാക്ടർ ആപ്പ്?

ലളിതമായി പറഞ്ഞാൽ, ഈ ഡോക്യുമെന്റ് രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത് SaaS ആപ്ലിക്കേഷനുകളുടെ വികസനം ലളിതമാക്കുന്നതിനാണ്, ആധുനിക ആപ്ലിക്കേഷനുകളുടെ വികസനത്തിൽ മിക്കപ്പോഴും നേരിടുന്ന പ്രശ്നങ്ങളും സമ്പ്രദായങ്ങളും സംബന്ധിച്ച് ഡവലപ്പർമാരെയും DevOps എഞ്ചിനീയർമാരെയും അറിയിക്കാൻ സഹായിക്കുന്നു.

Heroku പ്ലാറ്റ്‌ഫോമിന്റെ ഡവലപ്പർമാരാണ് പ്രമാണം സൃഷ്ടിച്ചത്.

ഏത് പ്രോഗ്രാമിംഗ് ഭാഷയിലും എഴുതപ്പെട്ടിട്ടുള്ള ആപ്ലിക്കേഷനുകളിലും ബാക്കിംഗ് സേവനങ്ങളുടെ (ഡാറ്റാബേസുകൾ, സന്ദേശ ക്യൂകൾ, കാഷെകൾ മുതലായവ) ഏതെങ്കിലും സംയോജനം ഉപയോഗിച്ച് പന്ത്രണ്ട് ഫാക്ടർ ആപ്പ് പ്രയോഗിക്കാൻ കഴിയും.

ഈ രീതിശാസ്ത്രത്തെ അടിസ്ഥാനമാക്കിയുള്ള ഘടകങ്ങളെ കുറിച്ച് ചുരുക്കത്തിൽ:

1. കോഡ്ബേസ് - പതിപ്പ് നിയന്ത്രണത്തിൽ ഒരു കോഡ്ബേസ് ട്രാക്ക് ചെയ്തു - ഒന്നിലധികം വിന്യാസങ്ങൾ
2. ആശ്രിതത്വം - ഡിപൻഡൻസികൾ വ്യക്തമായി പ്രഖ്യാപിക്കുകയും ഒറ്റപ്പെടുത്തുകയും ചെയ്യുക
3. കോൺഫിഗറേഷൻ - റൺടൈമിൽ കോൺഫിഗറേഷൻ സംരക്ഷിക്കുക
4. ബാക്കിംഗ് സേവനങ്ങൾ - ബാക്കിംഗ് സേവനങ്ങളെ പ്ലഗ്-ഇൻ ഉറവിടങ്ങളായി പരിഗണിക്കുക
5. നിർമ്മിക്കുക, വിടുക, പ്രവർത്തിപ്പിക്കുക - അസംബ്ലി, എക്സിക്യൂഷൻ ഘട്ടങ്ങൾ കർശനമായി വേർതിരിക്കുക
6. പ്രക്രിയകൾ - ഒന്നോ അതിലധികമോ അവസ്ഥയില്ലാത്ത പ്രക്രിയകളായി ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുക
7. പോർട്ട് ബൈൻഡിംഗ് - പോർട്ട് ബൈൻഡിംഗ് വഴി സേവനങ്ങൾ കയറ്റുമതി ചെയ്യുക
8. കൺകറൻസി - പ്രോസസ്സുകൾ ഉപയോഗിച്ച് നിങ്ങളുടെ ആപ്ലിക്കേഷൻ സ്കെയിൽ ചെയ്യുക
9. ഡിസ്പോസിബിലിറ്റി - വേഗത്തിലുള്ള സ്റ്റാർട്ടപ്പ്, ക്ലീൻ ഷട്ട്ഡൗൺ എന്നിവ ഉപയോഗിച്ച് വിശ്വാസ്യത വർദ്ധിപ്പിക്കുക
10. ആപ്ലിക്കേഷൻ വികസനം/ഓപ്പറേഷൻ പാരിറ്റി - നിങ്ങളുടെ വികസനം, സ്റ്റേജിംഗ്, പ്രൊഡക്ഷൻ പരിതസ്ഥിതികൾ എന്നിവ കഴിയുന്നത്ര സമാനമായി നിലനിർത്തുക
11. ലോഗിംഗ് - ഇവന്റുകളുടെ ഒരു സ്ട്രീം ആയി ലോഗ് കാണുക
12. അഡ്മിനിസ്ട്രേഷൻ ചുമതലകൾ - അഡ്‌ഹോക്ക് പ്രോസസ്സുകൾ ഉപയോഗിച്ച് അഡ്മിനിസ്ട്രേഷൻ/മാനേജ്‌മെന്റ് ജോലികൾ ചെയ്യുക

ഇനിപ്പറയുന്ന ഉറവിടങ്ങളിൽ നിന്ന് 12 ഘടകങ്ങളെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾ നിങ്ങൾക്ക് ലഭിക്കും:

• ഔദ്യോഗിക ഉറവിടം - നിർബന്ധമായും വായിക്കണം
• ഹബറിനെക്കുറിച്ചുള്ള ലേഖനം. പന്ത്രണ്ട് ഫാക്ടർ ആപ്പ് - ഔദ്യോഗിക വിവർത്തനം
• ഹബറിനെക്കുറിച്ചുള്ള ലേഖനം. 7 ഫാക്ടർ ആപ്പിൽ 12 മിസ്സിംഗ് ഘടകങ്ങൾ - അവ മെച്ചപ്പെടുത്തുക എന്ന ലക്ഷ്യത്തോടെ 12 ഘടകങ്ങളിലേക്ക് ഒരു പുതിയ രൂപം.

എന്താണ് ബ്ലൂ-ഗ്രീൻ വിന്യാസം?

ഒരു ആപ്ലിക്കേഷൻ ഡെലിവർ ചെയ്യുന്നതിനുള്ള ഒരു രീതിയാണ് ബ്ലൂ-ഗ്രീൻ വിന്യാസം ഉത്പാദനം അന്തിമ ക്ലയന്റ് തന്റെ ഭാഗത്തുനിന്ന് മാറ്റങ്ങളൊന്നും കാണാത്ത വിധത്തിൽ. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, പൂജ്യം ഉപയോഗിച്ച് ഒരു ആപ്ലിക്കേഷൻ വിന്യസിക്കുന്നു പ്രവർത്തനരഹിതം.

ക്ലാസിക് ബിജി ഡിപ്ലോയ് സ്കീം ചുവടെയുള്ള ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നത് പോലെയാണ്.

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

എല്ലാം വളരെ മനോഹരമായി കാണപ്പെടുന്നു, ഒറ്റനോട്ടത്തിൽ അതിൽ പ്രശ്നങ്ങളൊന്നും ഉണ്ടാകരുത്.
എന്നാൽ നമ്മൾ ആധുനിക ലോകത്ത് ജീവിക്കുന്നതിനാൽ, ക്ലാസിക്കൽ സ്കീമിൽ സൂചിപ്പിച്ചിരിക്കുന്നതുപോലെ ഫിസിക്കൽ സ്വിച്ചിംഗ് ഉള്ള ഓപ്ഷൻ ഞങ്ങൾക്ക് അനുയോജ്യമല്ല. ഇപ്പോൾ വിവരങ്ങൾ രേഖപ്പെടുത്തുക, ഞങ്ങൾ പിന്നീട് അതിലേക്ക് മടങ്ങും.

ചീത്തയും നല്ല ഉപദേശവും

നിരാകരണം: താഴെയുള്ള ഉദാഹരണങ്ങൾ ഞാൻ ഉപയോഗിക്കുന്ന യൂട്ടിലിറ്റികൾ/രീതികൾ കാണിക്കുന്നു, സമാനമായ ഫംഗ്‌ഷനുകളുള്ള ഏത് ബദലുകളും നിങ്ങൾക്ക് ഉപയോഗിക്കാം.

മിക്ക ഉദാഹരണങ്ങളും ഒരു തരത്തിൽ അല്ലെങ്കിൽ മറ്റൊരു തരത്തിൽ വെബ് ഡെവലപ്‌മെന്റുമായി (ഇതൊരു ആശ്ചര്യമാണ്), PHP, ഡോക്കർ എന്നിവയുമായി കൂടിച്ചേരും.

ചുവടെയുള്ള ഖണ്ഡികകൾ നിർദ്ദിഷ്ട ഉദാഹരണങ്ങൾ ഉപയോഗിച്ച് ഘടകങ്ങളുടെ ഉപയോഗത്തിന്റെ ലളിതമായ ഒരു പ്രായോഗിക വിവരണം നൽകുന്നു; നിങ്ങൾക്ക് ഈ വിഷയത്തിൽ കൂടുതൽ സിദ്ധാന്തം ലഭിക്കണമെങ്കിൽ, യഥാർത്ഥ ഉറവിടത്തിലേക്ക് മുകളിലുള്ള ലിങ്കുകൾ പിന്തുടരുക.

1. കോഡ്ബേസ്

സെർവറുകളിലേക്ക് ഒരു സമയം ഫയലുകൾ അപ്‌ലോഡ് ചെയ്യാൻ FTP, FileZilla എന്നിവ ഉപയോഗിക്കുക, പ്രൊഡക്ഷൻ സെർവറിലല്ലാതെ മറ്റെവിടെയും കോഡ് സൂക്ഷിക്കരുത്.

പ്രോജക്റ്റിന് എല്ലായ്പ്പോഴും ഒരൊറ്റ കോഡ് ബേസ് ഉണ്ടായിരിക്കണം, അതായത്, എല്ലാ കോഡും ഒന്നിൽ നിന്നാണ് വരുന്നത് Git സംഭരണിയാണ്. സെർവറുകൾ (പ്രൊഡക്ഷൻ, സ്റ്റേജിംഗ്, ടെസ്റ്റ്1, ടെസ്റ്റ്2...) ഒരു പൊതു സംഭരണിയുടെ ശാഖകളിൽ നിന്നുള്ള കോഡ് ഉപയോഗിക്കുന്നു. ഇതുവഴി ഞങ്ങൾ കോഡ് സ്ഥിരത കൈവരിക്കുന്നു.

2. ആശ്രിതത്വം

ഫോൾഡറുകളിലെ എല്ലാ ലൈബ്രറികളും പ്രോജക്റ്റിന്റെ റൂട്ടിലേക്ക് നേരിട്ട് ഡൗൺലോഡ് ചെയ്യുക. ലൈബ്രറിയുടെ നിലവിലെ പതിപ്പ് ഉള്ള ഫോൾഡറിലേക്ക് പുതിയ കോഡ് ട്രാൻസ്ഫർ ചെയ്തുകൊണ്ട് അപ്ഡേറ്റുകൾ ഉണ്ടാക്കുക. 20 സേവനങ്ങൾ കൂടി പ്രവർത്തിക്കുന്ന ഹോസ്റ്റ് സെർവറിൽ ആവശ്യമായ എല്ലാ യൂട്ടിലിറ്റികളും നേരിട്ട് ഇൻസ്റ്റാൾ ചെയ്യുക.

ഒരു പ്രോജക്റ്റിന് എല്ലായ്പ്പോഴും വ്യക്തമായി മനസ്സിലാക്കാവുന്ന ആശ്രിതത്വങ്ങളുടെ ഒരു ലിസ്റ്റ് ഉണ്ടായിരിക്കണം (ആശ്രിതത്വങ്ങൾ കൊണ്ട് ഞാൻ അർത്ഥമാക്കുന്നത് പരിസ്ഥിതിയെ കൂടിയാണ്). എല്ലാ ആശ്രിതത്വങ്ങളും വ്യക്തമായി നിർവചിക്കുകയും ഒറ്റപ്പെടുത്തുകയും വേണം.
നമുക്ക് ഒരു ഉദാഹരണമായി എടുക്കാം കമ്പോസുചെയ്യുന്നയാൾ и ഡോക്കർ.

കമ്പോസുചെയ്യുന്നയാൾ — PHP-യിൽ ലൈബ്രറികൾ ഇൻസ്റ്റാൾ ചെയ്യാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു പാക്കേജ് മാനേജർ. പതിപ്പുകൾ കർശനമായോ അയഞ്ഞോ വ്യക്തമാക്കാനും അവ വ്യക്തമായി നിർവചിക്കാനും കമ്പോസർ നിങ്ങളെ അനുവദിക്കുന്നു. സെർവറിൽ 20 വ്യത്യസ്‌ത പ്രോജക്റ്റുകൾ ഉണ്ടാകാം, ഓരോന്നിനും മറ്റൊന്നിൽ നിന്ന് സ്വതന്ത്രമായ പാക്കേജുകളുടെയും ലൈബ്രറികളുടെയും വ്യക്തിഗത ലിസ്റ്റ് ഉണ്ടായിരിക്കും.

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

3. കോൺഫിഗറേഷൻ

കോൺഫിഗറേഷനുകൾ കോഡിൽ നേരിട്ട് കോൺസ്റ്റന്റുകളായി സംഭരിക്കുക. ടെസ്റ്റ് സെർവറിനായി പ്രത്യേക സ്ഥിരാങ്കങ്ങൾ, ഉൽപ്പാദനത്തിനായി പ്രത്യേകം. പരിസ്ഥിതിയെ ആശ്രയിച്ച് ആപ്ലിക്കേഷന്റെ പ്രവർത്തനത്തെ പ്രോജക്റ്റിന്റെ ബിസിനസ് ലോജിക്കിൽ നേരിട്ട് ബന്ധിപ്പിക്കുക.

കോൺഫിഗറേഷനുകൾ - പ്രോജക്റ്റ് വിന്യാസങ്ങൾ വ്യത്യസ്തമാകേണ്ട ഒരേയൊരു മാർഗ്ഗമാണിത്. എൻവയോൺമെന്റ് വേരിയബിളുകളിലൂടെ (env vars) കോൺഫിഗറേഷനുകൾ കടന്നുപോകണം.

അതായത്, നിങ്ങൾ നിരവധി കോൺഫിഗറേഷൻ ഫയലുകൾ .config.prod .config.local സംഭരിക്കുകയും വിന്യാസസമയത്ത് .config (ആപ്ലിക്കേഷൻ ഡാറ്റ വായിക്കുന്ന പ്രധാന കോൺഫിഗറേഷൻ) എന്ന് പുനർനാമകരണം ചെയ്യുകയും ചെയ്താലും - ഇത് ശരിയായ സമീപനമായിരിക്കില്ല, കാരണം ഈ സാഹചര്യത്തിൽ കോൺഫിഗറേഷനുകളിൽ നിന്നുള്ള വിവരങ്ങൾ എല്ലാ ആപ്ലിക്കേഷൻ ഡെവലപ്പർമാർക്കും പൊതുവായി ലഭ്യമാകുകയും പ്രൊഡക്ഷൻ സെർവറിൽ നിന്നുള്ള ഡാറ്റ അപഹരിക്കപ്പെടുകയും ചെയ്യും. എല്ലാ കോൺഫിഗറേഷനുകളും നേരിട്ട് വിന്യാസ സംവിധാനത്തിൽ (CI/CD) സംഭരിക്കുകയും വിന്യാസ സമയത്ത് ഒരു പ്രത്യേക പരിതസ്ഥിതിക്ക് ആവശ്യമായ വ്യത്യസ്ത മൂല്യങ്ങളുള്ള വ്യത്യസ്ത പരിതസ്ഥിതികൾക്കായി സൃഷ്ടിക്കുകയും വേണം.

4. മൂന്നാം കക്ഷി സേവനങ്ങൾ

പരിസ്ഥിതിയുമായി കർശനമായി ബന്ധപ്പെട്ടിരിക്കുക, ചില പരിതസ്ഥിതികളിൽ ഒരേ സേവനങ്ങൾക്കായി വ്യത്യസ്ത കണക്ഷനുകൾ ഉപയോഗിക്കുക.

വാസ്തവത്തിൽ, ഈ പോയിന്റ് കോൺഫിഗറേഷനുകളെക്കുറിച്ചുള്ള പോയിന്റുമായി ശക്തമായി ഓവർലാപ്പ് ചെയ്യുന്നു, കാരണം ഈ പോയിന്റില്ലാതെ, സാധാരണ കോൺഫിഗറേഷൻ ഡാറ്റ നിർമ്മിക്കാൻ കഴിയില്ല, പൊതുവേ, കോൺഫിഗർ ചെയ്യാനുള്ള കഴിവ് ഒന്നുമായി കുറയും.

ക്യൂ സെർവറുകൾ, ഡാറ്റാബേസുകൾ, കാഷിംഗ് സേവനങ്ങൾ എന്നിവ പോലുള്ള ബാഹ്യ സേവനങ്ങളിലേക്കുള്ള എല്ലാ കണക്ഷനുകളും പ്രാദേശിക പരിസ്ഥിതിക്കും മൂന്നാം കക്ഷി / ഉൽപ്പാദന പരിതസ്ഥിതിക്കും ഒരുപോലെ ആയിരിക്കണം. മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, എപ്പോൾ വേണമെങ്കിലും, കണക്ഷൻ സ്ട്രിംഗ് മാറ്റുന്നതിലൂടെ, ആപ്ലിക്കേഷൻ കോഡ് മാറ്റാതെ തന്നെ ബേസ് #1 ലേക്ക് കോളുകൾ ബേസ് #2 ഉപയോഗിച്ച് എനിക്ക് മാറ്റിസ്ഥാപിക്കാം. അല്ലെങ്കിൽ, മുന്നോട്ട് നോക്കുമ്പോൾ, ഒരു ഉദാഹരണമായി, സേവനം സ്കെയിൽ ചെയ്യുമ്പോൾ, ഒരു അധിക കാഷെ സെർവറിനായി നിങ്ങൾ ഏതെങ്കിലും പ്രത്യേക രീതിയിൽ കണക്ഷൻ വ്യക്തമാക്കേണ്ടതില്ല.

5. ബിൽഡ്, റിലീസ്, എക്സിക്യൂട്ട്

സെർവറിൽ കോഡിന്റെ അവസാന പതിപ്പ് മാത്രം ഉണ്ടായിരിക്കുക, റിലീസ് പിൻവലിക്കാനുള്ള സാധ്യതയില്ല. ഡിസ്ക് സ്പേസ് പൂരിപ്പിക്കേണ്ടതില്ല. ഒരു പിശക് ഉപയോഗിച്ച് നിർമ്മാണത്തിലേക്ക് കോഡ് റിലീസ് ചെയ്യാൻ കഴിയുമെന്ന് കരുതുന്ന ഏതൊരാളും ഒരു മോശം പ്രോഗ്രാമറാണ്!

വിന്യാസത്തിന്റെ എല്ലാ ഘട്ടങ്ങളും പരസ്പരം വേർതിരിക്കേണ്ടതാണ്.

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

ഇവിടെയാണ് ഞങ്ങൾ ബ്ലൂ-ഗ്രീൻ വിന്യാസം ഓർക്കുന്നത്, ഇത് കോഡിന് ഇടയിൽ മാറാൻ മാത്രമല്ല, എല്ലാ വിഭവങ്ങൾക്കും പരിതസ്ഥിതികൾക്കും ഇടയിൽ മാറാനും നിങ്ങളെ അനുവദിക്കുന്നു.

6. പ്രക്രിയകൾ

ആപ്ലിക്കേഷനിൽ തന്നെ നേരിട്ട് ആപ്ലിക്കേഷൻ സ്റ്റേറ്റ് ഡാറ്റ സംഭരിക്കുക. ആപ്ലിക്കേഷന്റെ റാമിൽ തന്നെ സെഷനുകൾ ഉപയോഗിക്കുക. മൂന്നാം കക്ഷി സേവനങ്ങൾക്കിടയിൽ കഴിയുന്നത്ര പങ്കിടൽ ഉപയോഗിക്കുക. ആപ്ലിക്കേഷന് ഒരു പ്രോസസ്സ് മാത്രമേ ഉണ്ടാകൂ എന്നതും സ്കെയിലിംഗിന് അനുവദിക്കാത്തതും എന്ന വസ്തുതയെ ആശ്രയിക്കുക.

സെഷനുകളെ സംബന്ധിച്ച്, മൂന്നാം കക്ഷി സേവനങ്ങൾ (memcached, redis) നിയന്ത്രിക്കുന്ന ഒരു കാഷെയിൽ മാത്രം ഡാറ്റ സംഭരിക്കുക, അതിനാൽ നിങ്ങൾക്ക് 20 ആപ്ലിക്കേഷൻ പ്രോസസ്സുകൾ പ്രവർത്തിക്കുന്നുണ്ടെങ്കിൽപ്പോലും, അവയിലേതെങ്കിലും, കാഷെ ആക്‌സസ് ചെയ്‌താൽ, ക്ലയന്റുമായി പ്രവർത്തിക്കുന്നത് തുടരാൻ കഴിയും ഉപയോക്താവ് മറ്റൊരു പ്രക്രിയയിൽ ആപ്ലിക്കേഷനുമായി പ്രവർത്തിച്ച അതേ അവസ്ഥ. ഈ സമീപനത്തിലൂടെ, നിങ്ങൾ മൂന്നാം കക്ഷി സേവനങ്ങളുടെ എത്ര പകർപ്പുകൾ ഉപയോഗിച്ചാലും, എല്ലാം സാധാരണമായും ഡാറ്റയിലേക്കുള്ള ആക്‌സസ് പ്രശ്‌നങ്ങളില്ലാതെയും പ്രവർത്തിക്കുമെന്ന് ഇത് മാറുന്നു.

7. പോർട്ട് ബൈൻഡിംഗ്

മൂന്നാം കക്ഷി സേവനങ്ങളുമായി എങ്ങനെ പ്രവർത്തിക്കണമെന്ന് വെബ് സെർവറിന് മാത്രമേ അറിയൂ. അല്ലെങ്കിൽ ഇതിലും മികച്ചത്, വെബ് സെർവറിനുള്ളിൽ നേരിട്ട് മൂന്നാം കക്ഷി സേവനങ്ങൾ ഇൻസ്റ്റാൾ ചെയ്യുക. ഉദാഹരണത്തിന്, അപ്പാച്ചെയിലെ ഒരു PHP മൊഡ്യൂളായി.
ചില വിലാസത്തിലേക്കും പോർട്ടിലേക്കും (localgost:5432, localhost:3000, nginx:80, php-fpm:9000) നിങ്ങളുടെ എല്ലാ സേവനങ്ങളും പരസ്‌പരം ആക്‌സസ്സുചെയ്യണം, അതായത്, nginx-ൽ നിന്ന് എനിക്ക് php-fpm-ലേക്ക് ആക്‌സസ് ചെയ്യാൻ കഴിയും postgres, കൂടാതെ php-fpm മുതൽ postgres, nginx വരെയും യഥാർത്ഥത്തിൽ ഓരോ സേവനത്തിൽ നിന്നും എനിക്ക് മറ്റൊരു സേവനം ആക്സസ് ചെയ്യാൻ കഴിയും. ഈ രീതിയിൽ, ഒരു സേവനത്തിന്റെ പ്രവർത്തനക്ഷമത മറ്റൊരു സേവനത്തിന്റെ പ്രവർത്തനക്ഷമതയുമായി ബന്ധിപ്പിച്ചിട്ടില്ല.

8. സമാന്തരത

ഒരു പ്രക്രിയയിൽ പ്രവർത്തിക്കുക, അല്ലാത്തപക്ഷം നിരവധി പ്രക്രിയകൾക്ക് പരസ്പരം ഒത്തുപോകാൻ കഴിയില്ല!

സ്കെയിലിംഗിന് ഇടം നൽകുക. ഡോക്കർ കൂട്ടം ഇതിന് മികച്ചതാണ്.
വ്യത്യസ്ത മെഷീനുകൾക്കും ഒരേ മെഷീനിൽ ഒരു കൂട്ടം കണ്ടെയ്‌നറുകൾക്കുമിടയിൽ കണ്ടെയ്‌നറുകളുടെ ക്ലസ്റ്ററുകൾ സൃഷ്‌ടിക്കുന്നതിനും നിയന്ത്രിക്കുന്നതിനുമുള്ള ഒരു ഉപകരണമാണ് ഡോക്കർ സ്വാം.

swarm ഉപയോഗിച്ച്, ഓരോ പ്രോസസിനും ഞാൻ എത്ര റിസോഴ്‌സുകൾ അനുവദിക്കുമെന്നും അതേ സേവനത്തിന്റെ എത്ര പ്രോസസ്സുകൾ ഞാൻ സമാരംഭിക്കുമെന്നും എനിക്ക് നിർണ്ണയിക്കാനാകും, കൂടാതെ തന്നിരിക്കുന്ന പോർട്ടിൽ ഡാറ്റ സ്വീകരിക്കുന്ന ഇന്റേണൽ ബാലൻസർ അത് പ്രോസസ്സുകളിലേക്ക് സ്വയമേവ പ്രോക്‌സി ചെയ്യും. അങ്ങനെ, സെർവറിലെ ലോഡ് വർദ്ധിച്ചതായി കാണുമ്പോൾ, എനിക്ക് കൂടുതൽ പ്രോസസ്സുകൾ ചേർക്കാൻ കഴിയും, അതുവഴി ചില പ്രക്രിയകളിലെ ലോഡ് കുറയ്ക്കാം.

9. ഡിസ്പോസിബിലിറ്റി

പ്രോസസ്സുകളും ഡാറ്റയും ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ ക്യൂകൾ ഉപയോഗിക്കരുത്. ഒരു പ്രക്രിയയെ കൊല്ലുന്നത് മുഴുവൻ ആപ്ലിക്കേഷനെയും ബാധിക്കും. ഒരു സർവീസ് മുടങ്ങിയാൽ എല്ലാം മുടങ്ങും.

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

10. ആപ്ലിക്കേഷൻ ഡെവലപ്‌മെന്റ്/ഓപ്പറേഷൻ പാരിറ്റി

ആപ്ലിക്കേഷന്റെ പ്രൊഡക്ഷൻ, സ്റ്റേജിംഗ്, പ്രാദേശിക പതിപ്പ് എന്നിവ വ്യത്യസ്തമായിരിക്കണം. ഉൽ‌പാദനത്തിൽ ഞങ്ങൾ Yii ലൈറ്റ് ചട്ടക്കൂടും പ്രാദേശികമായി Yii ഉപയോഗിക്കുന്നു, അതുവഴി ഉൽ‌പാദനത്തിൽ ഇത് വേഗത്തിൽ പ്രവർത്തിക്കുന്നു!

വാസ്തവത്തിൽ, എല്ലാ വിന്യാസങ്ങളും കോഡ് ഉപയോഗിച്ചുള്ള പ്രവർത്തനങ്ങളും ഏതാണ്ട് സമാനമായ പരിതസ്ഥിതിയിലായിരിക്കണം (ഞങ്ങൾ ഫിസിക്കൽ ഹാർഡ്‌വെയറിനെക്കുറിച്ചല്ല സംസാരിക്കുന്നത്). കൂടാതെ, ഏതെങ്കിലും വികസന ജീവനക്കാരന് ആവശ്യമെങ്കിൽ ഉൽപ്പാദനത്തിലേക്ക് കോഡ് വിന്യസിക്കാൻ കഴിയണം, പ്രത്യേകം പരിശീലനം ലഭിച്ച ചില devops ഡിപ്പാർട്ട്മെന്റല്ല, പ്രത്യേക ശക്തിക്ക് നന്ദി മാത്രമേ ആപ്ലിക്കേഷൻ ഉൽപ്പാദനത്തിലേക്ക് ഉയർത്താൻ കഴിയൂ.

ഇതിന് ഡോക്കറും ഞങ്ങളെ സഹായിക്കുന്നു. മുമ്പത്തെ എല്ലാ പോയിന്റുകളും നിരീക്ഷിക്കുകയാണെങ്കിൽ, ഡോക്കർ ഉപയോഗിക്കുന്നത് ഉൽപ്പാദനത്തിലും ലോക്കൽ മെഷീനിലും പരിസ്ഥിതിയെ വിന്യസിക്കുന്ന പ്രക്രിയയെ ഒന്നോ രണ്ടോ കമാൻഡുകൾ നൽകുന്നതിന് കൊണ്ടുവരും.

11. രേഖകൾ

ഞങ്ങൾ ഫയലുകളിലേക്കും ഡാറ്റാബേസുകളിലേക്കും ലോഗുകൾ എഴുതുന്നു! ലോഗുകളിൽ നിന്ന് ഞങ്ങൾ ഫയലുകളും ഡാറ്റാബേസുകളും വൃത്തിയാക്കില്ല. നമുക്ക് 9000 പെറ്റ ബൈറ്റുകൾ ഉള്ള ഒരു ഹാർഡ് ഡ്രൈവ് വാങ്ങാം, അത് കൊള്ളാം.

എല്ലാ ലോഗുകളും സംഭവങ്ങളുടെ ഒരു സ്ട്രീം ആയി കണക്കാക്കണം. ലോഗുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിൽ ആപ്ലിക്കേഷൻ തന്നെ ഉൾപ്പെടരുത്. ലോഗുകൾ stdout-ലേക്ക് ഔട്ട്‌പുട്ട് ചെയ്യണം അല്ലെങ്കിൽ udp പോലുള്ള ഒരു പ്രോട്ടോക്കോൾ വഴി അയയ്ക്കണം, അതിനാൽ ലോഗുകൾ ഉപയോഗിച്ച് പ്രവർത്തിക്കുന്നത് അപ്ലിക്കേഷന് പ്രശ്‌നങ്ങളൊന്നും സൃഷ്ടിക്കുന്നില്ല. ഗ്രേലോഗ് ഇതിന് നല്ലതാണ്. udp വഴി എല്ലാ ലോഗുകളും സ്വീകരിക്കുന്ന ഗ്രേലോഗ് (പാക്കറ്റിന്റെ വിജയകരമായ സ്വീകരണത്തെക്കുറിച്ചുള്ള പ്രതികരണത്തിനായി ഈ പ്രോട്ടോക്കോളിന് കാത്തിരിക്കേണ്ടതില്ല) ആപ്ലിക്കേഷനെ ഒരു തരത്തിലും തടസ്സപ്പെടുത്തുന്നില്ല കൂടാതെ ലോഗുകളുടെ ഘടനയും പ്രോസസ്സിംഗും മാത്രം കൈകാര്യം ചെയ്യുന്നു. അത്തരം സമീപനങ്ങളുമായി പ്രവർത്തിക്കാൻ ആപ്ലിക്കേഷൻ ലോജിക്ക് മാറില്ല.

12. അഡ്മിനിസ്ട്രേഷൻ ചുമതലകൾ

ഡാറ്റ, ഡാറ്റാബേസുകൾ മുതലായവ അപ്‌ഡേറ്റ് ചെയ്യുന്നതിന്, API-യിൽ പ്രത്യേകം സൃഷ്‌ടിച്ച ഒരു എൻഡ്‌പോയിന്റ് ഉപയോഗിക്കുക, തുടർച്ചയായി 2 തവണ എക്‌സിക്യൂട്ട് ചെയ്യുന്നത് എല്ലാം തനിപ്പകർപ്പാക്കുന്നതിന് കാരണമാകും. എന്നാൽ നിങ്ങൾ മണ്ടനല്ല, നിങ്ങൾ രണ്ടുതവണ ക്ലിക്ക് ചെയ്യില്ല, ഞങ്ങൾക്ക് മൈഗ്രേഷൻ ആവശ്യമില്ല.

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

PHP, Laravel, Laradock, Docker-Compose എന്നിവയിൽ നടപ്പിലാക്കുന്നതിനുള്ള ഉദാഹരണം

P.S എല്ലാ ഉദാഹരണങ്ങളും MacOS-ൽ നിർമ്മിച്ചതാണ്. അവയിൽ മിക്കതും ലിനക്സിനും അനുയോജ്യമാണ്. വിൻഡോസ് ഉപയോക്താക്കളേ, എന്നോട് ക്ഷമിക്കൂ, പക്ഷേ ഞാൻ വളരെക്കാലമായി വിൻഡോസിൽ പ്രവർത്തിച്ചിട്ടില്ല.

നമ്മുടെ പിസിയിൽ PHP യുടെ ഒരു പതിപ്പും ഇൻസ്റ്റാൾ ചെയ്യാത്തതും ഒന്നുമില്ലാത്തതുമായ ഒരു സാഹചര്യം നമുക്ക് സങ്കൽപ്പിക്കാം.
ഡോക്കറിന്റെയും ഡോക്കർ-കമ്പോസിന്റെയും ഏറ്റവും പുതിയ പതിപ്പുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക. (ഇത് ഇന്റർനെറ്റിൽ കാണാം)

docker -v && 
docker-compose -v

1. ഇടുക ലാറാഡോക്ക്

git clone https://github.com/Laradock/laradock.git && 
ls

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

2. ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന് Laradock കോൺഫിഗർ ചെയ്യുക.

cd laradock && 
cp env-example .env

2.1 ഏതെങ്കിലും എഡിറ്ററിൽ ഹാബർ ഡയറക്ടറി (ലാറഡോക്ക് ക്ലോൺ ചെയ്തിരിക്കുന്ന പാരന്റ് ഫോൾഡർ) തുറക്കുക. (എന്റെ PHPS കൊടുങ്കാറ്റ് കേസിൽ)

ഈ ഘട്ടത്തിൽ ഞങ്ങൾ പ്രോജക്റ്റിന് ഒരു പേര് മാത്രമാണ് നൽകുന്നത്.

2.2 വർക്ക്‌സ്‌പെയ്‌സ് ചിത്രം സമാരംഭിക്കുക. (നിങ്ങളുടെ കാര്യത്തിൽ, ചിത്രങ്ങൾ നിർമ്മിക്കാൻ കുറച്ച് സമയമെടുക്കും)
ഡെവലപ്പറുടെ പേരിൽ ചട്ടക്കൂടിനൊപ്പം പ്രവർത്തിക്കാൻ പ്രത്യേകം തയ്യാറാക്കിയ ചിത്രമാണ് വർക്ക്‌സ്‌പെയ്‌സ്.

ഉപയോഗിച്ച് ഞങ്ങൾ കണ്ടെയ്നറിനുള്ളിലേക്ക് പോകുന്നു

docker-compose up -d workspace && 
docker-compose exec workspace bash

2.3 Laravel ഇൻസ്റ്റാൾ ചെയ്യുന്നു

composer create-project --prefer-dist laravel/laravel application

2.4 ഇൻസ്റ്റാളേഷന് ശേഷം, പ്രൊജക്റ്റ് ഉള്ള ഡയറക്ടറി സൃഷ്ടിച്ചിട്ടുണ്ടോ എന്ന് ഞങ്ങൾ പരിശോധിച്ച് കമ്പോസ് കിൽ ചെയ്യുക.

ls
exit
docker-compose down

2.5 നമുക്ക് PHPStorm-ലേക്ക് തിരികെ പോയി .env ഫയലിൽ നമ്മുടെ laravel ആപ്ലിക്കേഷന്റെ ശരിയായ പാത സജ്ജമാക്കാം.

3. എല്ലാ കോഡുകളും Git-ലേക്ക് ചേർക്കുക.

ഇത് ചെയ്യുന്നതിന്, ഞങ്ങൾ Github-ൽ (അല്ലെങ്കിൽ മറ്റെവിടെയെങ്കിലും) ഒരു ശേഖരം സൃഷ്ടിക്കും. നമുക്ക് ടെർമിനലിലെ habr ഡയറക്ടറിയിൽ പോയി താഴെ പറയുന്ന കോഡ് എക്സിക്യൂട്ട് ചെയ്യാം.

echo "# habr-12factor" >> README.md
git init
git add README.md
git commit -m "first commit"
git remote add origin [email protected]:nzulfigarov/habr-12factor.git # здесь будет ссылка на ваш репо
git push -u origin master
git status

എല്ലാം ക്രമത്തിലാണോയെന്ന് പരിശോധിക്കാം.

സൗകര്യാർത്ഥം, Git-നായി ചില വിഷ്വൽ ഇന്റർഫേസ് ഉപയോഗിക്കാൻ ഞാൻ ശുപാർശ ചെയ്യുന്നു, എന്റെ കാര്യത്തിൽ അത് GitKraken. (ഇതാ ഒരു റഫറൽ ലിങ്ക്)

4. നമുക്ക് ലോഞ്ച് ചെയ്യാം!

ആരംഭിക്കുന്നതിന് മുമ്പ്, 80, 443 പോർട്ടുകളിൽ ഒന്നും തൂങ്ങിക്കിടക്കുന്നില്ലെന്ന് ഉറപ്പാക്കുക.

docker-compose up -d nginx php-fpm

അതിനാൽ, ഞങ്ങളുടെ പ്രോജക്റ്റിൽ 3 വ്യത്യസ്ത സേവനങ്ങൾ അടങ്ങിയിരിക്കുന്നു:

• nginx - വെബ് സെർവർ
• php-fpm - ഒരു വെബ് സെർവറിൽ നിന്ന് അഭ്യർത്ഥനകൾ സ്വീകരിക്കുന്നതിനുള്ള php
• വർക്ക്‌സ്‌പെയ്‌സ് - ഡവലപ്പർമാർക്കുള്ള php

ഇപ്പോൾ, 4-ൽ 12 പോയിന്റുകൾ നിറവേറ്റുന്ന ഒരു ആപ്ലിക്കേഷൻ ഞങ്ങൾ സൃഷ്ടിച്ചു, അതായത്:

1. കോഡ്ബേസ് — എല്ലാ കോഡും ഒരു ശേഖരത്തിലാണ് (ചെറിയ കുറിപ്പ്: ലാറവൽ പ്രോജക്റ്റിനുള്ളിൽ ഡോക്കർ ചേർക്കുന്നത് ശരിയായിരിക്കാം, പക്ഷേ ഇത് പ്രധാനമല്ല).

2. ആശ്രിതത്വം - ഞങ്ങളുടെ എല്ലാ ഡിപൻഡൻസികളും ആപ്ലിക്കേഷൻ/composer.json-ലും ഓരോ കണ്ടെയ്‌നറിന്റെ ഓരോ ഡോക്കർഫയലിലും വ്യക്തമായി എഴുതിയിരിക്കുന്നു.

3. ബാക്കിംഗ് സേവനങ്ങൾ - ഓരോ സേവനങ്ങളും (php-fom, nignx, വർക്ക്‌സ്‌പെയ്‌സ്) അതിന്റേതായ ജീവിതം നയിക്കുന്നു, പുറത്തു നിന്ന് ബന്ധിപ്പിച്ചിരിക്കുന്നു, ഒരു സേവനവുമായി പ്രവർത്തിക്കുമ്പോൾ, മറ്റൊന്നിനെ ബാധിക്കില്ല.

4. പ്രക്രിയകൾ - ഓരോ സേവനവും ഒരു പ്രക്രിയയാണ്. ഓരോ സേവനങ്ങളും ആന്തരിക അവസ്ഥ നിലനിർത്തുന്നില്ല.

5. പോർട്ട് ബൈൻഡിംഗ്

docker ps

നമുക്ക് കാണാനാകുന്നതുപോലെ, ഓരോ സേവനവും അതിന്റേതായ പോർട്ടിൽ പ്രവർത്തിക്കുകയും മറ്റെല്ലാ സേവനങ്ങളിലേക്കും ആക്സസ് ചെയ്യാവുന്നതുമാണ്.

6. കൺകറൻസി

ഒരേ സേവനങ്ങളുടെ ഒന്നിലധികം പ്രക്രിയകൾ അവയ്ക്കിടയിൽ സ്വയമേവയുള്ള ലോഡ് ബാലൻസിംഗ് ഉപയോഗിച്ച് സൃഷ്ടിക്കാൻ ഡോക്കർ ഞങ്ങളെ അനുവദിക്കുന്നു.

നമുക്ക് കണ്ടെയ്നറുകൾ നിർത്തി പതാകയിലൂടെ ഓടിക്കാം --സ്കെയിൽ

docker-compose down && 
docker-compose up -d --scale php-fpm=3 nginx php-fpm

നമുക്ക് കാണാനാകുന്നതുപോലെ, php-fpm കണ്ടെയ്നറിന്റെ പകർപ്പുകൾ സൃഷ്ടിച്ചു. ഈ കണ്ടെയ്‌നറുമായി പ്രവർത്തിക്കുമ്പോൾ ഞങ്ങൾ ഒന്നും മാറ്റേണ്ടതില്ല. പോർട്ട് 9000-ലും ഞങ്ങൾ അത് ആക്‌സസ് ചെയ്യുന്നത് തുടരുന്നു, ഞങ്ങൾക്ക് കണ്ടെയ്‌നറുകൾക്കിടയിലുള്ള ലോഡ് ഡോക്കർ നിയന്ത്രിക്കുന്നു.

7. ഡിസ്പോസിബിലിറ്റി - ഓരോ കണ്ടെയ്നറും മറ്റൊന്നിന് ദോഷം വരുത്താതെ കൊല്ലാൻ കഴിയും. കണ്ടെയ്നർ നിർത്തുകയോ പുനരാരംഭിക്കുകയോ ചെയ്യുന്നത് തുടർന്നുള്ള ലോഞ്ചുകളിൽ ആപ്ലിക്കേഷന്റെ പ്രവർത്തനത്തെ ബാധിക്കില്ല. ഓരോ കണ്ടെയ്‌നറും എപ്പോൾ വേണമെങ്കിലും ഉയർത്താം.

8. ആപ്ലിക്കേഷൻ വികസനം/ഓപ്പറേഷൻ പാരിറ്റി - നമ്മുടെ എല്ലാ ചുറ്റുപാടുകളും ഒരുപോലെയാണ്. പ്രൊഡക്ഷനിലുള്ള ഒരു സെർവറിൽ സിസ്റ്റം പ്രവർത്തിപ്പിക്കുന്നതിലൂടെ, നിങ്ങളുടെ കമാൻഡുകളിൽ ഒന്നും മാറ്റേണ്ടതില്ല. എല്ലാം അതേ രീതിയിൽ ഡോക്കറിനെ അടിസ്ഥാനമാക്കിയുള്ളതായിരിക്കും.

9. ലോഗിംഗ് — ഈ കണ്ടെയ്‌നറുകളിലെ എല്ലാ ലോഗുകളും സ്ട്രീമിലേക്ക് പോകുകയും ഡോക്കർ കൺസോളിൽ ദൃശ്യമാവുകയും ചെയ്യുന്നു. (ഈ സാഹചര്യത്തിൽ, വാസ്തവത്തിൽ, മറ്റ് ഭവനങ്ങളിൽ നിർമ്മിച്ച പാത്രങ്ങളിൽ, നിങ്ങൾ ഇത് ശ്രദ്ധിച്ചില്ലെങ്കിൽ ഇത് അങ്ങനെയാകണമെന്നില്ല)

 docker-compose logs -f

എന്നാൽ PHP, Nginx എന്നിവയിലെ സ്ഥിരസ്ഥിതി മൂല്യങ്ങളും ഒരു ഫയലിലേക്ക് ലോഗുകൾ എഴുതുന്നു എന്നതിൽ ഒരു പിടിയുണ്ട്. 12 ഘടകങ്ങൾ നിറവേറ്റുന്നതിന്, അത് ആവശ്യമാണ് വിച്ഛേദിക്കുക ഓരോ കണ്ടെയ്‌നറിന്റെയും കോൺഫിഗറേഷനുകളിൽ വെവ്വേറെ ഒരു ഫയലിലേക്ക് ലോഗുകൾ എഴുതുന്നു.

stdout-ലേക്ക് മാത്രമല്ല, ഞാൻ മുകളിൽ സൂചിപ്പിച്ച ഗ്രേലോഗ് പോലുള്ളവയിലേക്കും ലോഗുകൾ അയയ്ക്കാനുള്ള കഴിവും ഡോക്കർ നൽകുന്നു. ഗ്രേലോഗിനുള്ളിൽ, ഞങ്ങൾക്ക് ഇഷ്ടമുള്ളതുപോലെ ലോഗുകൾ പ്രവർത്തിപ്പിക്കാം, ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ ഇത് ഒരു തരത്തിലും ശ്രദ്ധിക്കില്ല.

10. അഡ്മിനിസ്ട്രേഷൻ ചുമതലകൾ — 12 ഫാക്ടർ ആപ്ലിക്കേഷന്റെ സ്രഷ്‌ടാക്കൾ ആഗ്രഹിക്കുന്നതുപോലെ തന്നെ ആർട്ടിസാൻ ടൂളിന്റെ സഹായത്തോടെ എല്ലാ അഡ്മിനിസ്ട്രേഷൻ ജോലികളും ലാരാവെൽ വഴി പരിഹരിക്കപ്പെടുന്നു.

ഒരു ഉദാഹരണമായി, ചില കമാൻഡുകൾ എങ്ങനെ എക്സിക്യൂട്ട് ചെയ്യുന്നുവെന്ന് ഞാൻ കാണിക്കും.
ഞങ്ങൾ കണ്ടെയ്നറിലേക്ക് പോകുന്നു.

 
docker-compose exec workspace bash
php artisan list

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

11. കോൺഫിഗറേഷനുകൾ 12 രൂപ. നിർമ്മിക്കുക, വിടുക, പ്രവർത്തിപ്പിക്കുക

ഈ ഭാഗം ബ്ലൂ-ഗ്രീൻ ഡിപ്ലോയ്‌മെന്റിനായി സമർപ്പിക്കാൻ ഞാൻ ആഗ്രഹിച്ചു, പക്ഷേ ഇത് ഈ ലേഖനത്തിന് വളരെ വിപുലമായി മാറി. ഇതിനെക്കുറിച്ച് ഞാൻ ഒരു പ്രത്യേക ലേഖനം എഴുതും.

ചുരുക്കത്തിൽ, ആശയം സിഐ/സിഡി പോലുള്ള സിസ്റ്റങ്ങളെ അടിസ്ഥാനമാക്കിയുള്ളതാണ് ജെങ്കിൻസ് и ഗിറ്റ്ലാബ് സിഐ. രണ്ടിലും, നിങ്ങൾക്ക് ഒരു പ്രത്യേക പരിതസ്ഥിതിയുമായി ബന്ധപ്പെട്ട പരിസ്ഥിതി വേരിയബിളുകൾ സജ്ജമാക്കാൻ കഴിയും. അതനുസരിച്ച്, ഈ സാഹചര്യത്തിൽ, പോയിന്റ് സി നിറവേറ്റപ്പെടും കോൺഫിഗറേഷനുകൾ.

പിന്നെ കാര്യം നിർമ്മിക്കുക, വിടുക, പ്രവർത്തിപ്പിക്കുക പേരിനൊപ്പം ബിൽറ്റ്-ഇൻ ഫംഗ്‌ഷനുകൾ വഴി പരിഹരിക്കുന്നു പൈപ്പ്ലൈൻ.

പൈപ്പ്ലൈൻ വിന്യാസ പ്രക്രിയയെ പല ഘട്ടങ്ങളായി വിഭജിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു, അസംബ്ലി, റിലീസ്, എക്സിക്യൂഷൻ എന്നിവയുടെ ഘട്ടങ്ങൾ എടുത്തുകാണിക്കുന്നു. പൈപ്പ്ലൈനിലും, നിങ്ങൾക്ക് ബാക്കപ്പുകൾ സൃഷ്ടിക്കാൻ കഴിയും, തീർച്ചയായും എന്തും. പരിധിയില്ലാത്ത സാധ്യതകളുള്ള ഒരു ഉപകരണമാണിത്.

ആപ്ലിക്കേഷൻ കോഡ് ഇവിടെയുണ്ട് സാമൂഹികം.
ഈ ശേഖരം ക്ലോണുചെയ്യുമ്പോൾ സബ്മോഡ്യൂൾ ആരംഭിക്കാൻ മറക്കരുത്.

P.S.: ഈ സമീപനങ്ങളെല്ലാം മറ്റേതെങ്കിലും യൂട്ടിലിറ്റികളിലും പ്രോഗ്രാമിംഗ് ഭാഷകളിലും ഉപയോഗിക്കാവുന്നതാണ്. പ്രധാന കാര്യം സാരാംശം വ്യത്യസ്തമല്ല എന്നതാണ്.

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