🥇Jaotatud teenuste paigaldamine Yandex. Cloud'is Grafana näitel

Tere kõigile! Kursusetöö raames olen uurinud kodumaise pilveplatvormi võimalusi, nimelt Yandex.Cloud. Platvorm pakub erinevaid teenuseid praktiliste ülesannete lahendamiseks. Siiski võib mõnikord olla vajalik need teenused kasutada oma pilverakenduse seadistamiseks piisavalt ulatuslikku infrastruktuuri. Selles artiklis soovin jagada oma kogemusi sellise rakenduse seadistamisel.

Mida soovime saada?

Grafana — võimas tööriist analüütiliste ülesannete või mõne süsteemi seire ülesannete lahendamiseks. Oma põhipaketis on see virtuaalne masin koos Grafana veebiserveriga, samuti andmebaas (ClickHouse, InfluxDB jms) koos andmestikuga, mille alusel analüütikat luuakse.

Pärast virtuaalse masina koos veebiserveriga käivitamist on võimalik sisse logida selle hostisse ja saada ilus kasutajaliides, näidata andmebaase allikatena edasiseks tööks, luua juhtpaneele ja graafikuid.

Põhiversioonil on üks suur puudus — see ei ole absoluutselt talitlushäirete korral vastupidav. See tähendab, et kogu rakenduse töövõime sõltub ühest virtuaalsest masinast. Kui see ebaõnnestub või 10 inimest avavad korraga kasutajaliidese, siis tekivad probleemid.

Need lahendatakse lihtsalt: tuleb vaid… käitada palju identseid virtuaalseid masinaid koos veebiserveriga ja paigutada need L3 taseme koormuse tasakaalustaja alla. Kuid ka siin ei ole kõik nii lihtne. Grafana salvestab kasutajaseaded (teed andmebaasidele, juhtpaneelid, graafikud jne) otse oma virtuaalse masina kettale. Seega, kui muudad kasutajaliideses mõningaid seadeid, kajastuvad need muudatused ainult sel virtuaalsel masinal, kuhu tasakaalustaja meid suunab. See põhjustab meie rakenduse seadete järjepidevuse probleemide tekkimise.

Siin tuleb appi teine andmebaas, näiteks MySQL või selle analoog. Ütleme Grafanale, et ta peaks salvestama kasutajaseaded just sellele "varuabandele". Pärast piisab, kui igas masinas ühel korral viidata sellele andmebaasile, ja kõik ülejäänud kasutajaseaded saab redigeerida mis tahes virtuaalses masinas, nad jõuavad ka teistesse.

Siin on rakenduse lõpliku infrastruktuuri skeem:

Õpime käsitsi üles tõstma

MySQL ja ClickHouse

Enne sellise rakenduse paigaldamist ühe nupuvajutusega on vaja õppida, kuidas iga selle komponent käsitsi üles seada ja neid omavahel integreerida.

Siin aitab meid Yandex.Cloud, mis pakub L3-balanseere, ClickHouse'i ja MySQL'i hallatud teenustena. Kasutaja peab lihtsalt määrama parameetrid ja ootama, kuni platvorm viib kõik töökorda.

Registreerisin end, lõin endale pilve ja maksekonto. Pärast seda sisenesin pilve ja seadsin üles MySQL ja ClickHouse klastri minimaalsete seadistustega. Ootasin, kuni nad saavad aktiivseks.

Samuti ei tohi unustada luua igas klastris andmebaasi ja seadistada sellele juurdepääs sisselogimise ja parooliga. Sisenen siin detailidesse, et liideses on kõik piisavalt selge.

Mitteilmne detail oli selles, et nende andmebaasidel on palju hoste, mis tagavad nende tõrkeotsingu. Kuid Grafana vajab igas andmebaasis täpselt ühte hosti, millega ta töötab. Pikem lugemine. dokumentatsioon Pilv viis mind lahenduseni. Selgub, et host tüübiga c-<cluster_id>.rw.mdb.yandexcloud.net kaardistatakse praegusele aktiivsele meistrihostile, millel on vastav ID. Just seda anname Grafanale.

Veebiserver

Nüüd on aeg veebiserveri jaoks. Loodame tavalise Linuxi virtuaalmasina ja seadistame sellele Grafana käsitsi.

Ühendame SSH kaudu ja installime vajalikud paketid.

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

Pärast seda käivitame Grafana systemctl'i all ja paigaldame plugina ClickHouse'iga töötamiseks (jah, baaskomplektis ei tule see kaasa).

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

Kõik, pärast seda lihtsa käsu abil

sudo service grafana-server start

käivitame veebiserveri. Nüüd saab brauserisse sisestada virtuaalmasina välise IP-aadressi, määrata pordi 3000 ja näha Grafana ilusat kasutajaliidest.

Kuid ei ole mõtet kiirustada, enne kui Grafana seadistatakse, ei tohi unustada öelda, kus MySQL asub, et seal seada konfiguratsioon.

Kõik Grafana veebiserveri konfiguratsioonid asuvad failis /etc/grafana/grafana.ini. Otsitav rida näeb välja selline:

;url =

Seame host MySQL klastriga. Samas failis on kasutajanimi ja parool Grafana juurde, mis on ülaltoodud pildil ja mis on mõlemad vaikimisi võrdsed. admin.

Saad kasutada sed-käske:

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

On aeg veebiserver taaskäivitada!

sudo service grafana-server restart

Nüüd näitame Grafana kasutajaliideses ClickHouse'i andmeallika sõltuvusena.

Töötava konfiguratsiooni saavutamiseks kasutasin järgmisi seadeid:

URL-ina määrasin https://c-.rw.mdb.yandexcloud.net:8443

Kõik! Meil on üks funktsionaalne virtuaalne masin veebiserveriga, mis on ühendatud CH ja MySQL-iga. Juba on võimalik laadida andmeseti ClickHouse'i ja koostada armatuurlaudu. Kuid me pole veel oma eesmärki saavutanud ja ei ole loonud täieõiguslikku infrastruktuuri.

Packer

Yandex.Cloud võimaldab luua olemasoleva virtuaalse masina ketta pilti, ja selle alusel — piiramatu arv üksteisega identseid masinaid. Just seda me kasutame. Mugavalt pildi kogumiseks võime kasutada tööriista Packer HashiCorbilt. See võtab sisendiks json-faili pildi koostamise juhistega.

Meie json-fail koosneb kahest plokist: builders ja provisioners. Esimene plokk kirjeldab pildi parameetreid kui objekti, ning teine — juhiseid vajaliku sisuga täitmiseks.

Builders

{
"builders": [
    {
      "type": "yandex",
      "endpoint": "{{user `endpoint`}}",
      "folder_id": "",
      "subnet_id": "{{user `subnet_id`}}",
      "zone": "{{user `zone`}}",
      "labels": {},
      "use_ipv4_nat": true,
      "use_internal_ip": false,
      "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"
    }
  ],
...
}

Selles mallis tuleb määrata pilti moodustava sektsiooni identifikaator pilves, samuti teekonna teenuse konto võtme faili juurde, mis on eelnevalt selle sektsiooni jaoks loodud. Lisainfot teenuse kontode ja võtmete loomise kohta faili kujul leiad vastavast osast. dokumentatsioon.

Selline konfiguratsioon ütleb, et ketta pilt koostatakse platvormi põhjal ubuntu-1804-lts, ja see paigutatakse kasutaja vastavasse sektsiooni piltide peres GRAFANA koos nimega grafana-{{timestamp}}.

Provisioners

Nüüd on aeg rääkida huvitavamast konfiguratsioonist. Siin kirjeldatakse samme, mida tuleb virtuaalses masinas enne selle oleku salvestamist ketta kujutisse teha.

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

Siin on kõik toimingud jagatud kolme etappi. Esimeses etapis käivitatakse lihtne skript, mis loob abikatalooge.

prepare-ctg.sh:

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

Järgmisel etapil paigutame sellesse katalooge skripti, mis tuleb käivitada kohe pärast virtuaalse masina käivitamist. See skript sisestab vajalikud kasutajamuutujad Gafana konfiguratsioonifaili ja taaskäivitab veebiserveri.

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

Pärast seda jääb teha kolm asja:
1) paigaldada paketid
2) tuua Gafana systemctl alla ja paigaldada ClickHouse'i plugin
3) lisada skript setup.sh käivitamise järjekorda kohe pärast virtuaalse masina sisselülitamist.

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;

Nüüd jääb käivitada Packer ja saada väljundiks kujutis, mis paigutatakse määratud sektsiooni. Virtuaalmasina loomisel saab selle valida käivitatavaks kettaks ning pärast käivitamist saada valmis Gafana veebiserver.

Instantsi grupp ja koormuse tasakaalustaja

Pärast ketta kujutise loomist, mis võimaldab luua palju identseid Gafana veebiservereid, saame luua instantsi grupi. Yandex Cloud platvormil tähistab see termin virtuaalmasinate kogumit, millel on samad omadused. Instantsi grupi loomisel konfigureeritakse grupi kõigi masinate prototüüp ja seejärel ka rühma omadused (näiteks minimaalne ja maksimaalne aktiivsete masinate arv). Kui praegune arv ei vasta nendele kriteeriumitele, siis instantsi grupp eemaldab ise liigsed masinad või loob uusi nende järgi.

Meie ülesande raames loome veebiserverite instantsi grupi, mis sünnivad varem loodud ketta kujutisest.

Viimase instantsigruppide seadistamine on tõeliselt märkimisväärne. Sihtgrupp, mis integreerub Load Balancer'iga, võimaldab paar nupuvajutust kõrge taseme L3-balansseeri seadistamiseks selle grupi virtuaalmasinate peal.

Balansseeri seadistamisel rakendasin kahte olulist aspekti:

Seadsin ühtlasi nii, et balansseerija aktsepteerib kasutajatulekut 80. porti ja suunab selle virtuaalmasinate 3000. porti, kuhu Grafana elab.
Seadsin masinate elujõulisuse kontrolli, pingsades neid 3000. porti.

Mini kokkuvõte

Lõpuks suutsime ise lahti keerata soovitud rakenduse infrastruktuuri ja nüüd on meil kõrgelt usaldusväärne Grafana teenus. Vaja on lihtsalt teada balansseeri IP-aadressi kui sisenemispunkti rakendusse ja ClickHouse klastrihostit, et laadida sinna andmestik.

Tundub, et oleme võitnud? Jah, oleme. Kuid midagi häirib siiski. Kogu ülaltoodud protsess nõuab palju manuaalseid toiminguid ning ei ole kaugeltki skaleeritav, mistõttu sooviksime seda võimalusel automatiseerida. Sellele pühendatakse järgmine osa.

Integreerimine Terraform'iga

Kasutame taas HashiCorpi tööriista nimega Terraform. See aitab ühe nupuvajutusega rakenduse kogu infrastruktuuri üles seada, toetudes paarile muutujale, mille kasutaja edastab. Kirjutame retsepti, mida saab mitu korda erinevates kasutajate jaotustes käivitada.

Kogu töö Terraform'iga koosneb konfiguratsioonifaili kirjutamisest (*.tf) ja infrastruktuuri loomise alusest.

Muutujad

Faili algusesse paneme muutujad, millest sõltub, kus ja kuidas tulevane infrastruktuur üles seatakse.

variable "oauth_token" {
    type = string
    default = ""
}
variable "cloud_id" {
    type = string
    default = ""
}
variable "folder_id" {
    type = string
    default = ""
}
variable "service_account_id" {
    type = string
    default = ""
}
variable "image_id" {
    type = string
    default = ""
}
variable "username" {
    type = string
    default = ""
}
variable "password" {
    type = string
    default = ""
}
variable "dbname" {
    type = string
    default = ""
}
variable "public_key_path" {
    type = string
    default = ""
}

Kogu rakenduse deployeerimise protsess keskendub ketta pildi koostamisele ja nende muutujate seadistamisele. Selgitan, mille eest nad vastutavad:

oauth_token — token pilve juurde pääsemiseks. Seda saab hankida lingil.
cloud_id — pilve identifikaator, kus me rakendust üles seadma hakkame
folder_id — jaotuse identifikaator, kus rakendust käivitame
service_account_id — teenuse konto identifikaator vastavas pilviosas.
image_id — ketta pildi identifikaator, mis saadakse Packeriga
username ja parool — kasutajanimi ja parool juurdepääsuks mõlemale andmebaasile ja Grafana veebiserverile
dbname — andmebaasi nimi CH ja MySQL klastrites
public_key_path — tee faili, kus asub teie avalik ssh-võti, mille kaudu saab sisse logida nime all ubuntu veebiserveritega virtuaalmasinadesse

Pakkuja seadistamine

Nüüd tuleb seadistada Terraformi pakkuja — meie puhul Yandex:

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

Siit on näha, et kasutame ülal määratud muutujaid.

Võrk ja klastrid

Nüüd loome võrgu, milles meie infrastruktuuri elemendid suhtlevad, kolm alamsubti (üks igas regioonis) ja tõstame üles CH ja MySQL klastrid.


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

Nagu märgata, on iga kahest klastrist piisavalt tõrgeteta tänu kolme kättesaadavuse tsooni paigutusele.

Veebiserverid

Tundub, et võiks jätkata samas vaimus, kuid sattusin keerukusse. Enne tõstsin kõigepealt MySQL klastrit ja alles pärast seda, teades selle ID-d, koostasin kettapildi soovitud konfiguratsiooniga, kus määrasin klastri hosti. Kuid nüüd ei tea me klastri ID-d enne Terraformi käivitamist, sealhulgas pildi koostamise hetkel. Seetõttu pidin kasutama järgmist trikki.

Kasutades Amazoni metaandmete teenust, edastame virtuaalmasinale mõned parameetrid, mille ta vastu võtab ja töötleb. Me peame tagama, et pärast käivitamist läheks masin metaandmetesse MySQL klastri hosti ja kasutajanime-parooli jaoks, mille kasutaja on määranud Terraformi failis. Muudame faili sisu veidi. setup.sh, mis käivitub virtuaalmasina sisse lülitamisel.

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

Instantsigrupp ja tasakaalustaja

Uue kettapildi koostamise järel saame lõpuks täiendada oma faili Terraformile.

Määrame, et soovime kasutada olemasolevat kettapilti:

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

Nüüd loome instantsigruppi:

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

Oluline on märkida, kuidas me edastasime metaandmetesse cluster_uri, username ja parool. Just need tõmbab virtuaalmasin käivitamisel ja paneb Grafana konfiguratsiooni.

Küsimus on tasakaalustajas.

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

Veidi suhkrut

Jäänud on väike detail. Pärast infrastruktuuri ülesehitamist tuleb minna Grafana kasutajaliidesesse ja käsitsi lisada CH klaster (mille ID tuleb veel hankida) kui andmeallikas. Kuid Terraform teab, mis on klastri ID. Anname talle ülesande see töö lõpule viia.

Lisame uue teenusepakkuja — Grafana, ning hostiks anname talle tasakaalustaja IP-aadressi. Kõik muudatused, mida Terraform teeb masinas, kuhu tasakaalustaja suunab, kantakse MySQL-i, seega ka kõikidesse teistesse masinatesse.

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

Korrigeerime

Võtame tasakaalustaja IP-aadressi ja ClickHouse klastri hosti

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

Võib alustada

Kõik! Meie konfiguratsioonifail on valmis ja saame, määrates muutujad, öelda Terraformile tõsta kõik, mida oleme eespool kirjeldanud. Kogu protsess võttis mul umbes 15 minutit.
Lõpuks võib näha ilusa sõnumi:

Rakendamine lõpetatud! Ressursid: 9 lisatud, 0 muudetud, 0 purustatud.
Väljundid:

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

Ja pilves on nähtavad ülesseatud infrastruktuuri elemendid:

Teeme kokkuvõtte

Nüüd, Grafana näitel, oskab igaühel teist rakendusi käivitada laiaulatuslikus pilvearhitektuuris Yandex. Cloud platvormil. Selleks võivad abiks olla HashiCorp'i kasulikud tööriistad nagu Packer ja Terraform. Loodan, et see artikkel on kellelegi kasulik 🙂

P.S. Allpool lisatakse link reposiitoriumi, kus on leidnud valmis retseptid Packerile ja Terraformile, lõigud, mida ma selles artiklis olen maininud.

Repo

Allikas: habr.com