Jaotatud teenuste juurutamine Yandex.Cloudis Grafana näitel

Tere kõigile! Kursusetööd tehes uurisin meie kodumaise pilveplatvormi võimalusi, nagu Yandex.Cloud. Platvorm pakub erinevaid teenuseid praktiliste probleemide lahendamiseks. Kuid mõnikord on vajalik nende teenuste põhjal seadistada oma pilveprogramm ulatusliku infrastruktuuriga. Selles artiklis tahan jagada kogemusi sellise rakenduse juurutamisest.

Mida soovitakse saavutada?

Grafana — võimas tööriist analüüsivajaduste või süsteemide jälgimise ülesannete lahendamiseks. Selle põhivarustuses on virtuaalne masin koos Grafana veebiserveriga ning andmebaas (ClickHouse, InfluxDB jne), millel põhinev andmestik, mille alusel vahetatakse analüüsi.

Pärast virtuaalse masina käivitamist, kus on veebiserver, saab selle hosti sisse logida ja saada ilus UI, määrata andmebaasid allikateks edasiseks töötlemiseks, luua armatuurlaudu ja graafikuid.

Baasi versioonil on üks märkimisväärne puudus — see ei ole absoluutselt tõrkekindel. See tähendab, et rakenduse funktsionaalsus sõltub täielikult ühe virtuaalse masina töövõimest. Kui see ebaõnnestub või kui kümme inimest avavad samal ajal kasutajaliidese, tekivad probleemid.

Need lahendatakse lihtsalt: on vaja lihtsalt… käivitada palju sama tüüpi virtuaalseid masinaid koos veebiserveriga ja paigutada need L3- taseme koormuse tasakaalustaja alla. Kuid siin ei ole kõik nii lihtne. Grafana salvestab kasutaja seaded (andmebaaside teed, armatuurlaud, graafikud jne) otse oma virtuaalse masina kettale. Seega, kui teete UI-s mingeid muudatusi, kajastuvad need muudatused ainult seal, kuhu koormuse tasakaalustaja meid saatis. See viib rakenduste konfiguratsioonide ebajärjekindluseni ning tekitab probleeme käivitamise ja kasutamise osas.

Siin tuleb appi veel üks andmebaas, näiteks MySQL või selle analoog. Ütlesime Grafanale, et ta peab hoidma kasutaja seadistusi just selle "varu" andmebaasis. Pärast on piisav, kui igal masinal korra viidata sellele andmebaasile, ja kõik muud kasutaja seadistused saab redigeerida ükskõik millisel virtuaalmasinal, need kanduvad üle teistele.

Siin on rakenduse lõppstruktuuri skeem:

Õpime käsitsi üles seadma

MySQL ja ClickHouse

Enne kui sellist rakendust ühe nupuvajutusega üles seada, tuli õppida käsitsi igat komponenti üles seadma ja need omavahel integreerima.

Siin aitab meid Yandex.Cloud, mis pakub L3-balansiereid, ClickHouse'i ja MySQL managed-teenustena. Kasutajal on vaja vaid määrata parameetrid ja oodata, kuni platvorm viib kõik töökorda.

Registreerisin end, lõin enda jaoks pilve ja maksekonto. Pärast seda sisenesin pilve ja tõin seadmesse MySQL ja ClickHouse klastri minimaalsete seadistustega. Ootasin, kuni need aktiveeruvad.

Samuti ei tohi unustada luua igas klastri andmebaas ja seadistada ligipääs sellele kasutajanime ja parooli abil. Sügavale detailidesse ma ei lasku — liideses on kõik piisavalt selge.

Mitte nii ilmne detail oli see, et nende andmebaaside jaoks on mitmeid hoste, mis tagavad nende tõrketaluvuse. Kuid Grafana vajab iga andmebaasi tööks täpselt ühte hosti. Pikaajaline lugemine dokumentatsioonis Pilv viis mind lahendusele. Selgub, et hosti tüüp c-<cluster_id>.rw.mdb.yandexcloud.net mappib aktiivse peahosti praegusele klastri ID-le. Just seda me Grafanale anname.

Veebiserver

Nüüd on vuugimas nimetatud veebiserveri kätte. Käivitame tavalise virtuaalmaquina Linuxiga ja seadistame 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-all ja installime plugin ClickHouse'i kasutamiseks (jah, algkomplektis see ei sisaldu).

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

Kogu, pärast seda lihtsa käsuga

sudo service grafana-server start

käivitame veebiserveri. Nüüd saab brauserisse sisestada virtuaalmasina välist IP-aadressi, määrata pordiks 3000 ja näha Grafana ilusat kasutajaliidese olemasolu.

Kuid ei tasu kiirustada, enne kui Grafanat seadistama hakkame, tuleb kindlasti määrata MySQL tee, et seadeid seal hoida.

Kogu veebiserveri Grafana konfiguratsioon asub failis /etc/grafana/grafana.ini. Vajalik rida näeb välja nii:

;url =

Seame hosti MySQL klastrisse. Samas failis on sisendi ja parooli info Grafanale nagu ülaloleval pildil, mis on vaikimisi mõlemad admin.

Saame 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 õige aeg veebiserverit taaskäivitada!

sudo service grafana-server restart

Nüüd määrame Grafana kasutajaliideses ClickHouse andmeallikaks.

Saavutada töötav konfiguratsioon olen saanud järgmiste seadistustega:

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

Kõik! Meil on üks toimiv virtuaalmasin, millel on veebiserver, mis on ühendatud CH-ga ja MySQL-iga. Nüüd on võimalik yük yükida andmestikke ClickHouse'i ja ehitada juhtpaneele. Siiski pole me veel oma eesmärki saavutanud ja pole täielikku infrastruktuuri välja pannud.

Packer

Yandex.Cloud võimaldab luua olemasoleva virtuaalmasina ketta pilti, mille põhjal — niipalju identseid masinaid kui soovite. Just seda me teeme. Mugavalt pildi kogumiseks kasutame tööriista Packer HashiCorpi poolt. See võtab sisendina vastu json-faili, milles on pildi loomise juhised.

Meie json-fail koosneb kahest plokist: builders ja provisioners. Esimene plokk kirjeldab pildi parameetreid kui olemust, teine aga — 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 malleis tuleb määrata osa ID pilves, kus soovite luua kujundi, samuti tee teenusekonto võtmefailile, mis on eelnevalt selles osas loodud. Rohkem teenusekontode ja võtmete loomise kohta saate lugeda vastavas jaotises. dokumentatsioonis.

Selline konfiguratsioon ütleb, et kettapilt koostatakse platvormi põhjal ubuntu-1804-lts, asetatakse kasutaja vastavasse jaotisse kujundite perekonnas GRAFANA nimega grafana-{{timestamp}}.

Provisioners

Nüüd huvitavam osa konfiguratsioonist. Selles kirjeldatakse tegevuste järjestust, mille tuleb läbi viia virtuaalses masinas enne, kui külmutada selle olek kettapildiks.

{
...,
"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 tegevused jagatud kolmeks etapiks. Esimeses etapis käivitatakse lihtne skript, mis loob abikausta.

prepare-ctg.sh:

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

Järgmises etapis paigutame sellesse kausta skripti, mida tuleb käivitada kohe pärast virtuaalmasina alustamist. See skript lisab kasutaja muutujad, mis tuleb kirjutada Grafana 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 on veel kolm asja, mis tuleb teha:
1) paigaldada paketid
2) käivitada Grafana systemctl abil ja paigaldada ClickHouse plugin
3) lisada skript setup.sh käivitamise järjekorda kohe pärast virtuaalmasina 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 üle käivitada Packer ja saada väljundiks pilt, mis paigutatakse määratud sektsiooni. Virtuaalmasina loomisel saab seda valida alglaadurina ja pärast käivitamist saadakse valmis Grafana veebiserver.

Instantsi grupp ja koormuse tasakaalustaja

Pärast sellest, kui diskipilt on loodud, mille abil saab luua mitu sama Grafana veebi-serverit, saame luua instantsgrupi. Yandex.Cloudi platvormil nimetatakse seda mõistet virtuaalmasinate ühenduseks, millel on samad omadused. Instantsgrupi loomisel konfigureeritakse kõikide selle grupi masinate prototüüp ning seejärel grupi omadused (nt minimaalne ja maksimaalne aktiivsete masinate arv). Kui praegune arv ei vasta nendele kriteeriumidele, siis instantsgrupp eemaldab ise üleliigsed masinad või loob uusi sarnaste omadustega masiname.

Meie ülesande raames loome veebiserverite instantsgrupi, mis sünnib varem loodud diskipildist.

Tõeliselt tähelepanuväärne on instantsgrupi viimane seadistus. Integreeritud Load Balanceriga sihtgrupp aitab vaid paari nupuvajutusega seadistada L3-balanserit selle grupi virtuaalmasinate kohal.

Balanseri seadistamisel rakendasin kaks olulist punkti:

1. Seadsime, et koormuse jaotaja aktsepteerib kasutaja liiklust 80. pordil ning suunab selle virtuaalmasinate 3000. pordile, seal, kus Grafana resideerib.
2. Seadsime masinate elujõudluse kontrollimise, pingutades neid 3000. pordil.

Lühikokkuvõte

Lõpuks suutsime käsitsi üles seada soovitud rakenduse infrastruktuuri ning nüüd on meil kõrge kättesaadavusega Grafana teenus. On vajalik vaid teada koormuse jaotaja IP-aadressi rakenduse sisenemise punktina ja ClickHouse'i klastrihostina, et andmestik sinna laadida.

Näib, et võit? Jah, võit. Kuid siiski teatud asjad häirivad. Ükski eespool toodud protsess ei ole väga automatiseeritud ja nõuab palju käsitsi sekkumist, tahame seda võimalikult palju automatiseerida. Sellele pühendatakse järgmine osa.

Integratsioon Terraformiga

Kasutame taas HashiCorpi tööriista nimega Terraform. See aitab üksiku nupuvajutusega üles seada kogu rakenduse infrastruktuuri, tuginedes mitmele muutujale, mille kasutaja edastab. Kirjutame retsepti, mida saab mitmel korral erinevates kasutuskohtades käivitada.

Kõik töö Terraformiga seisneb konfiguratsioonifaili kirjutamises (*.tf) ja selle alusel infrastruktuuri loomises.

Muutujad

Alguses toome välja muutujad, millest sõltub, kus ja kuidas tulevane infrastruktuur rakendatakse.

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 juurutamisprotsess seisneb diskihalduse pildina koostamises ja nende muutujate seadistamises. Selgitan, mille eest need vastutavad:

oauth_token — juurdepääsutoken, et ligipääseda pilve. Seda saab hankida lingi kaudu.
cloud_id — pilve identifikaator, kus me rakendust juurutame
folder_id — kaustas oleva identifikaator, kus me rakendust juurutame
service_account_id — teenusekonto identifikaator vastavas pilveosas.
image_id — kettapildi identifikaator, mis saadakse Packeriga.
username ja password — kasutajanimi ja parool, et pääseda juurde nii andmebaasidele kui ka Grafana veebiserverile
dbname — andmebaasi nimi CH ja MySQL klastris
public_key_path — tee faili, mis sisaldab teie avalikku ssh-võtit, mille kaudu saab sisse logida nime all ubuntu virtuaalmasinatele, millel on veebiserverid

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

Võime märgata, et siin kasutame ülalloetletud muutujaid.

Võrk ja klastrid

Nüüd loome võrgu, kus meie infrastruktuuri elemendid suhtlevad, kolm alamvõrku (igaühes üks igas piirkonnas) ning tõstame üles CH ja MySQL klastrid.

resource "yandex_vpc_network" "grafana_network" {}

resource "yandex_vpc_subnet" "subnet_a" {
  zone           = "ee-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           = "ee-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           = "ee-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      = "ee-central1-a"
    subnet_id = yandex_vpc_subnet.subnet_a.id
  }

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

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

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

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

  host {
    type      = "ZOOKEEPER"
    zone      = "ee-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      = "ee-central1-a"
    subnet_id = yandex_vpc_subnet.subnet_a.id
  }
  host {
    zone      = "ee-central1-b"
    subnet_id = yandex_vpc_subnet.subnet_b.id
  }
  host {
    zone      = "ee-central1-c"
    subnet_id = yandex_vpc_subnet.subnet_c.id
  }
}

Nagu märkida, on iga kahe klastrit loodud piisavalt talitlushäirete kindlaks, kuna need asuvad kolmes kättesaadavuspiirkonnas.

Veebiserverid

Tundub, et võiks jätkata sama rada, kuid ma sattusin keerukusse. Varem tõstsin kõigepealt MySQL klastrit ja alles seejärel, teades selle ID-d, kogusin vajaliku konfiguratsiooniga ketaspildi, kus määrasin klastrile hosti. Kuid nüüd ei tea me klastrite ID-d enne Terraformi käivitamist, sealhulgas ka kujutise koostamise hetkel. Seetõttu pidime varuma järgmise triki.

Kasutades Amazoni metaandmete teenust, edastame virtuaalmasinale mõned parameetrid, mida see aktsepteerib ja töötleb. Meil on vajalik, et pärast käivitamist läheks masin metaandmete juurde, et leida MySQL klastrile host ja kasutajanimi-parool, mida kasutaja Terraformi failis määras. Teeme faili sisu veidi muudatusi setup.sh, mis käivitatakse virtuaalmasina sisselülitamise ajal.

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

Instantsi rühm ja tasakaalustaja

Uue ketaspildi ümber koostamisel saame lõpuks oma faili Terraformi jaoks täiendavalt kirjutada.

Määrame, et soovime kasutada olemasolevat ketaspilti:

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

Loo nüüd instantsrühma:

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

Tasub märkida, kuidas me metadatas edastasime cluster_uri, username ja password. Just nende andmed, mille virtuaalne masin käivitamise korral kätte saab ja Grafaana konfi paigutab.

Jääk on koormuse tasakaalustaja teha.

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

Natuke suhkrut

Ainus, mis jääb teha, on see, et kui infrastruktuur on üles seatud, tuleb minna Grafana UI-sse ja käsitsi lisada CH-klaster (mille ID tuleb veel hankida) andmeallikana. Kuid ID teab klastrist Terraform. Usaldame talle, et ta viib asja lõpule.

Lisame uue pakkuja — Grafana, ja anname hostiks balancer'i IP-aadressi. Kõik muudatused, mida Terraform masinas teeb, kuhu tema balancer suunab, peegelduvad MySQL-is, mis tähendab, et need jõuavad ka kõikidesse ülejäänud 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"
}

Kammime

Tõstame esile ClickHouse'i tasakaalustaja ja klastri IP-aadressi

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

Saab käivitada

Kõik! Meie konfiguratsioonifail on valmis ning pärast muutujate seadistamist saame öelda Terraformile, et tõsta üles kõik, mida ülal kirjeldasime. Kogu protsess võttis mul umbes 15 minutit.
Lõpus võib näha kaunist teadet:

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

Ja pilves on nähtavad tõstetud infrastruktuuri elemendid:

Teeme kokkuvõtte

Nüüd oskab igaüks teist Grafana näitel rakendusi Yandex.Cloudi platvormil keerulise pilvearhitektuuriga üles seada. Sellistes olukordades võivad abiks olla sellised kasulikud tööriistad nagu HashiCorpi Packer ja Terraform. Loodan, et kellelegi osutub see artikkel kasulikuks 🙂

P.S. Allpool jagan linki repole, kus leiate valmislahendused Packerile ja Terraformile, mille fragmente jagasin selles artiklis.

Repo

Allikas: habr.com