Pozdravljeni vsi skupaj! V okviru tečaja sem raziskoval zmožnosti domače oblačne platforme, kot je . Platforma ponuja različne storitve za reševanje praktičnih problemov. Vendar pa je včasih treba postaviti lastno aplikacijo v oblaku z dokaj obsežno infrastrukturo, ki temelji na teh storitvah. V tem članku želim deliti svoje izkušnje pri uvajanju takšne aplikacije.
Kaj želite prejeti?
— zmogljivo orodje za reševanje analitičnih problemov ali spremljanje problemov katerega koli sistema. V osnovni konfiguraciji je to virtualni stroj s spletnim strežnikom Grafana ter bazo podatkov (ClickHouse, InfluxDB idr.) s podatkovnim nizom, na katerem bo temeljila analitika.
Po zagonu virtualnega stroja s spletnim strežnikom lahko greste na njegovega gostitelja in dobite čudovit uporabniški vmesnik, določite baze podatkov kot vire za nadaljnje delo, ustvarite nadzorne plošče in grafe.
Osnovna različica ima eno pomembno pomanjkljivost - sploh ni odporna na napake. To pomeni, da je celotna funkcionalnost aplikacije odvisna od sposobnosti preživetja enega virtualnega stroja. Če zavrne ali 10 ljudi odpre uporabniški vmesnik hkrati, se bodo pojavile težave.
Rešiti jih je mogoče preprosto: preprosto morate ... namestiti veliko enakih virtualnih strojev s spletnim strežnikom in jih postaviti pod izravnalnik L3. Vendar tukaj ni vse tako jasno. Grafana shranjuje uporabniške nastavitve (poti do podatkovnih baz, nadzorne plošče, grafe itd.) neposredno na disk svojega virtualnega stroja. Če torej spremenimo nekatere nastavitve v uporabniškem vmesniku, se bodo te spremembe odrazile le na virtualnem stroju, kamor nas je poslal balanser. To bo vodilo do nedoslednih nastavitev za našo aplikacijo, kar bo povzročilo težave pri zagonu in uporabi.
Tu bo na pomoč priskočila druga baza podatkov, na primer MySQL ali njen enakovredni. Grafani povemo, da naj uporabniške nastavitve shrani v to »rezervno« bazo. Potem bo dovolj, da pot do te podatkovne baze določite enkrat na vsakem stroju in uredite vse ostale uporabniške nastavitve na katerem koli virtualnem stroju, ki se bodo razširile na ostale.
Tukaj je diagram končne aplikacijske infrastrukture:
Naučimo se dvigovati z rokami
MySQL in ClickHouse
Pred uvedbo takšne aplikacije s klikom na gumb se je bilo treba naučiti ravnati z vsako od njenih komponent in jih integrirati med seboj.
Tukaj nam bo pomagal Yandex.Cloud, ki ponuja L3 balancers, ClickHouse in MySQL kot upravljane storitve. Uporabnik mora samo določiti parametre in počakati, da platforma vse vzpostavi v delovnem stanju.
Registriral sem se, ustvaril oblak in plačilni račun. Po tem sem šel v oblak in z minimalnimi nastavitvami nastavil gruče MySQL in ClickHouse. Počakal sem, da so postali aktivni.
Ne pozabite ustvariti baze podatkov v vsaki gruči in konfigurirati dostop do nje s prijavo in geslom. Tu se ne bom spuščal v podrobnosti - v vmesniku je vse precej očitno.
Neočitna podrobnost je bila, da imajo te podatkovne baze veliko gostiteljev, kar zagotavlja njihovo odpornost na napake. Vendar pa Grafana zahteva točno enega gostitelja za vsako zbirko podatkov, s katero deluje. Dolgo branje Oblaki so me pripeljali do odločitve. Izkazalo se je, da je gostitelj vrste c-<cluster_id>.rw.mdb.yandexcloud.net preslikan v trenutnega aktivnega glavnega gostitelja gruče z ustreznim ID-jem. To bomo dali Grafanu.
spletni strežnik
Zdaj je na vrsti spletni strežnik. Vzpostavimo navaden virtualni stroj z Linuxom in na njem ročno nastavimo Grafana.
Povežimo se preko ssh in namestimo potrebne pakete.
sudo apt-get install -y apt-transport-https software-properties-common wget
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -
sudo add-apt-repository "deb https://packages.grafana.com/enterprise/deb stable main"
sudo apt-get update
sudo apt-get install -y grafana-enterprise
Nato poženemo Grafano pod systemctl in namestimo vtičnik za delo s ClickHouse (ja, ni priložen v osnovnem paketu).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceTo je to, nato s preprostim ukazom
sudo service grafana-server startzagnali bomo spletni strežnik. Zdaj lahko v brskalnik vnesete zunanji naslov IP virtualnega stroja, določite vrata 3000 in vidite čudovit uporabniški vmesnik Grafana.
Vendar ne hitite, preden nastavite Grafana, mu ne pozabite povedati poti do MySQL, da tam shranite nastavitve.
Celotna konfiguracija spletnega strežnika Grafana je v datoteki /etc/grafana/grafana.ini. Zahtevana vrstica izgleda takole:
;url =Gostitelj smo nastavili na gručo MySQL. V isti datoteki sta prijava in geslo za dostop do Grafana na zgornji sliki, ki sta privzeto enaki admin.
Uporabite lahko ukaze sed:
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
Čas je, da znova zaženete spletni strežnik!
sudo service grafana-server restartZdaj bomo v uporabniškem vmesniku Grafana določili ClickHouse kot DataSource.
Uspelo mi je doseči delujočo konfiguracijo z naslednjimi nastavitvami:
Navedel sem kot URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Vse! Imamo en delujoč virtualni stroj s spletnim strežnikom, ki je povezan s CH in MySQL. Nabor podatkov lahko že naložite v ClickHouse in ustvarite nadzorne plošče. Vendar še nismo dosegli svojega cilja in še nismo postavili popolne infrastrukture.
Packer
Yandex.Cloud vam omogoča, da ustvarite sliko diska obstoječega virtualnega stroja in na njegovi podlagi - poljubno število enakih strojev. Točno to bomo uporabili. Za priročno sestavljanje slike vzemite orodje od HashiCorp. Kot vhod vzame datoteko json z navodili za sestavljanje slike.
Naša datoteka json bo sestavljena iz dveh blokov: graditeljev in oskrbovalcev. Prvi blok opisuje parametre same slike kot entitete, drugi blok pa opisuje navodila za polnjenje s potrebno vsebino.
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"
}
],
...
}V tej predlogi morate nastaviti identifikator razdelka v oblaku, kjer želite ustvariti sliko, kot tudi pot do datoteke s ključi iz storitvenega računa, ki je bil predhodno ustvarjen v tem razdelku. Več o ustvarjanju servisnih računov in ključev v obliki datoteke lahko preberete v ustreznem razdelku .
Ta konfiguracija pravi, da bo slika diska zgrajena na podlagi platforme ubuntu-1804-lts, postavljen v ustrezen uporabniški razdelek v družini slik GRAFANA pod imenom grafana-{{timestamp}}.
Oskrbovalci
Zdaj prihaja bolj zanimiv del konfiguracije. Opisal bo zaporedje dejanj, ki jih bo treba izvesti na virtualnem stroju, preden se njegovo stanje zamrzne v sliko diska.
{
...,
"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"
]
}
]
}Tu so vsa dejanja razdeljena na 3 stopnje. Na prvi stopnji se izvede preprost skript, ki ustvari pomožni imenik.
pripravi-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaNa naslednji stopnji v ta imenik postavimo skript, ki ga bo treba zagnati takoj po zagonu virtualnega stroja. Ta skript bo uporabniške spremenljivke, ki jih je treba registrirati, postavil v konfiguracijo Grafana in znova zagnal spletni strežnik.
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 restartPo tem morate narediti še 3 stvari:
1) namestite pakete
2) zaženite Grafano pod systemctl in namestite vtičnik ClickHouse
3) postavite skript setup.sh v čakalno vrsto za zagon takoj po vklopu virtualnega stroja.
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-datasourcerun-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;Zdaj ostane le še, da zaženete Packer in dobite izhodno sliko v določenem razdelku. Pri ustvarjanju navideznega stroja ga lahko izberete kot zagonsko disketo in po zagonu prejmete že pripravljen spletni strežnik Grafana.
Skupina primerkov in izravnalnik
Ko imamo sliko diska, ki nam omogoča ustvarjanje številnih enakih spletnih strežnikov Grafana, lahko ustvarimo skupino primerkov. Na platformi Yandex.Cloud se ta izraz nanaša na združenje virtualnih strojev, ki imajo enake lastnosti. Pri ustvarjanju skupine primerkov se konfigurira prototip vseh strojev v tej skupini in nato značilnosti same skupine (na primer najmanjše in največje število aktivnih strojev). Če trenutna številka ne izpolnjuje teh kriterijev, bo skupina instanc sama odstranila nepotrebne stroje ali ustvarila nove po svoji podobi.
V okviru naše naloge bomo ustvarili instančno skupino spletnih strežnikov, ki bo generirana iz predhodno ustvarjene slike diska.
Kar je resnično izjemno, je zadnja nastavitev skupine. Ciljna skupina v integraciji z izravnalnikom obremenitve vam bo pomagala konfigurirati izravnalnik L3 na vrhu virtualnih strojev te skupine s klikom na nekaj gumbov.
Pri nastavitvi balanserja sem upošteval dve pomembni točki:
- Balancer sem naredil, da sprejme uporabniški promet na vratih 80 in ga preusmeri na vrata 3000 virtualnih strojev, točno tam, kjer živi Grafana.
- Nastavil sem preverjanje sposobnosti preživetja strojev tako, da sem jih pingal na vrata 3000.
Mini povzetek
Končno smo lahko ročno uvedli želeno aplikacijsko infrastrukturo in zdaj imamo zelo prožno storitev Grafana. Poznati morate le naslov IP izravnalnika kot vstopne točke v aplikacijo in gostitelja gruče ClickHouse, da lahko vanjo naložite nabor podatkov.
Zdi se kot zmaga? Ja, zmaga. Ampak nekaj me vseeno bega. Celoten zgornji postopek zahteva veliko ročnih korakov in sploh ni razširljiv; rad bi ga avtomatiziral, če je mogoče. Temu bo posvečen naslednji razdelek.
Terraform integracija
Ponovno bomo uporabili orodje podjetja HashiCorp, imenovano . Pomagal vam bo razmestiti celotno aplikacijsko infrastrukturo s klikom gumba na podlagi več spremenljivk, ki jih posreduje uporabnik. Napišimo recept, ki ga je mogoče večkrat zagnati v različnih razdelkih različnih uporabnikov.
Vse delo s Terraformom se zmanjša na pisanje konfiguracijske datoteke (*.tf) in ustvarjanje infrastrukture na njegovi podlagi.
Spremenljivke
Na samem začetku datoteke bomo vključili spremenljivke, ki določajo, kje in kako bo razporejena bodoča infrastruktura.
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>"
}Celoten postopek uvajanja aplikacije se bo zmanjšal na izdelavo slike diska in nastavitev teh spremenljivk. Naj pojasnim, za kaj so odgovorni:
oauth_token — žeton za dostop do oblaka. Dobite ga lahko pri .
cloud_id — identifikator oblaka, kamor bomo namestili aplikacijo
folder_id — identifikator razdelka, kjer bomo uvedli aplikacijo
service_account_id — identifikator storitvenega računa v ustreznem delu oblaka.
image_id — identifikator slike diska, pridobljene s programom Packer
uporabniško ime и geslo — uporabniško ime in geslo za dostop do obeh baz in spletnega strežnika Grafana
dbname — ime baze podatkov v gručah CH in MySQL
pot_javnega_ključa — pot do datoteke z vašim javnim ssh ključem, s katerim se lahko povežete pod imenom ubuntu na virtualne stroje s spletnimi strežniki
Nastavitev ponudnika
Zdaj morate konfigurirati ponudnika Terraform - v našem primeru Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Opazili boste, da tukaj uporabljamo zgoraj definirane spremenljivke.
Omrežje in grozdi
Sedaj bomo ustvarili omrežje, v katerem bodo komunicirali elementi naše infrastrukture, tri podomrežja (eno v vsaki regiji) in dvignili CH in MySQL grozde.
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
}
}Kot lahko vidite, je vsaka od obeh gruč ustvarjena precej odporna na napake, saj se nahajata v treh območjih razpoložljivosti.
Spletni strežniki
Zdelo se je, da bi lahko nadaljevali v istem duhu, a sem naletel na težave. Pred tem sem najprej dvignil gručo MySQL in šele nato, ko sem poznal njen ID, sem zbral sliko diska z zahtevano konfiguracijo, kjer sem določil gostitelja za gručo. Toda zdaj ne poznamo ID-ja gruče pred zagonom Terraforma, vključno s časom gradnje slike. Zato sem se moral zateči k naslednjemu .
Z uporabo Amazonove metapodatkovne storitve bomo virtualnemu stroju posredovali nekaj parametrov, ki jih bo sprejel in obdelal. Potrebujemo, da stroj preide na metapodatke za gostiteljem gruče MySQL in uporabniško ime-geslo, ki ju je uporabnik določil v datoteki Terraform po zagonu. Nekoliko spremenimo vsebino datoteke setup.sh, ki se zažene, ko je virtualni stroj vklopljen.
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 restartVhodna skupina in balanser
Ko smo ponovno zgradili novo sliko diska, lahko končno dodamo našo datoteko za Terraform.
Označimo, da želimo uporabiti obstoječo sliko diska:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Zdaj pa ustvarimo skupino primerkov:
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"
}
}Vredno je biti pozoren na to, kako smo ga posredovali v metapodatke cluster_uri, username и password. To je tisto, kar bo virtualni stroj odstranil ob zagonu in dal v konfiguracijo Grafana.
To je odvisno od balanserja.
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
}
}
}
}Malo sladkorja
Ostalo je le še malo. Ko je infrastruktura uvedena, boste morali odpreti uporabniški vmesnik Grafana in ročno dodati gručo CH (katere ID je treba še pridobiti) kot vir podatkov. Toda Terraform pozna ID gruče. Zaupajmo mu, da zadevo pripelje do konca.
Dodajmo novega ponudnika - Grafana in mu kot gostitelja dajmo IP naslov balanserja. Vse spremembe, ki jih Terraform naredi na stroju, za katerega določi njegov balanser, bodo rasle v MySQL in s tem na vseh drugih strojih.
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"
}Razčešimo se
Prikažimo naslov IP izravnalnika in gostitelja gruče ClickHouse
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"
}Lahko teče
Vse! Naša konfiguracijska datoteka je pripravljena in lahko z nastavitvijo spremenljivk ukažemo Terraformu, naj dvigne vse, kar smo opisali zgoraj. Celoten postopek mi je vzel približno 15 minut.
Na koncu lahko vidite lepo sporočilo:
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.25In v oblaku bodo vidni elementi dvignjene infrastrukture:
Seštejte
Zdaj, če uporabimo Grafana kot primer, lahko vsak od vas uvede aplikacije z obsežno arhitekturo oblaka na platformi Yandex.Cloud. Pri tem vam lahko pomagajo uporabna orodja podjetja HashiCorp, kot sta Packer in Terraform. Upam, da bo komu ta članek koristen :)
PS Spodaj bom priložil povezavo do skladišča, kjer lahko najdete že pripravljene recepte za Packer in Terraform, katerih delčke sem navedel v tem članku.
Vir: www.habr.com