🥇Մենք ընդունում ենք 10 իրադարձություն Yandex.Cloud-ում։ Մաս 000

Բարև բոլորին, ընկերներ:

* Այս հոդվածը հիմնված է REBRAIN & Yandex.Cloud բաց սեմինարի վրա, եթե նախընտրում եք դիտել տեսանյութը, կարող եք գտնել այն այս հղումով. https://youtu.be/cZLezUm0ekE

Վերջերս մենք հնարավորություն ունեցանք փորձել 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-ը, դուք դեռ պետք է մի փոքր համբերատար լինեք և գրեք բավականին պարզ ծառայություն մուտքային իրադարձությունները մշակելու համար: Մենք կօգտագործենք գոլանգը, քանի որ այն շատ լավ ապացուցել է իրեն որպես ցանցային հավելվածներ գրելու լեզու:

Մեկ ժամ (գուցե մի քանի ժամ) ծախսելուց հետո մենք ստանում ենք այսպիսի բան. https://github.com/RebrainMe/yandex-cloud-events/blob/master/app/main.go.

Որո՞նք են այն հիմնական կետերը, որոնք ես կցանկանայի նշել այստեղ.

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 գրադարանը ([] github.com/Shopify/sarama) կաֆկա կլաստերին հաղորդագրություններ ուղարկելու համար: Մենք անմիջապես սահմանեցինք պարամետրերը, որոնք ուղղված են մշակման առավելագույն արագությանը.

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

3. Մեր հավելվածն ունի նաև ներկառուցված պրոմեթևսի հաճախորդ, որը հավաքում է տարբեր չափումներ, ինչպիսիք են.

մեր դիմումին ուղղված հարցումների քանակը.
հարցումը կատարելիս սխալների քանակը (անհնար է կարդալ գրառման հարցումը, կոտրված json, անհնար է գրել Կաֆկային);
հաճախորդի մեկ հարցման մշակման ժամանակը, ներառյալ Կաֆկային հաղորդագրություն գրելու ժամանակը:

4. Երեք վերջնակետ, որը մշակում է մեր դիմումը.

/status - պարզապես վերադարձեք ok՝ ցույց տալու համար, որ մենք ողջ ենք: Թեև կարող եք ավելացնել որոշ ստուգումներ, օրինակ՝ Կաֆկա կլաստերի առկայությունը:
/metrics - ըստ այս url-ի, պրոմեթևսի հաճախորդը կվերադարձնի իր հավաքած չափումները:
/post-ը հիմնական վերջնակետն է, որտեղ կուղարկվեն POST հարցումները ներսում json-ով: Մեր հավելվածը ստուգում է json-ի վավերականությունը և եթե ամեն ինչ կարգին է, այն գրում է տվյալները Kafka կլաստերում:

Ես վերապահում կանեմ, որ կոդը կատարյալ չէ. այն կարող է (և պետք է) լրացվի: Օրինակ, դուք կարող եք դադարեցնել ներկառուցված ցանցի օգտագործումը և անցնել ավելի արագ http-ին: Կամ դուք կարող եք ձեռք բերել մշակման ժամանակ և պրոցեսորի ռեսուրսներ՝ տեղափոխելով json վավերականության ստուգումը ավելի ուշ փուլ, երբ տվյալները փոխանցվում են բուֆերից դեպի clickhouse կլաստեր:

Բացի խնդրի զարգացման կողմից, մենք անմիջապես մտածեցինք մեր ապագա ենթակառուցվածքի մասին և որոշեցինք մեր հավելվածը տեղադրել docker-ի միջոցով: Հավելվածի ստեղծման վերջնական 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: Տեղադրումը կատարվում է մեկ հրամանով (օրինակ՝ 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 թիմը գրել է շատ լավ plugin տերրաֆորմի համար ամպային ռեսուրսների կառավարման համար: Իմ կողմից ես պատրաստեցի 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/

Բոլոր հիմնական փոփոխականները, որոնք օգտագործվում են 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-ում, ներկայացված է ստորև բերված նկարում (անկեղծ վերցված է. 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): )

Նախաձեռնեք 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-ում սխալի հանդիպեցի. https://github.com/ansible/ansible/issues/32499#issuecomment-341578864. Որպեսզի դա նորից չկրկնվի, նախքան Terraform-ը գործարկելը env-ին մի փոքր փոփոխական ավելացրեք.

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

Terraform-ով թղթապանակում մենք ստեղծում ենք անհրաժեշտ ռեսուրսները.

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/ ubuntu@84.201.132.3: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 նշան կամ սպասարկման հաշվի բանալի: Այս մեթոդների մասին ավելի շատ մանրամասներ կարելի է գտնել փաստաթղթերում: 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

Մենք տեղեկատվություն ենք ստանում մեր պահեստի id-ի մասին, փոխանցում ենք բանալին և մուտք ենք գործում.

vozerov@mba:~/events/terraform (master) $ scp key.json ubuntu@84.201.132.3:
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-ում. https://youtu.be/cZLezUm0ekE

Եթե դուք հետաքրքրված եք առցանց մասնակցել նման միջոցառումներին և իրական ժամանակում հարցեր տալ, միացեք ալիք DevOps REBRAIN-ի կողմից.

Ցանկանում ենք հատուկ շնորհակալություն հայտնել Yandex.Cloud-ին նման միջոցառում կազմակերպելու հնարավորության համար։ Հղում նրանց - https://cloud.yandex.ru/prices

Եթե Ձեզ անհրաժեշտ է տեղափոխվել ամպ կամ ունեք հարցեր ձեր ենթակառուցվածքի վերաբերյալ, ազատ զգալ թողնել խնդրանք.

Հ.Գ Ամսական 2 անվճար աուդիտ ունենք, գուցե ձեր նախագիծը լինի դրանցից մեկը։

Source: www.habr.com