ProHoster > Օրագիր > Վարչակազմը > Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Բարեւ բոլորին! Որպես իմ կուրսային աշխատանքի մի մաս, ես ուսումնասիրեցի այնպիսի ներքին ամպային հարթակի հնարավորությունները, ինչպիսին Yandex.Cloud. Հարթակն առաջարկում է տարբեր ծառայություններ՝ գործնական խնդիրների լուծման համար։ Այնուամենայնիվ, երբեմն ձեզ անհրաժեշտ է ստեղծել ձեր սեփական ամպային հավելվածը՝ այս ծառայությունների վրա հիմնված բավականին ընդարձակ ենթակառուցվածքով: Այս հոդվածում ես ուզում եմ կիսվել նման հավելվածի տեղակայման իմ փորձով:

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Ի՞նչ եք ուզում ստանալ:

Գրաֆանա — հզոր գործիք ցանկացած համակարգի վերլուծական խնդիրների կամ մոնիտորինգի խնդիրների լուծման համար: Իր հիմնական կազմաձևով սա վիրտուալ մեքենա է Grafana վեբ սերվերով, ինչպես նաև տվյալների բազա (ClickHouse, InfluxDB և այլն) տվյալների բազայով, որի վրա հիմնված կլինի վերլուծությունը:

Վեբ սերվերով վիրտուալ մեքենա գործարկելուց հետո կարող եք գնալ դրա հոսթ և ստանալ գեղեցիկ միջերես, նշել տվյալների բազաները որպես հետագա աշխատանքի աղբյուրներ, ստեղծել վահանակներ և գծապատկերներ:

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Հիմնական տարբերակն ունի մեկ նշանակալի թերություն՝ այն բացարձակապես հանդուրժող չէ սխալների նկատմամբ: Այսինքն՝ հավելվածի ողջ ֆունկցիոնալությունը կախված է մեկ վիրտուալ մեքենայի կենսունակությունից։ Եթե ​​հրաժարվի կամ 10 հոգի միաժամանակ բացեն UI-ն, ապա խնդիրներ կառաջանան։

Դրանք կարելի է պարզապես լուծել. պարզապես անհրաժեշտ է... տեղակայել բազմաթիվ նույնական վիրտուալ մեքենաներ վեբ սերվերով և տեղադրել դրանք L3 հավասարակշռողի տակ: Բայց այստեղ ամեն ինչ այնքան էլ պարզ չէ: Grafana-ն պահում է օգտատիրոջ կարգավորումները (ուղիներ դեպի տվյալների շտեմարաններ, վահանակներ, գրաֆիկներ և այլն) անմիջապես իր վիրտուալ մեքենայի սկավառակի վրա: Այսպիսով, եթե մենք փոխենք որոշ կարգավորումներ UI-ում, այդ փոփոխությունները կարտացոլվեն միայն վիրտուալ մեքենայի վրա, որտեղ հավասարակշռողը մեզ ուղարկել է: Սա կհանգեցնի մեր հավելվածի անհամապատասխան կարգավորումների՝ գործարկման և օգտագործման հետ կապված խնդիրներ առաջացնելով:

Այստեղ օգնության կգա մեկ այլ տվյալների բազա, օրինակ՝ MySQL-ը կամ դրա համարժեքը։ Մենք Գրաֆանային ասում ենք, որ նա պետք է պահպանի օգտվողի կարգավորումները այս «պահեստային» տվյալների բազայում: Այնուհետև, բավական կլինի յուրաքանչյուր մեքենայի վրա մեկ անգամ նշել դեպի այս տվյալների բազայի ուղին և վիրտուալ մեքենաներից որևէ մեկի վրա խմբագրել օգտվողի մյուս բոլոր կարգավորումները, դրանք կտարածվեն մյուսների վրա:

Ահա վերջնական կիրառական ենթակառուցվածքի դիագրամ.

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Եկեք սովորենք բարձրացնել մեր ձեռքերով

MySQL և ClickHouse

Նախքան կոճակի սեղմումով նման հավելվածը տեղակայելը, անհրաժեշտ էր սովորել, թե ինչպես վարվել դրա յուրաքանչյուր բաղադրիչի հետ և ինտեգրել դրանք միմյանց հետ:

Այստեղ մեզ կօգնի Yandex.Cloud-ը, որը տրամադրում է L3 հավասարակշռողներ, ClickHouse և MySQL՝ որպես կառավարվող ծառայություններ։ Օգտագործողը պետք է միայն նշի պարամետրերը և սպասի, մինչև հարթակն ամեն ինչ աշխատի:

Ես գրանցվեցի, ստեղծեցի ամպ և վճարային հաշիվ: Դրանից հետո ես գնացի ամպ և տեղադրեցի MySQL և ClickHouse կլաստերները՝ նվազագույն կարգավորումներով։ Սպասեցի, մինչև նրանք ակտիվանան։

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակովԲաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Դուք նաև պետք է հիշեք, որ յուրաքանչյուր կլաստերում ստեղծել տվյալների բազա և կարգավորել մուտքը դեպի այն՝ օգտագործելով մուտքի և գաղտնաբառի միջոցով: Ես այստեղ մանրամասների մեջ չեմ մտնի, ամեն ինչ բավականին ակնհայտ է ինտերֆեյսի մեջ:

Ոչ ակնհայտ մանրամասնությունն այն էր, որ այս տվյալների շտեմարաններն ունեն բազմաթիվ հոսթներ, որոնք ապահովում են դրանց սխալների հանդուրժողականությունը։ Այնուամենայնիվ, Grafana-ն պահանջում է ճշգրիտ մեկ հոսթ յուրաքանչյուր տվյալների բազայի համար, որի հետ աշխատում է: Երկար ընթերցանություն փաստաթղթավորում Ամպերն ինձ որոշման բերեցին. Պարզվում է, որ տեսակի հյուրընկալող c-<cluster_id>.rw.mdb.yandexcloud.net քարտեզագրված կլաստերի ընթացիկ ակտիվ գլխավոր հյուրընկալողին՝ համապատասխան ID-ով: Ահա թե ինչ ենք տալու Գրաֆանային։

վեբ սերվեր

Այժմ դա կախված է վեբ սերվերին: Եկեք բարձրացնենք սովորական վիրտուալ մեքենա Linux-ով և ձեռքով կարգավորենք Grafana-ն դրա վրա:

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Եկեք միանանք ssh-ի միջոցով և տեղադրենք անհրաժեշտ փաթեթները։

sudo apt-get install -y apt-transport-https software-properties-common wget
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
sudo add-apt-repository "deb https://packages.grafana.com/enterprise/deb stable main"
sudo apt-get update
sudo apt-get install -y grafana-enterprise

Դրանից հետո եկեք գործարկենք Grafana-ն systemctl-ի տակ և տեղադրենք ClickHouse-ի հետ աշխատելու պլագինը (այո, այն չի մատակարարվում հիմնական փաթեթում):

sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasource

Վերջ, դրանից հետո պարզ հրամանով 

sudo service grafana-server start

մենք կգործարկենք վեբ սերվերը: Այժմ դուք կարող եք մուտքագրել վիրտուալ մեքենայի արտաքին IP հասցեն բրաուզերում, նշել պորտը 3000 և տեսնել գեղեցիկ Grafana UI-ը:
Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Բայց մի շտապեք, նախքան Grafana-ն կարգավորելը, դուք պետք է հիշեք, որ նրան ասեք դեպի MySQL ուղին, որպեսզի այնտեղ պահեք կարգավորումները:

Grafana վեբ սերվերի ամբողջ կոնֆիգուրացիան գտնվում է ֆայլում /etc/grafana/grafana.ini. Պահանջվող գիծն ունի հետևյալ տեսքը.

;url =

Մենք հոսթին դրեցինք MySQL կլաստերի վրա: Նույն ֆայլը պարունակում է վերևի նկարում պատկերված Grafana մուտք գործելու մուտքն ու գաղտնաբառը, որոնք ըստ նախնականի երկուսն էլ հավասար են admin.

Դուք կարող եք օգտագործել sed հրամանները.

sudo sed -i "s#.*;url =.*#url = mysql://${MYSQL_USERNAME}:${MYSQL_PASSWORD}@${MYSQL_CLUSTER_URI}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${GRAFANA_USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${GRAFANA_PASSWORD}#" /etc/grafana/grafana.ini

Ժամանակն է վերագործարկել վեբ սերվերը:

sudo service grafana-server restart

Այժմ Grafana UI-ում մենք կնշենք ClickHouse-ը որպես DataSource:

Ես կարողացա հասնել աշխատանքային կազմաձևման հետևյալ պարամետրերով.

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Ես նշել եմ որպես URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

Բոլորը! Մենք ունենք մեկ աշխատող վիրտուալ մեքենա՝ CH-ին և MySQL-ին միացված վեբ սերվերով: Դուք արդեն կարող եք վերբեռնել տվյալների հավաքածուն ClickHouse-ում և ստեղծել վահանակներ: Սակայն մենք դեռ չենք հասել մեր նպատակին և չենք տեղադրել լիարժեք ենթակառուցվածք։

Փաքեր

Yandex.Cloud-ը թույլ է տալիս ստեղծել գոյություն ունեցող վիրտուալ մեքենայի սկավառակի պատկեր, և դրա հիման վրա՝ ցանկացած թվով մեքենաներ, որոնք նույնական են միմյանց: Սա հենց այն է, ինչ մենք կօգտագործենք: Պատկերը հարմար հավաքելու համար վերցրեք գործիքը Փաքեր HashiCorp-ից: Որպես մուտքագրվում է json ֆայլ՝ պատկերը հավաքելու հրահանգներով:

Մեր json ֆայլը բաղկացած կլինի երկու բլոկից՝ շինարարներ և մատակարարներ: Առաջին բլոկը նկարագրում է պատկերի պարամետրերը որպես ամբողջություն, իսկ երկրորդ բլոկը նկարագրում է հրահանգներ այն անհրաժեշտ բովանդակությամբ լրացնելու համար:

Builders

{
"builders": [
    {
      "type": "yandex",
      "endpoint": "{{user `endpoint`}}",
      "folder_id": "<folder_id>",
      "subnet_id": "{{user `subnet_id`}}",
      "zone": "{{user `zone`}}",
      "labels": {},
      "use_ipv4_nat": true,
      "use_internal_ip": false,
      "service_account_key_file": "<service_account_key_file>",
      "image_name": "grafana-{{timestamp}}",
      "image_family": "grafana",
      "image_labels": {},
      "image_description": "GRAFANA",
      "source_image_family": "ubuntu-1804-lts",
      "disk_size_gb": 3,
      "disk_type": "network-hdd",
      "ssh_username": "ubuntu"
    }
  ],
...
}

Այս ձևանմուշում դուք պետք է սահմանեք ամպի այն հատվածի նույնացուցիչը, որտեղ ցանկանում եք ստեղծել պատկերը, ինչպես նաև դեպի ֆայլ տանող ուղին՝ այս բաժնում նախկինում ստեղծված ծառայության հաշվի բանալիներով: Ծառայությունների հաշիվներ և բանալիներ ֆայլի տեսքով ստեղծելու մասին ավելին կարող եք կարդալ համապատասխան բաժնում փաստաթղթավորում.

Այս կոնֆիգուրացիան ասում է, որ սկավառակի պատկերը կկառուցվի հարթակի հիման վրա ubuntu-1804-lts, տեղադրված է պատկերների ընտանիքում օգտագործողի համապատասխան բաժնում GRAFANA անվան տակ grafana-{{timestamp}}.

Մատակարարներ

Այժմ գալիս է կազմաձևման ավելի հետաքրքիր մասը: Այն կնկարագրի գործողությունների հաջորդականությունը, որոնք պետք է կատարվեն վիրտուալ մեքենայի վրա՝ նախքան դրա վիճակը սկավառակի պատկերի մեջ սառեցնելը: 

{
...,
"provisioners": [
    {
            "type": "shell",
            "pause_before": "5s",
            "scripts": [
                "prepare-ctg.sh"
            ]
        },
    {
            "type": "file",
            "source": "setup.sh",
            "destination": "/opt/grafana/setup.sh"
        },
        {
            "type": "shell",
        "execute_command": "sudo {{ .Vars }} bash '{{ .Path }}'",
            "pause_before": "5s",
            "scripts": [
                "install-packages.sh",
                "grafana-setup.sh",
                "run-setup-at-reboot.sh"
        ]
        }
  ]
}

Այստեղ բոլոր գործողությունները բաժանված են 3 փուլերի. Առաջին փուլում կատարվում է պարզ սցենար, որը ստեղծում է օժանդակ գրացուցակ:

պատրաստել-ctg.sh:

#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafana

Հաջորդ փուլում մենք այս գրացուցակում տեղադրում ենք սցենար, որը պետք է գործարկվի վիրտուալ մեքենան գործարկելուց անմիջապես հետո: Այս սկրիպտը կտեղադրի օգտվողի փոփոխականները, որոնք պետք է գրանցվեն Grafana կոնֆիգուրացիայի մեջ և կվերագործարկեն վեբ սերվերը:

setup.sh:

#!/bin/bash
CLUSTER_ID="<cluster_id>"
USERNAME="<username>"
PASSWORD="<password>"
sudo sed -i "s#.*;url =.*#url = mysql://${USERNAME}:${PASSWORD}@c-${CLUSTER_ID}.rw.mdb.yandexcloud.net#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${PASSWORD}#" /etc/grafana/grafana.ini
sudo service grafana-server restart

Դրանից հետո մնում է 3 բան անել.
1) տեղադրել փաթեթներ
2) գործարկել Grafana-ն systemctl-ի տակ և տեղադրել ClickHouse հավելվածը
3) setup.sh սկրիպտը տեղադրեք գործարկման հերթում՝ վիրտուալ մեքենան միացնելուց անմիջապես հետո:

install-packages.sh:

#!/bin/bash
sudo systemd-run --property='After=apt-daily.service apt-daily-upgrade.service' --wait /bin/true
sudo apt-get install -y apt-transport-https
sudo apt-get install -y software-properties-common wget
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
sudo add-apt-repository "deb https://packages.grafana.com/enterprise/deb stable main"
sudo apt-get update
sudo apt-get install -y grafana-enterprise

grafana-setup.sh:

#!/bin/bash
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasource

run-setup-at-reboot.sh:

#!/bin/bash
chmod +x /opt/grafana/setup.sh
cat > /etc/cron.d/first-boot <<EOF
PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games
@reboot root /bin/bash /opt/grafana/setup.sh > /var/log/yc-setup.log 2>&1
EOF
chmod +x /etc/cron.d/first-boot;

Այժմ մնում է գործարկել Packer-ը և ստանալ նշված հատվածում տեղադրված ելքային պատկերը: Վիրտուալ մեքենա ստեղծելիս կարող եք այն ընտրել որպես boot disk և գործարկումից հետո կստանաք պատրաստի Grafana վեբ սերվեր:

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով
Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Օրինակների խումբ և հավասարակշռող

Երբ մենք ունենք սկավառակի պատկեր, որը թույլ է տալիս մեզ ստեղծել բազմաթիվ նույնական Grafana վեբ սերվերներ, մենք կարող ենք ստեղծել օրինակների խումբ: Yandex.Cloud հարթակում այս տերմինը վերաբերում է վիրտուալ մեքենաների միավորմանը, որոնք ունեն նույն բնութագրերը: Օրինակների խումբ ստեղծելիս կազմաձևվում է այս խմբի բոլոր մեքենաների նախատիպը, այնուհետև բուն խմբի բնութագրերը (օրինակ՝ ակտիվ մեքենաների նվազագույն և առավելագույն քանակը): Եթե ​​ընթացիկ թիվը չի համապատասխանում այս չափանիշներին, ապա օրինակների խումբն ինքը կհեռացնի ավելորդ մեքենաները կամ կստեղծի նորերը՝ իր պատկերով:

Որպես մեր առաջադրանքի մաս, մենք կստեղծենք վեբ սերվերների մի խումբ, որը կստեղծվի նախկինում ստեղծված սկավառակի պատկերից:

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Իսկապես ուշագրավը վերջին օրինակի խմբի կարգավորումն է: Load Balancer-ի հետ ինտեգրված թիրախային խումբը կօգնի ձեզ կարգավորել L3 հավասարակշռիչը այս խմբի վիրտուալ մեքենաների վերևում՝ սեղմելով մի քանի կոճակ:

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Հավասարակշռիչը տեղադրելիս ես իրականացրեցի երկու կարևոր կետ.

  1. Ես ստիպեցի հավասարակշռողին ընդունել 80-րդ նավահանգստի օգտատերերի տրաֆիկը և այն վերահղել դեպի վիրտուալ մեքենաների 3000 նավահանգիստ, հենց այնտեղ, որտեղ ապրում է Գրաֆանան:
  2. Ես կարգավորեցի մեքենաների կենսունակության ստուգումը` դրանք 3000 նավահանգիստին կապելով:

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Մինի ամփոփում

Վերջապես, մենք կարողացանք ձեռքով տեղակայել ցանկալի հավելվածի ենթակառուցվածքը, և այժմ մենք ունենք բարձր ճկուն Grafana ծառայություն: Դուք միայն պետք է իմանաք հավասարակշռողի IP հասցեն՝ որպես հավելվածի մուտքի կետ և ClickHouse կլաստերի հոսթ, որպեսզի բեռնեք տվյալների բազան դրա մեջ:

Կթվա՞, թե դա հաղթանակ է: Այո, հաղթանակ: Բայց ինչ-որ բան դեռ շփոթեցնում է ինձ։ Վերոնշյալ ողջ գործընթացը պահանջում է բազմաթիվ ձեռքով քայլեր և ընդհանրապես մասշտաբային չէ, ես կցանկանայի այն ավտոմատացնել, եթե հնարավոր է: Ահա թե ինչին է նվիրված հաջորդ բաժինը:

Terraform ինտեգրում

Մենք կրկին կօգտագործենք HashiCorp-ի գործիքը, որը կոչվում է Terraform. Այն կօգնի ձեզ տեղակայել հավելվածի ողջ ենթակառուցվածքը կոճակի սեղմումով` հիմնվելով օգտագործողի կողմից փոխանցված մի քանի փոփոխականների վրա: Եկեք գրենք բաղադրատոմս, որը կարող է մի քանի անգամ գործարկվել տարբեր օգտվողների տարբեր բաժիններում:

Terraform-ի հետ ամբողջ աշխատանքը հանգում է կազմաձևման ֆայլ գրելուն (*.tf) և դրա հիման վրա ենթակառուցվածքների ստեղծումը։

Փոփոխականներ

Ֆայլի հենց սկզբում մենք կներառենք փոփոխականներ, որոնք որոշում են, թե որտեղ և ինչպես կտեղակայվի ապագա ենթակառուցվածքը: 

variable "oauth_token" {
    type = string
    default = "<oauth-token>"
}
variable "cloud_id" {
    type = string
    default = "<cloud-id>"
}
variable "folder_id" {
    type = string
    default = "<folder_id>"
}
variable "service_account_id" {
    type = string
    default = "<service_account_id>"
}
variable "image_id" {
    type = string
    default = "<image_id>"
}
variable "username" {
    type = string
    default = "<username>"
}
variable "password" {
    type = string
    default = "<password>"
}
variable "dbname" {
    type = string
    default = "<dbname>"
}
variable "public_key_path" {
    type = string
    default = "<path to ssh public key>"
}

Հավելվածի տեղակայման ողջ գործընթացը կհանգեցնի սկավառակի պատկերի ստեղծմանը և այս փոփոխականների տեղադրմանը: Թույլ տվեք բացատրել, թե ինչի համար են նրանք պատասխանատու.

oauth_token — ամպ մուտք գործելու նշան: Հնարավոր է ձեռք բերել ՈՒղեցույց.
cloud_id — ամպի նույնացուցիչ, որտեղ մենք կտեղակայենք հավելվածը
folder_id — բաժնի նույնացուցիչը, որտեղ մենք կտեղակայենք հավելվածը
service_account_id — ծառայության հաշվի նույնացուցիչը ամպի համապատասխան բաժնում:
image_id — Packer-ի միջոցով ստացված սկավառակի պատկերի նույնացուցիչը
օգտագործողի անունը и Գաղտնաբառ — օգտվողի անուն և գաղտնաբառ և՛ տվյալների բազաներ, և՛ Grafana վեբ սերվեր մուտք գործելու համար
dbname - տվյալների բազայի անունը CH և MySQL կլաստերների ներսում
public_key_path — ֆայլի ուղին ձեր հանրային ssh բանալիով, որը կարող եք օգտագործել անվան տակ միանալու համար ubuntu վեբ սերվերներով վիրտուալ մեքենաներին

Մատակարարի կարգավորում

Այժմ դուք պետք է կարգավորեք Terraform մատակարարը, մեր դեպքում, Yandex:

provider "yandex" {
  token     = var.oauth_token
  cloud_id  = var.cloud_id
  folder_id = var.folder_id
  zone      = "ru-central1-a"
}

Կնկատեք, որ այստեղ մենք օգտագործում ենք վերը նշված փոփոխականները:

Ցանց և կլաստերներ

Այժմ մենք կստեղծենք ցանց, որտեղ մեր ենթակառուցվածքի տարրերը կհաղորդակցվեն, երեք ենթացանց (մեկական յուրաքանչյուր տարածաշրջանում) և կբարձրացնեն CH և MySQL կլաստերները:


resource "yandex_vpc_network" "grafana_network" {}

resource "yandex_vpc_subnet" "subnet_a" {
  zone           = "ru-central1-a"
  network_id     = yandex_vpc_network.grafana_network.id
  v4_cidr_blocks = ["10.1.0.0/24"]
}

resource "yandex_vpc_subnet" "subnet_b" {
  zone           = "ru-central1-b"
  network_id     = yandex_vpc_network.grafana_network.id
  v4_cidr_blocks = ["10.2.0.0/24"]
}

resource "yandex_vpc_subnet" "subnet_c" {
  zone           = "ru-central1-c"
  network_id     = yandex_vpc_network.grafana_network.id
  v4_cidr_blocks = ["10.3.0.0/24"]
}

resource "yandex_mdb_clickhouse_cluster" "ch_cluster" {
  name        = "grafana-clickhouse"
  environment = "PRODUCTION"
  network_id  = yandex_vpc_network.grafana_network.id

  clickhouse {
    resources {
      resource_preset_id = "s2.micro"
      disk_type_id       = "network-ssd"
      disk_size          = 16
    }
  }

  zookeeper {
    resources {
      resource_preset_id = "s2.micro"
      disk_type_id       = "network-ssd"
      disk_size          = 10
    }
  }

  database {
    name = var.dbname
  }

  user {
    name     = var.username
    password = var.password
    permission {
      database_name = var.dbname
    }
  }

  host {
    type      = "CLICKHOUSE"
    zone      = "ru-central1-a"
    subnet_id = yandex_vpc_subnet.subnet_a.id
  }

  host {
    type      = "CLICKHOUSE"
    zone      = "ru-central1-b"
    subnet_id = yandex_vpc_subnet.subnet_b.id
  }

  host {
    type      = "CLICKHOUSE"
    zone      = "ru-central1-c"
    subnet_id = yandex_vpc_subnet.subnet_c.id
  }

  host {
    type      = "ZOOKEEPER"
    zone      = "ru-central1-a"
    subnet_id = yandex_vpc_subnet.subnet_a.id
  }

  host {
    type      = "ZOOKEEPER"
    zone      = "ru-central1-b"
    subnet_id = yandex_vpc_subnet.subnet_b.id
  }

  host {
    type      = "ZOOKEEPER"
    zone      = "ru-central1-c"
    subnet_id = yandex_vpc_subnet.subnet_c.id
  }
}

resource "yandex_mdb_mysql_cluster" "mysql_cluster" {
  name        = "grafana_mysql"
  environment = "PRODUCTION"
  network_id  = yandex_vpc_network.grafana_network.id
  version     = "8.0"

  resources {
    resource_preset_id = "s2.micro"
    disk_type_id       = "network-ssd"
    disk_size          = 16
  }

  database {
    name = var.dbname
  }

  user {
    name     = var.username
    password = var.password
    permission {
      database_name = var.dbname
      roles         = ["ALL"]
    }
  }

  host {
    zone      = "ru-central1-a"
    subnet_id = yandex_vpc_subnet.subnet_a.id
  }
  host {
    zone      = "ru-central1-b"
    subnet_id = yandex_vpc_subnet.subnet_b.id
  }
  host {
    zone      = "ru-central1-c"
    subnet_id = yandex_vpc_subnet.subnet_c.id
  }
}

Ինչպես տեսնում եք, երկու կլաստերներից յուրաքանչյուրը ստեղծվել է բավականին սխալ հանդուրժող՝ տեղադրվելով երեք հասանելիության գոտիներում:

Վեբ սերվերներ

Թվում էր, թե կարող ենք շարունակել նույն ոգով, բայց ես դժվարության հանդիպեցի։ Մինչ այս ես նախ բարձրացրեցի MySQL կլաստերը և միայն դրանից հետո, իմանալով դրա ID-ն, հավաքեցի սկավառակի պատկերը պահանջվող կոնֆիգուրացիայով, որտեղ ես նշել էի կլաստերի հոսթերը։ Բայց հիմա մենք չգիտենք կլաստերի ID-ն նախքան Terraform-ի գործարկումը, այդ թվում՝ պատկերը ստեղծելու ժամանակ: Ուստի ես ստիպված էի դիմել հետևյալին հնարք.

Օգտագործելով Amazon-ի մետատվյալների ծառայությունը՝ մենք վիրտուալ մեքենային կփոխանցենք որոշ պարամետրեր, որոնք նա կընդունի և կմշակի։ Մեզ պետք է, որ մեքենան գործարկելուց հետո գնա MySQL կլաստերի հոսթի և օգտվողի անուն-գաղտնաբառի հետևում գտնվող մետատվյալներին, որոնք օգտատերը նշել է Terraform ֆայլում: Եկեք մի փոքր փոխենք ֆայլի բովանդակությունը setup.sh, որն աշխատում է, երբ վիրտուալ մեքենան միացված է:

setup.sh:

#!/bin/bash
CLUSTER_URI="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/mysql_cluster_uri)"
USERNAME="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/username)"
PASSWORD="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/password)"
sudo sed -i "s#.*;url =.*#url = mysql://${USERNAME}:${PASSWORD}@${CLUSTER_URI}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${PASSWORD}#" /etc/grafana/grafana.ini
sudo service grafana-server restart

Ինտանս խումբ և հավասարակշռող

Նոր սկավառակի պատկերը վերակառուցելուց հետո մենք վերջապես կարող ենք ավելացնել մեր ֆայլը Terraform-ի համար:

Եկեք նշենք, որ մենք ցանկանում ենք օգտագործել առկա սկավառակի պատկերը.

data "yandex_compute_image" "grafana_image" {
  image_id = var.image_id
}

Հիմա եկեք ստեղծենք օրինակների խումբ.

resource "yandex_compute_instance_group" "grafana_group" {
  name               = "grafana-group"
  folder_id          = var.folder_id
  service_account_id = var.service_account_id
  instance_template {
    platform_id = "standard-v1"
    resources {
      memory = 1
      cores  = 1
    }
    boot_disk {
      mode = "READ_WRITE"
      initialize_params {
        image_id = data.yandex_compute_image.grafana_image.id
        size     = 4
      }
    }
    network_interface {
      network_id = yandex_vpc_network.grafana_network.id
      subnet_ids = [yandex_vpc_subnet.subnet_a.id, yandex_vpc_subnet.subnet_b.id, yandex_vpc_subnet.subnet_c.id]
      nat = "true"
    }
    metadata = {
      mysql_cluster_uri = "c-${yandex_mdb_mysql_cluster.mysql_cluster.id}.rw.mdb.yandexcloud.net:3306/${var.dbname}"
      username = var.username
      password = var.password
      ssh-keys = "ubuntu:${file("${var.public_key_path}")}"
    }
    network_settings {
      type = "STANDARD"
    }
  }

  scale_policy {
    fixed_scale {
      size = 6
    }
  }

  allocation_policy {
    zones = ["ru-central1-a", "ru-central1-b", "ru-central1-c"]
  }

  deploy_policy {
    max_unavailable = 2
    max_creating    = 2
    max_expansion   = 2
    max_deleting    = 2
  }

  load_balancer {
    target_group_name = "grafana-target-group"
  }
}

Արժե ուշադրություն դարձնել, թե ինչպես ենք այն փոխանցել մետատվյալներին cluster_uri, username и password. Հենց դրանք էլ վիրտուալ մեքենան կհանի գործարկման ժամանակ և կդնի Grafana կոնֆիգուրը:

Դա կախված է հավասարակշռողից:

resource "yandex_lb_network_load_balancer" "grafana_balancer" {
  name = "grafana-balancer"

  listener {
    name = "grafana-listener"
    port = 80
    target_port = 3000
    external_address_spec {
      ip_version = "ipv4"
    }
  }

  attached_target_group {
    target_group_id = yandex_compute_instance_group.grafana_group.load_balancer.0.target_group_id

    healthcheck {
      name = "healthcheck"
      tcp_options {
        port = 3000
      }
    }
  }
}

Մի քիչ շաքարավազ

Քիչ է մնացել։ Ենթակառուցվածքը տեղադրվելուց հետո դուք պետք է գնաք Grafana UI և ձեռքով ավելացնեք CH կլաստերը (որի ID-ն դեռ պետք է ձեռք բերել) որպես տվյալների աղբյուր: Սակայն Terraform-ը գիտի կլաստերի ID-ն: Եկեք նրան վստահենք գործի իրականացմանը։

Եկեք ավելացնենք նոր պրովայդեր՝ Grafana, և որպես հոսթ նրան տանք հավասարակշռողի IP հասցեն: Բոլոր փոփոխությունները, որոնք Terraform-ը կատարում է այն մեքենայի վրա, որտեղ դրա հավասարակշռիչը որոշում է, կաճի MySQL-ում, և հետևաբար բոլոր մյուս մեքենաներում:

provider "grafana" {
  url  = "http://${[for s in yandex_lb_network_load_balancer.grafana_balancer.listener: s.external_address_spec.0.address].0}"
  auth = "${var.username}:${var.password}"
}

resource "grafana_data_source" "ch_data_source" {
  type          = "vertamedia-clickhouse-datasource"
  name          = "grafana"
  url           = "https://c-${yandex_mdb_clickhouse_cluster.ch_cluster.id}.rw.mdb.yandexcloud.net:8443"
  basic_auth_enabled = "true"
  basic_auth_username = var.username
  basic_auth_password = var.password
  is_default = "true"
  access_mode = "proxy"
}

Եկեք սանրենք մեր մազերը

Եկեք ցուցադրենք հավասարակշռողի IP հասցեն և ClickHouse կլաստերի հոսթը

output "grafana_balancer_ip_address" {
  value = [for s in yandex_lb_network_load_balancer.grafana_balancer.listener: s.external_address_spec.0.address].0
}

output "clickhouse_cluster_host" {
  value = "https://c-${yandex_mdb_clickhouse_cluster.ch_cluster.id}.rw.mdb.yandexcloud.net:8443"
}

Կարող է վազել

Բոլորը! Մեր կազմաձևման ֆայլը պատրաստ է, և մենք կարող ենք, փոփոխականները դնելով, ասել Terraform-ին բարձրացնել այն ամենը, ինչ մենք նկարագրեցինք վերևում: Ամբողջ գործընթացը ինձնից տևեց մոտ 15 րոպե:
Վերջում կարող եք տեսնել մի գեղեցիկ հաղորդագրություն. 

Apply complete! Resources: 9 added, 0 changed, 0 destroyed.
Outputs:

clickhouse_cluster_host = https://c-c9q14ipa2ngadqsbp2iq.rw.mdb.yandexcloud.net:8443
grafana_balancer_ip_address = 130.193.50.25

Իսկ ամպի մեջ տեսանելի կլինեն բարձրացված ենթակառուցվածքի տարրերը.

Բաշխված ծառայությունների տեղակայում Yandex.Cloud-ում՝ Grafana-ի օրինակով

Ամփոփել

Այժմ, օգտագործելով Grafana-ն որպես օրինակ, ձեզնից յուրաքանչյուրը կարող է տեղակայել ամպային ճարտարապետությամբ հավելվածներ Yandex.Cloud հարթակում: HashiCorp-ի օգտակար գործիքները, ինչպիսիք են Packer-ը և Terraform-ը, կարող են օգնել ձեզ այս հարցում: Հուսով եմ, որ ինչ-որ մեկին այս հոդվածը օգտակար կլինի :)

Հ.Գ. Ստորև ես կցեմ հղումը պահեստին, որտեղ դուք կարող եք գտնել պատրաստի բաղադրատոմսեր Packer-ի և Terraform-ի համար, որոնց հատվածները տրամադրել եմ այս հոդվածում:

պահոց

Source: www.habr.com

Добавить комментарий