განაწილებული სერვისების განთავსება Yandex.Cloud-ში Grafana-ს მაგალითის გამოყენებით

Სალამი ყველას! როგორც ჩემი კურსის მუშაობის ნაწილი, მე გამოვიკვლიე ისეთი შიდა ღრუბლოვანი პლატფორმის შესაძლებლობები, როგორიცაა Yandex.Cloud. პლატფორმა გთავაზობთ სხვადასხვა სერვისს პრაქტიკული პრობლემების გადასაჭრელად. თუმცა, ზოგჯერ გჭირდებათ საკუთარი ღრუბლოვანი აპლიკაციის დაყენება ამ სერვისებზე დაფუძნებული საკმაოდ ვრცელი ინფრასტრუქტურით. ამ სტატიაში მინდა გაგიზიაროთ ჩემი გამოცდილება ასეთი აპლიკაციის განლაგების შესახებ.

რისი მიღება გსურთ?

გრაფანა — მძლავრი ინსტრუმენტი ნებისმიერი სისტემის ანალიტიკური პრობლემების გადასაჭრელად ან პრობლემების მონიტორინგისთვის. მისი ძირითადი კონფიგურაციით, ეს არის ვირტუალური მანქანა Grafana ვებ სერვერით, ასევე მონაცემთა ბაზა (ClickHouse, InfluxDB და ა.შ.) მონაცემთა ნაკრებით, რომელზეც დაფუძნებული იქნება ანალიტიკა.

ვებ სერვერით ვირტუალური მანქანის გაშვების შემდეგ, შეგიძლიათ გადახვიდეთ მის ჰოსტში და მიიღოთ ლამაზი ინტერფეისი, მიუთითოთ მონაცემთა ბაზები, როგორც წყაროები შემდგომი მუშაობისთვის, შექმნათ დაფები და გრაფიკები.

საბაზისო ვერსიას აქვს ერთი მნიშვნელოვანი ნაკლი - ის საერთოდ არ არის შეცდომის შემწყნარებლობა. ანუ, აპლიკაციის მთელი ფუნქციონირება დამოკიდებულია ერთი ვირტუალური მანქანის სიცოცხლისუნარიანობაზე. თუ ის უარს იტყვის ან 10 ადამიანი გახსნის ინტერფეისს ერთდროულად, მაშინ პრობლემები წარმოიქმნება.

მათი მოგვარება მარტივია: თქვენ უბრალოდ უნდა... განათავსოთ მრავალი იდენტური ვირტუალური მანქანა ვებ სერვერთან და მოათავსოთ ისინი L3 ბალანსერის ქვეშ. მაგრამ აქ ყველაფერი ასე ნათელი არ არის. Grafana ინახავს მომხმარებლის პარამეტრებს (ბილიკებს მონაცემთა ბაზებისკენ, დაფები, გრაფიკები და ა.შ.) პირდაპირ მისი ვირტუალური მანქანის დისკზე. ამრიგად, თუ ჩვენ შევცვლით ზოგიერთ პარამეტრს UI-ში, ეს ცვლილებები აისახება მხოლოდ ვირტუალურ მანქანაზე, სადაც ბალანსერი გამოგვიგზავნა. ეს გამოიწვევს ჩვენი აპლიკაციის არათანმიმდევრულ პარამეტრებს, რაც გამოიწვევს პრობლემებს გაშვებასა და გამოყენებასთან დაკავშირებით.

აქ სხვა მონაცემთა ბაზა მოვა სამაშველოში, მაგალითად, MySQL ან მისი ექვივალენტი. ჩვენ ვეუბნებით გრაფანას, რომ მან უნდა შეინახოს მომხმარებლის პარამეტრები ამ „სათადარიგო“ მონაცემთა ბაზაში. ამის შემდეგ, საკმარისი იქნება თითოეულ მანქანაზე ერთხელ მიუთითოთ ამ მონაცემთა ბაზის გზა და შეცვალოთ ყველა სხვა მომხმარებლის პარამეტრი რომელიმე ვირტუალურ მანქანაზე; ისინი გავრცელდება სხვებზე.

აქ არის საბოლოო განაცხადის ინფრასტრუქტურის დიაგრამა:

ვისწავლოთ ხელით აწევა

MySQL და ClickHouse

ღილაკზე დაწკაპუნებით ასეთი აპლიკაციის განთავსებამდე საჭირო იყო იმის გაგება, თუ როგორ უნდა დამუშავდეს მისი თითოეული კომპონენტი და ინტეგრირდეს ერთმანეთთან.

აქ დაგვეხმარება Yandex.Cloud, რომელიც გთავაზობთ L3 ბალანსერებს, ClickHouse-ს და MySQL-ს, როგორც მართულ სერვისებს. მომხმარებელმა მხოლოდ უნდა მიუთითოს პარამეტრები და დაელოდოს, სანამ პლატფორმა ყველაფერს მუშა მდგომარეობაში მოაქვს.

მე დავრეგისტრირდი, შევქმენი ღრუბელი და გადახდის ანგარიში. ამის შემდეგ მივედი ღრუბელში და დავაყენე MySQL და ClickHouse კლასტერები მინიმალური პარამეტრებით. დაველოდე სანამ გააქტიურდნენ.

თქვენ ასევე უნდა გახსოვდეთ, რომ შექმნათ მონაცემთა ბაზა თითოეულ კლასტერში და დააკონფიგურიროთ მასზე წვდომა შესვლისა და პაროლის გამოყენებით. აქ დეტალებში არ შევალ - ყველაფერი საკმაოდ აშკარაა ინტერფეისში.

არააშკარა დეტალი ის იყო, რომ ამ მონაცემთა ბაზებს ბევრი ჰოსტი ჰყავს, რაც უზრუნველყოფს მათ შეცდომის ტოლერანტობას. თუმცა, Grafana მოითხოვს ზუსტად ერთ ჰოსტს თითოეული მონაცემთა ბაზისთვის, რომლებთანაც მუშაობს. ხანგრძლივი კითხვა დოკუმენტაცია ღრუბლებმა მიმიყვანა გადაწყვეტილებამდე. გამოდის, რომ სახეობის მასპინძელი c-<cluster_id>.rw.mdb.yandexcloud.net ასახულია კლასტერის მიმდინარე აქტიურ მთავარ ჰოსტზე შესაბამისი ID-ით. სწორედ ამას მივცემთ გრაფანას.

ვებ სერვერი

ახლა საქმე ვებ სერვერზეა. მოდით გავზარდოთ ჩვეულებრივი ვირტუალური მანქანა Linux-ით და ხელით დავაკონფიგურიროთ 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.

მაგრამ არ იჩქაროთ, სანამ 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.

მე მოვახერხე სამუშაო კონფიგურაციის მიღწევა შემდეგი პარამეტრებით:

მე მივუთითე, როგორც URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

ყველა! ჩვენ გვაქვს ერთი მოქმედი ვირტუალური მანქანა ვებ სერვერით, რომელიც დაკავშირებულია CH და MySQL-თან. თქვენ უკვე შეგიძლიათ ატვირთოთ მონაცემთა ნაკრები ClickHouse-ში და შექმნათ დაფები. თუმცა, ჩვენ ჯერ ვერ მივაღწიეთ დასახულ მიზანს და არ გვაქვს განლაგებული სრულფასოვანი ინფრასტრუქტურა.

Packer

Yandex.Cloud საშუალებას გაძლევთ შექმნათ არსებული ვირტუალური მანქანის დისკის გამოსახულება და მის საფუძველზე - ნებისმიერი რაოდენობის მანქანა ერთმანეთის იდენტური. ეს არის ზუსტად ის, რასაც ჩვენ გამოვიყენებთ. გამოსახულების მოსახერხებლად ასაწყობად, აიღეთ ინსტრუმენტი Packer 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-ის გაშვება და გამომავალი გამოსახულების მიღება მითითებულ განყოფილებაში. ვირტუალური მანქანის შექმნისას შეგიძლიათ აირჩიოთ ის ჩატვირთვის დისკად და გაშვების შემდეგ მიიღებთ მზა Grafana ვებ სერვერს.

ინსტანციის ჯგუფი და ბალანსერი

მას შემდეგ რაც გვექნება დისკის სურათი, რომელიც საშუალებას გვაძლევს შევქმნათ მრავალი იდენტური Grafana ვებ სერვერი, ჩვენ შეგვიძლია შევქმნათ ინსტანციის ჯგუფი. Yandex.Cloud პლატფორმაზე ეს ტერმინი ეხება ვირტუალური მანქანების გაერთიანებას, რომლებსაც აქვთ იგივე მახასიათებლები. ინსტანციის ჯგუფის შექმნისას, კონფიგურირებულია ამ ჯგუფის ყველა აპარატის პროტოტიპი, შემდეგ კი თავად ჯგუფის მახასიათებლები (მაგალითად, აქტიური მანქანების მინიმალური და მაქსიმალური რაოდენობა). თუ ამჟამინდელი ნომერი არ აკმაყოფილებს ამ კრიტერიუმებს, მაშინ ინსტანციის ჯგუფი თავად ამოიღებს არასაჭირო მანქანებს ან შექმნის ახალს საკუთარი სურათით.

როგორც ჩვენი ამოცანის ნაწილი, ჩვენ შევქმნით ვებ სერვერების მაგალითების ჯგუფს, რომელიც გენერირებული იქნება ადრე შექმნილი დისკის სურათიდან.

რაც ნამდვილად აღსანიშნავია არის ბოლო ინსტანციის ჯგუფის დაყენება. Load Balancer-თან ინტეგრაციის სამიზნე ჯგუფი დაგეხმარებათ ამ ჯგუფის ვირტუალური მანქანების თავზე L3 ბალანსერის კონფიგურაციაში რამდენიმე ღილაკზე დაწკაპუნებით.

ბალანსერის დაყენებისას მე განვახორციელე ორი მნიშვნელოვანი პუნქტი:

1. მე ვაიძულებდი ბალანსერს მიეღო მომხმარებლის ტრაფიკი 80-ე პორტზე და გადამისამართდი ვირტუალური მანქანების 3000 პორტზე, ზუსტად იქ, სადაც Grafana ცხოვრობს.
2. მე დავაყენე მანქანების სიცოცხლისუნარიანობის შემოწმება 3000 პორტზე პინგით.

მინი რეზიუმე

საბოლოოდ, ჩვენ შევძელით სასურველი აპლიკაციის ინფრასტრუქტურის ხელით განლაგება და ახლა გვაქვს უაღრესად გამძლე Grafana სერვისი. თქვენ მხოლოდ უნდა იცოდეთ ბალანსერის IP მისამართი, როგორც აპლიკაციაში შესვლის წერტილი და ClickHouse კლასტერის ჰოსტი, რათა ჩატვირთოთ მონაცემთა ნაკრები მასში.

როგორც ჩანს, გამარჯვებაა? დიახ, გამარჯვება. მაგრამ რაღაც მაინც მაბნევს. ზემოაღნიშნული მთელი პროცესი მოითხოვს უამრავ სახელმძღვანელო ნაბიჯს და საერთოდ არ არის მასშტაბირებადი; მსურს მისი ავტომატიზაცია, თუ ეს შესაძლებელია. სწორედ ამას დაეთმობა შემდეგი განყოფილება.

ტერაფორმული ინტეგრაცია

ჩვენ კვლავ გამოვიყენებთ ინსტრუმენტს 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 კლასტერებში
საჯარო_გასაღების_გზა — ფაილის გზა თქვენი საჯარო 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-ის გაშვებამდე, მათ შორის სურათის აგების დროს. ამიტომ მომიწია მიმემართა შემდეგი ხრიკი.

ამაზონის მეტამონაცემების სერვისის გამოყენებით ვირტუალურ მანქანას გადავცემთ რამდენიმე პარამეტრს, რომელსაც ის მიიღებს და დაამუშავებს. ჩვენ გვჭირდება მანქანა გადავიდეს მეტამონაცემებზე 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

ღრუბელში კი ამაღლებული ინფრასტრუქტურის ელემენტები გამოჩნდება:

შეაჯამებს

ახლა, Grafana-ს მაგალითის გამოყენებით, თითოეულ თქვენგანს შეუძლია განათავსოს აპლიკაციები ფართო ღრუბლოვანი არქიტექტურით Yandex.Cloud პლატფორმაზე. ამაში დაგეხმარებათ HashiCorp-ის ისეთი სასარგებლო ინსტრუმენტები, როგორიცაა Packer და Terraform. ვიმედოვნებ ვინმეს ეს სტატია გამოადგება :)

PS ქვემოთ დავდებ ლინკს საცავზე, სადაც შეგიძლიათ იპოვოთ მზა რეცეპტები Packer-ისა და Terraform-ისთვის, რომელთა ფრაგმენტები მე მოგაწოდეთ ამ სტატიაში.

საცავი

წყარო: www.habr.com