Hi almal! As deel van my kursuswerk het ek die moontlikhede van so 'n huishoudelike wolkplatform soos . Die platform bied verskeie dienste om praktiese probleme op te los. Soms is dit egter nodig om u wolktoepassing op te stel met 'n taamlik uitgebreide infrastruktuur gebaseer op hierdie dienste. In hierdie artikel wil ek die ervaring van die implementering van so 'n toepassing deel.
Wat wil jy ontvang?
- 'n kragtige instrument vir die oplossing van analitiese probleme of monitering van probleme van enige stelsels. In sy basiese konfigurasie is dit 'n virtuele masjien met die Grafana-webbediener, sowel as 'n databasis (ClickHouse, InfluxDB, ens.) met 'n datastel wat gebruik sal word om analise te bou.
Nadat u 'n virtuele masjien met 'n webbediener begin het, kan u na sy gasheer gaan en 'n pragtige UI kry, databasisse as bronne vir verdere werk spesifiseer, dashboards en grafieke skep.
Die basiese weergawe het een beduidende nadeel - dit is glad nie foutverdraagsaam nie. Dit wil sê, die hele prestasie van die toepassing hang af van die lewensvatbaarheid van een virtuele masjien. As sy weier of as 10 mense die UI op dieselfde tyd oopmaak, sal probleme ontstaan.
Hulle word eenvoudig opgelos: jy hoef net baie identiese virtuele masjiene met 'n webbediener te ontplooi en dit onder 'n L3-balanseerder te plaas. Maar nie alles is hier so duidelik nie. Grafana stoor gebruikerinstellings (paaie na databasisse, dashboards, grafika, ens.) direk op die skyf van sy virtuele masjien. Dus, as u sekere instellings in die UI verander, sal hierdie veranderinge slegs vertoon word op die virtuele masjien waarheen die balanseerder ons gestuur het. Dit sal lei tot inkonsekwente instellings vir ons toepassing, probleme met die bekendstelling en gebruik.
Hier sal 'n ander databasis tot die redding kom, byvoorbeeld MySQL of sy ekwivalent. Ons sê vir Grafana dat sy gebruikersinstellings in hierdie "spaar" databasis moet stoor. Daarna sal dit genoeg wees om die pad na hierdie databasis op elke masjien een keer te spesifiseer, en alle ander gebruikersinstellings op enige van die virtuele masjiene te wysig, hulle sal op die res groei.
Hier is 'n diagram van die finale toepassingsinfrastruktuur:
Leer om met jou hande op te lig
MySQL en ClickHouse
Voordat so 'n toepassing met die klik van 'n knoppie ontplooi is, was dit nodig om te leer hoe om elkeen van sy komponente met handvatsels op te lig en dit met mekaar te integreer.
Yandex.Cloud sal ons hier help, wat L3-balanseerders, ClickHouse en MySQL as bestuurde dienste verskaf. Die gebruiker hoef net die parameters te spesifiseer en te wag totdat die platform alles in 'n werkende toestand bring.
Ek het geregistreer, 'n wolk en 'n rekeningrekening vir myself geskep. Daarna het ek in die wolk gegaan en MySQL- en ClickHouse-klusters met minimale instellings verhoog. Wag totdat hulle aktief word.
Jy moet ook onthou om 'n databasis in elke groepering te skep en toegang daartoe te konfigureer deur login en wagwoord. Ek sal nie hier in besonderhede ingaan nie - alles is redelik duidelik in die koppelvlak.
Die nie-vanselfsprekende detail was dat hierdie databasisse baie gashere het wat hul fouttoleransie verskaf. Grafana benodig egter presies een gasheer vir elke databasis waarmee dit werk. Lang lees Die wolke het my tot 'n besluit gelei. Dit blyk dat 'n gasheer van die vorm c-<cluster_id>.rw.mdb.yandexcloud.net Kaarte na die huidige aktiewe groepmeestergasheer met die ooreenstemmende ID. Dit is wat ons vir Grafana sal gee.
Webbediener
Nou is dit aan die webbediener. Kom ons verhoog 'n gewone virtuele masjien met Linux en stel Grafana met ons hande daarop op.
Kom ons koppel via ssh en installeer die nodige pakkette.
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
Daarna sal ons Grafana onder systemctl begin en die inprop installeer om met ClickHouse te werk (ja, dit word nie in die basiese pakket verskaf nie).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceAlles daarna met 'n eenvoudige opdrag
sudo service grafana-server startons sal die webbediener begin. Nou sal dit moontlik wees om die eksterne IP-adres van die virtuele masjien in die blaaier in te ry, poort 3000 te spesifiseer en die pragtige UI-grafana te sien.
Maar moenie haastig wees nie, voordat jy Grafana opstel, moet jy nie vergeet om die pad na MySQL te spesifiseer sodat dit die instellings daar kan stoor nie.
Die hele konfigurasie van die Grafana-webbediener is in die lêer /etc/grafana/grafana.ini. Die vereiste lyn lyk soos volg:
;url =Ons stel die gasheer bloot aan die MySQL-groepering. Dieselfde lêer bevat die login en wagwoord vir toegang tot Grafana in die prent hierbo, wat albei by verstek gelyk is admin.
Jy kan sed-opdragte gebruik:
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
Dit is tyd om die webbediener te herbegin!
sudo service grafana-server restartNou in die Grafana UI, sal ons ClickHouse spesifiseer as die databron.
Ek het daarin geslaag om 'n werkende konfigurasie met die volgende instellings te bereik:
Ek het as URL gegee https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Almal! Ons het een werkende virtuele masjien met 'n webbediener gekoppel aan CH en MySQL. Jy kan reeds die datastel na ClickHouse oplaai en dashboards bou. Ons het egter nog nie ons doelwit bereik nie en het nie ’n volwaardige infrastruktuur ontplooi nie.
Packer
Yandex.Cloud laat jou toe om 'n skyfbeeld van 'n bestaande virtuele masjien te skep, en op grond daarvan kan jy soveel identiese masjiene skep as wat jy wil. Dit is presies wat ons sal gebruik. Om die prent gerieflik saam te stel, neem die instrument van HashiCorp. Dit neem as invoer 'n json-lêer met instruksies vir die bou van die prent.
Ons json-lêer sal uit twee blokke bestaan: bouers en voorsieners. Die eerste blok beskryf die parameters van die beeld self as 'n entiteit, en die tweede een beskryf die instruksies om dit met die nodige inhoud te vul.
bouers
{
"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"
}
],
...
}In hierdie sjabloon moet jy die identifiseerder van die afdeling in die wolk stel waar jy 'n prent wil skep, sowel as die pad na die lêer met die sleutels van die diensrekening wat voorheen in hierdie afdeling geskep is. Jy kan meer lees oor die skep van diensrekeninge en sleutels in die vorm van 'n lêer in die ooreenstemmende afdeling. .
Hierdie konfigurasie sê dat die skyfbeeld op grond van die platform gebou sal word ubuntu-1804-lts, geplaas in die toepaslike gebruikersafdeling in die beeldfamilie GRAFANA onder die naam grafana-{{timestamp}}.
Voorsieners
Nou vir die meer interessante deel van die konfigurasie. Dit sal die volgorde van aksies beskryf wat op 'n virtuele masjien uitgevoer moet word voordat die toestand daarvan in 'n skyfbeeld vries.
{
...,
"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"
]
}
]
}Hier word alle aksies in 3 fases verdeel. In die eerste stadium word 'n eenvoudige skrif uitgevoer wat 'n hulpgids skep.
voorberei-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaIn die volgende stadium plaas ons 'n skrip in hierdie gids, wat onmiddellik na die aanvang van die virtuele masjien uitgevoer moet word. Hierdie skrip sal die gebruikerveranderlikes wat ingestel moet word in Grafana se konfigurasie plaas en die webbediener herbegin.
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 restartDaarna is daar 3 dinge om te doen:
1) installeer pakkette
2) begin Grafana onder systemctl en installeer die ClickHouse-inprop
3) plaas die setup.sh-skrip in die tou om onmiddellik te loop nadat die virtuele masjien aangeskakel is.
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;Nou bly dit om Packer te laat loop en die uitvoerbeeld in die gespesifiseerde partisie geplaas te kry. Wanneer jy 'n virtuele masjien skep, kan jy dit as 'n selflaaiskyf kies en, nadat jy begin het, 'n klaargemaakte Grafana-webbediener kry.
Instansgroep en balanseerder
Sodra daar 'n skyfbeeld is wat jou toelaat om baie identiese Grafana-webbedieners te skep, kan ons 'n instansiegroep skep. Op die Yandex.Cloud-platform verwys hierdie term na die unie van virtuele masjiene wat dieselfde eienskappe het. Wanneer 'n instansiegroep geskep word, word die prototipe van alle masjiene in hierdie groep opgestel, en dan die kenmerke van die groep self (byvoorbeeld die minimum en maksimum aantal aktiewe masjiene). As die huidige nommer nie aan hierdie kriterium voldoen nie, sal die instansiegroep self onnodige masjiene verwyder of nuwes in die beeld en gelykenis skep.
As deel van ons taak, sal ons 'n voorbeeldgroep webbedieners skep wat uit die voorheen geskepde skyfbeeld voortgebring sal word.
Die laaste instansie groepinstelling is regtig opvallend. Die teikengroep in integrasie met Load Balancer sal jou help om 'n L3-balanseerder bo-op die virtuele masjiene van hierdie groep op te stel deur 'n paar knoppies te druk.
Toe ek die balanseerder opgestel het, het ek twee belangrike punte geïmplementeer:
- Ek het dit so gemaak dat die balanseerder gebruikersverkeer op poort 80 aanvaar, en dit herlei na poort 3000 van virtuele masjiene, net waar Grafana woon.
- Stel masjiengesondheidsondersoeke op deur dit op poort 3000 te ping.
mini-totaal
Uiteindelik kon ons die gewenste toepassingsinfrastruktuur handmatig ontplooi, en nou het ons 'n hoogs veerkragtige Grafana-diens. Dit is slegs nodig om die IP-adres van die balanseerder as die toegangspunt tot die toepassing en die gasheer van die ClickHouse-groepering te ken om die datastel daarin te laai.
Dit lyk asof dit 'n oorwinning is? Ja, oorwinning. Maar iets pla my steeds. Die hele proses hierbo vereis baie handhandelinge en skaal glad nie, ek wil dit outomatiseer indien moontlik. Dit sal die fokus van die volgende afdeling wees.
Integrasie met Terraform
Ons sal weer 'n instrument van HashiCorp genaamd gebruik . Dit sal help om die hele toepassingsinfrastruktuur te ontplooi met die klik van 'n knoppie, gebaseer op 'n paar veranderlikes wat deur die gebruiker deurgegee word. Kom ons skryf 'n resep wat verskeie kere in verskillende afdelings van verskillende gebruikers uitgevoer kan word.
Alle werk met Terraform kom neer op die skryf van 'n konfigurasielêer (*.tf) en die skepping van infrastruktuur wat daarop gebaseer is.
veranderlikes
Heel aan die begin van die lêer sal ons die veranderlikes uithaal wat bepaal waar en hoe die toekomstige infrastruktuur ontplooi gaan word.
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>"
}Die hele proses van die implementering van 'n toepassing sal daarop neerkom om 'n skyfbeeld te bou en hierdie veranderlikes in te stel. Kom ek verduidelik waarvoor hulle verantwoordelik is:
oauth_token - 'n teken vir toegang tot die wolk. Kan verkry word deur .
wolk_id - identifiseerder van die wolk waar ons die toepassing sal ontplooi
folder_id - identifiseerder van die afdeling waar ons die toepassing sal ontplooi
diens_rekening-ID - identifiseerder van die diensrekening in die ooreenstemmende afdeling van die wolk.
beeld_id - identifiseerder van die skyfbeeld wat met Packer verkry is
Gebruikersnaam и Wagwoord - gebruikersnaam en wagwoord om toegang te verkry tot beide databasisse en die Grafana-webbediener
dbnaam - databasisnaam binne CH- en MySQL-klusters
publieke_sleutelpad - die pad na die lêer met u publieke ssh-sleutel, waardeur u onder die naam kan koppel ubuntu na virtuele masjiene met webbedieners
Verskaffer instelling
Nou moet u die Terraform-verskaffer instel - in ons geval, Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
U kan sien dat ons hier die veranderlikes gebruik wat hierbo gedefinieer is.
Netwerk en groepe
Kom ons skep nou 'n netwerk waarin elemente van ons infrastruktuur sal kommunikeer, drie subnette (een in elke streek) en die CH- en MySQL-klusters verhoog.
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
}
}Soos u kan sien, is elk van die twee trosse gebou om redelik foutverdraagsaam te wees deur in drie beskikbaarheidsones geplaas te word.
Webbedieners
Dit wil voorkom asof jy in dieselfde gees kan voortgaan, maar ek het probleme ondervind. Voor dit het ek eers die MySQL-groepering opgewek en eers daarna, met die kennis van sy ID, het ek 'n skyfbeeld met die verlangde konfigurasie versamel, waar ek die gasheer vir die groep gespesifiseer het. Maar nou ken ons nie die groep-ID voor die bekendstelling van Terraform nie, insluitend ten tyde van die beeldbou. Ek moes my dus tot die volgende wend .
Deur die metadata-diens van Amazon te gebruik, sal ons 'n paar parameters na die virtuele masjien deurgee, wat dit sal aanvaar en verwerk. Ons het die masjien nodig om na die metadata vir die MySQL-gasheer van die groepering te gaan en vir die gebruikersnaam-wagwoord wat die gebruiker in die Terraform-lêer gespesifiseer het nadat dit begin is. Verander die inhoud van die lêer effens setup.sh, wat loop wanneer die virtuele masjien aangeskakel is.
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 restartIntansiegroep en balanseerder
Nadat ons die nuwe skyfbeeld herbou het, kan ons uiteindelik ons lêer vir Terraform byvoeg.
Ons dui aan dat ons 'n bestaande skyfbeeld wil gebruik:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Kom ons skep nou 'n instansiegroep:
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"
}
}Dit is die moeite werd om aandag te skenk aan hoe ons na die metadata oorgedra het cluster_uri, username и password. Dit is hul virtuele masjien wat dit by opstart sal kry en dit in die Grafana-konfigurasie sal plaas.
Dit gaan oor die balanseerder.
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
}
}
}
}Bietjie suiker
Daar was baie min oor. Nadat die infrastruktuur ontplooi is, sal jy na die Grafana UI moet gaan en die CH-kluster (wie se ID jy nog moet kry) handmatig byvoeg as 'n databron. Maar Terraform ken die groep-ID. Kom ons kry hom om die werk klaar te maak.
Kom ons voeg 'n nuwe verskaffer by - Grafana, en skuif die balanseerder IP as 'n gasheer. Alle veranderinge wat Terraform maak op die masjien waar sy balanseerder bepaal, sal groei in MySQL, en dus op alle ander masjiene.
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"
}Kom ons kam
Vertoon balanseerder IP en ClickHouse-groepgasheer
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"
}Kan hardloop
Almal! Ons konfigurasielêer is gereed en ons kan, deur veranderlikes in te stel, Terraform sê om alles wat ons hierbo beskryf het in te samel. Die hele proses het my sowat 15 minute geneem.
Aan die einde kan jy 'n pragtige boodskap sien:
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.25En in die wolk sal elemente van die verhoogde infrastruktuur sigbaar wees:
Som op
Nou, met die voorbeeld van Grafana, kan elkeen van julle toepassings met uitgestrekte wolkargitektuur op die Yandex.Cloud-platform ontplooi. Nuttige gereedskap van HashiCorp soos Packer en Terraform kan jou hiermee help. Ek hoop dat hierdie artikel vir iemand nuttig sal wees 🙂
NS Hieronder heg ek 'n skakel na die bewaarplek aan, waar jy klaargemaakte resepte vir Packer en Terraform kan vind, fragmente waarvan ek in hierdie artikel aangehaal het.
Bron: will.com