🥇Paskirstytų paslaugų diegimas Yandex.Cloud naudojant Grafana kaip pavyzdį

Sveiki visi! Kursinio darbo metu tyrinėjau tokios vietinės debesų platformos galimybes kaip Yandex.Cloud. Platformoje siūlomos įvairios paslaugos, skirtos praktinių problemų sprendimui. Tačiau kartais jums reikia sukurti savo debesų programą su gana plačia infrastruktūra, pagrįsta šiomis paslaugomis. Šiame straipsnyje noriu pasidalinti savo patirtimi diegiant tokią programą.

Ką norite gauti?

grafana — galingas įrankis sprendžiant analitines problemas arba stebint bet kokių sistemų problemas. Pagal pagrindinę konfigūraciją tai yra virtuali mašina su „Grafana“ žiniatinklio serveriu, taip pat duomenų bazė („ClickHouse“, „InfluxDB“ ir kt.) su duomenų rinkiniu, kuriuo bus grindžiama analizė.

Paleidę virtualią mašiną su žiniatinklio serveriu, galite nueiti į jos pagrindinį kompiuterį ir gauti gražią vartotojo sąsają, nurodyti duomenų bazes kaip šaltinius tolesniam darbui, kurti prietaisų skydelius ir grafikus.

Pagrindinė versija turi vieną reikšmingą trūkumą – ji visiškai neatspari gedimams. Tai yra, visas programos funkcionalumas priklauso nuo vienos virtualios mašinos gyvybingumo. Jei jis atsisako arba 10 žmonių tuo pačiu metu atidaro vartotojo sąsają, kils problemų.

Jas galima išspręsti paprastai: tereikia... įdiegti daug identiškų virtualių mašinų su žiniatinklio serveriu ir įdėti jas po L3 balansavimo priemone. Bet čia ne viskas taip aišku. „Grafana“ saugo vartotojo nustatymus (keliai į duomenų bazes, prietaisų skydelius, grafikus ir kt.) tiesiai savo virtualios mašinos diske. Taigi, jei pakeisime kai kuriuos vartotojo sąsajos nustatymus, šie pakeitimai atsispindės tik virtualioje mašinoje, į kurią mus atsiuntė balansuotojas. Dėl to mūsų programos nustatymai bus nenuoseklūs, o tai sukels paleidimo ir naudojimo problemų.

Čia į pagalbą ateis kita duomenų bazė, pavyzdžiui, MySQL arba jos atitikmuo. Mes sakome Grafanai, kad ji turėtų saugoti vartotojo nustatymus šioje „atsarginėje“ duomenų bazėje. Vėliau pakaks vieną kartą kiekvienoje mašinoje nurodyti kelią į šią duomenų bazę ir redaguoti visus kitus vartotojo nustatymus bet kurioje virtualioje mašinoje; jie bus išplėsti ir kitose.

Čia yra galutinės taikomosios infrastruktūros diagrama:

Išmokime kelti rankomis

MySQL ir ClickHouse

Prieš diegiant tokią programą vienu mygtuko paspaudimu, reikėjo išmokti tvarkyti kiekvieną jos komponentą ir integruoti juos tarpusavyje.

Čia mums padės Yandex.Cloud, kuris teikia L3 balansavimo priemones, ClickHouse ir MySQL kaip valdomas paslaugas. Vartotojui tereikia nurodyti parametrus ir palaukti, kol platforma viską sutvarkys.

Užsiregistravau, sukūriau debesį ir mokėjimo sąskaitą. Po to nuėjau į debesį ir su minimaliais nustatymais sukūriau MySQL ir ClickHouse grupes. Laukiau, kol jie suaktyvės.

Taip pat turite nepamiršti sukurti duomenų bazę kiekviename klasteryje ir sukonfigūruoti prieigą prie jos naudodami prisijungimo vardą ir slaptažodį. Čia nesileisiu į detales - sąsajoje viskas gana akivaizdu.

Neakivaizdi detalė buvo ta, kad šiose duomenų bazėse yra daug pagrindinių kompiuterių, kurie užtikrina jų atsparumą gedimams. Tačiau „Grafana“ reikalauja tiksliai vieno pagrindinio kompiuterio kiekvienai duomenų bazei, su kuria ji dirba. Ilgas skaitymas dokumentacija Debesys privedė mane prie sprendimo. Pasirodo, kad rūšies šeimininkas c-<cluster_id>.rw.mdb.yandexcloud.net susietas su dabartine aktyvia pagrindine klasterio priegloba su atitinkamu ID. Tai mes padovanosime Grafanai.

Tinklapio serveris

Dabar tai priklauso nuo žiniatinklio serverio. Pakelkime įprastą virtualią mašiną su Linux ir rankiniu būdu sukonfigūruokime joje „Grafana“.

Prisijunkime per ssh ir suinstaliuokime reikiamus paketus.

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

Po to paleiskime Grafana pagal systemctl ir įdiekime priedą darbui su ClickHouse (taip, jis nėra pateiktas pagrindiniame pakete).

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

Tai viskas, po to su paprasta komanda

sudo service grafana-server start

paleisime žiniatinklio serverį. Dabar naršyklėje galite įvesti išorinį virtualios mašinos IP adresą, nurodyti 3000 prievadą ir pamatyti gražią Grafana vartotojo sąsają.

Tačiau neskubėkite, prieš nustatydami „Grafana“, nepamirškite nurodyti jai kelio į „MySQL“, kad ten būtų išsaugoti nustatymai.

Visa Grafana žiniatinklio serverio konfigūracija yra faile /etc/grafana/grafana.ini. Reikalinga eilutė atrodo taip:

;url =

Mes nustatome pagrindinį kompiuterį į MySQL klasterį. Tame pačiame faile yra prisijungimo vardas ir slaptažodis, kad galėtumėte pasiekti Grafana aukščiau esančiame paveikslėlyje, kurie pagal numatytuosius nustatymus yra vienodi admin.

Galite naudoti sed komandas:

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

Atėjo laikas iš naujo paleisti žiniatinklio serverį!

sudo service grafana-server restart

Dabar „Grafana“ vartotojo sąsajoje nurodysime „ClickHouse“ kaip duomenų šaltinį.

Man pavyko pasiekti veikiančią konfigūraciją su šiais parametrais:

Nurodžiau kaip URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

Viskas! Turime vieną veikiančią virtualią mašiną su žiniatinklio serveriu, prijungtu prie CH ir MySQL. Jau galite įkelti duomenų rinkinį į „ClickHouse“ ir kurti prietaisų skydelius. Tačiau mes dar nepasiekėme savo tikslo ir neišskleidėme visavertės infrastruktūros.

Pakuotojas

„Yandex.Cloud“ leidžia sukurti esamos virtualios mašinos disko vaizdą, o jo pagrindu – bet kokį skaičių mašinų, identiškų viena kitai. Būtent tai ir naudosime. Norėdami patogiai surinkti vaizdą, pasiimkite įrankį Pakuotojas iš HashiCorp. Kaip įvestis naudojamas json failas su instrukcijomis, kaip surinkti vaizdą.

Mūsų json failą sudarys du blokai: kūrėjai ir teikėjai. Pirmame bloke aprašomi paties vaizdo, kaip esybės, parametrai, o antrajame – instrukcijos, kaip jį užpildyti reikiamu turiniu.

statybininkai

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

Šiame šablone turite nustatyti debesyje esančios sekcijos, kurioje norite sukurti vaizdą, identifikatorių, taip pat kelią į failą su raktais iš anksčiau šioje skiltyje sukurtos paslaugos paskyros. Daugiau apie paslaugų paskyrų ir raktų kūrimą failo forma galite perskaityti atitinkamame skyriuje dokumentacija.

Ši konfigūracija sako, kad disko vaizdas bus sukurtas remiantis platforma ubuntu-1804-lts, patalpintas atitinkamame vaizdo šeimos naudotojo skyriuje GRAFANA po pavadinimu grafana-{{timestamp}}.

Teikėjai

Dabar ateina įdomesnė konfigūracijos dalis. Jame bus aprašyta veiksmų seka, kurią reikės atlikti virtualioje mašinoje prieš užfiksuojant jos būseną į disko vaizdą.

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

Čia visi veiksmai suskirstyti į 3 etapus. Pirmajame etape vykdomas paprastas scenarijus, sukuriantis pagalbinį katalogą.

ready-ctg.sh:

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

Kitame etape į šį katalogą įdedame scenarijų, kurį reikės paleisti iškart paleidus virtualią mašiną. Šis scenarijus įtrauks vartotojo kintamuosius, kuriuos reikia užregistruoti „Grafana“ konfigūracijoje, ir iš naujo paleis žiniatinklio 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

Po to liko 3 dalykai:
1) įdiegti paketus
2) paleiskite Grafana pagal systemctl ir įdiekite ClickHouse papildinį
3) Įdėkite setup.sh scenarijų į paleidimo eilę iškart po to, kai įjungsite virtualią mašiną.

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;

Dabar belieka paleisti „Packer“ ir gauti išvesties vaizdą į nurodytą skyrių. Kurdami virtualią mašiną galite pasirinkti ją kaip įkrovos diską ir paleidę gausite paruoštą Grafana žiniatinklio serverį.

Instancijų grupė ir balansuotojas

Kai turėsime disko vaizdą, leidžiantį sukurti daug identiškų „Grafana“ žiniatinklio serverių, galime sukurti egzempliorių grupę. „Yandex.Cloud“ platformoje šis terminas reiškia virtualių mašinų, turinčių tas pačias charakteristikas, sąjungą. Kuriant egzempliorių grupę sukonfigūruojamas visų šios grupės mašinų prototipas, o tada – pačios grupės charakteristikos (pavyzdžiui, minimalus ir maksimalus aktyvių mašinų skaičius). Jei dabartinis skaičius neatitinka šių kriterijų, tada pati egzempliorių grupė pašalins nereikalingus įrenginius arba sukurs naujus savo paveikslėlyje.

Vykdydami užduotį sukursime žiniatinklio serverių egzempliorių grupę, kuri bus sugeneruota iš anksčiau sukurto disko vaizdo.

Kas tikrai nuostabu, yra paskutinio egzemplioriaus grupės sąranka. Tikslinė grupė, integruota su „Load Balancer“, padės sukonfigūruoti L3 balansavimo priemonę ant šios grupės virtualių mašinų spustelėjus keletą mygtukų.

Nustatydamas balansuotoją įgyvendinau du svarbius dalykus:

Aš priverčiau balansuotoją priimti vartotojo srautą per 80 prievadą ir nukreipti jį į 3000 virtualių mašinų prievadą, būtent ten, kur gyvena Grafana.
Aš nustatiau mašinų gyvybingumo patikrinimą, prisijungdamas juos prie 3000 prievado.

Mini santrauka

Galiausiai galėjome rankiniu būdu įdiegti norimą taikomųjų programų infrastruktūrą, o dabar turime labai atsparią „Grafana“ paslaugą. Norėdami įkelti duomenų rinkinį, turite žinoti tik balansyro IP adresą kaip įėjimo į programą ir ClickHouse klasterio pagrindinį adresą.

Ar tai atrodytų kaip pergalė? Taip, pergalė. Bet kažkas mane vis tiek glumina. Visam aukščiau aprašytam procesui reikia atlikti daug rankinių veiksmų ir jis visiškai nekeičiamas; jei įmanoma, norėčiau jį automatizuoti. Tam bus skirtas kitas skyrius.

Terraformų integracija

Mes vėl naudosime HashiCorp įrankį, vadinamą Terraformas. Tai padės jums vienu mygtuko paspaudimu įdiegti visą programos infrastruktūrą, atsižvelgiant į kelis vartotojo perduodamus kintamuosius. Parašykime receptą, kurį galima paleisti kelis kartus skirtingose skirtingų vartotojų skiltyse.

Visas darbas su Terraform yra parašytas konfigūracijos failas (*.tf) ir juo grindžiamos infrastruktūros kūrimas.

Kintamieji

Pačioje failo pradžioje įtrauksime kintamuosius, kurie nustato, kur ir kaip bus įdiegta būsima infrastruktūra.

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

Visas programos diegimo procesas apsiribos disko atvaizdo kūrimu ir šių kintamųjų nustatymu. Leiskite man paaiškinti, už ką jie atsakingi:

oauth_token - prieigos prie debesies prieigos raktas. Galima gauti iki nuoroda.
debesies_id — debesies identifikatorius, kuriame įdiegsime programą
aplanko_id — sekcijos identifikatorius, kuriame įdiegsime programą
paslaugos_sąskaitos_id — paslaugos paskyros identifikatorius atitinkamoje debesies skiltyje.
vaizdo_id — disko vaizdo, gauto naudojant Packer, identifikatorius
Nick и slaptažodis — vartotojo vardas ir slaptažodis, kad galėtumėte pasiekti tiek duomenų bazes, tiek Grafana žiniatinklio serverį
dbname — duomenų bazės pavadinimas CH ir MySQL klasteriuose
viešasis_rakto_kelias - kelias į failą su viešuoju ssh raktu, kurį galite naudoti prisijungdami pagal pavadinimą ubuntu į virtualias mašinas su žiniatinklio serveriais

Teikėjo sąranka

Dabar turite sukonfigūruoti „Terraform“ teikėją - mūsų atveju „Yandex“:

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

Pastebėsite, kad čia naudojame aukščiau apibrėžtus kintamuosius.

Tinklas ir klasteriai

Dabar sukursime tinklą, kuriame bendraus mūsų infrastruktūros elementai, tris potinklius (po vieną kiekviename regione) ir kelsime CH ir MySQL grupes.


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

Kaip matote, kiekviena iš dviejų grupių yra gana atspari gedimams, nes yra patalpinta į tris pasiekiamumo zonas.

Web serveriai

Atrodytų, galėtume tęsti ta pačia dvasia, bet susidūriau su sunkumais. Prieš tai pirmiausia iškėliau MySQL klasterį ir tik po to, žinodamas jo ID, surinkau disko atvaizdą su reikiama konfigūracija, kur klasteriui nurodžiau hostą. Tačiau dabar mes nežinome klasterio ID prieš paleisdami „Terraform“, įskaitant vaizdo kūrimo laiką. Todėl turėjau griebtis šių dalykų triukas.

Naudodamiesi „Amazon“ metaduomenų paslauga, kai kuriuos parametrus perduosime virtualiai mašinai, kurią ji priims ir apdoros. Įrenginys turi pereiti prie „MySQL“ klasterio pagrindinio kompiuterio ir vartotojo vardo slaptažodžio metaduomenų, kuriuos vartotojas nurodė „Terraform“ faile po paleidimo. Šiek tiek pakeiskime failo turinį setup.sh, kuris veikia, kai įjungiama virtualioji mašina.

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 grupė ir balansuotojas

Atkūrę naują disko vaizdą, pagaliau galime pridėti failą, skirtą Terraform.

Nurodykime, kad norime naudoti esamą disko vaizdą:

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

Dabar sukurkime egzempliorių grupę:

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

Verta atkreipti dėmesį į tai, kaip mes tai perdavėme į metaduomenis cluster_uri, username и password. Būtent juos virtualioji mašina išims paleidžiant ir įves „Grafana“ konfigūraciją.

Tai priklauso nuo balansuotojo.

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

Šiek tiek cukraus

Liko tik truputis. Įdiegę infrastruktūrą turėsite eiti į „Grafana“ vartotojo sąsają ir rankiniu būdu pridėti CH klasterį (kurio ID dar reikia gauti) kaip duomenų šaltinį. Tačiau „Terraform“ žino klasterio ID. Patikėkime jam įgyvendinti reikalą.

Pridėkime naują teikėją – Grafana ir suteikime jai balansuotojo IP adresą kaip prieglobą. Visi „Terraform“ atlikti mašinos pakeitimai, kuriuos nustato jo balansavimo priemonė, augs „MySQL“, taigi ir visose kitose mašinose.

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

Iššukuokime plaukus

Parodykime balansavimo priemonės IP adresą ir ClickHouse klasterio pagrindinį kompiuterį

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

Gali bėgti

Viskas! Mūsų konfigūracijos failas yra paruoštas ir, nustatydami kintamuosius, galime nurodyti Terraform pakelti viską, ką aprašėme aukščiau. Visas procesas man užtruko apie 15 minučių.
Pabaigoje galite pamatyti gražią žinutę:

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

O debesyje bus matomi iškeltos infrastruktūros elementai:

Apibendrinant

Dabar, naudodamiesi „Grafana“ kaip pavyzdžiu, kiekvienas iš jūsų galite įdiegti programas su besiplečiančia debesų architektūra „Yandex.Cloud“ platformoje. Tai gali padėti naudingi „HashiCorp“ įrankiai, tokie kaip „Packer“ ir „Terraform“. Tikiuosi, kad kam nors šis straipsnis bus naudingas :)

PS Žemiau pridėsiu nuorodą į saugyklą, kurioje rasite paruoštus „Packer“ ir „Terraform“ receptus, kurių fragmentus pateikiau šiame straipsnyje.

saugykla

Šaltinis: www.habr.com

Paskirstytų paslaugų diegimas „Yandex.Cloud“, kaip pavyzdį naudojant „Grafana“.