Բարև բոլորին, ընկերներ:
* Այս հոդվածը հիմնված է REBRAIN & Yandex.Cloud բաց սեմինարի վրա, եթե նախընտրում եք դիտել տեսանյութը, կարող եք գտնել այն այս հղումով.
Վերջերս մենք հնարավորություն ունեցանք փորձել Yandex.Cloud-ը ուղիղ եթերում։ Քանի որ մենք ցանկանում էինք երկար ու ծանր զննել, մենք անմիջապես հրաժարվեցինք ամպային բազայով պարզ Wordpress բլոգի գործարկման գաղափարից. դա չափազանց ձանձրալի էր: Որոշ մտածելուց հետո մենք որոշեցինք տեղակայել արտադրության ծառայության ճարտարապետության նման մի բան՝ իրադարձությունները գրեթե իրական ժամանակի ռեժիմում ստանալու և վերլուծելու համար:
Ես միանգամայն վստահ եմ, որ առցանց (և ոչ միայն) բիզնեսների ճնշող մեծամասնությունը ինչ-որ կերպ հավաքում է տեղեկատվության մեծ մասը իրենց օգտատերերի և նրանց գործողությունների մասին: Առնվազն դա անհրաժեշտ է որոշակի որոշումներ կայացնելու համար. օրինակ, եթե դուք կառավարում եք առցանց խաղ, կարող եք դիտել վիճակագրությունը, թե որ մակարդակում են օգտվողներն ամենից հաճախ խրված և ջնջում ձեր խաղալիքը: Կամ ինչու օգտատերերը հեռանում են ձեր կայքից առանց որևէ բան գնելու (բարև, Yandex.Metrica):
Այսպիսով, մեր պատմությունը. ինչպես մենք գրեցինք հավելված golang-ով, փորձարկեցինք kafka-ն ընդդեմ rabbitmq-ի ընդդեմ yqs-ի, գրեցինք տվյալների հոսքը Clickhouse կլաստերում և պատկերացրինք տվյալները՝ օգտագործելով yandex datalens: Բնականաբար, այս ամենը համեմված էր ենթակառուցվածքային հիացմունքներով՝ docker-ի, terraform-ի, gitlab ci-ի և, իհարկե, պրոմեթևսի տեսքով: Գնացինք!
Ես կցանկանայի անմիջապես վերապահում անել, որ մենք չենք կարողանա ամեն ինչ կարգավորել մեկ նիստում, դրա համար մեզ անհրաժեշտ կլինեն շարքի մի քանի հոդվածներ: Մի փոքր կառուցվածքի մասին.
Մաս 1 (դուք կարդում եք այն): Մենք կորոշենք լուծման առանձնահատկությունները և ճարտարապետությունը, ինչպես նաև կգրենք հավելված գոլանգով:
Մաս 2. Մենք թողարկում ենք մեր հավելվածը արտադրության մեջ, այն դարձնում ենք մասշտաբային և փորձարկում ենք բեռը:
Մաս 3. Փորձենք պարզել, թե ինչու պետք է հաղորդագրությունները պահենք բուֆերում և ոչ թե ֆայլերում, ինչպես նաև համեմատենք kafka, rabbitmq և yandex հերթերի ծառայությունները։
Մաս 4 Մենք կտեղակայենք Clickhouse կլաստերը, կգրենք հոսքային ծառայություն՝ այնտեղ բուֆերից տվյալներ փոխանցելու համար և կստեղծենք վիզուալիզացիա datalens-ում:
Մաս 5 Եկեք պատշաճ ձևի բերենք ամբողջ ենթակառուցվածքը. կարգավորենք ci/cd-ը gitlab ci-ի միջոցով, միացնենք մոնիտորինգը և ծառայության հայտնաբերումը Պրոմեթևսի և հյուպատոսի միջոցով:
TK
Նախ, եկեք ձևակերպենք տեխնիկական առաջադրանքը. կոնկրետ ինչ ենք ուզում ստանալ արդյունքում:
- Մենք ցանկանում ենք ունենալ այնպիսի վերջնակետ, ինչպիսին events.kis.im-ն է (kis.im-ը փորձնական տիրույթն է, որը մենք կօգտագործենք բոլոր հոդվածներում), որը պետք է իրադարձություններ ստանա HTTPS-ի միջոցով:
- Իրադարձությունները պարզ json են, ինչպիսիք են՝ {“իրադարձություն”: “view”, “os”: “linux”, “browser”: “chrome”}: Վերջնական փուլում մի քիչ էլ դաշտ կավելացնենք, բայց դա մեծ դեր չի խաղա։ Ցանկության դեպքում կարող եք անցնել պրոտոբուֆին։
- Ծառայությունը պետք է կարողանա վայրկյանում մշակել 10 իրադարձություն:
- Հորիզոնական մասշտաբը պետք է հնարավոր լինի՝ պարզապես նոր օրինակներ ավելացնելով մեր լուծմանը: Եվ լավ կլինի, եթե մենք կարողանանք առջևի հատվածը տեղափոխել տարբեր աշխարհագրական դիրքեր՝ հաճախորդների հարցումների հետաձգումը նվազեցնելու համար:
- Սխալների հանդուրժողականություն: Լուծումը պետք է բավականաչափ կայուն լինի և կարողանա գոյատևել ցանկացած մասերի անկումից (իհարկե մինչև որոշակի քանակ):
ճարտարապետություն
Ընդհանուր առմամբ, այս տեսակի առաջադրանքների համար վաղուց են հորինվել դասական ճարտարապետություններ, որոնք թույլ են տալիս արդյունավետ մասշտաբներ: Նկարը ցույց է տալիս մեր լուծման օրինակը:
Այսպիսով, ինչ ունենք.
1. Ձախ կողմում մեր սարքերն են, որոնք ստեղծում են տարբեր իրադարձություններ, լինեն դա սմարթֆոնի խաղալիքի մակարդակը լրացնող խաղացողներ, թե սովորական բրաուզերի միջոցով առցանց խանութում պատվերներ ստեղծելը: Իրադարձությունը, ինչպես նշված է ճշգրտման մեջ, պարզ json է, որն ուղարկվում է մեր վերջնական կետին՝ events.kis.im:
2. Առաջին երկու սերվերները պարզ հավասարակշռողներ են, նրանց հիմնական խնդիրներն են.
- Մշտապես հասանելի եղեք։ Դա անելու համար կարող եք օգտագործել, օրինակ, keepalived-ը, որը խնդիրների դեպքում կփոխանցի վիրտուալ IP-ն հանգույցների միջև։
- Դադարեցնել TLS-ը: Այո, մենք կդադարեցնենք TLS-ը նրանց վրա: Նախ, որպեսզի մեր լուծումը համապատասխանի տեխնիկական բնութագրերին, և երկրորդ՝ մեր հետին սերվերներից գաղտնագրված կապի հաստատման բեռը թեթեւացնելու համար:
- Հավասարակշռել մուտքային հարցումները հասանելի backend սերվերներին: Հիմնական բառն այստեղ հասանելի է: Ելնելով դրանից՝ մենք գալիս ենք այն ըմբռնմանը, որ բեռի հավասարակշռողները պետք է կարողանան վերահսկել մեր սերվերները հավելվածներով և դադարեցնել տրաֆիկի հավասարակշռումը դեպի ձախողված հանգույցներ:
3. Հավասարակշռողներից հետո մենք ունենք կիրառական սերվերներ, որոնք աշխատում են բավականին պարզ հավելվածով: Այն պետք է կարողանա ընդունել մուտքային հարցումները HTTP-ի միջոցով, վավերացնել ուղարկված json-ը և տվյալները դնել բուֆերի մեջ:
4. Դիագրամում կաֆկան ցույց է տալիս որպես բուֆեր, չնայած, իհարկե, այս մակարդակում կարող են օգտագործվել նմանատիպ այլ ծառայություններ։ Երրորդ հոդվածում կհամեմատենք Kafka-ն, rabbitmq-ը և yq-ը։
5. Մեր ճարտարապետության նախավերջին կետը Clickhouse-ն է՝ սյունակային տվյալների բազա, որը թույլ է տալիս պահպանել և մշակել հսկայական քանակությամբ տվյալներ: Այս մակարդակում մենք պետք է տվյալները փոխանցենք բուֆերից դեպի պահեստավորման համակարգ (այս մասին ավելին 4-րդ հոդվածում):
Այս դիզայնը մեզ թույլ է տալիս յուրաքանչյուր շերտը ինքնուրույն չափել հորիզոնական: Backend սերվերները չեն կարող հաղթահարել, եկեք ավելացնենք ևս մեկ բան, ի վերջո, դրանք քաղաքացիություն չունեցող հավելվածներ են, և, հետևաբար, դա կարելի է անել նույնիսկ ինքնաբերաբար: Կաֆկայի ոճի բուֆերը չի աշխատում. եկեք ավելացնենք ավելի շատ սերվերներ և նրանց փոխանցենք մեր թեմայի որոշ բաժիններ: Clickhouse-ը չի կարող դա կարգավորել, դա անհնար է :) Փաստորեն, մենք նաև միացնելու ենք սերվերները և կկտրենք տվյալները:
Ի դեպ, եթե ցանկանում եք մեր տեխնիկական բնութագրերի և մասշտաբի կամընտիր մասը իրականացնել տարբեր աշխարհագրական դիրքերում, ապա ավելի պարզ բան չկա.
Յուրաքանչյուր աշխարհագրական դիրքում մենք տեղադրում ենք բեռի հավասարակշռող սարք՝ հավելվածով և կաֆկայով: Ընդհանուր առմամբ, բավարար է 2 հավելվածի սերվեր, 3 կաֆկա հանգույց և ամպային հավասարակշռիչ, օրինակ՝ cloudflare, որը կստուգի հավելվածի հանգույցների առկայությունը և հաշվեկշռի հարցումները ըստ աշխարհագրական դիրքի՝ հաճախորդի աղբյուրի IP հասցեի հիման վրա: Այսպիսով, ամերիկյան հաճախորդի կողմից ուղարկված տվյալները կհայտնվեն ամերիկյան սերվերների վրա: Իսկ Աֆրիկայի տվյալները աֆրիկյան են:
Այնուհետև ամեն ինչ բավականին պարզ է. մենք օգտագործում ենք հայելային գործիքը Kafka հավաքածուից և պատճենում ենք բոլոր տվյալները բոլոր վայրերից Ռուսաստանում տեղակայված մեր կենտրոնական տվյալների կենտրոնում: Ներքին մասում մենք վերլուծում ենք տվյալները և գրանցում այն Clickhouse-ում հետագա վիզուալիզացիայի համար:
Այսպիսով, մենք դասավորեցինք ճարտարապետությունը. եկեք սկսենք ցնցել Yandex.Cloud-ը:
Դիմում գրելը
Նախքան Cloud-ը, դուք դեռ պետք է մի փոքր համբերատար լինեք և գրեք բավականին պարզ ծառայություն մուտքային իրադարձությունները մշակելու համար: Մենք կօգտագործենք գոլանգը, քանի որ այն շատ լավ ապացուցել է իրեն որպես ցանցային հավելվածներ գրելու լեզու:
Մեկ ժամ (գուցե մի քանի ժամ) ծախսելուց հետո մենք ստանում ենք այսպիսի բան. .
Որո՞նք են այն հիմնական կետերը, որոնք ես կցանկանայի նշել այստեղ.
1. Հավելվածը գործարկելիս կարող եք նշել երկու դրոշ: Մեկը պատասխանատու է այն նավահանգստի համար, որի վրա մենք կլսենք մուտքային http հարցումները (-addr): Երկրորդը kafka սերվերի հասցեի համար է, որտեղ մենք կգրանցենք մեր իրադարձությունները (-kafka).
addr = flag.String("addr", ":8080", "TCP address to listen to")
kafka = flag.String("kafka", "127.0.0.1:9092", "Kafka endpoints”)2. Հավելվածն օգտագործում է sarama գրադարանը () կաֆկա կլաստերին հաղորդագրություններ ուղարկելու համար: Մենք անմիջապես սահմանեցինք պարամետրերը, որոնք ուղղված են մշակման առավելագույն արագությանը.
config := sarama.NewConfig()
config.Producer.RequiredAcks = sarama.WaitForLocal
config.Producer.Compression = sarama.CompressionSnappy
config.Producer.Return.Successes = true3. Մեր հավելվածն ունի նաև ներկառուցված պրոմեթևսի հաճախորդ, որը հավաքում է տարբեր չափումներ, ինչպիսիք են.
- մեր դիմումին ուղղված հարցումների քանակը.
- հարցումը կատարելիս սխալների քանակը (անհնար է կարդալ գրառման հարցումը, կոտրված json, անհնար է գրել Կաֆկային);
- հաճախորդի մեկ հարցման մշակման ժամանակը, ներառյալ Կաֆկային հաղորդագրություն գրելու ժամանակը:
4. Երեք վերջնակետ, որը մշակում է մեր դիմումը.
- /status - պարզապես վերադարձեք ok՝ ցույց տալու համար, որ մենք ողջ ենք: Թեև կարող եք ավելացնել որոշ ստուգումներ, օրինակ՝ Կաֆկա կլաստերի առկայությունը:
- /metrics - ըստ այս url-ի, պրոմեթևսի հաճախորդը կվերադարձնի իր հավաքած չափումները:
- /post-ը հիմնական վերջնակետն է, որտեղ կուղարկվեն POST հարցումները ներսում json-ով: Մեր հավելվածը ստուգում է json-ի վավերականությունը և եթե ամեն ինչ կարգին է, այն գրում է տվյալները Kafka կլաստերում:
Ես վերապահում կանեմ, որ կոդը կատարյալ չէ. այն կարող է (և պետք է) լրացվի: Օրինակ, դուք կարող եք դադարեցնել ներկառուցված ցանցի օգտագործումը և անցնել ավելի արագ http-ին: Կամ դուք կարող եք ձեռք բերել մշակման ժամանակ և պրոցեսորի ռեսուրսներ՝ տեղափոխելով json վավերականության ստուգումը ավելի ուշ փուլ, երբ տվյալները փոխանցվում են բուֆերից դեպի clickhouse կլաստեր:
Բացի խնդրի զարգացման կողմից, մենք անմիջապես մտածեցինք մեր ապագա ենթակառուցվածքի մասին և որոշեցինք մեր հավելվածը տեղադրել docker-ի միջոցով: Հավելվածի ստեղծման վերջնական Dockerfile-ն է . Ընդհանուր առմամբ, դա բավականին պարզ է, միակ կետը, որին ես կցանկանայի ուշադրություն դարձնել, բազմաստիճան հավաքումն է, որը թույլ է տալիս նվազեցնել մեր կոնտեյների վերջնական պատկերը:
Առաջին քայլերը ամպի մեջ
Առաջին հերթին գրանցվեք . Բոլոր անհրաժեշտ դաշտերը լրացնելուց հետո մեզ հաշիվ կստեղծեն և դրամաշնորհ կտրամադրեն որոշակի գումարի դիմաց, որը կարող է օգտագործվել ամպային ծառայությունները փորձարկելու համար։ Եթե ցանկանում եք կրկնել մեր հոդվածի բոլոր քայլերը, ապա այս դրամաշնորհը ձեզ պետք է բավարարի։
Գրանցվելուց հետո ձեզ համար կստեղծվի առանձին ամպ և լռելյայն գրացուցակ, որում կարող եք սկսել ստեղծել ամպային ռեսուրսներ։ Ընդհանուր առմամբ, Yandex.Cloud-ում ռեսուրսների հարաբերությունն այսպիսի տեսք ունի.
Մեկ հաշվի համար կարող եք ստեղծել մի քանի ամպ: Եվ ամպի ներսում տարբեր դիրեկտորիաներ պատրաստեք տարբեր ընկերության նախագծերի համար: Այս մասին ավելին կարող եք կարդալ փաստաթղթերում. . Ի դեպ, ստորև տեքստում հաճախ կանդրադառնամ դրան։ Երբ ես զրոյից ստեղծեցի ամբողջ ենթակառուցվածքը, փաստաթղթերն ինձ օգնեցին մեկից ավելի անգամ, ուստի խորհուրդ եմ տալիս ուսումնասիրել այն:
Ամպը կառավարելու համար կարող եք օգտագործել և՛ վեբ ինտերֆեյսը, և՛ վահանակի օգտակար ծրագիրը՝ yc: Տեղադրումն իրականացվում է մեկ հրամանով (Linux-ի և Mac Os-ի համար).
curl https://storage.yandexcloud.net/yandexcloud-yc/install.sh | bashԵթե ձեր ներքին անվտանգության մասնագետը մոլեգնում է ինտերնետից սկրիպտներ գործարկելու մասին, ապա, առաջին հերթին, դուք կարող եք բացել սկրիպտը և կարդալ այն, և երկրորդ՝ մենք այն գործարկում ենք մեր օգտատիրոջ ներքո՝ առանց արմատային իրավունքների:
Եթե ցանկանում եք Windows-ի համար հաճախորդ տեղադրել, կարող եք օգտագործել հրահանգները իսկ հետո կատարել 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:~ $Սկզբունքորեն, գործընթացը պարզ է. նախ դուք պետք է ստանաք oauth նշան ամպը կառավարելու համար, ընտրեք ամպը և այն թղթապանակը, որը դուք կօգտագործեք:
Եթե դուք ունեք մի քանի հաշիվներ կամ թղթապանակներ նույն ամպում, կարող եք ստեղծել լրացուցիչ պրոֆիլներ՝ առանձին կարգավորումներով, yc config պրոֆիլի ստեղծման և դրանց միջև անցնելու միջոցով:
Բացի վերը նշված մեթոդներից, Yandex.Cloud թիմը գրել է շատ լավ ամպային ռեսուրսների կառավարման համար: Իմ կողմից ես պատրաստեցի git պահոց, որտեղ նկարագրեցի բոլոր ռեսուրսները, որոնք կստեղծվեն որպես հոդվածի մաս. . Մեզ հետաքրքրում է գլխավոր մասնաճյուղը, եկեք կլոնավորենք այն լոկալ.
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/Բոլոր հիմնական փոփոխականները, որոնք օգտագործվում են terraform-ում, գրված են main.tf ֆայլում։ Սկսելու համար terraform պանակում ստեղծեք 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 կազմաձևման ցանկից, քանի որ մենք արդեն կարգավորել ենք կոնսոլի կոմունալ ծրագիրը: Խորհուրդ եմ տալիս անհապաղ ավելացնել private.auto.tfvars-ը .gitignore-ում, որպեսզի պատահաբար անձնական տվյալները չհրապարակվեն:
private.auto.tfvars-ում մենք նաև նշել ենք տվյալներ Cloudflare-ից՝ DNS գրառումներ ստեղծելու և հիմնական տիրույթի events.kis.im-ը մեր սերվերներին վստահորդելու համար: Եթե դուք չեք ցանկանում օգտագործել cloudflare, ապա հեռացրեք cloudflare մատակարարի սկզբնավորումը main.tf-ում և dns.tf ֆայլը, որը պատասխանատու է անհրաժեշտ dns գրառումների ստեղծման համար:
Մեր աշխատանքում մենք համատեղելու ենք բոլոր երեք մեթոդները՝ վեբ ինտերֆեյսը, կոնսոլային կոմունալը և տերրաֆորմը:
Վիրտուալ ցանցեր
Անկեղծ ասած, դուք կարող եք բաց թողնել այս քայլը, քանի որ նոր ամպ ստեղծելիս ավտոմատ կերպով կունենաք առանձին ցանց և 3 ենթացանցեր՝ մեկական հասանելիության յուրաքանչյուր գոտու համար: Բայց մենք դեռ կցանկանայինք առանձին ցանց ստեղծել մեր նախագծի համար՝ իր հասցեներով։ Ընդհանուր դիագրամը, թե ինչպես է ցանցը աշխատում Yandex.Cloud-ում, ներկայացված է ստորև բերված նկարում (անկեղծ վերցված է. )
Այսպիսով, դուք ստեղծում եք ընդհանուր ցանց, որի շրջանակներում ռեսուրսները կարող են շփվել միմյանց հետ: Յուրաքանչյուր հասանելիության գոտու համար ստեղծվում է ենթացանց՝ իր հասցեագրմամբ և միացված է ընդհանուր ցանցին։ Արդյունքում, դրա մեջ գտնվող բոլոր ամպային ռեսուրսները կարող են հաղորդակցվել, նույնիսկ եթե դրանք գտնվում են տարբեր հասանելիության գոտիներում: Տարբեր ամպային ցանցերի հետ կապված ռեսուրսները կարող են միմյանց տեսնել միայն արտաքին հասցեների միջոցով: Ի դեպ, ինչպես է այս կախարդանքն աշխատում ներսում, .
Ցանցի ստեղծումը նկարագրված է շտեմարանից network.tf ֆայլում: Այնտեղ մենք ստեղծում ենք մեկ ընդհանուր մասնավոր ցանց ներքին և դրան միացնում ենք երեք ենթացանց տարբեր հասանելիության գոտիներում՝ ներքին-a (172.16.1.0/24), ներքին-b (172.16.2.0/24), ներքին-c (172.16.3.0/24): )
Նախաձեռնեք terraform և ստեղծեք ցանցեր.
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-ի միջոցով, ուստի նախքան terraform-ը սկսելը, համոզվեք, որ ունեք ansible-ի վերջին տարբերակներից մեկը: Եվ տեղադրեք անհրաժեշտ դերերը 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 թղթապանակի ներսում կա .ansible.cfg կազմաձևման ֆայլի օրինակ, որը ես օգտագործում եմ: Դա կարող է օգտակար լինել:
Վիրտուալ մեքենաներ ստեղծելուց առաջ համոզվեք, որ ssh-agent-ն աշխատում է և ավելացված է ssh ստեղն, հակառակ դեպքում terraform-ը չի կարողանա միանալ ստեղծված մեքենաներին: Ես, իհարկե, os x-ում սխալի հանդիպեցի. . Որպեսզի դա նորից չկրկնվի, նախքան Terraform-ը գործարկելը env-ին մի փոքր փոփոխական ավելացրեք.
vozerov@mba:~/events/terraform (master) $ export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YESTerraform-ով թղթապանակում մենք ստեղծում ենք անհրաժեշտ ռեսուրսները.
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 ...Եթե ամեն ինչ հաջողությամբ ավարտվի (և դա պետք է լինի), ապա մենք կունենանք երեք վիրտուալ մեքենա.
- build - մեքենա փորձարկման և հավելված ստեղծելու համար: Docker-ը տեղադրվել է ավտոմատ կերպով Ansible-ի կողմից:
- մոնիտորինգ՝ դրա վրա տեղադրված մոնիտորինգի մեքենա՝ պրոմեթևս և գրաֆանա։ Մուտք / գաղտնաբառ ստանդարտ. admin / admin
- 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 հասցեները: Հետևյալի ողջ ընթացքում ես կօգտագործեմ IP հասցեները ssh-ի միջոցով միանալու և հավելվածը փորձարկելու համար: Եթե դուք ունեք cloudflare հաշիվ, որը միացված է terraform-ին, ազատ զգալ օգտագործեք նոր ստեղծված 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-ով:
Հավելվածի հավաքում
Հիանալի, կան սերվերներ, կա հավելված, մնում է հավաքել և հրապարակել: Կառուցման համար մենք կօգտագործենք սովորական docker build-ը, բայց որպես պատկերի պահեստ՝ մենք կօգտագործենք ծառայությունը Yandex-ից՝ կոնտեյներային ռեգիստրից: Բայց առաջին հերթին առաջինը:
Մենք պատճենում ենք հավելվածը build machine-ում, մուտք ենք գործում 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Գործի կեսն ավարտված է. այժմ մենք կարող ենք ստուգել մեր հավելվածի ֆունկցիոնալությունը՝ գործարկելով այն և ուղարկելով այն kafka:
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) $Հավելվածը հաջողությամբ արձագանքեց ձայնագրությանը և նշելով այն բաժանման ID-ն և օֆսեթը, որում ներառված էր հաղորդագրությունը: Մնում է միայն 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 նշան կամ սպասարկման հաշվի բանալի: Այս մեթոդների մասին ավելի շատ մանրամասներ կարելի է գտնել փաստաթղթերում: . Մենք կօգտագործենք ծառայության հաշվի բանալին, այնպես որ մենք ստեղծում ենք հաշիվ.
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Մենք տեղեկատվություն ենք ստանում մեր պահեստի id-ի մասին, փոխանցում ենք բանալին և մուտք ենք գործում.
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:~$Պատկերը ռեեստր վերբեռնելու համար մեզ անհրաժեշտ է կոնտեյների ռեեստրի ID-ն, մենք այն վերցնում ենք 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 կոմունալ ծրագիրը Linux մեքենայի վրա, կարող եք օգտագործել հրամանը
yc container registry configure-dockerդոկերը կարգավորելու համար:
Ամփոփում
Մենք շատ քրտնաջան աշխատանք ենք կատարել և արդյունքում.
- Մենք մշակեցինք մեր ապագա ծառայության ճարտարապետությունը:
- Գոլանգով դիմում գրեցինք, որն իրականացնում է մեր բիզնես տրամաբանությունը։
- Մենք այն հավաքեցինք և լցրեցինք մասնավոր կոնտեյների ռեգիստր:
Հաջորդ մասում մենք կանցնենք հետաքրքիր բաներին՝ մենք կթողարկենք մեր հավելվածը արտադրության մեջ և վերջապես կգործարկենք դրա վրա բեռը: Մի փոխիր:
Այս նյութը գտնվում է REBRAIN & Yandex.Cloud բաց սեմինարի տեսագրության մեջ. Մենք ընդունում ենք վայրկյանում 10 հարցում Yandex Cloud-ում.
Եթե դուք հետաքրքրված եք առցանց մասնակցել նման միջոցառումներին և իրական ժամանակում հարցեր տալ, միացեք.
Ցանկանում ենք հատուկ շնորհակալություն հայտնել Yandex.Cloud-ին նման միջոցառում կազմակերպելու հնարավորության համար։ Հղում նրանց -
Եթե Ձեզ անհրաժեշտ է տեղափոխվել ամպ կամ ունեք հարցեր ձեր ենթակառուցվածքի վերաբերյալ, .
Հ.Գ Ամսական 2 անվճար աուդիտ ունենք, գուցե ձեր նախագիծը լինի դրանցից մեկը։
Source: www.habr.com