തുടർച്ചയായ സംയോജനത്തിനായി ഡോക്കറിലെ മൈക്രോസർവീസുകളുടെ ഓട്ടോമേറ്റഡ് ടെസ്റ്റിംഗ്

മൈക്രോസർവീസ് ആർക്കിടെക്ചറിന്റെ വികസനവുമായി ബന്ധപ്പെട്ട പ്രോജക്റ്റുകളിൽ, CI/CD ഒരു മനോഹരമായ അവസരത്തിന്റെ വിഭാഗത്തിൽ നിന്ന് അടിയന്തിര ആവശ്യത്തിന്റെ വിഭാഗത്തിലേക്ക് മാറുന്നു. തുടർച്ചയായ സംയോജനത്തിന്റെ അവിഭാജ്യ ഘടകമാണ് ഓട്ടോമേറ്റഡ് ടെസ്റ്റിംഗ്, ടീമിന് കുടുംബാംഗങ്ങളുമായും സുഹൃത്തുക്കളുമായും നിരവധി മനോഹരമായ സായാഹ്നങ്ങൾ നൽകാൻ കഴിയുന്ന ഒരു സമർത്ഥമായ സമീപനം. അല്ലെങ്കിൽ, പദ്ധതി ഒരിക്കലും പൂർത്തിയാകില്ല.

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

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

ഈ സമീപനത്തിന്റെ ഓട്ടോമേഷൻ നിരവധി പ്രശ്നങ്ങൾ അവതരിപ്പിക്കുന്നു, അതിനുള്ള പരിഹാരം ചുവടെ വിവരിക്കും:

• ഒരേ ഡോക്കർ ഹോസ്റ്റിലെ സമാന്തര ടാസ്ക്കുകളുടെ വൈരുദ്ധ്യങ്ങൾ;
• ടെസ്റ്റ് ആവർത്തന സമയത്ത് ഡാറ്റാബേസിലെ ഐഡന്റിഫയർ വൈരുദ്ധ്യങ്ങൾ;
• മൈക്രോസർവീസുകൾ തയ്യാറാകുന്നതിനായി കാത്തിരിക്കുന്നു;
• ബാഹ്യ സിസ്റ്റങ്ങളിലേക്ക് ലോഗുകൾ ലയിപ്പിക്കുകയും ഔട്ട്പുട്ട് ചെയ്യുകയും ചെയ്യുന്നു;
• ഔട്ട്ഗോയിംഗ് HTTP അഭ്യർത്ഥനകൾ പരിശോധിക്കുന്നു;
• വെബ് സോക്കറ്റ് ടെസ്റ്റിംഗ് (SignalR ഉപയോഗിച്ച്);
• OAuth പ്രാമാണീകരണവും അംഗീകാരവും പരിശോധിക്കുന്നു.

ഈ ലേഖനം അടിസ്ഥാനമാക്കിയുള്ളതാണ് എന്റെ പ്രസംഗം SECR 2019-ൽ. അതിനാൽ വായിക്കാൻ മടിയുള്ളവർക്ക്, പ്രസംഗത്തിന്റെ റെക്കോർഡിംഗ് ഇവിടെയുണ്ട്.

ടെസ്റ്റിന് കീഴിലുള്ള സേവനം, ഡോക്കറിലെ ഒരു ഡാറ്റാബേസ്, ആമസോൺ AWS സേവനങ്ങൾ എന്നിവ പ്രവർത്തിപ്പിക്കുന്നതിന് ഒരു സ്‌ക്രിപ്റ്റ് എങ്ങനെ ഉപയോഗിക്കാമെന്ന് ഈ ലേഖനത്തിൽ ഞാൻ നിങ്ങളോട് പറയും, തുടർന്ന് പോസ്റ്റ്‌മാനിലെ പരിശോധനകൾ, അവ പൂർത്തിയാക്കിയ ശേഷം സൃഷ്ടിച്ച കണ്ടെയ്‌നറുകൾ നിർത്തി ഇല്ലാതാക്കുക. ഓരോ തവണയും കോഡ് മാറുമ്പോൾ ടെസ്റ്റുകൾ നടപ്പിലാക്കുന്നു. ഈ രീതിയിൽ, ഓരോ പതിപ്പും AWS ഡാറ്റാബേസിലും സേവനങ്ങളിലും ശരിയായി പ്രവർത്തിക്കുന്നുവെന്ന് ഞങ്ങൾ ഉറപ്പാക്കുന്നു.

ഡെവലപ്പർമാർ തന്നെ അവരുടെ വിൻഡോസ് ഡെസ്‌ക്‌ടോപ്പുകളിലും ലിനക്‌സിന് കീഴിലുള്ള Gitlab CI സെർവറിലും ഒരേ സ്‌ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്നു.

ന്യായീകരിക്കാൻ, പുതിയ ടെസ്റ്റുകൾ അവതരിപ്പിക്കുന്നതിന്, ഡെവലപ്പറുടെ കമ്പ്യൂട്ടറിലോ അല്ലെങ്കിൽ ഒരു കമ്മിറ്റിൽ ടെസ്റ്റുകൾ നടത്തുന്ന സെർവറിലോ അധിക ടൂളുകൾ ഇൻസ്റ്റാൾ ചെയ്യേണ്ടതില്ല. ഡോക്കർ ഈ പ്രശ്നം പരിഹരിക്കുന്നു.

ഇനിപ്പറയുന്ന കാരണങ്ങളാൽ പരിശോധന ഒരു പ്രാദേശിക സെർവറിൽ പ്രവർത്തിക്കണം:

• നെറ്റ്‌വർക്ക് ഒരിക്കലും പൂർണ്ണമായും വിശ്വസനീയമല്ല. ആയിരം അഭ്യർത്ഥനകളിൽ ഒന്ന് പരാജയപ്പെട്ടേക്കാം;
  ഈ സാഹചര്യത്തിൽ, ഓട്ടോമാറ്റിക് ടെസ്റ്റ് പ്രവർത്തിക്കില്ല, ജോലി നിർത്തും, നിങ്ങൾ ലോഗുകളിൽ കാരണം നോക്കേണ്ടിവരും;
• ഇടയ്ക്കിടെയുള്ള അഭ്യർത്ഥനകൾ ചില മൂന്നാം കക്ഷി സേവനങ്ങൾ അനുവദിക്കില്ല.

കൂടാതെ, സ്റ്റാൻഡ് ഉപയോഗിക്കുന്നത് അഭികാമ്യമല്ല കാരണം:

• ഒരു സ്റ്റാൻഡിൽ പ്രവർത്തിക്കുന്ന മോശം കോഡ് മാത്രമല്ല, ശരിയായ കോഡിന് പ്രോസസ്സ് ചെയ്യാൻ കഴിയാത്ത ഡാറ്റയും തകർക്കാൻ കഴിയും;
• ടെസ്റ്റ് സമയത്ത് തന്നെ ടെസ്റ്റ് വരുത്തിയ എല്ലാ മാറ്റങ്ങളും പഴയപടിയാക്കാൻ നമ്മൾ എത്ര ശ്രമിച്ചാലും, എന്തെങ്കിലും തെറ്റ് സംഭവിക്കാം (അല്ലെങ്കിൽ, എന്തിനാണ് ടെസ്റ്റ്?).

പ്രോജക്റ്റിനെയും പ്രോസസ് ഓർഗനൈസേഷനെയും കുറിച്ച്

ആമസോൺ AWS ക്ലൗഡിലെ ഡോക്കറിൽ പ്രവർത്തിക്കുന്ന ഒരു മൈക്രോ സർവീസ് വെബ് ആപ്ലിക്കേഷൻ ഞങ്ങളുടെ കമ്പനി വികസിപ്പിച്ചെടുത്തു. പ്രോജക്റ്റിൽ യൂണിറ്റ് ടെസ്റ്റുകൾ ഇതിനകം ഉപയോഗിച്ചിരുന്നു, എന്നാൽ യൂണിറ്റ് ടെസ്റ്റുകൾ കണ്ടെത്താത്ത പിശകുകൾ പലപ്പോഴും സംഭവിച്ചു. ഡാറ്റാബേസ്, ആമസോൺ സേവനങ്ങൾ എന്നിവയ്‌ക്കൊപ്പം ഒരു മുഴുവൻ മൈക്രോസർവീസും പരിശോധിക്കേണ്ടത് ആവശ്യമാണ്.

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

പ്രോജക്റ്റ് ആർക്കിടെക്ചർ

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

SQS, SNS

HTTPS പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് സന്ദേശങ്ങൾ ഒരു ക്യൂവിൽ ഇടാനും ക്യൂവിൽ നിന്ന് സന്ദേശങ്ങൾ വായിക്കാനും SQS നിങ്ങളെ അനുവദിക്കുന്നു.

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

ഓരോ സന്ദേശവും ഒന്നിലധികം സേവനങ്ങളിലേക്ക് ഡെലിവർ ചെയ്യണമെങ്കിൽ, ഓരോ സ്വീകർത്താവിനും അതിന്റേതായ ക്യൂ ഉണ്ടായിരിക്കണം, കൂടാതെ ഒന്നിലധികം ക്യൂകളിലേക്ക് സന്ദേശങ്ങൾ ഡ്യൂപ്ലിക്കേറ്റ് ചെയ്യാൻ SNS ആവശ്യമാണ്.

SNS-ൽ നിങ്ങൾ ഒരു വിഷയം സൃഷ്ടിക്കുകയും അതിലേക്ക് സബ്‌സ്‌ക്രൈബ് ചെയ്യുകയും ചെയ്യുന്നു, ഉദാഹരണത്തിന്, ഒരു SQS ക്യൂ. നിങ്ങൾക്ക് വിഷയത്തിലേക്ക് സന്ദേശങ്ങൾ അയയ്ക്കാൻ കഴിയും. ഈ സാഹചര്യത്തിൽ, ഈ വിഷയം സബ്‌സ്‌ക്രൈബുചെയ്‌ത ഓരോ ക്യൂവിലേക്കും സന്ദേശം അയയ്‌ക്കുന്നു. സന്ദേശങ്ങൾ വായിക്കുന്നതിനുള്ള ഒരു രീതി SNS-നില്ല. ഡീബഗ്ഗിംഗ് അല്ലെങ്കിൽ ടെസ്റ്റിംഗ് സമയത്ത് എസ്എൻഎസിലേക്ക് എന്താണ് അയച്ചതെന്ന് നിങ്ങൾ കണ്ടെത്തേണ്ടതുണ്ടെങ്കിൽ, നിങ്ങൾക്ക് ഒരു SQS ക്യൂ സൃഷ്ടിക്കാനും ആവശ്യമുള്ള വിഷയത്തിലേക്ക് സബ്‌സ്‌ക്രൈബ് ചെയ്യാനും ക്യൂ വായിക്കാനും കഴിയും.

API ഗേറ്റ്‌വേ

മിക്ക സേവനങ്ങളും ഇന്റർനെറ്റിൽ നിന്ന് നേരിട്ട് ആക്സസ് ചെയ്യാൻ കഴിയില്ല. ആക്‌സസ് അവകാശങ്ങൾ പരിശോധിക്കുന്ന API ഗേറ്റ്‌വേ വഴിയാണ് പ്രവേശനം. ഇത് ഞങ്ങളുടെ സേവനം കൂടിയാണ്, അതിനുള്ള പരിശോധനകളും ഉണ്ട്.

തത്സമയ അറിയിപ്പുകൾ

ആപ്ലിക്കേഷൻ ഉപയോഗിക്കുന്നു സിഗ്നൽ ആർഉപയോക്താവിന് തത്സമയ അറിയിപ്പുകൾ കാണിക്കാൻ. അറിയിപ്പ് സേവനത്തിലാണ് ഇത് നടപ്പിലാക്കുന്നത്. ഇത് ഇൻറർനെറ്റിൽ നിന്ന് നേരിട്ട് ആക്‌സസ് ചെയ്യാവുന്നതും OAuth-ൽ തന്നെ പ്രവർത്തിക്കുന്നതുമാണ്, കാരണം OAuth ഉം അറിയിപ്പ് സേവനവും സമന്വയിപ്പിക്കുന്നതുമായി താരതമ്യപ്പെടുത്തുമ്പോൾ വെബ് സോക്കറ്റുകൾക്കുള്ള പിന്തുണ ഗേറ്റ്‌വേയിലേക്ക് നിർമ്മിക്കുന്നത് അപ്രായോഗികമാണ്.

അറിയപ്പെടുന്ന ടെസ്റ്റിംഗ് സമീപനം

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

В Microsoft-ൽ നിന്നുള്ള ലേഖനം ഇൻ-മെമ്മറി ഡാറ്റാബേസ് ഉപയോഗിക്കാനും മോക്ക് ഒബ്‌ജക്‌റ്റുകൾ നടപ്പിലാക്കാനും നിർദ്ദേശിക്കപ്പെട്ടിരിക്കുന്നു.

എന്റിറ്റി ഫ്രെയിംവർക്ക് പിന്തുണയ്ക്കുന്ന DBMS-കളിൽ ഒന്നാണ് ഇൻ-മെമ്മറി ഡാറ്റാബേസ്. ഇത് പരീക്ഷണത്തിനായി പ്രത്യേകം സൃഷ്ടിച്ചതാണ്. അത്തരം ഒരു ഡാറ്റാബേസിലെ ഡാറ്റ അത് ഉപയോഗിക്കുന്ന പ്രക്രിയ അവസാനിക്കുന്നതുവരെ മാത്രമേ സംഭരിക്കപ്പെടുകയുള്ളൂ. ഇതിന് പട്ടികകൾ സൃഷ്‌ടിക്കേണ്ടതില്ല, ഡാറ്റയുടെ സമഗ്രത പരിശോധിക്കുന്നില്ല.

മോക്ക് ഒബ്‌ജക്‌റ്റുകൾ അവർ മാറ്റിസ്ഥാപിക്കുന്ന ക്ലാസിനെ മാതൃകയാക്കുന്നത് ടെസ്റ്റ് ഡെവലപ്പർ അത് എങ്ങനെ പ്രവർത്തിക്കുന്നുവെന്ന് മനസ്സിലാക്കുന്നിടത്തോളം മാത്രമാണ്.

നിങ്ങൾ ഒരു ടെസ്റ്റ് നടത്തുമ്പോൾ പോസ്‌റ്റ്‌ഗ്രെസ് സ്വയമേവ ആരംഭിക്കുന്നതിനും മൈഗ്രേഷനുകൾ നടത്തുന്നതിനും എങ്ങനെ നേടാം എന്ന് Microsoft ലേഖനത്തിൽ വ്യക്തമാക്കിയിട്ടില്ല. എന്റെ പരിഹാരം ഇത് ചെയ്യുന്നു, കൂടാതെ, മൈക്രോസർവീസിലേക്ക് തന്നെ ടെസ്റ്റുകൾക്കായി പ്രത്യേകമായി ഒരു കോഡും ചേർക്കുന്നില്ല.

നമുക്ക് പരിഹാരത്തിലേക്ക് പോകാം

വികസന പ്രക്രിയയിൽ, എല്ലാ പ്രശ്നങ്ങളും സമയബന്ധിതമായി കണ്ടെത്തുന്നതിന് യൂണിറ്റ് ടെസ്റ്റുകൾ പര്യാപ്തമല്ലെന്ന് വ്യക്തമായി, അതിനാൽ ഈ പ്രശ്നത്തെ മറ്റൊരു കോണിൽ നിന്ന് സമീപിക്കാൻ തീരുമാനിച്ചു.

ഒരു പരീക്ഷണ അന്തരീക്ഷം സജ്ജീകരിക്കുന്നു

ഒരു പരീക്ഷണ അന്തരീക്ഷം വിന്യസിക്കുക എന്നതാണ് ആദ്യ ചുമതല. ഒരു മൈക്രോസർവീസ് പ്രവർത്തിപ്പിക്കുന്നതിന് ആവശ്യമായ ഘട്ടങ്ങൾ:

• ലോക്കൽ എൻവയോൺമെന്റിനായി ടെസ്റ്റിന് കീഴിലുള്ള സേവനം കോൺഫിഗർ ചെയ്യുക, എൻവയോൺമെന്റ് വേരിയബിളുകളിൽ ഡാറ്റാബേസിലേക്കും AWS ലേക്കും ബന്ധിപ്പിക്കുന്നതിനുള്ള വിശദാംശങ്ങൾ വ്യക്തമാക്കുക;
• Postgres ആരംഭിച്ച് Liquibase പ്രവർത്തിപ്പിച്ച് മൈഗ്രേഷൻ നടത്തുക.
  റിലേഷണൽ ഡിബിഎംഎസുകളിൽ, ഡാറ്റാബേസിലേക്ക് ഡാറ്റ എഴുതുന്നതിന് മുമ്പ്, നിങ്ങൾ ഒരു ഡാറ്റ സ്കീമ സൃഷ്ടിക്കേണ്ടതുണ്ട്, മറ്റൊരു രീതിയിൽ പറഞ്ഞാൽ, പട്ടികകൾ. ഒരു ആപ്ലിക്കേഷൻ അപ്‌ഡേറ്റ് ചെയ്യുമ്പോൾ, പുതിയ പതിപ്പ് ഉപയോഗിക്കുന്ന ഫോമിലേക്ക് പട്ടികകൾ കൊണ്ടുവരണം, കൂടാതെ ഡാറ്റ നഷ്‌ടപ്പെടാതെ തന്നെ. ഇതിനെ മൈഗ്രേഷൻ എന്ന് വിളിക്കുന്നു. തുടക്കത്തിൽ ശൂന്യമായ ഒരു ഡാറ്റാബേസിൽ പട്ടികകൾ സൃഷ്ടിക്കുന്നത് മൈഗ്രേഷന്റെ ഒരു പ്രത്യേക സാഹചര്യമാണ്. മൈഗ്രേഷൻ ആപ്ലിക്കേഷനിൽ തന്നെ നിർമ്മിക്കാം. .NET, NodeJS എന്നിവയ്ക്ക് മൈഗ്രേഷൻ ചട്ടക്കൂടുകളുണ്ട്. ഞങ്ങളുടെ കാര്യത്തിൽ, സുരക്ഷാ കാരണങ്ങളാൽ, ഡാറ്റാ സ്കീമ മാറ്റാനുള്ള അവകാശം മൈക്രോസർവീസുകൾക്ക് നഷ്ടപ്പെടുന്നു, കൂടാതെ മൈഗ്രേഷൻ ലിക്വിബേസ് ഉപയോഗിച്ചാണ് നടത്തുന്നത്.
• Amazon LocalStack സമാരംഭിക്കുക. വീട്ടിലിരുന്ന് പ്രവർത്തിപ്പിക്കാനുള്ള AWS സേവനങ്ങളുടെ ഒരു നിർവ്വഹണമാണിത്. ഡോക്കർ ഹബ്ബിൽ ലോക്കൽസ്റ്റാക്കിനായി ഒരു റെഡിമെയ്ഡ് ഇമേജ് ഉണ്ട്.
• LocalStack-ൽ ആവശ്യമായ എന്റിറ്റികൾ സൃഷ്ടിക്കാൻ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുക. ഷെൽ സ്ക്രിപ്റ്റുകൾ AWS CLI ഉപയോഗിക്കുന്നു.

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

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

ടെസ്റ്റ് സമയത്ത്, എല്ലാം ഡോക്കറിൽ പ്രവർത്തിക്കുന്നു: ടെസ്റ്റിന് കീഴിലുള്ള സേവനം, പോസ്റ്റ്ഗ്രെസ്, മൈഗ്രേഷൻ ടൂൾ, പോസ്റ്റ്മാൻ അല്ലെങ്കിൽ അതിന്റെ കൺസോൾ പതിപ്പ് - ന്യൂമാൻ.

ഡോക്കർ നിരവധി പ്രശ്നങ്ങൾ പരിഹരിക്കുന്നു:

• ഹോസ്റ്റ് കോൺഫിഗറേഷനിൽ നിന്നുള്ള സ്വാതന്ത്ര്യം;
• ഡിപൻഡൻസികൾ ഇൻസ്റ്റാൾ ചെയ്യുന്നു: ഡോക്കർ ഹബ്ബിൽ നിന്ന് ഡോക്കർ ചിത്രങ്ങൾ ഡൗൺലോഡ് ചെയ്യുന്നു;
• സിസ്റ്റത്തെ അതിന്റെ യഥാർത്ഥ അവസ്ഥയിലേക്ക് തിരികെ കൊണ്ടുവരുന്നു: കണ്ടെയ്നറുകൾ നീക്കം ചെയ്യുക.

ഡോക്കർ-രചന ഇൻറർനെറ്റിൽ നിന്ന് ഒറ്റപ്പെട്ട ഒരു വെർച്വൽ നെറ്റ്‌വർക്കിലേക്ക് കണ്ടെയ്‌നറുകളെ സംയോജിപ്പിക്കുന്നു, അതിൽ ഡൊമെയ്‌ൻ നാമങ്ങൾ ഉപയോഗിച്ച് കണ്ടെയ്‌നറുകൾ പരസ്പരം കണ്ടെത്തുന്നു.

ഒരു ഷെൽ സ്ക്രിപ്റ്റ് ഉപയോഗിച്ചാണ് ടെസ്റ്റ് നിയന്ത്രിക്കുന്നത്. വിൻഡോസിൽ ടെസ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ ഞങ്ങൾ git-bash ഉപയോഗിക്കുന്നു. അതിനാൽ, വിൻഡോസിനും ലിനക്സിനും ഒരു സ്ക്രിപ്റ്റ് മതിയാകും. പ്രോജക്റ്റിലെ എല്ലാ ഡെവലപ്പർമാരും Git, Docker എന്നിവ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്. വിൻഡോസിൽ Git ഇൻസ്റ്റാൾ ചെയ്യുമ്പോൾ, git-bash ഇൻസ്റ്റാൾ ചെയ്യപ്പെടുന്നു, അതിനാൽ എല്ലാവർക്കും അത് ഉണ്ട്.

സ്ക്രിപ്റ്റ് ഇനിപ്പറയുന്ന ഘട്ടങ്ങൾ ചെയ്യുന്നു:

• ഡോക്കർ ചിത്രങ്ങൾ നിർമ്മിക്കുന്നു

  docker-compose build

• ഡാറ്റാബേസും ലോക്കൽസ്റ്റാക്കും സമാരംഭിക്കുന്നു

  docker-compose up -d <контейнер>

• ഡാറ്റാബേസ് മൈഗ്രേഷനും ലോക്കൽസ്റ്റാക്കിന്റെ തയ്യാറെടുപ്പും

  docker-compose run <контейнер>

• പരീക്ഷണ ഘട്ടത്തിലാണ് സേവനം ആരംഭിക്കുന്നത്

  docker-compose up -d <сервис>

• ടെസ്റ്റ് നടത്തുന്നു (ന്യൂമാൻ)
• എല്ലാ കണ്ടെയ്നറുകളും നിർത്തുന്നു

  docker-compose down

• സ്ലാക്കിൽ ഫലങ്ങൾ പോസ്റ്റുചെയ്യുന്നു
  പച്ച ചെക്ക്‌മാർക്കോ റെഡ് ക്രോസോ ഉള്ള സന്ദേശങ്ങളും ലോഗിലേക്കുള്ള ലിങ്കും ഉള്ള ഒരു ചാറ്റ് ഞങ്ങൾക്കുണ്ട്.

ഇനിപ്പറയുന്ന ഡോക്കർ ചിത്രങ്ങൾ ഈ ഘട്ടങ്ങളിൽ ഉൾപ്പെട്ടിരിക്കുന്നു:

• ഉൽപ്പാദനത്തിന്റെ അതേ ചിത്രമാണ് പരീക്ഷിക്കുന്ന സേവനം. എൻവയോൺമെന്റ് വേരിയബിളുകൾ വഴിയാണ് ടെസ്റ്റിനുള്ള കോൺഫിഗറേഷൻ.
• Postgres, Redis, LocalStack എന്നിവയ്ക്കായി, ഡോക്കർ ഹബിൽ നിന്നുള്ള റെഡിമെയ്ഡ് ഇമേജുകൾ ഉപയോഗിക്കുന്നു. ലിക്വിബേസിനും ന്യൂമാനും റെഡിമെയ്ഡ് ചിത്രങ്ങളുമുണ്ട്. ഞങ്ങൾ അവരുടെ അസ്ഥികൂടത്തിൽ ഞങ്ങളുടെ ഫയലുകൾ കൂട്ടിച്ചേർക്കുന്നു.
• LocalStack തയ്യാറാക്കാൻ, നിങ്ങൾ ഒരു റെഡിമെയ്ഡ് AWS CLI ഇമേജ് ഉപയോഗിക്കുകയും അതിനെ അടിസ്ഥാനമാക്കി ഒരു സ്ക്രിപ്റ്റ് അടങ്ങിയ ഒരു ഇമേജ് സൃഷ്ടിക്കുകയും ചെയ്യുന്നു.

ഉപയോഗിക്കുന്നു വോളിയം, കണ്ടെയ്‌നറിലേക്ക് ഫയലുകൾ ചേർക്കുന്നതിന് നിങ്ങൾ ഒരു ഡോക്കർ ഇമേജ് നിർമ്മിക്കേണ്ടതില്ല. എന്നിരുന്നാലും, വോളിയങ്ങൾ നമ്മുടെ പരിസ്ഥിതിക്ക് അനുയോജ്യമല്ല, കാരണം Gitlab CI ടാസ്ക്കുകൾ തന്നെ കണ്ടെയ്നറുകളിൽ പ്രവർത്തിക്കുന്നു. അത്തരമൊരു കണ്ടെയ്‌നറിൽ നിന്ന് നിങ്ങൾക്ക് ഡോക്കറിനെ നിയന്ത്രിക്കാനാകും, എന്നാൽ വോള്യങ്ങൾ ഹോസ്റ്റ് സിസ്റ്റത്തിൽ നിന്നുള്ള ഫോൾഡറുകൾ മാത്രമേ മൌണ്ട് ചെയ്യൂ, മറ്റൊരു കണ്ടെയ്നറിൽ നിന്നല്ല.

നിങ്ങൾ നേരിട്ടേക്കാവുന്ന പ്രശ്നങ്ങൾ

തയ്യാറെടുപ്പിനായി കാത്തിരിക്കുന്നു

ഒരു സേവനമുള്ള ഒരു കണ്ടെയ്‌നർ പ്രവർത്തിക്കുമ്പോൾ, കണക്ഷനുകൾ സ്വീകരിക്കാൻ അത് തയ്യാറാണെന്ന് ഇതിനർത്ഥമില്ല. കണക്ഷൻ തുടരാൻ നിങ്ങൾ കാത്തിരിക്കണം.

ഈ പ്രശ്നം ചിലപ്പോൾ ഒരു സ്ക്രിപ്റ്റ് ഉപയോഗിച്ച് പരിഹരിക്കപ്പെടും കാത്തിരിക്കുക, ഒരു TCP കണക്ഷൻ സ്ഥാപിക്കാനുള്ള അവസരത്തിനായി കാത്തിരിക്കുന്നു. എന്നിരുന്നാലും, LocalStack ഒരു 502 Bad Gateway പിശക് വരുത്തിയേക്കാം. കൂടാതെ, അതിൽ നിരവധി സേവനങ്ങൾ അടങ്ങിയിരിക്കുന്നു, അവയിലൊന്ന് തയ്യാറാണെങ്കിൽ, ഇത് മറ്റുള്ളവരെക്കുറിച്ച് ഒന്നും പറയുന്നില്ല.

തീരുമാനം: SQS-ൽ നിന്നും SNS-ൽ നിന്നും 200 പ്രതികരണത്തിനായി കാത്തിരിക്കുന്ന LocalStack പ്രൊവിഷനിംഗ് സ്ക്രിപ്റ്റുകൾ.

സമാന്തര ടാസ്‌ക് വൈരുദ്ധ്യങ്ങൾ

ഒരേ ഡോക്കർ ഹോസ്റ്റിൽ ഒന്നിലധികം ടെസ്റ്റുകൾ ഒരേസമയം പ്രവർത്തിക്കാൻ കഴിയും, അതിനാൽ കണ്ടെയ്‌നറിന്റെയും നെറ്റ്‌വർക്കിന്റെയും പേരുകൾ അദ്വിതീയമായിരിക്കണം. മാത്രമല്ല, ഒരേ സേവനത്തിന്റെ വിവിധ ശാഖകളിൽ നിന്നുള്ള ടെസ്റ്റുകളും ഒരേസമയം പ്രവർത്തിക്കാൻ കഴിയും, അതിനാൽ ഓരോ കമ്പോസ് ഫയലിലും അവയുടെ പേരുകൾ എഴുതിയാൽ മാത്രം പോരാ.

തീരുമാനം: സ്ക്രിപ്റ്റ് COMPOSE_PROJECT_NAME വേരിയബിളിനെ ഒരു അദ്വിതീയ മൂല്യത്തിലേക്ക് സജ്ജമാക്കുന്നു.

വിൻഡോസ് സവിശേഷതകൾ

വിൻഡോസിൽ ഡോക്കർ ഉപയോഗിക്കുമ്പോൾ ഞാൻ ചൂണ്ടിക്കാണിക്കാൻ ആഗ്രഹിക്കുന്ന നിരവധി കാര്യങ്ങളുണ്ട്, കാരണം പിശകുകൾ സംഭവിക്കുന്നത് എന്തുകൊണ്ടാണെന്ന് മനസിലാക്കാൻ ഈ അനുഭവങ്ങൾ പ്രധാനമാണ്.

1. ഒരു കണ്ടെയ്‌നറിലെ ഷെൽ സ്‌ക്രിപ്‌റ്റുകൾക്ക് ലിനക്‌സ് ലൈൻ അവസാനങ്ങൾ ഉണ്ടായിരിക്കണം.
   ഷെൽ CR ചിഹ്നം ഒരു വാക്യഘടന പിശകാണ്. പിശക് സന്ദേശത്തിൽ നിന്ന് ഇത് അങ്ങനെയാണെന്ന് പറയാൻ പ്രയാസമാണ്. വിൻഡോസിൽ അത്തരം സ്ക്രിപ്റ്റുകൾ എഡിറ്റുചെയ്യുമ്പോൾ, നിങ്ങൾക്ക് ശരിയായ ടെക്സ്റ്റ് എഡിറ്റർ ആവശ്യമാണ്. കൂടാതെ, പതിപ്പ് നിയന്ത്രണ സംവിധാനം ശരിയായി ക്രമീകരിച്ചിരിക്കണം.

ഇങ്ങനെയാണ് git ക്രമീകരിച്ചിരിക്കുന്നത്:

git config core.autocrlf input

1. Git-bash സ്റ്റാൻഡേർഡ് ലിനക്സ് ഫോൾഡറുകൾ അനുകരിക്കുന്നു, ഒരു exe ഫയലിലേക്ക് വിളിക്കുമ്പോൾ (docker.exe ഉൾപ്പെടെ), വിൻഡോസ് പാത്തുകൾ ഉപയോഗിച്ച് സമ്പൂർണ്ണ ലിനക്സ് പാത്തുകൾ മാറ്റിസ്ഥാപിക്കുന്നു. എന്നിരുന്നാലും, ലോക്കൽ മെഷീനിൽ (അല്ലെങ്കിൽ ഒരു കണ്ടെയ്നറിലെ പാതകൾ) അല്ലാത്ത പാതകൾക്ക് ഇത് അർത്ഥമാക്കുന്നില്ല. ഈ സ്വഭാവം പ്രവർത്തനരഹിതമാക്കാൻ കഴിയില്ല.

തീരുമാനം: പാതയുടെ തുടക്കത്തിൽ ഒരു അധിക സ്ലാഷ് ചേർക്കുക: /bin എന്നതിന് പകരം //bin. Linux അത്തരം പാതകൾ മനസ്സിലാക്കുന്നു; അതിനായി, നിരവധി സ്ലാഷുകൾ ഒന്നിന് തുല്യമാണ്. എന്നാൽ git-bash അത്തരം പാതകളെ തിരിച്ചറിയുന്നില്ല, അവയെ പരിവർത്തനം ചെയ്യാൻ ശ്രമിക്കുന്നില്ല.

ലോഗ് ഔട്ട്പുട്ട്

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

ചെയ്യേണ്ടതായിരുന്നു യഥാർത്ഥ പരിഹാരം ഡോർക്കർ-കമ്പോസ് അപ് പതാകയില്ല -d, എന്നാൽ ഷെൽ കഴിവുകൾ ഉപയോഗിച്ച്, ഈ പ്രക്രിയ പശ്ചാത്തലത്തിലേക്ക് അയയ്ക്കുക:

docker-compose up <service> &

ഡോക്കറിൽ നിന്ന് ഒരു മൂന്നാം കക്ഷി സേവനത്തിലേക്ക് ലോഗുകൾ അയയ്ക്കുന്നത് വരെ ഇത് പ്രവർത്തിച്ചു. ഡോർക്കർ-കമ്പോസ് അപ് കൺസോളിലേക്ക് ലോഗുകൾ ഔട്ട്പുട്ട് ചെയ്യുന്നത് നിർത്തി. എന്നിരുന്നാലും, ടീം പ്രവർത്തിച്ചു ഡോക്കർ അറ്റാച്ചുചെയ്യുക.

തീരുമാനം:

docker attach --no-stdin ${COMPOSE_PROJECT_NAME}_<сервис>_1 &

ടെസ്റ്റ് ആവർത്തന സമയത്ത് ഐഡന്റിഫയർ വൈരുദ്ധ്യം

നിരവധി ആവർത്തനങ്ങളിൽ ടെസ്റ്റുകൾ നടത്തുന്നു. ഡാറ്റാബേസ് മായ്‌ച്ചിട്ടില്ല. ഡാറ്റാബേസിലെ റെക്കോർഡുകൾക്ക് അദ്വിതീയ ഐഡികളുണ്ട്. അഭ്യർത്ഥനകളിൽ ഞങ്ങൾ നിർദ്ദിഷ്ട ഐഡികൾ എഴുതിയാൽ, രണ്ടാമത്തെ ആവർത്തനത്തിൽ ഞങ്ങൾക്ക് ഒരു വൈരുദ്ധ്യം ലഭിക്കും.

അത് ഒഴിവാക്കാൻ, ഒന്നുകിൽ ഐഡികൾ അദ്വിതീയമായിരിക്കണം, അല്ലെങ്കിൽ ടെസ്റ്റ് സൃഷ്ടിച്ച എല്ലാ ഒബ്ജക്റ്റുകളും ഇല്ലാതാക്കണം. ആവശ്യകതകൾ കാരണം ചില വസ്തുക്കൾ ഇല്ലാതാക്കാൻ കഴിയില്ല.

തീരുമാനം: പോസ്റ്റ്മാൻ സ്ക്രിപ്റ്റുകൾ ഉപയോഗിച്ച് GUID-കൾ സൃഷ്ടിക്കുക.

var uuid = require('uuid');
var myid = uuid.v4();
pm.environment.set('myUUID', myid);

തുടർന്ന് ചോദ്യത്തിൽ ചിഹ്നം ഉപയോഗിക്കുക {{myUUID}}, അത് വേരിയബിളിന്റെ മൂല്യം ഉപയോഗിച്ച് മാറ്റിസ്ഥാപിക്കും.

LocalStack വഴിയുള്ള സഹകരണം

പരീക്ഷിക്കുന്ന സേവനം ഒരു SQS ക്യൂവിൽ വായിക്കുകയോ എഴുതുകയോ ചെയ്യുന്നുവെങ്കിൽ, ഇത് സ്ഥിരീകരിക്കുന്നതിന്, ഈ ക്യൂവിൽ ടെസ്റ്റ് തന്നെ പ്രവർത്തിക്കണം.

തീരുമാനം: പോസ്റ്റ്മാൻ മുതൽ ലോക്കൽസ്റ്റാക്കിലേക്കുള്ള അഭ്യർത്ഥനകൾ.

AWS സേവനങ്ങൾ API ഡോക്യുമെന്റ് ചെയ്‌തിരിക്കുന്നു, ഇത് ഒരു SDK ഇല്ലാതെ തന്നെ അന്വേഷണങ്ങൾ നടത്താൻ അനുവദിക്കുന്നു.

ഒരു സേവനം ഒരു ക്യൂവിലേക്ക് എഴുതുകയാണെങ്കിൽ, ഞങ്ങൾ അത് വായിക്കുകയും സന്ദേശത്തിന്റെ ഉള്ളടക്കം പരിശോധിക്കുകയും ചെയ്യും.

സേവനം SNS-ലേക്ക് സന്ദേശങ്ങൾ അയയ്ക്കുകയാണെങ്കിൽ, തയ്യാറെടുപ്പ് ഘട്ടത്തിൽ LocalStack ഒരു ക്യൂ സൃഷ്ടിക്കുകയും ഈ SNS വിഷയത്തിലേക്ക് സബ്‌സ്‌ക്രൈബ് ചെയ്യുകയും ചെയ്യുന്നു. അപ്പോൾ എല്ലാം മുകളിൽ വിവരിച്ചതിലേക്ക് വരുന്നു.

സേവനത്തിന് ക്യൂവിൽ നിന്ന് ഒരു സന്ദേശം വായിക്കണമെങ്കിൽ, മുമ്പത്തെ ടെസ്റ്റ് ഘട്ടത്തിൽ ഞങ്ങൾ ഈ സന്ദേശം ക്യൂവിൽ എഴുതുന്നു.

ടെസ്റ്റിന് കീഴിലുള്ള മൈക്രോസർവീസിൽ നിന്ന് ഉത്ഭവിക്കുന്ന HTTP അഭ്യർത്ഥനകൾ പരിശോധിക്കുന്നു

ചില സേവനങ്ങൾ AWS അല്ലാതെ മറ്റെന്തെങ്കിലും ഉപയോഗിച്ച് HTTP വഴി പ്രവർത്തിക്കുന്നു, കൂടാതെ ചില AWS സവിശേഷതകൾ LocalStack-ൽ നടപ്പിലാക്കിയിട്ടില്ല.

തീരുമാനം: ഈ സന്ദർഭങ്ങളിൽ ഇത് സഹായിക്കും മോക്ക്സെർവർ, അതിൽ ഒരു റെഡിമെയ്ഡ് ചിത്രമുണ്ട് ഡോക്കർ ഹബ്. പ്രതീക്ഷിക്കുന്ന അഭ്യർത്ഥനകളും അവയ്ക്കുള്ള പ്രതികരണങ്ങളും ഒരു HTTP അഭ്യർത്ഥന വഴി ക്രമീകരിച്ചിരിക്കുന്നു. API രേഖപ്പെടുത്തപ്പെട്ടിരിക്കുന്നു, അതിനാൽ ഞങ്ങൾ പോസ്റ്റ്മാനിൽ നിന്ന് അഭ്യർത്ഥനകൾ നടത്തുന്നു.

OAuth പ്രാമാണീകരണവും അംഗീകാരവും പരിശോധിക്കുന്നു

ഞങ്ങൾ OAuth ഉപയോഗിക്കുന്നു JSON വെബ് ടോക്കണുകൾ (JWT). പരിശോധനയ്ക്ക് ഞങ്ങൾക്ക് പ്രാദേശികമായി പ്രവർത്തിപ്പിക്കാൻ കഴിയുന്ന ഒരു OAuth ദാതാവ് ആവശ്യമാണ്.

സേവനവും OAuth ദാതാവും തമ്മിലുള്ള എല്ലാ ഇടപെടലുകളും രണ്ട് അഭ്യർത്ഥനകളിലേക്ക് വരുന്നു: ആദ്യം, കോൺഫിഗറേഷൻ അഭ്യർത്ഥിക്കുന്നു /.well-known/openid-configuration, തുടർന്ന് കോൺഫിഗറേഷനിൽ നിന്നുള്ള വിലാസത്തിൽ പൊതു കീ (JWKS) അഭ്യർത്ഥിക്കുന്നു. ഇതെല്ലാം സ്റ്റാറ്റിക് ഉള്ളടക്കമാണ്.

തീരുമാനം: ഞങ്ങളുടെ ടെസ്റ്റ് OAuth ദാതാവ് ഒരു സ്റ്റാറ്റിക് ഉള്ളടക്ക സെർവറും അതിൽ രണ്ട് ഫയലുകളുമാണ്. ടോക്കൺ ഒരിക്കൽ ജനറേറ്റ് ചെയ്യുകയും Git-ൽ പ്രതിജ്ഞാബദ്ധമാവുകയും ചെയ്യുന്നു.

സിഗ്നൽആർ ടെസ്റ്റിംഗിന്റെ സവിശേഷതകൾ

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

ഒരു സിഗ്നൽആർ ക്ലയന്റ് ഒരു ബ്രൗസർ മാത്രമല്ല. .NET Core-ന് കീഴിൽ അതിനായി ഒരു ക്ലയന്റ് ലൈബ്രറിയുണ്ട്. .NET Core-ൽ എഴുതിയ ക്ലയന്റ്, ഒരു കണക്ഷൻ സ്ഥാപിക്കുകയും, ആധികാരികത ഉറപ്പാക്കുകയും, സന്ദേശങ്ങളുടെ ഒരു പ്രത്യേക ശ്രേണിക്കായി കാത്തിരിക്കുകയും ചെയ്യുന്നു. ഒരു അപ്രതീക്ഷിത സന്ദേശം ലഭിക്കുകയോ കണക്ഷൻ നഷ്ടപ്പെടുകയോ ചെയ്താൽ, ക്ലയന്റ് 1 എന്ന കോഡ് ഉപയോഗിച്ച് പുറത്തുകടക്കുന്നു. അവസാനം പ്രതീക്ഷിച്ച സന്ദേശം ലഭിച്ചാൽ, 0 എന്ന കോഡ് ഉപയോഗിച്ച് ക്ലയന്റ് പുറത്തുകടക്കുന്നു.

ന്യൂമാൻ ക്ലയന്റുമായി ഒരേസമയം പ്രവർത്തിക്കുന്നു. സന്ദേശങ്ങൾ ആവശ്യമുള്ള എല്ലാവരിലേക്കും ഡെലിവർ ചെയ്തിട്ടുണ്ടോയെന്ന് പരിശോധിക്കാൻ നിരവധി ക്ലയന്റുകളെ സമാരംഭിച്ചു.

ഒന്നിലധികം ക്ലയന്റുകളെ പ്രവർത്തിപ്പിക്കുന്നതിന് ഓപ്ഷൻ ഉപയോഗിക്കുക --സ്കെയിൽ ഡോക്കർ-കമ്പോസ് കമാൻഡ് ലൈനിൽ.

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

തീരുമാനം: കണ്ടെയ്നറിലെ ക്ലയന്റ് മെക്കാനിസം ഉപയോഗിക്കുന്നു ഹെൽത്ത് ചെക്ക്ഹോസ്റ്റിലെ സ്ക്രിപ്റ്റിനെ അതിന്റെ സ്റ്റാറ്റസ് അറിയിക്കാൻ. കണക്ഷൻ സ്ഥാപിതമായ ഉടൻ തന്നെ ക്ലയന്റ് ഒരു നിർദ്ദിഷ്ട പാതയിൽ ഒരു ഫയൽ സൃഷ്ടിക്കുന്നു, /healthcheck എന്ന് പറയുക. ഡോക്കർ ഫയലിലെ HealthCheck സ്ക്രിപ്റ്റ് ഇതുപോലെ കാണപ്പെടുന്നു:

HEALTHCHECK --interval=3s CMD if [ ! -e /healthcheck ]; then false; fi

ടീം ഡോക്കർ പരിശോധന കണ്ടെയ്‌നറിന്റെ സാധാരണ നില, ആരോഗ്യ നില, എക്‌സിറ്റ് കോഡ് എന്നിവ കാണിക്കുന്നു.

ന്യൂമാൻ പൂർത്തിയാക്കിയ ശേഷം, കോഡ് 0 ഉപയോഗിച്ച് ക്ലയന്റുമായുള്ള എല്ലാ കണ്ടെയ്‌നറുകളും അവസാനിപ്പിച്ചിട്ടുണ്ടോയെന്ന് സ്‌ക്രിപ്റ്റ് പരിശോധിക്കുന്നു.

ഹാപ്പിന്നസ് നിലവിലുണ്ട്

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

ഈ ടെസ്റ്റുകൾ 30+ ഡെവലപ്പർമാരുടെ ഒരു ടീമിനെ പതിവായി വിന്യാസങ്ങളുള്ള 10+ മൈക്രോസർവീസുകളുടെ സങ്കീർണ്ണമായ ഇടപെടൽ ഉള്ള ഒരു ആപ്ലിക്കേഷനിലെ പിശകുകളിൽ നിന്ന് സംരക്ഷിക്കുന്നു.

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