🥇Pag-deploy ng mga distributed na serbisyo sa Yandex.Cloud gamit ang Grafana bilang isang halimbawa

Kamusta kayong lahat! Bilang bahagi ng aking course work, sinaliksik ko ang mga kakayahan ng naturang domestic cloud platform bilang Yandex.Cloud. Ang platform ay nag-aalok ng iba't ibang mga serbisyo para sa paglutas ng mga praktikal na problema. Gayunpaman, kung minsan kailangan mong i-set up ang iyong sariling cloud application na may medyo malawak na imprastraktura batay sa mga serbisyong ito. Sa artikulong ito gusto kong ibahagi ang aking karanasan sa pag-deploy ng naturang application.

Ano ang gusto mong matanggap?

grafana — isang makapangyarihang tool para sa paglutas ng mga analytical na problema o pagsubaybay sa mga problema ng anumang system. Sa pangunahing configuration nito, isa itong virtual machine na may Grafana web server, pati na rin ang database (ClickHouse, InfluxDB, atbp.) na may dataset kung saan ibabatay ang analytics.

Pagkatapos maglunsad ng virtual machine na may web server, maaari kang pumunta sa host nito at makakuha ng magandang UI, tukuyin ang mga database bilang mga mapagkukunan para sa karagdagang trabaho, lumikha ng mga dashboard at graph.

Ang pangunahing bersyon ay may isang makabuluhang disbentaha - ito ay hindi fault-tolerant sa lahat. Ibig sabihin, ang buong functionality ng application ay nakasalalay sa viability ng isang virtual machine. Kung tumanggi ito o bubuksan ng 10 tao ang UI sa parehong oras, magkakaroon ng mga problema.

Malutas ang mga ito nang simple: kailangan mo lang... mag-deploy ng maraming magkakaparehong virtual machine na may web server at ilagay ang mga ito sa ilalim ng L3 balancer. Ngunit hindi lahat ay malinaw dito. Ang Grafana ay nag-iimbak ng mga setting ng user (mga landas patungo sa mga database, dashboard, graph, atbp.) nang direkta sa disk ng virtual machine nito. Kaya, kung babaguhin namin ang ilang mga setting sa UI, ang mga pagbabagong ito ay makikita lamang sa virtual machine kung saan ipinadala sa amin ng balancer. Ito ay hahantong sa hindi tugmang mga setting para sa aming application, na magdudulot ng mga problema sa paglulunsad at paggamit.

Narito ang isa pang database ay darating upang iligtas, halimbawa, ang MySQL o ang katumbas nito. Sinasabi namin kay Grafana na dapat siyang mag-imbak ng mga setting ng user sa "reserbang" database na ito. Pagkatapos, sapat na upang tukuyin ang landas patungo sa database na ito nang isang beses sa bawat makina, at i-edit ang lahat ng iba pang setting ng user sa alinman sa mga virtual machine; mapapalawak sila sa iba.

Narito ang isang diagram ng panghuling imprastraktura ng aplikasyon:

Matuto tayong magbuhat gamit ang ating mga kamay

MySQL at ClickHouse

Bago i-deploy ang naturang application sa pamamagitan ng pag-click ng isang pindutan, ito ay kinakailangan upang matutunan kung paano pangasiwaan ang bawat isa sa mga bahagi nito at isama ang mga ito sa isa't isa.

Dito tutulungan kami ng Yandex.Cloud, na nagbibigay ng mga L3 balancer, ClickHouse at MySQL bilang mga pinamamahalaang serbisyo. Kailangan lamang ng user na tukuyin ang mga parameter at maghintay hanggang ang platform ay dalhin ang lahat sa ayos ng trabaho.

Nagrehistro ako, gumawa ng cloud at isang account sa pagbabayad. Pagkatapos noon, pumunta ako sa cloud at nag-set up ng MySQL at ClickHouse cluster na may kaunting mga setting. Naghintay ako hanggang sa maging aktibo sila.

Kailangan mo ring tandaan na lumikha ng isang database sa bawat cluster at i-configure ang access dito gamit ang isang login at password. Hindi ako pupunta sa mga detalye dito - lahat ay medyo halata sa interface.

Ang hindi halatang detalye ay ang mga database na ito ay may maraming host, na nagsisiguro sa kanilang pagpapahintulot sa kasalanan. Gayunpaman, ang Grafana ay nangangailangan ng eksaktong isang host para sa bawat database na ginagamit nito. Mahabang pagbabasa dokumentasyon Dinala ako ng mga ulap sa isang desisyon. Ito ay lumiliko out na ang host ng mga species c-<cluster_id>.rw.mdb.yandexcloud.net nakamapa sa kasalukuyang aktibong master host ng cluster na may kaukulang ID. Ito ang ibibigay natin kay Grafana.

Web server

Ngayon ay nasa web server na. Magtaas tayo ng isang regular na virtual machine na may Linux at manu-manong i-configure ang Grafana dito.

Kumonekta tayo sa pamamagitan ng ssh at i-install ang mga kinakailangang pakete.

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

Pagkatapos nito, patakbuhin natin ang Grafana sa ilalim ng systemctl at i-install ang plugin para sa pagtatrabaho sa ClickHouse (oo, hindi ito ibinibigay sa pangunahing pakete).

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

Iyon lang, pagkatapos nito sa isang simpleng utos

sudo service grafana-server start

sisimulan natin ang web server. Ngayon ay maaari mong ipasok ang panlabas na IP address ng virtual machine sa browser, tukuyin ang port 3000 at makita ang magandang Grafana UI.

Ngunit huwag magmadali, bago i-set up ang Grafana, dapat mong tandaan na sabihin dito ang landas sa MySQL upang maiimbak ang mga setting doon.

Ang buong configuration ng Grafana web server ay nasa file /etc/grafana/grafana.ini. Ang kinakailangang linya ay ganito ang hitsura:

;url =

Itinakda namin ang host sa MySQL cluster. Ang parehong file ay naglalaman ng login at password para sa pag-access sa Grafana sa larawan sa itaas, na bilang default ay parehong pantay admin.

Maaari mong gamitin ang sed command:

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

Oras na para i-restart ang web server!

sudo service grafana-server restart

Ngayon sa Grafana UI tutukuyin namin ang ClickHouse bilang DataSource.

Nagawa kong makamit ang isang gumaganang pagsasaayos gamit ang mga sumusunod na setting:

Tinukoy ko bilang URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

Lahat! Mayroon kaming isang gumaganang virtual machine na may web server na nakakonekta sa CH at MySQL. Maaari mo nang i-upload ang dataset sa ClickHouse at bumuo ng mga dashboard. Gayunpaman, hindi pa namin nakakamit ang aming layunin at hindi nag-deploy ng isang ganap na imprastraktura.

Packer

Yandex.Cloud ay nagbibigay-daan sa iyo upang lumikha ng isang disk image ng isang umiiral na virtual machine, at sa batayan nito - anumang bilang ng mga machine na magkapareho sa bawat isa. Ito mismo ang gagamitin natin. Upang maginhawang tipunin ang imahe, kunin ang tool Packer mula sa HashiCorp. Ito ay tumatagal bilang input ng isang json file na may mga tagubilin para sa pag-assemble ng imahe.

Ang aming json file ay bubuo ng dalawang bloke: mga builder at provisioner. Inilalarawan ng unang bloke ang mga parameter ng larawan mismo bilang isang entity, at ang pangalawang bloke ay naglalarawan ng mga tagubilin para sa pagpuno nito ng kinakailangang nilalaman.

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"
    }
  ],
...
}

Sa template na ito, kailangan mong itakda ang identifier ng seksyon sa cloud kung saan mo gustong likhain ang larawan, pati na rin ang path sa file na may mga key mula sa account ng serbisyo na dati nang ginawa sa seksyong ito. Maaari kang magbasa nang higit pa tungkol sa paggawa ng mga account ng serbisyo at mga susi sa anyo ng isang file sa kaukulang seksyon dokumentasyon.

Sinasabi ng pagsasaayos na ito na ang imahe ng disk ay bubuo batay sa platform ubuntu-1804-lts, inilagay sa naaangkop na seksyon ng user sa pamilya ng larawan GRAFANA sa ilalim ng pangalan grafana-{{timestamp}}.

Mga tagapagbigay

Dumating na ngayon ang mas kawili-wiling bahagi ng pagsasaayos. Ilalarawan nito ang pagkakasunud-sunod ng mga aksyon na kailangang gawin sa virtual machine bago i-freeze ang estado nito sa isang imahe ng disk.

{
...,
"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"
        ]
        }
  ]
}

Narito ang lahat ng mga aksyon ay nahahati sa 3 yugto. Sa unang yugto, ang isang simpleng script ay isinasagawa na lumilikha ng isang pantulong na direktoryo.

prepare-ctg.sh:

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

Sa susunod na yugto, naglalagay kami ng script sa direktoryong ito, na kakailanganing ilunsad kaagad pagkatapos simulan ang virtual machine. Ilalagay ng script na ito ang mga variable ng user na kailangang mairehistro sa Grafana config at i-restart ang web server.

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

Pagkatapos nito, may 3 bagay na dapat gawin:
1) mag-install ng mga pakete
2) patakbuhin ang Grafana sa ilalim ng systemctl at i-install ang ClickHouse plugin
3) ilagay ang setup.sh script sa launch queue kaagad pagkatapos i-on ang virtual machine.

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;

Ngayon ang lahat na natitira ay upang patakbuhin ang Packer at ilagay ang output na imahe sa tinukoy na seksyon. Kapag lumilikha ng isang virtual machine, maaari mong piliin ito bilang isang boot disk at pagkatapos ng paglunsad ay makakatanggap ka ng isang yari na Grafana web server.

Instance group at balancer

Kapag mayroon na kaming disk image na nagbibigay-daan sa amin na lumikha ng maraming magkakaparehong mga web server ng Grafana, maaari kaming lumikha ng isang grupo ng halimbawa. Sa Yandex.Cloud platform, ang terminong ito ay tumutukoy sa unyon ng mga virtual machine na may parehong mga katangian. Kapag gumagawa ng isang pangkat ng halimbawa, ang prototype ng lahat ng mga makina sa pangkat na ito ay na-configure, at pagkatapos ay ang mga katangian ng pangkat mismo (halimbawa, ang minimum at maximum na bilang ng mga aktibong makina). Kung ang kasalukuyang numero ay hindi nakakatugon sa mga pamantayang ito, ang pangkat ng halimbawa mismo ay mag-aalis ng mga hindi kinakailangang makina o gagawa ng mga bago sa sarili nitong larawan.

Bilang bahagi ng aming gawain, gagawa kami ng isang halimbawang pangkat ng mga web server na bubuo mula sa naunang ginawang disk image.

Ang talagang kapansin-pansin ay ang huling instance group setup. Ang target na grupo sa pagsasama sa Load Balancer ay tutulong sa iyo na i-configure ang isang L3 balancer sa ibabaw ng mga virtual machine ng pangkat na ito sa pamamagitan ng pag-click sa ilang mga button.

Kapag nagse-set up ng balancer, ipinatupad ko ang dalawang mahalagang punto:

Ginawa kong tanggapin ng balancer ang trapiko ng gumagamit sa port 80 at i-redirect ito sa port 3000 ng mga virtual machine, kung saan mismo nakatira si Grafana.
Nag-set up ako ng pagsuri sa posibilidad ng mga makina sa pamamagitan ng pag-ping sa kanila sa port 3000.

Mini na buod

Sa wakas, nagawa naming manu-manong i-deploy ang ninanais na imprastraktura ng application, at ngayon ay mayroon na kaming mataas na nababanat na serbisyo ng Grafana. Kailangan mo lang malaman ang IP address ng balancer bilang entry point sa application at ang host ng ClickHouse cluster upang mai-load ang dataset dito.

Ito ay tila isang tagumpay? Oo, tagumpay. Pero may gumugulo pa rin sa akin. Ang buong proseso sa itaas ay nangangailangan ng maraming manu-manong hakbang at hindi nasusukat; Gusto kong i-automate ito kung maaari. Ito ang ilalaan sa susunod na seksyon.

Pagsasama ng Terraform

Muli kaming gagamit ng tool mula sa HashiCorp na tinatawag Terraform. Makakatulong ito sa iyong i-deploy ang buong imprastraktura ng application sa pag-click ng isang button, batay sa ilang mga variable na ipinasa ng user. Sumulat tayo ng isang recipe na maaaring tumakbo nang maraming beses sa iba't ibang mga seksyon ng iba't ibang mga gumagamit.

Ang lahat ng trabaho sa Terraform ay bumaba sa pagsusulat ng configuration file (*.tf) at ang paglikha ng imprastraktura batay dito.

Mga variable

Sa umpisa pa lang ng file, isasama namin ang mga variable na tumutukoy kung saan at paano idi-deploy ang imprastraktura sa hinaharap.

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>"
}

Ang buong proseso ng pag-deploy ng application ay bababa sa pagbuo ng isang disk image at pagtatakda ng mga variable na ito. Hayaan akong ipaliwanag kung ano ang kanilang pananagutan:

oauth_token — isang token para sa pag-access sa cloud. Maaaring makuha ng link.
cloud_id — cloud identifier kung saan namin ide-deploy ang application
folder_id — section identifier kung saan namin ide-deploy ang application
service_account_id — service account identifier sa kaukulang seksyon ng cloud.
image_id — identifier ng disk image na nakuha gamit ang Packer
username и password — username at password upang ma-access ang parehong mga database at ang Grafana web server
dbname — pangalan ng database sa loob ng mga cluster ng CH at MySQL
public_key_path — path sa file gamit ang iyong pampublikong ssh key, na magagamit mo upang kumonekta sa ilalim ng pangalan ubuntu sa mga virtual machine na may mga web server

Setup ng provider

Ngayon ay kailangan mong i-configure ang provider ng Terraform - sa aming kaso, Yandex:

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

Mapapansin mo na dito ginagamit namin ang mga variable na tinukoy sa itaas.

Network at mga kumpol

Ngayon ay gagawa kami ng network kung saan ang mga elemento ng aming imprastraktura ay makikipag-usap, tatlong subnet (isa sa bawat rehiyon) at magtataas ng CH at MySQL cluster.


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
  }
}

Gaya ng nakikita mo, ang bawat isa sa dalawang kumpol ay ginawang medyo fault-tolerant sa pamamagitan ng pagiging matatagpuan sa tatlong availability zone.

Mga web server

Tila maaari kaming magpatuloy sa parehong espiritu, ngunit nahirapan ako. Bago ito, una kong itinaas ang isang MySQL cluster at pagkatapos lamang nito, alam ang ID nito, nakolekta ko ang isang imahe ng disk na may kinakailangang pagsasaayos, kung saan tinukoy ko ang host sa cluster. Ngunit ngayon ay hindi namin alam ang cluster ID bago ilunsad ang Terraform, kasama ang panahon ng pagbuo ng imahe. Samakatuwid, kinailangan kong gawin ang mga sumusunod panlilinlang.

Gamit ang serbisyo ng metadata ng Amazon, ipapasa namin ang ilang parameter sa virtual machine, na tatanggapin at ipoproseso nito. Kailangan namin ang makina upang pumunta sa metadata sa likod ng MySQL cluster host at username-password, na tinukoy ng user sa Terraform file, pagkatapos magsimula. Baguhin natin nang bahagya ang mga nilalaman ng file setup.sh, na tumatakbo kapag naka-on ang virtual machine.

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

Intance group at balancer

Ang pagkakaroon ng muling pagtatayo ng bagong disk image, maaari na naming idagdag ang aming file para sa Terraform.

Ipahiwatig natin na gusto nating gumamit ng umiiral nang disk image:

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

Ngayon, gumawa tayo ng isang pangkat ng halimbawa:

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"
  }
}

Ito ay nagkakahalaga ng pagbibigay pansin sa kung paano namin ipinasa ito sa metadata cluster_uri, username и password. Ito ang mga ito na dadalhin ng virtual machine sa startup at ilagay sa Grafana config.

Bahala na ang balancer.

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
      }
    }
  }
}

Konting asukal

Kaunti na lang ang natitira. Pagkatapos ma-deploy ang imprastraktura, kakailanganin mong pumunta sa Grafana UI at manu-manong idagdag ang CH cluster (ang ID kung saan kailangan pa ring makuha) bilang Data Source. Ngunit alam ng Terraform ang cluster ID. Ipagkatiwala natin sa kanya ang pagsasakatuparan ng usapin.

Magdagdag tayo ng bagong provider - Grafana, at ibigay sa kanya ang IP address ng balancer bilang isang host. Ang lahat ng mga pagbabago na ginagawa ng Terraform sa makina kung saan tinutukoy ng balancer nito ay lalago sa MySQL, at samakatuwid sa lahat ng iba pang makina.

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"
}

Magsuklay tayo ng buhok

Ipakita natin ang balancer IP address at ang host ng ClickHouse cluster

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"
}

Pwedeng tumakbo

Lahat! Ang aming configuration file ay handa na at maaari naming, sa pamamagitan ng pagtatakda ng mga variable, sabihin sa Terraform na itaas ang lahat ng aming inilarawan sa itaas. Ang buong proseso ay tumagal ng halos 15 minuto.
Sa dulo makikita mo ang isang magandang mensahe:

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

At sa cloud, makikita ang mga elemento ng nakataas na imprastraktura:

Magbuo

Ngayon, gamit ang Grafana bilang isang halimbawa, bawat isa sa inyo ay maaaring mag-deploy ng mga application na may malawak na cloud architecture sa Yandex.Cloud platform. Ang mga kapaki-pakinabang na tool mula sa HashiCorp tulad ng Packer at Terraform ay makakatulong sa iyo dito. Umaasa ako na may nakahanap na kapaki-pakinabang ang artikulong ito :)

PS Sa ibaba ay maglalagay ako ng isang link sa repositoryo kung saan makakahanap ka ng mga handa na recipe para sa Packer at Terraform, mga fragment na ibinigay ko sa artikulong ito.

imbakan

Pinagmulan: www.habr.com

Pag-deploy ng mga distributed na serbisyo sa Yandex.Cloud gamit ang Grafana bilang isang halimbawa