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

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

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

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

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

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

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

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

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

Սովորենք ձեռքերով բարձրացնել

MySQL և ClickHouse

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

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

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

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

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

վեբ սերվեր

Հիմա ժամանակն է վեբ սերվերի։ Եկեք կարգավորենք սովորական վիրտուալ մեքենա՝ օգտագործելով Linux և մենք մեր ձեռքերով դրա վրա կտեղադրենք Գրաֆանա։

Եկեք միանանք 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-ը։

Բայց մի շտապեք, 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-ը կնշենք որպես տվյալների աղբյուր։

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

Որպես 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 փուլի։ Առաջին քայլը պարզ սկրիպտ գործարկելն է, որը ստեղծում է օժանդակ գրացուցակ։

prepare-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-ը և պատկերը տեղադրել նշված բաժնում որպես արդյունք։ Վիրտուալ մեքենա ստեղծելիս կարող եք այն ընտրել որպես բեռնման սկավառակ, և այն գործարկելուց հետո կստանաք պատրաստի Grafana վեբ սերվեր։

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

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

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

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

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

Ես այնպես եմ կարգավորել, որ հավասարակշռիչը ստանա օգտատիրոջ տրաֆիկը 80-րդ պորտում և վերահասցեագրի այն վիրտուալ մեքենաների 3000-րդ պորտին, որտեղ էլ գտնվում է Գրաֆանան։
Կարգավորվել է մեքենաների առողջության ստուգումը՝ դրանք 3000 պորտում պինգ անելով։

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

Վերջապես, մենք կարողացանք ձեռքով տեղակայել ցանկալի ծրագրային ենթակառուցվածքը, և այժմ մենք ունենք բարձր կայունությամբ 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 — ամպին մուտք գործելու թոքեն։ Դուք կարող եք այն ստանալ՝ ՈՒղեցույց.
ամպային_իդենտիֆիկացիա — այն ամպի նույնականացուցիչը, որտեղ մենք տեղակայելու ենք ծրագիրը
թղթապանակի_իդենտիֆիկացիա — այն բաժնի նույնականացուցիչը, որտեղ մենք կտեղակայենք ծրագիրը
ծառայության_հաշվի_հավելված — ամպի համապատասխան բաժնում ծառայության հաշվի նույնականացուցիչը։
image_id — Packer-ի միջոցով ստացված սկավառակի պատկերի նույնականացուցիչը
օգտագործողի անունը и Գաղտնաբառ — օգտանուն և գաղտնաբառ՝ տվյալների բազաներին և Grafana վեբ սերվերին մուտք գործելու համար
dbname — CH և MySQL կլաստերների ներսում գտնվող տվյալների բազայի անվանումը
հանրային_բանալի_ուղի — ֆայլի ուղին ձեր հանրային 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"
}

Եկեք սանրենք այն

Մենք կարտածենք հավասարակշռիչի և ClickHouse կլաստերի հոսթի IP հասցեն։

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

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

Ամփոփել

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

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

պահոց

Source: www.habr.com