Yandex.Cloud-ൽ ഞങ്ങൾ 10 ഇവന്റുകൾ സ്വീകരിക്കുന്നു. ഭാഗം 000

എല്ലാവർക്കും ഹലോ, സുഹൃത്തുക്കളേ!

* ഈ ലേഖനം REBRAIN & Yandex.Cloud ഓപ്പൺ വർക്ക്ഷോപ്പിനെ അടിസ്ഥാനമാക്കിയുള്ളതാണ്, നിങ്ങൾക്ക് വീഡിയോ കാണാൻ താൽപ്പര്യമുണ്ടെങ്കിൽ, ഈ ലിങ്കിൽ അത് കണ്ടെത്താനാകും - https://youtu.be/cZLezUm0ekE

Yandex.Cloud ലൈവ് പരീക്ഷിക്കാൻ ഞങ്ങൾക്ക് അടുത്തിടെ അവസരം ലഭിച്ചു. ദീർഘവും കഠിനവുമായ അന്വേഷണം നടത്താൻ ഞങ്ങൾ ആഗ്രഹിച്ചതിനാൽ, ക്ലൗഡ് ബേസ് ഉള്ള ഒരു ലളിതമായ വേർഡ്പ്രസ്സ് ബ്ലോഗ് സമാരംഭിക്കുക എന്ന ആശയം ഞങ്ങൾ ഉടൻ ഉപേക്ഷിച്ചു - ഇത് വളരെ വിരസമായിരുന്നു. കുറച്ച് ആലോചിച്ച ശേഷം, തത്സമയ മോഡിൽ ഇവന്റുകൾ സ്വീകരിക്കുന്നതിനും വിശകലനം ചെയ്യുന്നതിനുമായി പ്രൊഡക്ഷൻ സർവീസ് ആർക്കിടെക്ചറിന് സമാനമായ ഒന്ന് വിന്യസിക്കാൻ ഞങ്ങൾ തീരുമാനിച്ചു.

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

അതിനാൽ, ഞങ്ങളുടെ കഥ: ഞങ്ങൾ എങ്ങനെ ഗോലാംഗിൽ ഒരു ആപ്ലിക്കേഷൻ എഴുതി, കാഫ്ക vs rabbitmq vs yqs പരീക്ഷിച്ചു, ഒരു ക്ലിക്ക്ഹൗസ് ക്ലസ്റ്ററിൽ ഡാറ്റ സ്ട്രീമിംഗ് എഴുതി, yandex datalens ഉപയോഗിച്ച് ഡാറ്റ ദൃശ്യവൽക്കരിച്ചു. സ്വാഭാവികമായും, ഇതെല്ലാം ഡോക്കർ, ടെറാഫോം, ഗിറ്റ്‌ലാബ് സിഐ, തീർച്ചയായും പ്രോമിത്യൂസ് എന്നിവയുടെ രൂപത്തിലുള്ള ഇൻഫ്രാസ്ട്രക്ചർ ഡിലൈറ്റുകളാൽ രുചികരമായിരുന്നു. നമുക്ക് പോകാം!

ഒറ്റയിരിപ്പിൽ എല്ലാം ക്രമീകരിക്കാൻ ഞങ്ങൾക്ക് കഴിയില്ലെന്ന് ഉടൻ തന്നെ ഒരു റിസർവേഷൻ നടത്താൻ ഞാൻ ആഗ്രഹിക്കുന്നു - ഇതിനായി ഞങ്ങൾക്ക് പരമ്പരയിലെ നിരവധി ലേഖനങ്ങൾ ആവശ്യമാണ്. ഘടനയെക്കുറിച്ച് കുറച്ച്:

ഭാഗം 1 (നിങ്ങൾ ഇത് വായിക്കുന്നു). പരിഹാരത്തിന്റെ സവിശേഷതകളും വാസ്തുവിദ്യയും ഞങ്ങൾ തീരുമാനിക്കും, കൂടാതെ ഗോലാംഗിൽ ഒരു ആപ്ലിക്കേഷൻ എഴുതുകയും ചെയ്യും.
ഭാഗം 2. ഞങ്ങൾ ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ പ്രൊഡക്ഷനിലേക്ക് വിടുകയും അത് സ്കെയിലബിൾ ആക്കുകയും ലോഡ് പരിശോധിക്കുകയും ചെയ്യുന്നു.
ഭാഗം 3. എന്തുകൊണ്ടാണ് നമുക്ക് സന്ദേശങ്ങൾ ഫയലുകളിലല്ല ബഫറിൽ സംഭരിക്കേണ്ടതെന്ന് കണ്ടെത്താനും കാഫ്ക, റാബിറ്റ്എംക്യു, യാൻഡെക്സ് ക്യൂ സേവനങ്ങൾ എന്നിവ താരതമ്യം ചെയ്യാനും ശ്രമിക്കാം.
ഭാഗം 4 ഞങ്ങൾ ഒരു ക്ലിക്ക്ഹൗസ് ക്ലസ്റ്റർ വിന്യസിക്കും, അവിടെയുള്ള ബഫറിൽ നിന്ന് ഡാറ്റ കൈമാറാൻ ഒരു സ്ട്രീമിംഗ് സേവനം എഴുതുകയും ഡാറ്റാലെൻസിൽ വിഷ്വലൈസേഷൻ സജ്ജീകരിക്കുകയും ചെയ്യും.
ഭാഗം 5 നമുക്ക് മുഴുവൻ ഇൻഫ്രാസ്ട്രക്ചറും ശരിയായ രൂപത്തിലേക്ക് കൊണ്ടുവരാം - gitlab ci ഉപയോഗിച്ച് ci/cd സജ്ജീകരിക്കുക, പ്രോമിത്യൂസും കോൺസലും ഉപയോഗിച്ച് നിരീക്ഷണവും സേവന കണ്ടെത്തലും ബന്ധിപ്പിക്കുക.

ടി.കെ.

ആദ്യം, നമുക്ക് റഫറൻസ് നിബന്ധനകൾ രൂപപ്പെടുത്താം - ഫലമായി നമുക്ക് കൃത്യമായി എന്താണ് ലഭിക്കേണ്ടത്.

1. Events.kis.im (kis.im എന്നത് എല്ലാ ലേഖനങ്ങളിലും ഞങ്ങൾ ഉപയോഗിക്കുന്ന ടെസ്റ്റ് ഡൊമെയ്‌നാണ്) പോലെയുള്ള ഒരു എൻഡ്‌പോയിന്റ് ഉണ്ടായിരിക്കാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു, അത് HTTPS ഉപയോഗിച്ച് ഇവന്റുകൾ സ്വീകരിക്കും.
2. ഇവന്റുകൾ പോലെയുള്ള ലളിതമായ ഒരു json ആണ്: {“event”: “view”, “os”: “linux”, “browser”: “chrome”}. അവസാന ഘട്ടത്തിൽ ഞങ്ങൾ കുറച്ച് കൂടുതൽ ഫീൽഡുകൾ ചേർക്കും, പക്ഷേ ഇത് വലിയ പങ്ക് വഹിക്കില്ല. നിങ്ങൾക്ക് വേണമെങ്കിൽ, നിങ്ങൾക്ക് പ്രോട്ടോബഫിലേക്ക് മാറാം.
3. സേവനത്തിന് സെക്കൻഡിൽ 10 ഇവന്റുകൾ പ്രോസസ്സ് ചെയ്യാൻ കഴിയണം.
4. ഞങ്ങളുടെ പരിഹാരത്തിലേക്ക് പുതിയ സംഭവങ്ങൾ ചേർത്തുകൊണ്ട് തിരശ്ചീനമായി സ്കെയിൽ ചെയ്യാൻ സാധിക്കണം. ക്ലയന്റ് അഭ്യർത്ഥനകൾക്കുള്ള കാലതാമസം കുറയ്ക്കുന്നതിന് മുൻഭാഗം വ്യത്യസ്‌ത ജിയോലൊക്കേഷനുകളിലേക്ക് നീക്കാൻ കഴിയുമെങ്കിൽ അത് നന്നായിരിക്കും.
5. തെറ്റ് സഹിഷ്ണുത. പരിഹാരം വേണ്ടത്ര സ്ഥിരതയുള്ളതും ഏതെങ്കിലും ഭാഗങ്ങളുടെ വീഴ്ചയെ അതിജീവിക്കാൻ കഴിയുന്നതും ആയിരിക്കണം (ഒരു നിശ്ചിത എണ്ണം വരെ, തീർച്ചയായും).

വാസ്തുവിദ്യ

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

അതിനാൽ നമുക്ക് എന്താണ് ഉള്ളത്:

1. സ്‌മാർട്ട്‌ഫോണിലെ കളിപ്പാട്ടത്തിൽ ഒരു ലെവൽ പൂർത്തിയാക്കുന്ന കളിക്കാരോ സാധാരണ ബ്രൗസറിലൂടെ ഒരു ഓൺലൈൻ സ്റ്റോറിൽ ഒരു ഓർഡർ സൃഷ്‌ടിക്കുന്നതോ ആകട്ടെ, വിവിധ ഇവന്റുകൾ സൃഷ്‌ടിക്കുന്ന ഞങ്ങളുടെ ഉപകരണങ്ങൾ ഇടതുവശത്താണ്. സ്പെസിഫിക്കേഷനിൽ വ്യക്തമാക്കിയിട്ടുള്ള ഒരു ഇവന്റ്, ഞങ്ങളുടെ അവസാന പോയിന്റിലേക്ക് അയയ്ക്കുന്ന ഒരു ലളിതമായ json ആണ് - events.kis.im.

2. ആദ്യത്തെ രണ്ട് സെർവറുകൾ ലളിതമായ ബാലൻസറുകളാണ്, അവയുടെ പ്രധാന ജോലികൾ ഇവയാണ്:

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

3. ബാലൻസറുകൾക്ക് ശേഷം, ഞങ്ങൾക്ക് വളരെ ലളിതമായ ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്ന ആപ്ലിക്കേഷൻ സെർവറുകൾ ഉണ്ട്. ഇതിന് HTTP വഴി ഇൻകമിംഗ് അഭ്യർത്ഥനകൾ സ്വീകരിക്കാനും അയച്ച json സാധൂകരിക്കാനും ഡാറ്റ ഒരു ബഫറിൽ ഇടാനും കഴിയണം.

4. ഡയഗ്രം കാഫ്കയെ ഒരു ബഫറായി കാണിക്കുന്നു, എന്നിരുന്നാലും, തീർച്ചയായും, സമാനമായ മറ്റ് സേവനങ്ങൾ ഈ തലത്തിൽ ഉപയോഗിക്കാനാകും. ഞങ്ങൾ മൂന്നാം ലേഖനത്തിൽ കാഫ്ക, rabbitmq, yqs എന്നിവ താരതമ്യം ചെയ്യും.

5. ഞങ്ങളുടെ ആർക്കിടെക്ചറിന്റെ അവസാന പോയിന്റ് ക്ലിക്ക്ഹൗസ് ആണ് - ഒരു വലിയ അളവിലുള്ള ഡാറ്റ സംഭരിക്കാനും പ്രോസസ്സ് ചെയ്യാനും നിങ്ങളെ അനുവദിക്കുന്ന ഒരു കോളം ഡാറ്റാബേസ്. ഈ തലത്തിൽ, ഞങ്ങൾ ബഫറിൽ നിന്ന് സ്റ്റോറേജ് സിസ്റ്റത്തിലേക്ക് തന്നെ ഡാറ്റ കൈമാറേണ്ടതുണ്ട് (ഇതിനെക്കുറിച്ച് കൂടുതൽ ലേഖനം 4 ൽ).

ഓരോ പാളിയും സ്വതന്ത്രമായി തിരശ്ചീനമായി സ്കെയിൽ ചെയ്യാൻ ഈ ഡിസൈൻ ഞങ്ങളെ അനുവദിക്കുന്നു. ബാക്കെൻഡ് സെർവറുകൾക്ക് നേരിടാൻ കഴിയില്ല - നമുക്ക് ഒരു കാര്യം കൂടി ചേർക്കാം - എല്ലാത്തിനുമുപരി, അവ സ്‌റ്റേറ്റ്‌ലെസ് ആപ്ലിക്കേഷനുകളാണ്, അതിനാൽ ഇത് യാന്ത്രികമായി പോലും ചെയ്യാൻ കഴിയും. കാഫ്ക ശൈലിയിലുള്ള ബഫർ പ്രവർത്തിക്കുന്നില്ല-നമുക്ക് കൂടുതൽ സെർവറുകൾ ചേർക്കുകയും നമ്മുടെ വിഷയത്തിന്റെ ചില പാർട്ടീഷനുകൾ അവയിലേക്ക് മാറ്റുകയും ചെയ്യാം. Clickhouse-ന് ഇത് കൈകാര്യം ചെയ്യാൻ കഴിയില്ല - ഇത് അസാധ്യമാണ് :) വാസ്തവത്തിൽ, ഞങ്ങൾ സെർവറുകൾ കണക്റ്റുചെയ്‌ത് ഡാറ്റ പങ്കിടുകയും ചെയ്യും.

വഴിയിൽ, വ്യത്യസ്ത ജിയോലൊക്കേഷനുകളിൽ ഞങ്ങളുടെ സാങ്കേതിക സവിശേഷതകളുടെയും സ്കെയിലിന്റെയും ഓപ്ഷണൽ ഭാഗം നടപ്പിലാക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ലളിതമായി ഒന്നുമില്ല:

ഓരോ ജിയോലൊക്കേഷനിലും ഞങ്ങൾ ആപ്ലിക്കേഷനും കാഫ്കയും ഉള്ള ഒരു ലോഡ് ബാലൻസർ വിന്യസിക്കുന്നു. പൊതുവേ, 2 ആപ്ലിക്കേഷൻ സെർവറുകൾ, 3 കാഫ്ക നോഡുകൾ, ഒരു ക്ലൗഡ് ബാലൻസർ എന്നിവ മതി, ഉദാഹരണത്തിന്, ക്ലൗഡ്ഫ്ലെയർ, ഇത് ക്ലയന്റിന്റെ ഉറവിട ഐപി വിലാസത്തെ അടിസ്ഥാനമാക്കി ജിയോലൊക്കേഷൻ വഴി ആപ്ലിക്കേഷൻ നോഡുകളുടെയും ബാലൻസ് അഭ്യർത്ഥനകളുടെയും ലഭ്യത പരിശോധിക്കും. അങ്ങനെ, ഒരു അമേരിക്കൻ ക്ലയന്റ് അയച്ച ഡാറ്റ അമേരിക്കൻ സെർവറുകളിൽ എത്തും. ആഫ്രിക്കയിൽ നിന്നുള്ള ഡാറ്റ ആഫ്രിക്കൻ ഭാഷയിലാണ്.

അപ്പോൾ എല്ലാം വളരെ ലളിതമാണ് - ഞങ്ങൾ കാഫ്ക സെറ്റിൽ നിന്നുള്ള മിറർ ടൂൾ ഉപയോഗിക്കുന്നു കൂടാതെ എല്ലാ സ്ഥലങ്ങളിൽ നിന്നുമുള്ള എല്ലാ ഡാറ്റയും റഷ്യയിൽ സ്ഥിതിചെയ്യുന്ന ഞങ്ങളുടെ കേന്ദ്ര ഡാറ്റാ സെന്ററിലേക്ക് പകർത്തുന്നു. ആന്തരികമായി, ഞങ്ങൾ ഡാറ്റ പാഴ്‌സ് ചെയ്യുകയും തുടർന്നുള്ള ദൃശ്യവൽക്കരണത്തിനായി ക്ലിക്ക്ഹൗസിൽ രേഖപ്പെടുത്തുകയും ചെയ്യുന്നു.

അതിനാൽ, ഞങ്ങൾ വാസ്തുവിദ്യ ക്രമീകരിച്ചു - നമുക്ക് Yandex.Cloud കുലുക്കാൻ തുടങ്ങാം!

ഒരു അപേക്ഷ എഴുതുന്നു

ക്ലൗഡിന് മുമ്പ്, ഇൻകമിംഗ് ഇവന്റുകൾ പ്രോസസ്സ് ചെയ്യുന്നതിന് നിങ്ങൾ അൽപ്പം ക്ഷമയോടെയിരിക്കുകയും വളരെ ലളിതമായ ഒരു സേവനം എഴുതുകയും വേണം. ഞങ്ങൾ golang ഉപയോഗിക്കും, കാരണം അത് നെറ്റ്‌വർക്ക് ആപ്ലിക്കേഷനുകൾ എഴുതുന്നതിനുള്ള ഒരു ഭാഷയായി സ്വയം തെളിയിച്ചിട്ടുണ്ട്.

ഒരു മണിക്കൂർ ചെലവഴിച്ചതിന് ശേഷം (ഒരുപക്ഷേ രണ്ട് മണിക്കൂർ), ഞങ്ങൾക്ക് ഇതുപോലൊന്ന് ലഭിക്കും: https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/main.go.

ഞാൻ ഇവിടെ ശ്രദ്ധിക്കാൻ ആഗ്രഹിക്കുന്ന പ്രധാന പോയിന്റുകൾ എന്തൊക്കെയാണ്:

1. ആപ്ലിക്കേഷൻ ആരംഭിക്കുമ്പോൾ, നിങ്ങൾക്ക് രണ്ട് ഫ്ലാഗുകൾ വ്യക്തമാക്കാം. ഇൻകമിംഗ് http അഭ്യർത്ഥനകൾ (-addr) ഞങ്ങൾ ശ്രദ്ധിക്കുന്ന പോർട്ടിന്റെ ഉത്തരവാദിത്തം ഒരാളാണ്. രണ്ടാമത്തേത് കാഫ്ക സെർവർ വിലാസത്തിനായുള്ളതാണ്, അവിടെ ഞങ്ങൾ ഞങ്ങളുടെ ഇവന്റുകൾ രേഖപ്പെടുത്തും (-കാഫ്ക):

addr     = flag.String("addr", ":8080", "TCP address to listen to")
kafka    = flag.String("kafka", "127.0.0.1:9092", "Kafka endpoints”)

2. ആപ്ലിക്കേഷൻ സാരമ ലൈബ്രറി ഉപയോഗിക്കുന്നു ([] github.com/Shopify/saram) കാഫ്ക ക്ലസ്റ്ററിലേക്ക് സന്ദേശങ്ങൾ അയക്കാൻ. പരമാവധി പ്രോസസ്സിംഗ് വേഗത ലക്ഷ്യമിട്ട് ഞങ്ങൾ ഉടൻ തന്നെ ക്രമീകരണങ്ങൾ സജ്ജമാക്കി:

config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal
config.Producer.Compression = sarama.CompressionSnappy
config.Producer.Return.Successes = true

3. ഞങ്ങളുടെ ആപ്ലിക്കേഷനിൽ ഒരു ബിൽറ്റ്-ഇൻ പ്രോമിത്യൂസ് ക്ലയന്റ് ഉണ്ട്, അത് ഇനിപ്പറയുന്നതുപോലുള്ള വിവിധ അളവുകൾ ശേഖരിക്കുന്നു:

• ഞങ്ങളുടെ അപേക്ഷയിലേക്കുള്ള അഭ്യർത്ഥനകളുടെ എണ്ണം;
• അഭ്യർത്ഥന നടപ്പിലാക്കുമ്പോൾ പിശകുകളുടെ എണ്ണം (പോസ്റ്റ് അഭ്യർത്ഥന വായിക്കുന്നത് അസാധ്യമാണ്, തകർന്ന json, കാഫ്കയിലേക്ക് എഴുതുന്നത് അസാധ്യമാണ്);
• ക്ലയന്റിൽ നിന്നുള്ള ഒരു അഭ്യർത്ഥനയുടെ പ്രോസസ്സിംഗ് സമയം, കാഫ്കയ്ക്ക് ഒരു സന്ദേശം എഴുതുന്നതിനുള്ള സമയം ഉൾപ്പെടെ.

4. ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ പ്രോസസ്സ് ചെയ്യുന്ന മൂന്ന് എൻഡ് പോയിന്റുകൾ:

• / സ്റ്റാറ്റസ് - നമ്മൾ ജീവിച്ചിരിപ്പുണ്ടെന്ന് കാണിക്കാൻ ശരി എന്ന് തിരികെ നൽകുക. കാഫ്ക ക്ലസ്റ്ററിന്റെ ലഭ്യത പോലുള്ള ചില പരിശോധനകൾ നിങ്ങൾക്ക് ചേർക്കാമെങ്കിലും.
• /മെട്രിക്സ് - ഈ യുആർഎൽ അനുസരിച്ച്, പ്രോമിത്യൂസ് ക്ലയന്റ് അത് ശേഖരിച്ച അളവുകൾ തിരികെ നൽകും.
• json ഉള്ളിലുള്ള POST അഭ്യർത്ഥനകൾ അയയ്‌ക്കുന്ന പ്രധാന അവസാന പോയിന്റാണ് / പോസ്റ്റ്. ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ സാധുതയ്ക്കായി json പരിശോധിക്കുന്നു, എല്ലാം ശരിയാണെങ്കിൽ, അത് കാഫ്ക ക്ലസ്റ്ററിലേക്ക് ഡാറ്റ എഴുതുന്നു.

കോഡ് പൂർണ്ണമല്ലെന്ന് ഞാൻ ഒരു റിസർവേഷൻ നടത്തും - അത് പൂർത്തിയാക്കാൻ കഴിയും (കൂടാതെ വേണം!). ഉദാഹരണത്തിന്, നിങ്ങൾക്ക് ബിൽറ്റ്-ഇൻ നെറ്റ്/http ഉപയോഗിക്കുന്നത് നിർത്തി വേഗതയേറിയ fasthttp-യിലേക്ക് മാറാം. അല്ലെങ്കിൽ json വാലിഡിറ്റി പരിശോധന പിന്നീടുള്ള ഘട്ടത്തിലേക്ക് മാറ്റുന്നതിലൂടെ നിങ്ങൾക്ക് പ്രോസസ്സിംഗ് സമയവും cpu ഉറവിടങ്ങളും നേടാനാകും - ഡാറ്റ ബഫറിൽ നിന്ന് ക്ലിക്ക്ഹൗസ് ക്ലസ്റ്ററിലേക്ക് മാറ്റുമ്പോൾ.

പ്രശ്നത്തിന്റെ വികസന വശത്തിന് പുറമേ, ഞങ്ങളുടെ ഭാവി ഇൻഫ്രാസ്ട്രക്ചറിനെക്കുറിച്ച് ഞങ്ങൾ ഉടൻ ചിന്തിക്കുകയും ഡോക്കർ വഴി ഞങ്ങളുടെ അപേക്ഷ വിന്യസിക്കാൻ തീരുമാനിക്കുകയും ചെയ്തു. ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനുള്ള അവസാന ഡോക്കർഫയൽ https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/Dockerfile. പൊതുവേ, ഇത് വളരെ ലളിതമാണ്, ഞാൻ ശ്രദ്ധിക്കാൻ ആഗ്രഹിക്കുന്ന ഒരേയൊരു കാര്യം മൾട്ടിസ്റ്റേജ് അസംബ്ലിയാണ്, ഇത് ഞങ്ങളുടെ കണ്ടെയ്നറിന്റെ അന്തിമ ചിത്രം കുറയ്ക്കാൻ ഞങ്ങളെ അനുവദിക്കുന്നു.

ക്ലൗഡിലെ ആദ്യ ചുവടുകൾ

ആദ്യം, രജിസ്റ്റർ ചെയ്യുക cloud.yandex.ru. ആവശ്യമായ എല്ലാ ഫീൽഡുകളും പൂരിപ്പിച്ച ശേഷം, ഞങ്ങൾ ഒരു അക്കൗണ്ട് സൃഷ്ടിക്കുകയും ക്ലൗഡ് സേവനങ്ങൾ പരീക്ഷിക്കാൻ ഉപയോഗിക്കാവുന്ന ഒരു നിശ്ചിത തുകയ്ക്ക് ഗ്രാന്റ് നൽകുകയും ചെയ്യും. ഞങ്ങളുടെ ലേഖനത്തിൽ നിന്നുള്ള എല്ലാ ഘട്ടങ്ങളും ആവർത്തിക്കാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, ഈ ഗ്രാന്റ് നിങ്ങൾക്ക് മതിയാകും.

രജിസ്ട്രേഷനുശേഷം, നിങ്ങൾക്കായി ഒരു പ്രത്യേക ക്ലൗഡും സ്ഥിരസ്ഥിതി ഡയറക്ടറിയും സൃഷ്ടിക്കപ്പെടും, അതിൽ നിങ്ങൾക്ക് ക്ലൗഡ് ഉറവിടങ്ങൾ സൃഷ്ടിക്കാൻ തുടങ്ങാം. പൊതുവേ, Yandex.Cloud-ൽ, വിഭവങ്ങളുടെ ബന്ധം ഇതുപോലെ കാണപ്പെടുന്നു:

ഒരു അക്കൗണ്ടിനായി നിങ്ങൾക്ക് നിരവധി ക്ലൗഡുകൾ സൃഷ്ടിക്കാൻ കഴിയും. ക്ലൗഡിനുള്ളിൽ, വ്യത്യസ്ത കമ്പനി പ്രോജക്റ്റുകൾക്കായി വ്യത്യസ്ത ഡയറക്ടറികൾ ഉണ്ടാക്കുക. ഡോക്യുമെന്റേഷനിൽ നിങ്ങൾക്ക് ഇതിനെക്കുറിച്ച് കൂടുതൽ വായിക്കാം - https://cloud.yandex.ru/docs/resource-manager/concepts/resources-hierarchy. വഴിയിൽ, ഞാൻ പലപ്പോഴും അത് വാചകത്തിൽ താഴെ പരാമർശിക്കും. ഞാൻ ആദ്യം മുതൽ മുഴുവൻ ഇൻഫ്രാസ്ട്രക്ചറും സജ്ജീകരിച്ചപ്പോൾ, ഡോക്യുമെന്റേഷൻ എന്നെ ഒന്നിലധികം തവണ സഹായിച്ചു, അതിനാൽ അത് പഠിക്കാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു.

ക്ലൗഡ് മാനേജ് ചെയ്യാൻ, നിങ്ങൾക്ക് വെബ് ഇന്റർഫേസും കൺസോൾ യൂട്ടിലിറ്റിയും ഉപയോഗിക്കാം - yc. ഒരു കമാൻഡ് ഉപയോഗിച്ചാണ് ഇൻസ്റ്റലേഷൻ നടത്തുന്നത് (ലിനക്സിനും മാക് ഓസിനും):

curl https://storage.yandexcloud.net/yandexcloud-yc/install.sh | bash

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

നിങ്ങൾക്ക് വിൻഡോസിനായി ഒരു ക്ലയന്റ് ഇൻസ്റ്റാൾ ചെയ്യണമെങ്കിൽ, നിങ്ങൾക്ക് നിർദ്ദേശങ്ങൾ ഉപയോഗിക്കാം ഇവിടെ എന്നിട്ട് എക്സിക്യൂട്ട് ചെയ്യുക yc initഇത് പൂർണ്ണമായും ഇച്ഛാനുസൃതമാക്കാൻ:

vozerov@mba:~ $ yc init
Welcome! This command will take you through the configuration process.
Please go to https://oauth.yandex.ru/authorize?response_type=token&client_id= in order to obtain OAuth token.

Please enter OAuth token:
Please select cloud to use:
 [1] cloud-b1gv67ihgfu3bp (id = b1gv67ihgfu3bpt24o0q)
 [2] fevlake-cloud (id = b1g6bvup3toribomnh30)
Please enter your numeric choice: 2
Your current cloud has been set to 'fevlake-cloud' (id = b1g6bvup3toribomnh30).
Please choose folder to use:
 [1] default (id = b1g5r6h11knotfr8vjp7)
 [2] Create a new folder
Please enter your numeric choice: 1
Your current folder has been set to 'default' (id = b1g5r6h11knotfr8vjp7).
Do you want to configure a default Compute zone? [Y/n]
Which zone do you want to use as a profile default?
 [1] ru-central1-a
 [2] ru-central1-b
 [3] ru-central1-c
 [4] Don't set default zone
Please enter your numeric choice: 1
Your profile default Compute zone has been set to 'ru-central1-a'.
vozerov@mba:~ $

തത്വത്തിൽ, പ്രക്രിയ ലളിതമാണ് - ആദ്യം നിങ്ങൾ ക്ലൗഡ് നിയന്ത്രിക്കുന്നതിന് ഒരു ഓത്ത് ടോക്കൺ നേടേണ്ടതുണ്ട്, ക്ലൗഡും നിങ്ങൾ ഉപയോഗിക്കുന്ന ഫോൾഡറും തിരഞ്ഞെടുക്കുക.

ഒരേ ക്ലൗഡിനുള്ളിൽ നിങ്ങൾക്ക് നിരവധി അക്കൗണ്ടുകളോ ഫോൾഡറുകളോ ഉണ്ടെങ്കിൽ, yc കോൺഫിഗറേഷൻ പ്രൊഫൈൽ സൃഷ്‌ടിച്ച് അവയ്‌ക്കിടയിൽ മാറുന്നതിലൂടെ പ്രത്യേക ക്രമീകരണങ്ങളുള്ള അധിക പ്രൊഫൈലുകൾ സൃഷ്‌ടിക്കാം.

മേൽപ്പറഞ്ഞ രീതികൾക്ക് പുറമേ, Yandex.Cloud ടീം വളരെ നന്നായി എഴുതി ടെറാഫോമിനുള്ള പ്ലഗിൻ ക്ലൗഡ് ഉറവിടങ്ങൾ കൈകാര്യം ചെയ്യുന്നതിന്. എന്റെ ഭാഗത്ത്, ഞാൻ ഒരു ജിറ്റ് ശേഖരം തയ്യാറാക്കി, അവിടെ ലേഖനത്തിന്റെ ഭാഗമായി സൃഷ്ടിക്കുന്ന എല്ലാ വിഭവങ്ങളും ഞാൻ വിവരിച്ചു - https://github.com/rebrainme/yandex-cloud-events/. ഞങ്ങൾക്ക് മാസ്റ്റർ ബ്രാഞ്ചിൽ താൽപ്പര്യമുണ്ട്, നമുക്ക് അത് പ്രാദേശികമായി ക്ലോൺ ചെയ്യാം:

vozerov@mba:~ $ git clone https://github.com/rebrainme/yandex-cloud-events/ events
Cloning into 'events'...
remote: Enumerating objects: 100, done.
remote: Counting objects: 100% (100/100), done.
remote: Compressing objects: 100% (68/68), done.
remote: Total 100 (delta 37), reused 89 (delta 26), pack-reused 0
Receiving objects: 100% (100/100), 25.65 KiB | 168.00 KiB/s, done.
Resolving deltas: 100% (37/37), done.
vozerov@mba:~ $ cd events/terraform/

ടെറാഫോമിൽ ഉപയോഗിക്കുന്ന എല്ലാ പ്രധാന വേരിയബിളുകളും main.tf ഫയലിൽ എഴുതിയിരിക്കുന്നു. ആരംഭിക്കുന്നതിന്, ടെറാഫോം ഫോൾഡറിൽ ഇനിപ്പറയുന്ന ഉള്ളടക്കമുള്ള ഒരു private.auto.tfvars ഫയൽ സൃഷ്‌ടിക്കുക:

# Yandex Cloud Oauth token
yc_token = ""
# Yandex Cloud ID
yc_cloud_id = ""
# Yandex Cloud folder ID
yc_folder_id = ""
# Default Yandex Cloud Region
yc_region = "ru-central1-a"
# Cloudflare email
cf_email = ""
# Cloudflare token
cf_token = ""
# Cloudflare zone id
cf_zone_id = ""

ഞങ്ങൾ ഇതിനകം കൺസോൾ യൂട്ടിലിറ്റി ക്രമീകരിച്ചിരിക്കുന്നതിനാൽ എല്ലാ വേരിയബിളുകളും yc config ലിസ്റ്റിൽ നിന്ന് എടുക്കാം. സ്വകാര്യ ഡാറ്റ അബദ്ധത്തിൽ പ്രസിദ്ധീകരിക്കാതിരിക്കാൻ, .gitignore-ലേക്ക് ഉടൻ തന്നെ private.auto.tfvars ചേർക്കാൻ ഞാൻ നിങ്ങളെ ഉപദേശിക്കുന്നു.

private.auto.tfvars-ൽ ഞങ്ങൾ Cloudflare-ൽ നിന്നുള്ള ഡാറ്റയും വ്യക്തമാക്കിയിട്ടുണ്ട് - DNS റെക്കോർഡുകൾ സൃഷ്‌ടിക്കാനും ഞങ്ങളുടെ സെർവറുകളിലേക്ക് events.kis.im എന്ന പ്രധാന ഡൊമെയ്‌ൻ പ്രോക്‌സി ചെയ്യാനും. നിങ്ങൾക്ക് ക്ലൗഡ്ഫ്ലെയർ ഉപയോഗിക്കാൻ താൽപ്പര്യമില്ലെങ്കിൽ, main.tf-ലും ആവശ്യമായ dns റെക്കോർഡുകൾ സൃഷ്‌ടിക്കുന്നതിന് ഉത്തരവാദിയായ dns.tf ഫയലിലും ക്ലൗഡ്ഫ്ലെയർ പ്രൊവൈഡറിന്റെ സമാരംഭം നീക്കം ചെയ്യുക.

ഞങ്ങളുടെ ജോലിയിൽ ഞങ്ങൾ മൂന്ന് രീതികളും സംയോജിപ്പിക്കും - വെബ് ഇന്റർഫേസ്, കൺസോൾ യൂട്ടിലിറ്റി, ടെറാഫോം.

വെർച്വൽ നെറ്റ്‌വർക്കുകൾ

സത്യം പറഞ്ഞാൽ, നിങ്ങൾക്ക് ഈ ഘട്ടം ഒഴിവാക്കാം, കാരണം നിങ്ങൾ ഒരു പുതിയ ക്ലൗഡ് സൃഷ്‌ടിക്കുമ്പോൾ, നിങ്ങൾക്ക് സ്വയമേവ ഒരു പ്രത്യേക നെറ്റ്‌വർക്കും സൃഷ്‌ടിച്ച 3 സബ്‌നെറ്റുകളും ഉണ്ടാകും - ഓരോ ലഭ്യത മേഖലയ്ക്കും ഒന്ന്. എന്നാൽ ഞങ്ങളുടെ പ്രോജക്റ്റിനായി അതിന്റേതായ വിലാസം ഉപയോഗിച്ച് ഒരു പ്രത്യേക നെറ്റ്‌വർക്ക് നിർമ്മിക്കാൻ ഞങ്ങൾ ഇപ്പോഴും ആഗ്രഹിക്കുന്നു. Yandex.Cloud-ൽ നെറ്റ്‌വർക്ക് എങ്ങനെ പ്രവർത്തിക്കുന്നു എന്നതിന്റെ പൊതുവായ ഡയഗ്രം ചുവടെയുള്ള ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നു (സത്യസന്ധമായി എടുത്തത് https://cloud.yandex.ru/docs/vpc/concepts/)

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

നെറ്റ്‌വർക്ക് സൃഷ്‌ടിക്കൽ റിപ്പോസിറ്ററിയിൽ നിന്നുള്ള network.tf ഫയലിൽ വിവരിച്ചിരിക്കുന്നു. അവിടെ ഞങ്ങൾ ഒരു പൊതു സ്വകാര്യ നെറ്റ്‌വർക്ക് ഇന്റേണൽ സൃഷ്‌ടിക്കുകയും അതിലേക്ക് വ്യത്യസ്ത ലഭ്യത സോണുകളിൽ മൂന്ന് സബ്‌നെറ്റുകളെ ബന്ധിപ്പിക്കുകയും ചെയ്യുന്നു - ഇന്റേണൽ-എ (172.16.1.0/24), ഇന്റേണൽ-ബി (172.16.2.0/24), ഇന്റേണൽ-സി (172.16.3.0/24). ).

ടെറാഫോം ആരംഭിച്ച് നെറ്റ്‌വർക്കുകൾ സൃഷ്ടിക്കുക:

vozerov@mba:~/events/terraform (master) $ terraform init
... skipped ..

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_vpc_subnet.internal-a -target yandex_vpc_subnet.internal-b -target yandex_vpc_subnet.internal-c

... skipped ...

Plan: 4 to add, 0 to change, 0 to destroy.

Do you want to perform these actions?
  Terraform will perform the actions described above.
  Only 'yes' will be accepted to approve.

  Enter a value: yes

yandex_vpc_network.internal: Creating...
yandex_vpc_network.internal: Creation complete after 3s [id=enp2g2rhile7gbqlbrkr]
yandex_vpc_subnet.internal-a: Creating...
yandex_vpc_subnet.internal-b: Creating...
yandex_vpc_subnet.internal-c: Creating...
yandex_vpc_subnet.internal-a: Creation complete after 6s [id=e9b1dad6mgoj2v4funog]
yandex_vpc_subnet.internal-b: Creation complete after 7s [id=e2liv5i4amu52p64ac9p]
yandex_vpc_subnet.internal-c: Still creating... [10s elapsed]
yandex_vpc_subnet.internal-c: Creation complete after 10s [id=b0c2qhsj2vranoc9vhcq]

Apply complete! Resources: 4 added, 0 changed, 0 destroyed.

കൊള്ളാം! ഞങ്ങൾ ഞങ്ങളുടെ നെറ്റ്‌വർക്ക് സൃഷ്ടിച്ചു, ഇപ്പോൾ ഞങ്ങളുടെ ആന്തരിക സേവനങ്ങൾ സൃഷ്ടിക്കാൻ തയ്യാറാണ്.

വെർച്വൽ മെഷീനുകൾ സൃഷ്ടിക്കുന്നു

ആപ്ലിക്കേഷൻ പരിശോധിക്കുന്നതിന്, ഞങ്ങൾക്ക് രണ്ട് വെർച്വൽ മെഷീനുകൾ മാത്രമേ സൃഷ്ടിക്കേണ്ടതുള്ളൂ - ആപ്ലിക്കേഷൻ നിർമ്മിക്കുന്നതിനും പ്രവർത്തിപ്പിക്കുന്നതിനും ഞങ്ങൾക്ക് ആദ്യത്തേത് ആവശ്യമാണ്, രണ്ടാമത്തേത് കാഫ്ക പ്രവർത്തിപ്പിക്കുന്നതിന്, ഞങ്ങൾ ഇൻകമിംഗ് സന്ദേശങ്ങൾ സംഭരിക്കുന്നതിന് ഇത് ഉപയോഗിക്കും. ഞങ്ങൾ മറ്റൊരു മെഷീൻ സൃഷ്ടിക്കും, അവിടെ ഞങ്ങൾ ആപ്ലിക്കേഷൻ നിരീക്ഷിക്കാൻ പ്രോമിത്യൂസ് ക്രമീകരിക്കും.

വെർച്വൽ മെഷീനുകൾ അൻസിബിൾ ഉപയോഗിച്ച് കോൺഫിഗർ ചെയ്യപ്പെടും, അതിനാൽ ടെറാഫോം ആരംഭിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾക്ക് അൻസിബിളിന്റെ ഏറ്റവും പുതിയ പതിപ്പുകളിലൊന്ന് ഉണ്ടെന്ന് ഉറപ്പാക്കുക. അൻസിബിൾ ഗാലക്സി ഉപയോഗിച്ച് ആവശ്യമായ റോളുകൾ ഇൻസ്റ്റാൾ ചെയ്യുക:

vozerov@mba:~/events/terraform (master) $ cd ../ansible/
vozerov@mba:~/events/ansible (master) $ ansible-galaxy install -r requirements.yml
- cloudalchemy-prometheus (master) is already installed, skipping.
- cloudalchemy-grafana (master) is already installed, skipping.
- sansible.kafka (master) is already installed, skipping.
- sansible.zookeeper (master) is already installed, skipping.
- geerlingguy.docker (master) is already installed, skipping.
vozerov@mba:~/events/ansible (master) $

ansible ഫോൾഡറിനുള്ളിൽ ഞാൻ ഉപയോഗിക്കുന്ന ഒരു ഉദാഹരണം .ansible.cfg കോൺഫിഗറേഷൻ ഫയൽ ഉണ്ട്. അത് പ്രയോജനപ്പെട്ടേക്കാം.

വെർച്വൽ മെഷീനുകൾ സൃഷ്‌ടിക്കുന്നതിന് മുമ്പ്, നിങ്ങൾക്ക് ssh-ഏജന്റ് റണ്ണിംഗ് ഉണ്ടെന്നും ഒരു ssh കീ ചേർത്തിട്ടുണ്ടെന്നും ഉറപ്പാക്കുക, അല്ലാത്തപക്ഷം സൃഷ്‌ടിച്ച മെഷീനുകളിലേക്ക് ടെറാഫോമിന് കണക്റ്റുചെയ്യാൻ കഴിയില്ല. തീർച്ചയായും, ഞാൻ os x-ൽ ഒരു ബഗ് കണ്ടു: https://github.com/ansible/ansible/issues/32499#issuecomment-341578864. ഇത് വീണ്ടും സംഭവിക്കുന്നത് തടയാൻ, Terraform സമാരംഭിക്കുന്നതിന് മുമ്പ് env-ലേക്ക് ഒരു ചെറിയ വേരിയബിൾ ചേർക്കുക:

vozerov@mba:~/events/terraform (master) $ export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES

ടെറാഫോം ഉള്ള ഫോൾഡറിൽ ഞങ്ങൾ ആവശ്യമായ ഉറവിടങ്ങൾ സൃഷ്ടിക്കുന്നു:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_compute_instance.build -target yandex_compute_instance.monitoring -target yandex_compute_instance.kafka
yandex_vpc_network.internal: Refreshing state... [id=enp2g2rhile7gbqlbrkr]
data.yandex_compute_image.ubuntu_image: Refreshing state...
yandex_vpc_subnet.internal-a: Refreshing state... [id=e9b1dad6mgoj2v4funog]

An execution plan has been generated and is shown below.
Resource actions are indicated with the following symbols:
  + create

... skipped ...

Plan: 3 to add, 0 to change, 0 to destroy.

... skipped ...

എല്ലാം വിജയകരമായി അവസാനിച്ചാൽ (അത് ആയിരിക്കണം), അപ്പോൾ ഞങ്ങൾക്ക് മൂന്ന് വെർച്വൽ മെഷീനുകൾ ഉണ്ടാകും:

1. ബിൽഡ് - ഒരു ആപ്ലിക്കേഷൻ പരീക്ഷിക്കുന്നതിനും നിർമ്മിക്കുന്നതിനുമുള്ള ഒരു യന്ത്രം. അൻസിബിൾ സ്വയമേവ ഡോക്കർ ഇൻസ്റ്റാൾ ചെയ്തു.
2. മോണിറ്ററിംഗ് - ഒരു മോണിറ്ററിംഗ് മെഷീൻ - പ്രോമിത്യൂസും ഗ്രാഫാനയും അതിൽ ഇൻസ്റ്റാൾ ചെയ്തിട്ടുണ്ട്. ലോഗിൻ / പാസ്‌വേഡ് സ്റ്റാൻഡേർഡ്: അഡ്മിൻ / അഡ്മിൻ
3. പോർട്ട് 9092-ൽ ആക്‌സസ് ചെയ്യാവുന്ന കാഫ്ക ഇൻസ്റ്റാൾ ചെയ്തിട്ടുള്ള ഒരു ചെറിയ യന്ത്രമാണ് കാഫ്ക.

അവയെല്ലാം സ്ഥലത്തുണ്ടെന്ന് ഉറപ്പാക്കാം:

vozerov@mba:~/events (master) $ yc compute instance list
+----------------------+------------+---------------+---------+---------------+-------------+
|          ID          |    NAME    |    ZONE ID    | STATUS  |  EXTERNAL IP  | INTERNAL IP |
+----------------------+------------+---------------+---------+---------------+-------------+
| fhm081u8bkbqf1pa5kgj | monitoring | ru-central1-a | RUNNING | 84.201.159.71 | 172.16.1.35 |
| fhmf37k03oobgu9jmd7p | kafka      | ru-central1-a | RUNNING | 84.201.173.41 | 172.16.1.31 |
| fhmt9pl1i8sf7ga6flgp | build      | ru-central1-a | RUNNING | 84.201.132.3  | 172.16.1.26 |
+----------------------+------------+---------------+---------+---------------+-------------+

ഉറവിടങ്ങൾ നിലവിലുണ്ട്, ഇവിടെ നിന്ന് നമുക്ക് അവരുടെ ഐപി വിലാസങ്ങൾ ലഭിക്കും. ഇനിപ്പറയുന്നവയിൽ ഉടനീളം ssh വഴി കണക്റ്റുചെയ്യാനും ആപ്ലിക്കേഷൻ പരിശോധിക്കാനും ഞാൻ IP വിലാസങ്ങൾ ഉപയോഗിക്കും. ടെറാഫോമുമായി ബന്ധിപ്പിച്ചിരിക്കുന്ന ഒരു ക്ലൗഡ്ഫ്ലെയർ അക്കൗണ്ട് നിങ്ങൾക്കുണ്ടെങ്കിൽ, പുതുതായി സൃഷ്ടിച്ച DNS പേരുകൾ ഉപയോഗിക്കാൻ മടിക്കേണ്ടതില്ല.
വഴിയിൽ, ഒരു വെർച്വൽ മെഷീൻ സൃഷ്ടിക്കുമ്പോൾ, ഒരു ആന്തരിക ഐപിയും ഒരു ആന്തരിക DNS പേരും നൽകിയിരിക്കുന്നു, അതിനാൽ നിങ്ങൾക്ക് നെറ്റ്‌വർക്കിനുള്ളിലെ സെർവറുകൾ പേര് ഉപയോഗിച്ച് ആക്സസ് ചെയ്യാൻ കഴിയും:

ubuntu@build:~$ ping kafka.ru-central1.internal
PING kafka.ru-central1.internal (172.16.1.31) 56(84) bytes of data.
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=1 ttl=63 time=1.23 ms
64 bytes from kafka.ru-central1.internal (172.16.1.31): icmp_seq=2 ttl=63 time=0.625 ms
^C
--- kafka.ru-central1.internal ping statistics ---
2 packets transmitted, 2 received, 0% packet loss, time 1001ms
rtt min/avg/max/mdev = 0.625/0.931/1.238/0.308 ms

ആപ്ലിക്കേഷനിൽ കാഫ്‌ക് ഉപയോഗിച്ച് എൻഡ്‌പോയിന്റ് സൂചിപ്പിക്കാൻ ഇത് ഞങ്ങൾക്ക് ഉപയോഗപ്രദമാകും.

ആപ്ലിക്കേഷൻ അസംബിൾ ചെയ്യുന്നു

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

ഞങ്ങൾ ആപ്ലിക്കേഷൻ ബിൽഡ് മെഷീനിലേക്ക് പകർത്തുകയും ssh വഴി ലോഗിൻ ചെയ്യുകയും ചിത്രം കൂട്ടിച്ചേർക്കുകയും ചെയ്യുന്നു:

vozerov@mba:~/events/terraform (master) $ cd ..
vozerov@mba:~/events (master) $ rsync -av app/ [email protected]:app/

... skipped ...

sent 3849 bytes  received 70 bytes  7838.00 bytes/sec
total size is 3644  speedup is 0.93

vozerov@mba:~/events (master) $ ssh 84.201.132.3 -l ubuntu
ubuntu@build:~$ cd app
ubuntu@build:~/app$ sudo docker build -t app .
Sending build context to Docker daemon  6.144kB
Step 1/9 : FROM golang:latest AS build
... skipped ...

Successfully built 9760afd8ef65
Successfully tagged app:latest

പകുതി യുദ്ധം പൂർത്തിയായി - ഇപ്പോൾ ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ സമാരംഭിച്ച് കാഫ്കയിലേക്ക് അയച്ചുകൊണ്ട് അതിന്റെ പ്രവർത്തനക്ഷമത പരിശോധിക്കാം:

ubuntu@build:~/app$ sudo docker run --name app -d -p 8080:8080 app /app/app -kafka=kafka.ru-central1.internal:9092</code>

С локальной машинки можно отправить тестовый event и посмотреть на ответ:

<code>vozerov@mba:~/events (master) $ curl -D - -s -X POST -d '{"key1":"data1"}' http://84.201.132.3:8080/post
HTTP/1.1 200 OK
Content-Type: application/json
Date: Mon, 13 Apr 2020 13:53:54 GMT
Content-Length: 41

{"status":"ok","partition":0,"Offset":0}
vozerov@mba:~/events (master) $

റെക്കോർഡിംഗിന്റെ വിജയത്തോടെ ആപ്ലിക്കേഷൻ പ്രതികരിച്ചു കൂടാതെ സന്ദേശം ഉൾപ്പെടുത്തിയിരിക്കുന്ന പാർട്ടീഷന്റെയും ഓഫ്‌സെറ്റിന്റെയും ഐഡി സൂചിപ്പിക്കുന്നു. Yandex.Cloud-ൽ ഒരു രജിസ്ട്രി സൃഷ്‌ടിച്ച് അവിടെ ഞങ്ങളുടെ ചിത്രം അപ്‌ലോഡ് ചെയ്യുക മാത്രമാണ് ചെയ്യേണ്ടത് (മൂന്ന് ലൈനുകൾ ഉപയോഗിച്ച് ഇത് എങ്ങനെ ചെയ്യാമെന്ന് registry.tf ഫയലിൽ വിവരിച്ചിരിക്കുന്നു). ഒരു സംഭരണം സൃഷ്ടിക്കുക:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_container_registry.events

... skipped ...

Plan: 1 to add, 0 to change, 0 to destroy.

... skipped ...

Apply complete! Resources: 1 added, 0 changed, 0 destroyed.

കണ്ടെയ്‌നർ രജിസ്‌ട്രിയിൽ ആധികാരികമാക്കുന്നതിന് നിരവധി മാർഗങ്ങളുണ്ട് - ഒരു ഓത്ത് ടോക്കൺ, ഒരു iam ടോക്കൺ അല്ലെങ്കിൽ ഒരു സേവന അക്കൗണ്ട് കീ എന്നിവ ഉപയോഗിച്ച്. ഈ രീതികളെക്കുറിച്ചുള്ള കൂടുതൽ വിശദാംശങ്ങൾ ഡോക്യുമെന്റേഷനിൽ കാണാം. https://cloud.yandex.ru/docs/container-registry/operations/authentication. ഞങ്ങൾ സേവന അക്കൗണ്ട് കീ ഉപയോഗിക്കും, അതിനാൽ ഞങ്ങൾ ഒരു അക്കൗണ്ട് സൃഷ്ടിക്കുന്നു:

vozerov@mba:~/events/terraform (master) $ terraform apply -target yandex_iam_service_account.docker -target yandex_resourcemanager_folder_iam_binding.puller -target yandex_resourcemanager_folder_iam_binding.pusher

... skipped ...

Apply complete! Resources: 3 added, 0 changed, 0 destroyed.

ഇപ്പോൾ അവശേഷിക്കുന്നത് അതിനായി ഒരു കീ ഉണ്ടാക്കുക എന്നതാണ്:

vozerov@mba:~/events/terraform (master) $ yc iam key create --service-account-name docker -o key.json
id: ajej8a06kdfbehbrh91p
service_account_id: ajep6d38k895srp9osij
created_at: "2020-04-13T14:00:30Z"
key_algorithm: RSA_2048

ഞങ്ങളുടെ സ്റ്റോറേജിന്റെ ഐഡിയെക്കുറിച്ചുള്ള വിവരങ്ങൾ ഞങ്ങൾക്ക് ലഭിക്കും, കീ കൈമാറുകയും ലോഗിൻ ചെയ്യുകയും ചെയ്യുക:

vozerov@mba:~/events/terraform (master) $ scp key.json [email protected]:
key.json                                                                                                                    100% 2392   215.1KB/s   00:00

vozerov@mba:~/events/terraform (master) $ ssh 84.201.132.3 -l ubuntu

ubuntu@build:~$ cat key.json | sudo docker login --username json_key --password-stdin cr.yandex
WARNING! Your password will be stored unencrypted in /home/ubuntu/.docker/config.json.
Configure a credential helper to remove this warning. See
https://docs.docker.com/engine/reference/commandline/login/#credentials-store

Login Succeeded
ubuntu@build:~$

ചിത്രം രജിസ്‌ട്രിയിലേക്ക് അപ്‌ലോഡ് ചെയ്യുന്നതിന്, ഞങ്ങൾക്ക് കണ്ടെയ്‌നർ രജിസ്‌ട്രി ഐഡി ആവശ്യമാണ്, ഞങ്ങൾ അത് yc യൂട്ടിലിറ്റിയിൽ നിന്ന് എടുക്കുന്നു:

vozerov@mba:~ $ yc container registry get events
id: crpdgj6c9umdhgaqjfmm
folder_id:
name: events
status: ACTIVE
created_at: "2020-04-13T13:56:41.914Z"

അതിനുശേഷം, ഞങ്ങൾ ഞങ്ങളുടെ ചിത്രം ഒരു പുതിയ പേരിൽ ടാഗ് ചെയ്യുകയും അപ്‌ലോഡ് ചെയ്യുകയും ചെയ്യുന്നു:

ubuntu@build:~$ sudo docker tag app cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
ubuntu@build:~$ sudo docker push cr.yandex/crpdgj6c9umdhgaqjfmm/events:v1
The push refers to repository [cr.yandex/crpdgj6c9umdhgaqjfmm/events]
8c286e154c6e: Pushed
477c318b05cb: Pushed
beee9f30bc1f: Pushed
v1: digest: sha256:1dd5aaa9dbdde2f60d833be0bed1c352724be3ea3158bcac3cdee41d47c5e380 size: 946

ചിത്രം വിജയകരമായി ലോഡുചെയ്‌തുവെന്ന് ഞങ്ങൾക്ക് പരിശോധിക്കാൻ കഴിയും:

vozerov@mba:~/events/terraform (master) $ yc container repository list
+----------------------+-----------------------------+
|          ID          |            NAME             |
+----------------------+-----------------------------+
| crpe8mqtrgmuq07accvn | crpdgj6c9umdhgaqjfmm/events |
+----------------------+-----------------------------+

വഴിയിൽ, നിങ്ങൾ ഒരു ലിനക്സ് മെഷീനിൽ yc യൂട്ടിലിറ്റി ഇൻസ്റ്റാൾ ചെയ്യുകയാണെങ്കിൽ, നിങ്ങൾക്ക് കമാൻഡ് ഉപയോഗിക്കാം

yc container registry configure-docker

ഡോക്കർ കോൺഫിഗർ ചെയ്യാൻ.

തീരുമാനം

ഞങ്ങൾ വളരെയധികം കഠിനാധ്വാനം ചെയ്തിട്ടുണ്ട്, അതിന്റെ ഫലമായി:

1. ഞങ്ങളുടെ ഭാവി സേവനത്തിന്റെ വാസ്തുവിദ്യയുമായി ഞങ്ങൾ വന്നു.
2. ഞങ്ങളുടെ ബിസിനസ്സ് യുക്തി നടപ്പിലാക്കുന്ന ഒരു ആപ്ലിക്കേഷൻ ഞങ്ങൾ golang-ൽ എഴുതി.
3. ഞങ്ങൾ അത് ശേഖരിച്ച് ഒരു സ്വകാര്യ കണ്ടെയ്നർ രജിസ്ട്രിയിലേക്ക് ഒഴിച്ചു.

അടുത്ത ഭാഗത്ത്, ഞങ്ങൾ രസകരമായ കാര്യങ്ങളിലേക്ക് നീങ്ങും - ഞങ്ങൾ ഞങ്ങളുടെ ആപ്ലിക്കേഷൻ പ്രൊഡക്ഷനിലേക്ക് വിടുകയും ഒടുവിൽ അതിൽ ലോഡ് ലോഞ്ച് ചെയ്യുകയും ചെയ്യും. മാറരുത്!

ഈ മെറ്റീരിയൽ ഓപ്പൺ വർക്ക്ഷോപ്പ് REBRAIN & Yandex.Cloud-ന്റെ വീഡിയോ റെക്കോർഡിംഗിലാണ്: Yandex ക്ലൗഡിൽ സെക്കൻഡിൽ 10 അഭ്യർത്ഥനകൾ ഞങ്ങൾ സ്വീകരിക്കുന്നു - https://youtu.be/cZLezUm0ekE

ഓൺലൈനിൽ ഇത്തരം പരിപാടികളിൽ പങ്കെടുക്കാനും തത്സമയം ചോദ്യങ്ങൾ ചോദിക്കാനും നിങ്ങൾക്ക് താൽപ്പര്യമുണ്ടെങ്കിൽ, ബന്ധപ്പെടുക REBRAIN എന്നയാളുടെ ചാനൽ DevOps.

അത്തരമൊരു ഇവന്റ് ഹോസ്റ്റുചെയ്യാനുള്ള അവസരത്തിന് Yandex.Cloud-ന് പ്രത്യേക നന്ദി പറയാൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്നു. അവയിലേക്കുള്ള ലിങ്ക് - https://cloud.yandex.ru/prices

നിങ്ങൾക്ക് ക്ലൗഡിലേക്ക് നീങ്ങണമെങ്കിൽ അല്ലെങ്കിൽ നിങ്ങളുടെ ഇൻഫ്രാസ്ട്രക്ചറിനെ കുറിച്ച് ചോദ്യങ്ങളുണ്ടെങ്കിൽ, ഒരു അഭ്യർത്ഥന നൽകാൻ മടിക്കേണ്ടതില്ല.

PS ഞങ്ങൾക്ക് പ്രതിമാസം 2 സൗജന്യ ഓഡിറ്റുകൾ ഉണ്ട്, ഒരുപക്ഷേ നിങ്ങളുടെ പ്രോജക്റ്റ് അവയിലൊന്നായിരിക്കാം.

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