Hajutatud teenuste juurutamine Yandex.Cloudis, kasutades näitena Grafanat

Tere kõigile! Kursusetöö raames uurisin sellise kodumaise pilveplatvormi võimalusi nagu Yandex.Cloud. Platvorm pakub erinevaid teenuseid praktiliste probleemide lahendamiseks. Mõnikord tuleb aga nendel teenustel põhineva üsna ulatusliku infrastruktuuriga üles seada oma pilverakendus. Selles artiklis tahan jagada oma kogemusi sellise rakenduse juurutamisel.

Mida soovite saada?

grafana — võimas tööriist analüütiliste probleemide lahendamiseks või mis tahes süsteemide probleemide jälgimiseks. Põhikonfiguratsioonis on see virtuaalne masin Grafana veebiserveriga, samuti andmebaas (ClickHouse, InfluxDB jne) koos andmekogumiga, millel põhinevad analüüsid.

Pärast veebiserveriga virtuaalmasina käivitamist saate minna selle hosti ja hankida ilus kasutajaliides, määrata edasiseks tööks allikateks andmebaasid, luua armatuurlaudu ja graafikuid.

Põhiversioonil on üks märkimisväärne puudus – see ei ole üldse tõrkekindel. See tähendab, et kogu rakenduse funktsionaalsus sõltub ühe virtuaalmasina elujõulisusest. Kui see keeldub või 10 inimest avavad kasutajaliidese korraga, siis tekivad probleemid.

Neid saab lahendada lihtsalt: peate lihtsalt... juurutama veebiserveriga palju identseid virtuaalmasinaid ja asetama need L3 tasakaalustaja alla. Kuid siin pole kõik nii selge. Grafana salvestab kasutaja seadistused (teed andmebaasidesse, armatuurlauad, graafikud jne) otse oma virtuaalmasina kettale. Seega, kui muudame kasutajaliideses mõnda seadet, kajastuvad need muudatused ainult selles virtuaalmasinas, kuhu tasakaalustaja meid saatis. See toob kaasa meie rakenduse seaded vastuolus, põhjustades probleeme käivitamise ja kasutamisega.

Siin tuleb appi teine ​​andmebaas, näiteks MySQL või selle ekvivalent. Me ütleme Grafanale, et ta peaks salvestama kasutaja seaded sellesse "varu" andmebaasi. Seejärel piisab, kui määrata igas masinas üks kord selle andmebaasi tee ja redigeerida kõiki muid kasutajasätteid mis tahes virtuaalmasinas; need laienevad ka teistele.

Siin on lõpliku rakenduse infrastruktuuri diagramm:

Õpime kätega tõstma

MySQL ja ClickHouse

Enne sellise rakenduse ühe nupuvajutusega juurutamist oli vaja õppida, kuidas iga selle komponenti käsitleda ja neid omavahel integreerida.

Siin aitab meid Yandex.Cloud, mis pakub hallatavate teenustena L3 tasakaalustajaid, ClickHouse'i ja MySQL-i. Kasutajal tuleb vaid täpsustada parameetrid ja oodata, kuni platvorm kõik töökorda viib.

Registreerisin, tegin pilve ja maksekonto. Pärast seda läksin pilve ja seadistasin MySQL ja ClickHouse klastrid minimaalsete sätetega. Ootasin, kuni nad aktiveeruvad.

Samuti peate meeles pidama, et igas klastris tuleb luua andmebaas ja konfigureerida sellele juurdepääs sisselogimise ja parooli abil. Ma ei lasku siin üksikasjadesse - liideses on kõik üsna ilmne.

Mitteilmne detail oli see, et neil andmebaasidel on palju hoste, mis tagavad nende veataluvuse. Grafana nõuab aga täpselt ühte hosti iga andmebaasi jaoks, millega ta töötab. Pikk lugemine dokumentatsioon Pilved viisid mind otsusele. Selgub, et liigi peremees c-<cluster_id>.rw.mdb.yandexcloud.net vastendatud vastava ID-ga klastri praeguse aktiivse peamise hostiga. Selle me anname Grafanale.

veebiserver

Nüüd on aeg veebiserveri jaoks. Seadistame tavalise virtuaalmasina, millel on Linux ja me seame Grafana sellele oma kätega üles.

Ü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 ClickHouse'iga töötamiseks mõeldud plugina (jah, seda pole põhipaketis kaasas).

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

See on kõik, pärast seda lihtsa käsuga

sudo service grafana-server start

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

Kuid ärge kiirustage, enne Grafana seadistamist peate meeles pidama, et ütlete talle MySQL-i tee, et sätteid sinna salvestada.

Grafana veebiserveri kogu konfiguratsioon on failis /etc/grafana/grafana.ini. Nõutav rida näeb välja selline:

;url =

Seadsime hostiks MySQL-i klastri. Sama fail sisaldab ülaloleval pildil Grafanale juurdepääsuks vajalikku sisselogimist ja parooli, mis vaikimisi on mõlemad võrdsed admin.

Saate 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 määrame Grafana kasutajaliideses andmeallikaks ClickHouse.

Suutsin saavutada toimiva konfiguratsiooni järgmiste seadistustega:

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

Kõik! Meil on üks töötav virtuaalmasin, mille veebiserver on ühendatud CH ja MySQL-iga. Saate juba andmestiku ClickHouse'i üles laadida ja armatuurlaudu luua. Kuid me pole veel oma eesmärki saavutanud ega ole kasutusele võtnud täisväärtuslikku infrastruktuuri.

Pakkija

Yandex.Cloud võimaldab teil luua olemasoleva virtuaalmasina kettapildi ja selle põhjal - mis tahes arvu üksteisega identseid masinaid. See on täpselt see, mida me kasutame. Pildi mugavaks kokkupanemiseks võtke tööriist Pakkija firmalt HashiCorp. See võtab sisendiks json-faili koos juhistega pildi kokkupanekuks.

Meie json-fail koosneb kahest plokist: koostajad ja pakkujad. Esimene plokk kirjeldab pildi enda kui olemi parameetreid ja teine ​​plokk kirjeldab juhiseid selle täitmiseks vajaliku sisuga.

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

Selles mallis peate määrama pilves oleva jaotise identifikaatori, kuhu soovite pilti luua, samuti faili tee selles jaotises varem loodud teenusekonto võtmetega. Lisateavet teenusekontode ja võtmete loomise kohta faili kujul saate lugeda vastavast jaotisest dokumentatsioon.

See konfiguratsioon ütleb, et ketta kujutis ehitatakse platvormi alusel ubuntu-1804-lts, mis on paigutatud pildiperekonna vastavasse kasutajate sektsiooni GRAFANA nime all grafana-{{timestamp}}.

Varustajad

Nüüd tuleb konfiguratsiooni huvitavam osa. See kirjeldab toimingute jada, mis tuleb virtuaalmasinas enne selle oleku kettakujutiseks külmutamist 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 3 etappi. Esimeses etapis käivitatakse lihtne skript, mis loob abikataloogi.

ready-ctg.sh:

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

Järgmises etapis asetame sellesse kataloogi skripti, mis tuleb kohe pärast virtuaalmasina käivitamist käivitada. See skript paneb Grafana konfiguratsioonis registreeritavad kasutajamuutujad 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 jäänud teha 3 asja:
1) installige paketid
2) käivitage Grafana systemctl all ja installige plugin ClickHouse
3) pane setup.sh skript kohe peale virtuaalmasina sisselülitamist käivitusjärjekorda.

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 vaid käivitada Packer ja panna väljundpilt määratud jaotisesse. Virtuaalse masina loomisel saate selle valida alglaadimiskettaks ja peale käivitamist saate valmis Grafana veebiserveri.

Instantside rühm ja tasakaalustaja

Kui meil on ketta kujutis, mis võimaldab meil luua palju identseid Grafana veebiservereid, saame luua eksemplarirühma. Platvormil Yandex.Cloud tähistab see termin samade omadustega virtuaalmasinate liitu. Eksemplarirühma loomisel konfigureeritakse kõigi selles rühmas olevate masinate prototüüp ja seejärel rühma enda omadused (näiteks aktiivsete masinate minimaalne ja maksimaalne arv). Kui praegune number nendele kriteeriumidele ei vasta, eemaldab eksemplarirühm ise mittevajalikud masinad või loob uued oma pildi järgi.

Oma ülesande raames loome veebiserverite eksemplarirühma, mis genereeritakse eelnevalt loodud kettapildist.

Tõeliselt tähelepanuväärne on viimase eksemplari rühma seadistamine. Load Balanceriga integreeritud sihtrühm aitab teil paari nupuga klõpsates seadistada L3 tasakaalustaja selle rühma virtuaalmasinate peale.

Tasakaalustaja seadistamisel rakendasin kahte olulist punkti:

1. Panin tasakaalustaja aktsepteerima kasutajaliiklust pordis 80 ja suunama selle virtuaalmasinate porti 3000, täpselt seal, kus Grafana elab.
2. Seadistasin masinate elujõulisuse kontrollimise, pingitades need porti 3000.

Mini kokkuvõte

Lõpuks saime soovitud rakenduste infrastruktuuri käsitsi juurutada ja nüüd on meil väga vastupidav Grafana teenus. Andmestiku sellesse laadimiseks peate teadma ainult tasakaalustaja IP-aadressi kui rakenduse sisenemispunkti ja ClickHouse klastri hosti.

Kas see tundub võiduna? Jah, võit. Aga miski ajab mind ikkagi segadusse. Kogu ülaltoodud protsess nõuab palju käsitsi samme ja pole üldse skaleeritav; sooviksin seda võimaluse korral automatiseerida. Sellele on pühendatud järgmine osa.

Terraformi integreerimine

Kasutame taas HashiCorpi tööriista nimega Terraform. See aitab teil ühe nupuvajutusega juurutada kogu rakenduse infrastruktuuri, mis põhineb mitmel kasutaja edastatud muutujal. Kirjutame retsepti, mida saab erinevate kasutajate erinevates osades mitu korda käivitada.

Kogu töö Terraformiga taandub konfiguratsioonifaili kirjutamisele (*.tf) ja sellel põhineva infrastruktuuri loomine.

Muutujad

Faili alguses lisame muutujad, mis määravad, kus ja kuidas tulevane infrastruktuur juurutatakse.

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

Kogu rakenduse juurutamisprotsess taandub kettapildi loomisele ja nende muutujate seadistamisele. Lubage mul selgitada, mille eest nad vastutavad:

oauth_token — žetoon pilvele juurdepääsuks. Saab kätte link.
cloud_id — pilveidentifikaator, kuhu rakenduse juurutame
kausta_id — jaotise identifikaator, kuhu rakenduse juurutame
teenuse_konto_id — teenusekonto identifikaator pilve vastavas jaotises.
pildi_id — Packeri abil saadud ketta kujutise identifikaator
kasutajanimi и parool — kasutajanimi ja parool juurdepääsuks nii andmebaasidele kui ka Grafana veebiserverile
dbname — andmebaasi nimi CH ja MySQL klastrites
avalik_võtme_tee — tee failini oma avaliku ssh-võtmega, mida saate kasutada nime all ühenduse loomiseks ubuntu veebiserveritega virtuaalmasinatele

Pakkuja seadistamine

Nüüd peate konfigureerima 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"
}

Märkate, et siin kasutame ülalpool määratletud muutujaid.

Võrgustik ja klastrid

Nüüd loome võrgu, milles meie infrastruktuuri elemendid suhtlevad, kolm alamvõrku (üks igas piirkonnas) ja tõstame CH ja MySQL klastreid.

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 näete, on kõik kaks klastrit loodud üsna tõrketaluvusega, kuna need asuvad kolmes saadavustsoonis.

Veebiserverid

Näib, et võiksime samas vaimus jätkata, aga sattusin raskustesse. Enne seda tõstsin kõigepealt üles MySQL klastri ja alles pärast seda, teades selle ID-d, kogusin vajaliku konfiguratsiooniga kettapildi, kus määrasin klastrile hosti. Kuid nüüd ei tea me klastri ID-d enne Terraformi käivitamist, sealhulgas pildi loomise ajal. Seetõttu pidin kasutama järgmist trikk.

Amazoni metaandmete teenust kasutades edastame mõned parameetrid virtuaalmasinale, mille see vastu võtab ja töötleb. Vajame, et masin läheks pärast käivitamist MySQL-i klastri hosti ja kasutajanime-parooli taga olevate metaandmete juurde, mille kasutaja määras Terraformi failis. Muudame veidi faili sisu setup.sh, mis töötab siis, kui virtuaalmasin on sisse lülitatud.

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 grupp ja tasakaalustaja

Pärast uue kettapildi ümberehitamist saame lõpuks lisada oma faili Terraformi jaoks.

Näitame, et tahame kasutada olemasolevat kettapilti:

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

Nüüd loome eksemplarirü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 pöörata tähelepanu sellele, kuidas me selle metaandmetesse edastasime cluster_uri, username и password. Just need võtab virtuaalmasin käivitamisel välja ja sisestab Grafana konfiguratsiooni.

See on tasakaalustaja otsustada.

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

Ainult natuke on jäänud. Pärast infrastruktuuri juurutamist peate minema Grafana kasutajaliidese ja lisama käsitsi andmeallikana CH-klastri (mille ID tuleb veel hankida). Kuid Terraform teab klastri ID-d. Usaldagem temale asja ellu viimine.

Lisame uue pakkuja – Grafana ja anname talle hostina tasakaalustaja IP-aadressi. Kõik muudatused, mida Terraform teeb masinas, mille tasakaalustaja määrab, kasvavad MySQL-is ja seega ka kõigis teistes masinates.

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 juukseid

Kuvame tasakaalustaja IP-aadressi ja ClickHouse'i 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"
}

Saab joosta

Kõik! Meie konfiguratsioonifail on valmis ja muutujate määramisega saame öelda, et Terraform tõstaks kõik ülalkirjeldatud. Kogu protsess võttis mul umbes 15 minutit.
Lõpus näete ilusat sõnumit:

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:

Kokkuvõtteks

Grafana näitel saab igaüks teist juurutada laialivalguva pilvarhitektuuriga rakendusi platvormil Yandex.Cloud. HashiCorpi kasulikud tööriistad, nagu Packer ja Terraform, võivad teid selles aidata. Loodan, et kellelegi on see artikkel kasulik :)

PS Allpool lisan lingi hoidlale, kust leiate Packeri ja Terraformi valmisretseptid, mille fragmente ma selles artiklis esitasin.

hoidla

Allikas: www.habr.com