🥇අපි Yandex.Cloud හි සිදුවීම් 10 ක් පිළිගනිමු. 000 කොටස

හැමෝටම ආයුබෝවන්, මිත්‍රවරුනි!

* මෙම ලිපිය REBRAIN & Yandex.Cloud විවෘත වැඩමුළුව මත පදනම් වේ, ඔබ වීඩියෝව නැරඹීමට කැමති නම්, ඔබට එය මෙම සබැඳියෙන් සොයාගත හැකිය - https://youtu.be/cZLezUm0ekE

Yandex.Cloud සජීවීව උත්සාහ කිරීමට අපට මෑතකදී අවස්ථාව ලැබුණි. අපට දිගු හා වෙහෙස මහන්සි වී විමර්ශනය කිරීමට අවශ්‍ය වූ බැවින්, වලාකුළු පදනමක් සහිත සරල වර්ඩ්ප්‍රෙස් බ්ලොග් අඩවියක් දියත් කිරීමේ අදහස අපි වහාම අතහැර දැමුවෙමු - එය ඉතා නීරස විය. මදක් සිතා බැලීමෙන් පසුව, ආසන්න තත්‍ය කාලීන ප්‍රකාරයේදී සිදුවීම් ලබා ගැනීම සහ විශ්ලේෂණය කිරීම සඳහා නිෂ්පාදන සේවා ගෘහ නිර්මාණ ශිල්පයකට සමාන දෙයක් යෙදවීමට අපි තීරණය කළෙමු.

සබැඳි (සහ පමණක් නොව) ව්‍යාපාරවලින් අතිමහත් බහුතරයක් කෙසේ හෝ ඔවුන්ගේ පරිශීලකයින් සහ ඔවුන්ගේ ක්‍රියාවන් පිළිබඳ තොරතුරු කන්දක් රැස් කරන බව මට නිසැක ය. අවම වශයෙන්, නිශ්චිත තීරණ ගැනීම සඳහා මෙය අවශ්‍ය වේ - නිදසුනක් ලෙස, ඔබ සබැඳි ක්‍රීඩාවක් කළමනාකරණය කරන්නේ නම්, පරිශීලකයින් බොහෝ විට සිරවී ඔබේ සෙල්ලම් බඩු මකා දමන්නේ කුමන මට්ටමේ සංඛ්‍යාලේඛන දෙස බැලිය හැකිය. එසේත් නැතිනම් පරිශීලකයින් කිසිවක් මිලදී නොගෙන ඔබේ වෙබ් අඩවිය හැර යන්නේ ඇයි (හෙලෝ, Yandex.Metrica).

ඉතින්, අපේ කතාව: අපි golang හි යෙදුමක් ලිවූ ආකාරය, kafka vs rabbitmq එදිරිව yqs පරීක්ෂා කර, Clickhouse පොකුරක දත්ත ප්‍රවාහය ලියා yandex datalens භාවිතයෙන් දත්ත දෘශ්‍යමාන කළ ආකාරය. ස්වාභාවිකවම, මේ සියල්ල ඩොකර්, ටෙරාෆෝම්, ගිට්ලැබ් සීඅයි සහ, ඇත්ත වශයෙන්ම, ප්‍රොමිතියස් වැනි යටිතල පහසුකම් වලින් රස වින්දා. අපි යමු!

අපට එකවරම සියල්ල වින්‍යාස කිරීමට නොහැකි වන බව වහාම වෙන් කරවා ගැනීමට මම කැමතියි - මේ සඳහා අපට ලිපි මාලාවේ ලිපි කිහිපයක් අවශ්‍ය වේ. ව්යුහය ගැන ටිකක්:

1 කොටස (ඔබ එය කියවනවා). විසඳුමේ පිරිවිතරයන් සහ ගෘහ නිර්මාණ ශිල්පය පිළිබඳව අපි තීරණය කරන්නෙමු, තවද golang වලින් යෙදුමක් ලියන්නෙමු.
2 කොටස. අපි අපගේ යෙදුම නිෂ්පාදනයට මුදා හරිමු, එය පරිමාණය කළ හැකි සහ බර පරීක්ෂා කරන්න.
3 කොටස. අපි ලිපිගොනු වල නොව බෆරයක පණිවිඩ ගබඩා කළ යුත්තේ මන්දැයි සොයා බැලීමට උත්සාහ කරමු, එසේම kafka, rabbitmq සහ yandex පෝලිම් සේවාව සංසන්දනය කරන්න.
4 කොටස අපි Clickhouse පොකුරක් යොදවන්නෙමු, එහි ඇති බෆරයෙන් දත්ත මාරු කිරීමට ප්‍රවාහ සේවාවක් ලියන්නෙමු, සහ datalens තුළ දෘශ්‍යකරණය සකසන්නෙමු.
5 කොටස සම්පූර්ණ යටිතල ව්‍යුහයම නිසි හැඩයට ගෙන යමු - gitlab ci භාවිතයෙන් ci/cd සකසන්න, prometheus සහ consul භාවිතා කරමින් අධීක්ෂණය සහ සේවා සොයාගැනීම සම්බන්ධ කරන්න.

ටී.කේ

පළමුව, අපි යොමු නියමයන් සකස් කරමු - ප්රතිඵලය ලෙස අපට ලබා ගැනීමට අවශ්ය දේ.

අපට HTTPS භාවිතයෙන් සිද්ධි ලැබිය යුතු events.kis.im (kis.im යනු අපි සියලුම ලිපි පුරාවට භාවිත කරන පරීක්ෂණ වසම) වැනි අවසන් ලක්ෂ්‍යයක් ලබා ගැනීමට අවශ්‍යයි.
සිදුවීම් වැනි සරල json: {“සිදුවීම”: “දර්ශනය”, “os”: “linux”, “browser”: “chrome”}. අවසාන අදියරේදී අපි තව ටිකක් ක්ෂේත්‍ර එකතු කරන්නෙමු, නමුත් මෙය විශාල කාර්යභාරයක් ඉටු නොකරනු ඇත. ඔබට අවශ්ය නම්, ඔබට protobuf වෙත මාරු විය හැක.
සේවාවට තත්පරයකට සිදුවීම් 10 ක් සැකසීමට හැකි විය යුතුය.
අපගේ විසඳුමට නව අවස්ථා එකතු කිරීමෙන් තිරස් අතට පරිමාණය කිරීමට හැකි විය යුතුය. සේවාලාභී ඉල්ලීම් සඳහා ප්‍රමාදය අඩු කිරීම සඳහා අපට ඉදිරිපස කොටස විවිධ භූ ස්ථාන වෙත ගෙන යා හැකි නම් එය ඉතා හොඳ වනු ඇත.
වැරදි ඉවසීම. විසඳුම ප්රමාණවත් තරම් ස්ථායී විය යුතු අතර ඕනෑම කොටස්වල වැටීමෙන් බේරීමට හැකි විය යුතුය (නිශ්චිත සංඛ්යාවක් දක්වා, ඇත්ත වශයෙන්ම).

ගෘහ නිර්මාණ ශිල්පය

සාමාන්යයෙන්, මෙම ආකාරයේ කාර්යය සඳහා, කාර්යක්ෂම පරිමාණය කිරීමට ඉඩ සලසන සම්භාව්ය ගෘහ නිර්මාණ ශිල්පය දිගු කලක් තිස්සේ සොයාගෙන ඇත. රූපය අපගේ විසඳුමේ උදාහරණයක් පෙන්වයි.

ඉතින් අපට ඇති දේ:

1. වම් පසින් විවිධ සිදුවීම් උත්පාදනය කරන අපගේ උපාංග වේ, එය ක්‍රීඩකයින් ස්මාර්ට් ජංගම දුරකතනයේ සෙල්ලම් බඩුවක මට්ටමක් සම්පූර්ණ කිරීම හෝ සාමාන්‍ය බ්‍රවුසරයක් හරහා සබැඳි වෙළඳසැලක ඇණවුමක් නිර්මාණය කරයි. පිරිවිතරයේ දක්වා ඇති පරිදි සිදුවීමක්, අපගේ අවසාන ලක්ෂ්‍යය වෙත යවනු ලබන සරල json වේ - events.kis.im.

2. පළමු සේවාදායකයන් දෙක සරල සමතුලිතයන් වේ, ඒවායේ ප්‍රධාන කාර්යයන් වන්නේ:

නිරන්තරයෙන් ලබා ගත හැකි වන්න. මෙය සිදු කිරීම සඳහා, ඔබට භාවිතා කළ හැකිය, උදාහරණයක් ලෙස, Keepalived, ගැටළු ඇති විට නෝඩ් අතර අථත්ය IP මාරු කරනු ඇත.
TLS අවසන් කරන්න. ඔව්, අපි ඔවුන් මත TLS අවසන් කරන්නෙමු. පළමුව, අපගේ විසඳුම තාක්ෂණික පිරිවිතරයන්ට අනුකූල වන පරිදි, සහ දෙවනුව, අපගේ පසුපෙළ සේවාදායකයන්ගෙන් සංකේතාත්මක සම්බන්ධතාවයක් ස්ථාපිත කිරීමේ බර ඉවත් කිරීම සඳහා.
ලබා ගත හැකි පසුබිම් සේවාදායකයන්ට ලැබෙන ඉල්ලීම් සමතුලිත කරන්න. මෙහි ප්‍රධාන වචනය ප්‍රවේශ විය හැකිය. මේ මත පදනම්ව, යෙදුම් සමඟ අපගේ සේවාදායකයන් නිරීක්ෂණය කිරීමට සහ අසාර්ථක නෝඩ් වෙත ගමනාගමනය සමතුලිත කිරීම නැවැත්වීමට load balancers හට හැකි විය යුතු බව අපි අවබෝධ කර ගනිමු.

3. සමතුලිතයන්ගෙන් පසුව, තරමක් සරල යෙදුමක් ධාවනය වන යෙදුම් සේවාදායකයන් අප සතුව ඇත. එයට HTTP හරහා එන ඉල්ලීම් පිළිගැනීමට, යවන ලද json වලංගු කිරීමට සහ දත්ත බෆරයකට දැමීමට හැකි විය යුතුය.

4. රූප සටහන කෆ්කා බෆරයක් ලෙස පෙන්වයි, කෙසේ වෙතත්, ඇත්ත වශයෙන්ම, මෙම මට්ටමින් වෙනත් සමාන සේවාවන් භාවිතා කළ හැකිය. අපි තුන්වන ලිපියෙන් Kafka, rabbitmq සහ yqs සංසන්දනය කරමු.

5. අපගේ ගෘහනිර්මාණ ශිල්පයේ අවසාන ලක්ෂ්‍යය වන්නේ Clickhouse - විශාල දත්ත ප්‍රමාණයක් ගබඩා කිරීමට සහ සැකසීමට ඔබට ඉඩ සලසන තීරු දත්ත සමුදායකි. මෙම මට්ටමේදී, අපි බෆරයේ සිට ගබඩා පද්ධතියට දත්ත මාරු කළ යුතුය (මේ ගැන වැඩි විස්තර 4 වන ලිපියේ).

මෙම සැලසුම මඟින් සෑම ස්ථරයක්ම ස්වාධීනව තිරස් අතට පරිමාණය කිරීමට අපට ඉඩ සලසයි. පසුබිම් සේවාදායකයන්ට මුහුණ දිය නොහැක - අපි තවත් එක් දෙයක් එකතු කරමු - සියල්ලට පසු, ඒවා අස්ථායී යෙදුම් වන අතර එබැවින් මෙය ස්වයංක්‍රීයව පවා කළ හැකිය. Kafka-style buffer එක ක්‍රියා නොකරයි - අපි තවත් සේවාදායකයන් එකතු කර අපගේ මාතෘකාවේ සමහර කොටස් ඒවාට මාරු කරමු. Clickhouse හට එය හැසිරවිය නොහැක - එය කළ නොහැකි ය :) ඇත්ත වශයෙන්ම, අපි සේවාදායකයන් සම්බන්ධ කර දත්ත කැබලි කරන්නෙමු.

මාර්ගය වන විට, විවිධ භූ ස්ථාන වල අපගේ තාක්ෂණික පිරිවිතර සහ පරිමාණයේ විකල්ප කොටස ක්‍රියාත්මක කිරීමට ඔබට අවශ්‍ය නම්, ඊට වඩා සරල දෙයක් නොමැත:

සෑම භූගෝලීය ස්ථානයකම අපි යෙදුම සහ කෆ්කා සමඟ පැටවුම් සමතුලිතතාවයක් යොදන්නෙමු. සාමාන්‍යයෙන්, යෙදුම් සේවාදායකයන් 2 ක්, කෆ්කා නෝඩ් 3 ක් සහ ක්ලවුඩ් බැලන්සර් එකක් ප්‍රමාණවත් වේ, උදාහරණයක් ලෙස, ක්ලවුඩ් ෆ්ලෙයාර්, ප්‍රමාණවත් වේ, එමඟින් සේවාලාභියාගේ මූලාශ්‍ර IP ලිපිනය මත පදනම්ව භූ පිහිටීම අනුව යෙදුම් නෝඩ් සහ ශේෂ ඉල්ලීම් තිබේද යන්න පරීක්ෂා කරනු ඇත. මේ අනුව, ඇමරිකානු සේවාදායකයෙකු විසින් එවන ලද දත්ත ඇමරිකානු සේවාදායකයන් වෙත ගොඩබසිනු ඇත. අප්‍රිකාවේ දත්ත අප්‍රිකානු භාෂාවෙන් ඇත.

එවිට සෑම දෙයක්ම ඉතා සරලයි - අපි Kafka කට්ටලයෙන් දර්පණ මෙවලම භාවිතා කරන අතර රුසියාවේ පිහිටා ඇති අපගේ මධ්යම දත්ත මධ්යස්ථානය වෙත සියලුම ස්ථාන වලින් සියලුම දත්ත පිටපත් කරන්නෙමු. අභ්‍යන්තරව, අපි දත්ත විග්‍රහ කර පසුව දෘශ්‍යකරණය සඳහා ක්ලික්හවුස් හි සටහන් කරමු.

ඉතින්, අපි ගෘහ නිර්මාණ ශිල්පය නිරාකරණය කර ඇත - අපි Yandex.Cloud සොලවන්න පටන් ගනිමු!

අයදුම්පතක් ලිවීම

වලාකුළට පෙර, ඔබ තවමත් ටිකක් ඉවසිලිවන්තව සිටිය යුතු අතර පැමිණෙන සිදුවීම් සැකසීමට තරමක් සරල සේවාවක් ලියන්න. ජාල යෙදුම් ලිවීම සඳහා භාෂාවක් ලෙස එය ඉතා හොඳින් ඔප්පු වී ඇති නිසා අපි golang භාවිතා කරන්නෙමු.

පැයක් ගත කිරීමෙන් පසු (සමහර විට පැය කිහිපයක්), අපට මෙවැනි දෙයක් ලැබේ: https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/main.go.

මම මෙහි සටහන් කිරීමට කැමති ප්‍රධාන කරුණු මොනවාද:

1. යෙදුම ආරම්භ කරන විට, ඔබට කොඩි දෙකක් නියම කළ හැකිය. අපි එන http ඉල්ලීම්වලට (-addr) සවන් දෙන වරාය සඳහා එකක් වගකිව යුතුය. දෙවැන්න අපගේ සිදුවීම් (-kafka) පටිගත කරන කෆ්කා සේවාදායක ලිපිනය සඳහා ය:

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, Kafka වෙත ලිවීමට නොහැකි වීම);
කෆ්කා වෙත පණිවිඩයක් ලිවීමේ කාලය ඇතුළුව, සේවාදායකයාගෙන් එක් ඉල්ලීමක් සඳහා සැකසුම් කාලය.

4. අපගේ යෙදුම ක්‍රියාවට නංවන අවසාන ලක්ෂ්‍ය තුනක්:

/ තත්ත්‍වය - අපි ජීවතුන් අතර සිටින බව පෙන්වීමට OK යන්න ආපසු දෙන්න. ඔබට කෆ්කා පොකුරේ ඇති බව වැනි චෙක්පත් කිහිපයක් එකතු කළ හැකි වුවද.
/මෙට්රික්ස් - මෙම url එකට අනුව, prometheus සේවාලාභියා එය එකතු කර ඇති මිතික ආපසු ලබා දෙනු ඇත.
/post යනු json ඇතුලත POST ඉල්ලීම් යවන ප්‍රධාන අන්ත ලක්ෂ්‍යය වේ. අපගේ යෙදුම වලංගු භාවය සඳහා json පරීක්ෂා කරන අතර සියල්ල හරි නම්, එය Kafka පොකුරට දත්ත ලියයි.

කේතය පරිපූර්ණ නොවන බව මම වෙන්කරවා ගන්නෙමි - එය සම්පූර්ණ කළ හැකි (සහ කළ යුතු!) උදාහරණයක් ලෙස, ඔබට බිල්ට් net/http භාවිතය නතර කර වේගවත් fasthttp වෙත මාරු විය හැක. එසේත් නැතිනම් json වලංගු පරීක්ෂාව පසුකාලීන අදියරකට ගෙන යාමෙන් ඔබට සැකසුම් කාලය සහ cpu සම්පත් ලබා ගත හැක - දත්ත බෆරයෙන් ක්ලික්හවුස් පොකුරට මාරු කළ විට.

ගැටලුවේ සංවර්ධන පැත්තට අමතරව, අපි වහාම අපගේ අනාගත යටිතල පහසුකම් ගැන සිතා අපගේ අයදුම්පත ඩොකර් හරහා යෙදවීමට තීරණය කළෙමු. යෙදුම ගොඩනැගීම සඳහා අවසන් Dockerfile වේ 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 config පැතිකඩ හරහා වෙනම සැකසුම් සමඟ අමතර පැතිකඩ නිර්මාණය කර ඒවා අතර මාරු කළ හැකිය.

ඉහත ක්රම වලට අමතරව, Yandex.Cloud කණ්ඩායම ඉතා හොඳින් ලිවීය ටෙරාෆෝම් සඳහා ප්ලගිනය වලාකුළු සම්පත් කළමනාකරණය සඳහා. මගේ පැත්තෙන්, මම git ගබඩාවක් සකස් කළෙමි, එහිදී මම ලිපියේ කොටසක් ලෙස නිර්මාණය කරන සියලුම සම්පත් විස්තර කළෙමි - 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 ලැයිස්තුවෙන් ගත හැක. අහම්බෙන් පුද්ගලික දත්ත ප්‍රකාශයට පත් නොකිරීමට, වහාම private.auto.tfvars .gitignore වෙත එක් කරන ලෙස මම ඔබට උපදෙස් දෙමි.

private.auto.tfvars හි අපි Cloudflare වෙතින් දත්ත ද නියම කළෙමු - DNS වාර්තා සෑදීමට සහ ප්‍රධාන වසම events.kis.im අපගේ සේවාදායකයන්ට ප්‍රොක්සි කිරීමට. ඔබට cloudflare භාවිතා කිරීමට අවශ්‍ය නැතිනම්, අවශ්‍ය dns වාර්තා නිර්මාණය කිරීම සඳහා වගකිව යුතු main.tf සහ dns.tf ගොනුවේ cloudflare සපයන්නාගේ ආරම්භය ඉවත් කරන්න.

අපගේ කාර්යයේදී අපි ක්‍රම තුනම ඒකාබද්ධ කරන්නෙමු - වෙබ් අතුරු මුහුණත, කොන්සෝල උපයෝගීතාව සහ ටෙරාෆෝම්.

අතථ්‍ය ජාල

අවංකවම, ඔබට මෙම පියවර මඟ හැරිය හැක, මන්ද ඔබ නව වලාකුළක් සාදන විට, ඔබට ස්වයංක්‍රීයව වෙනම ජාලයක් සහ උපජාල 3ක් සාදනු ඇත - එක් එක් පවතින කලාපය සඳහා එකක්. නමුත් අපි තවමත් අපේ ව්‍යාපෘතිය සඳහා වෙනම ජාලයක් එහිම ආමන්ත්‍රණයක් ඇති කිරීමට කැමතියි. Yandex.Cloud හි ජාලය ක්‍රියා කරන ආකාරය පිළිබඳ සාමාන්‍ය රූප සටහන පහත රූපයේ දැක්වේ (අවංකව උපුටා ගන්නා ලදී https://cloud.yandex.ru/docs/vpc/concepts/)

එබැවින්, ඔබ සම්පත් එකිනෙකා සමඟ සන්නිවේදනය කළ හැකි පොදු ජාලයක් නිර්මාණය කරයි. සෑම ලබා ගත හැකි කලාපයක් සඳහාම, උපජාලයක් එහිම ආමන්ත්‍රණයකින් සාදා සාමාන්‍ය ජාලයට සම්බන්ධ කර ඇත. එහි ප්රතිඵලයක් වශයෙන්, එහි ඇති සියලුම වලාකුළු සම්පත් විවිධ ලබා ගත හැකි කලාපවල වුවද, සන්නිවේදනය කළ හැකිය. විවිධ ක්ලවුඩ් ජාලවලට සම්බන්ධ සම්පත් එකිනෙකා දැකිය හැක්කේ බාහිර ලිපින හරහා පමණි. මාර්ගය වන විට, මෙම මැජික් ඇතුළත ක්‍රියා කරන්නේ කෙසේද, Habré හි හොඳින් විස්තර කර ඇත.

ජාල නිර්මාණය Network.tf ගොනුවේ ගබඩාවෙන් විස්තර කෙරේ. එහිදී අපි අභ්‍යන්තරයේ එක් පොදු පුද්ගලික ජාලයක් සාදා එයට විවිධ පවතින කලාප තුළ උපජාල තුනක් සම්බන්ධ කරමු - අභ්‍යන්තර-a (172.16.1.0/24), අභ්‍යන්තර-b (172.16.2.0/24), අභ්‍යන්තර-c (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.

මහා! අපි අපගේ ජාලය නිර්මාණය කර ඇති අතර දැන් අපගේ අභ්‍යන්තර සේවාවන් නිර්මාණය කිරීමට සූදානම්.

අතථ්‍ය යන්ත්‍ර නිර්මාණය කිරීම

යෙදුම පරීක්ෂා කිරීම සඳහා, අපට අවශ්‍ය වන්නේ අථත්‍ය යන්ත්‍ර දෙකක් පමණි - අපට පළමු යෙදුම ගොඩනඟා ක්‍රියාත්මක කිරීමට අවශ්‍ය වනු ඇත, දෙවැන්න kafka ධාවනය කිරීමට, අපි එන පණිවිඩ ගබඩා කිරීමට භාවිතා කරමු. තවද අපි යෙදුම නිරීක්ෂණය කිරීමට ප්‍රොමිතියස් වින්‍යාස කරන තවත් යන්ත්‍රයක් සාදන්නෙමු.

අතථ්‍ය යන්ත්‍ර ඇන්සිබල් භාවිතයෙන් වින්‍යාස කරනු ඇත, එබැවින් ටෙරාෆෝම් ආරම්භ කිරීමට පෙර, ඔබ සතුව ඇන්සිබල් හි නවතම අනුවාදයක් ඇති බවට වග බලා ගන්න. සහ ansible galaxy සමඟ අවශ්‍ය භූමිකාවන් ස්ථාපනය කරන්න:

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 folder එක ඇතුලේ මම පාවිච්චි කරන .ansible.cfg configuration file එකක් තියෙනවා. එය ප්රයෝජනවත් විය හැකිය.

අතථ්‍ය යන්ත්‍ර සෑදීමට පෙර, ඔබ සතුව ssh-agent ධාවනය සහ 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 ...

සෑම දෙයක්ම සාර්ථකව අවසන් වූයේ නම් (එය විය යුතුය), එවිට අපට අථත්‍ය යන්ත්‍ර තුනක් ඇත:

ගොඩනැගීම - යෙදුමක් පරීක්ෂා කිරීම සහ ගොඩනැගීම සඳහා යන්ත්‍රයක්. ඇන්සිබල් විසින් ඩොකර් ස්වයංක්‍රීයව ස්ථාපනය කරන ලදී.
අධීක්ෂණ - අධීක්ෂණ යන්ත්‍රයක් - ප්‍රොමිතියස් සහ ග්‍රැෆානා එහි ස්ථාපනය කර ඇත. පිවිසුම් / මුරපදය සම්මත: පරිපාලක / පරිපාලක
kafka යනු කෆ්කා ස්ථාපනය කර ඇති කුඩා යන්ත්‍රයකි, 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 |
+----------------------+------------+---------------+---------+---------------+-------------+

සම්පත් පවතින අතර, මෙතැන් සිට අපට ඔවුන්ගේ IP ලිපින ලබා ගත හැක. පහත දැක්වෙන දේ පුරාවට මම ssh හරහා සම්බන්ධ වීමට සහ යෙදුම පරීක්ෂා කිරීමට IP ලිපින භාවිතා කරමි. ඔබට ටෙරාෆෝම් වෙත සම්බන්ධ ක්ලවුඩ්ෆ්ලේර් ගිණුමක් තිබේ නම්, නැවුම් ලෙස සාදන ලද DNS නම් භාවිතා කිරීමට නිදහස් වන්න.
මාර්ගය වන විට, අතථ්‍ය යන්ත්‍රයක් නිර්මාණය කිරීමේදී, අභ්‍යන්තර IP සහ අභ්‍යන්තර 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

යෙදුමට kafk සමඟ අවසන් ලක්ෂ්‍යය දැක්වීමට මෙය අපට ප්‍රයෝජනවත් වනු ඇත.

අයදුම්පත එකලස් කිරීම

නියමයි, සේවාදායකයන් ඇත, යෙදුමක් ඇත - ඉතිරිව ඇත්තේ එය එකලස් කර එය ප්‍රකාශයට පත් කිරීම පමණි. ගොඩනැගීම සඳහා අපි සුපුරුදු ඩොකර් ගොඩනැගීම භාවිතා කරනු ඇත, නමුත් රූප ගබඩාවක් ලෙස අපි 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.

බහාලුම් රෙජිස්ට්‍රිය තුළ සත්‍යාපනය කිරීමට ක්‍රම කිහිපයක් තිබේ - oauth ටෝකනයක්, 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

ඩොකර් වින්‍යාස කිරීමට.

නිගමනය

අපි බොහෝ වෙහෙස මහන්සි වී වැඩ කර ඇති අතර එහි ප්රතිඵලයක් වශයෙන්:

අපි අපේ අනාගත සේවයේ ගෘහ නිර්මාණ ශිල්පය සමඟ ආවා.
අපි අපේ ව්‍යාපාර තර්කනය ක්‍රියාත්මක කරන යෙදුමක් golang වලින් ලිව්වා.
අපි එය එකතු කර පුද්ගලික බහාලුම් රෙජිස්ට්රි එකකට වත් කළා.

ඊළඟ කොටසේදී, අපි සිත්ගන්නා කරුණු වෙත යන්නෙමු - අපි අපගේ යෙදුම නිෂ්පාදනයට මුදා හැර අවසානයේ එය මත පැටවීම දියත් කරන්නෙමු. මාරු කරන්න එපා!

මෙම ද්රව්යය විවෘත වැඩමුළුව REBRAIN සහ Yandex.Cloud හි වීඩියෝ පටිගත කිරීමෙහි ඇත: අපි Yandex Cloud මත තත්පරයකට ඉල්ලීම් 10 ක් පිළිගනිමු - https://youtu.be/cZLezUm0ekE

ඔබ අන්තර්ජාලය හරහා එවැනි සිදුවීම් වලට සහභාගී වීමට සහ තත්‍ය කාලීනව ප්‍රශ්න ඇසීමට කැමති නම්, සම්බන්ධ වන්න REBRAIN නාලිකාව මගින් DevOps.

එවැනි උත්සවයක් පැවැත්වීම සඳහා Yandex.Cloud වෙත විශේෂ ස්තුතිය පුද කිරීමට අපි කැමැත්තෙමු. ඒවාට සබැඳිය - https://cloud.yandex.ru/prices

ඔබට වලාකුළ වෙත යාමට අවශ්‍ය නම් හෝ ඔබේ යටිතල පහසුකම් පිළිබඳ ප්‍රශ්න තිබේ නම්, ඉල්ලීමක් ඉදිරිපත් කිරීමට නිදහස් වන්න.

PS අපට මසකට නොමිලේ විගණන 2ක් ඇත, සමහරවිට ඔබේ ව්‍යාපෘතිය ඒවායින් එකක් වනු ඇත.

මූලාශ්රය: www.habr.com

අපි Yandex.Cloud හි සිදුවීම් 10 ක් පිළිගනිමු. 000 කොටස