Dag Allemaal! Als onderdeel van mijn cursuswerk heb ik onderzoek gedaan naar de mogelijkheden van een dergelijk huishoudelijk cloudplatform als . Het platform biedt verschillende diensten aan voor het oplossen van praktische problemen. Soms moet je echter een eigen cloudapplicatie opzetten met een vrij uitgebreide infrastructuur op basis van deze diensten. In dit artikel wil ik mijn ervaring delen met het inzetten van een dergelijke applicatie.
Wat wil je ontvangen?
— een krachtig hulpmiddel voor het oplossen van analytische problemen of het monitoren van problemen van welk systeem dan ook. In de basisconfiguratie is dit een virtuele machine met een Grafana-webserver, evenals een database (ClickHouse, InfluxDB, enz.) met een dataset waarop analyses zullen worden gebaseerd.
Nadat u een virtuele machine met een webserver hebt gelanceerd, kunt u naar de host gaan en een prachtige gebruikersinterface krijgen, databases specificeren als bronnen voor verder werk, dashboards en grafieken maken.
De basisversie heeft één belangrijk nadeel: hij is helemaal niet fouttolerant. Dat wil zeggen dat de volledige functionaliteit van de applicatie afhankelijk is van de levensvatbaarheid van één virtuele machine. Als het weigert of als 10 mensen tegelijkertijd de gebruikersinterface openen, zullen er problemen ontstaan.
Ze kunnen eenvoudig worden opgelost: u hoeft alleen maar... veel identieke virtuele machines met een webserver in te zetten en deze onder een L3-balancer te plaatsen. Maar niet alles is hier zo duidelijk. Grafana slaat gebruikersinstellingen (paden naar databases, dashboards, grafieken, enz.) rechtstreeks op de schijf van zijn virtuele machine op. Als we dus enkele instellingen in de gebruikersinterface wijzigen, worden deze wijzigingen alleen weerspiegeld op de virtuele machine waarnaar de balancer ons heeft gestuurd. Dit zal leiden tot inconsistente instellingen voor onze applicatie, wat problemen veroorzaakt bij het starten en gebruiken.
Hier komt een andere database te hulp, bijvoorbeeld MySQL of het equivalent daarvan. We vertellen Grafana dat ze gebruikersinstellingen in deze “reserve” database moet opslaan. Daarna is het voldoende om het pad naar deze database één keer op elke machine op te geven en alle andere gebruikersinstellingen op een van de virtuele machines te bewerken; ze zullen zich uitbreiden naar de andere.
Hier is een diagram van de uiteindelijke applicatie-infrastructuur:
Laten we leren tillen met onze handen
MySQL en ClickHouse
Voordat een dergelijke applicatie met één klik op de knop kon worden geïmplementeerd, was het noodzakelijk om te leren omgaan met elk van de componenten en deze met elkaar te integreren.
Hier zal Yandex.Cloud ons helpen, dat L3-balancers, ClickHouse en MySQL als beheerde services levert. De gebruiker hoeft alleen de parameters op te geven en te wachten tot het platform alles in werkende staat brengt.
Ik heb me geregistreerd, een cloud en een betaalaccount aangemaakt. Daarna ging ik naar de cloud en zette MySQL- en ClickHouse-clusters op met minimale instellingen. Ik wachtte tot ze actief werden.
U moet er ook aan denken om in elk cluster een database aan te maken en de toegang daartoe te configureren met behulp van een gebruikersnaam en wachtwoord. Ik zal hier niet in details treden - alles is vrij duidelijk in de interface.
Het niet voor de hand liggende detail was dat deze databases veel hosts hebben, die hun fouttolerantie garanderen. Grafana heeft echter precies één host nodig voor elke database waarmee het werkt. Lang lezen De wolken brachten mij tot een besluit. Het blijkt dat de gastheer van de soort is c-<cluster_id>.rw.mdb.yandexcloud.net toegewezen aan de huidige actieve masterhost van het cluster met de bijbehorende ID. Dit is wat we aan Grafana zullen geven.
web Server
Nu is het aan de webserver. Laten we een gewone virtuele machine met Linux opzetten en Grafana daarop handmatig configureren.
Laten we verbinding maken via ssh en de benodigde pakketten installeren.
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
Laten we daarna Grafana onder systemctl uitvoeren en de plug-in installeren om met ClickHouse te werken (ja, deze wordt niet meegeleverd in het basispakket).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceDat is alles, daarna met een eenvoudig commando
sudo service grafana-server startwe zullen de webserver starten. Nu kunt u het externe IP-adres van de virtuele machine in de browser invoeren, poort 3000 opgeven en de prachtige Grafana UI zien.
Maar haast u niet, voordat u Grafana instelt, moet u eraan denken om het pad naar MySQL te vertellen, zodat de instellingen daar kunnen worden opgeslagen.
De volledige configuratie van de Grafana-webserver staat in het bestand /etc/grafana/grafana.ini. De vereiste regel ziet er als volgt uit:
;url =We hebben de host ingesteld op het MySQL-cluster. Hetzelfde bestand bevat de login en het wachtwoord voor toegang tot Grafana in de bovenstaande afbeelding, die standaard beide gelijk zijn admin.
U kunt sed-opdrachten gebruiken:
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
Het is tijd om de webserver opnieuw op te starten!
sudo service grafana-server restartNu zullen we in de Grafana-gebruikersinterface ClickHouse specificeren als een gegevensbron.
Ik kon een werkende configuratie bereiken met de volgende instellingen:
Ik heb opgegeven als de URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Alle! We hebben één werkende virtuele machine met een webserver verbonden met CH en MySQL. U kunt de dataset nu al uploaden naar ClickHouse en dashboards bouwen. We hebben ons doel echter nog niet bereikt en hebben nog geen volwaardige infrastructuur ingezet.
Packer
Met Yandex.Cloud kunt u een schijfkopie maken van een bestaande virtuele machine, en op basis daarvan een willekeurig aantal machines die identiek zijn aan elkaar. Dit is precies wat we zullen gebruiken. Neem de tool om de afbeelding gemakkelijk samen te stellen van HashiCorp. Als invoer is een json-bestand nodig met instructies voor het samenstellen van de afbeelding.
Ons json-bestand zal uit twee blokken bestaan: builders en provisioners. Het eerste blok beschrijft de parameters van de afbeelding zelf als een entiteit, en het tweede blok beschrijft instructies om deze met de benodigde inhoud te vullen.
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"
}
],
...
}In deze sjabloon moet u de ID instellen van de sectie in de cloud waar u de afbeelding wilt maken, evenals het pad naar het bestand met de sleutels van het serviceaccount dat eerder in deze sectie is aangemaakt. Meer over het aanmaken van serviceaccounts en sleutels in de vorm van een bestand leest u in de betreffende paragraaf .
Deze configuratie zegt dat de schijfimage zal worden gebouwd op basis van het platform ubuntu-1804-lts, geplaatst in de juiste gebruikerssectie in de afbeeldingsfamilie GRAFANA onder de naam grafana-{{timestamp}}.
Bevoorraders
Nu komt het interessantere deel van de configuratie. Het beschrijft de reeks acties die op de virtuele machine moeten worden uitgevoerd voordat de status ervan in een schijfkopie wordt bevroren.
{
...,
"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 zijn alle acties verdeeld in 3 fasen. In de eerste fase wordt een eenvoudig script uitgevoerd dat een hulpmap aanmaakt.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaIn de volgende fase plaatsen we een script in deze map, dat onmiddellijk moet worden gestart na het starten van de virtuele machine. Dit script plaatst de gebruikersvariabelen die moeten worden geregistreerd in de Grafana-configuratie en start de webserver opnieuw op.
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 restartHierna zijn er nog 3 dingen te doen:
1) pakketten installeren
2) voer Grafana uit onder systemctl en installeer de ClickHouse-plug-in
3) plaats het setup.sh-script in de opstartwachtrij onmiddellijk na het inschakelen van de virtuele machine.
install-pakketten.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-bij-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;Nu hoeft u alleen nog maar Packer uit te voeren en de uitvoerafbeelding in de opgegeven sectie te plaatsen. Bij het aanmaken van een virtuele machine kunt u deze selecteren als opstartschijf en na het opstarten ontvangt u een kant-en-klare Grafana-webserver.
Instantiegroep en balancer
Zodra we een schijfkopie hebben waarmee we veel identieke Grafana-webservers kunnen maken, kunnen we een instantiegroep maken. Op het Yandex.Cloud-platform verwijst deze term naar de vereniging van virtuele machines die dezelfde kenmerken hebben. Bij het maken van een instantiegroep wordt het prototype van alle machines in deze groep geconfigureerd, en vervolgens de kenmerken van de groep zelf (bijvoorbeeld het minimale en maximale aantal actieve machines). Als het huidige aantal niet aan deze criteria voldoet, zal de instantiegroep zelf onnodige machines verwijderen of nieuwe naar zijn eigen image maken.
Als onderdeel van onze taak zullen we een instantiegroep van webservers maken die wordt gegenereerd op basis van de eerder gemaakte schijfkopie.
Wat echt opmerkelijk is, is de laatste instantiegroepconfiguratie. De doelgroep in integratie met Load Balancer helpt u door op een aantal knoppen te klikken een L3-balancer te configureren bovenop de virtuele machines van deze groep.
Bij het opzetten van de balancer heb ik twee belangrijke punten geïmplementeerd:
- Ik heb de balancer het gebruikersverkeer op poort 80 laten accepteren en het omleiden naar poort 3000 van de virtuele machines, precies waar Grafana woont.
- Ik heb het controleren van de levensvatbaarheid van machines ingesteld door ze naar poort 3000 te pingen.
Mini-samenvatting
Eindelijk konden we de gewenste applicatie-infrastructuur handmatig implementeren, en nu hebben we een zeer veerkrachtige Grafana-service. U hoeft alleen het IP-adres van de balancer als toegangspunt tot de applicatie en de host van het ClickHouse-cluster te kennen om de dataset daarin te laden.
Het lijkt een overwinning? Ja, overwinning. Maar iets verwart mij nog steeds. Het hele proces hierboven vereist veel handmatige stappen en is helemaal niet schaalbaar; ik zou het graag willen automatiseren als dat mogelijk is. Dit is waar het volgende deel aan zal worden gewijd.
Terraform-integratie
We gaan weer gebruik maken van een tool van HashiCorp genaamd . Het helpt u de volledige applicatie-infrastructuur met één klik op de knop te implementeren, op basis van verschillende variabelen die door de gebruiker worden doorgegeven. Laten we een recept schrijven dat meerdere keren kan worden uitgevoerd in verschillende secties van verschillende gebruikers.
Al het werk met Terraform komt neer op het schrijven van een configuratiebestand (*.tf) en het creëren van infrastructuur die daarop is gebaseerd.
variabelen
Helemaal aan het begin van het bestand nemen we variabelen op die bepalen waar en hoe de toekomstige infrastructuur zal worden ingezet.
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>"
}Het hele applicatie-implementatieproces komt neer op het bouwen van een schijfkopie en het instellen van deze variabelen. Laat me uitleggen waar ze verantwoordelijk voor zijn:
oauth_token — een token voor toegang tot de cloud. Kan verkregen worden door .
cloud_id — cloud-ID waar we de applicatie zullen inzetten
map_id — sectie-ID waar we de applicatie zullen inzetten
service_account_id — serviceaccount-ID in het overeenkomstige gedeelte van de cloud.
afbeelding_id — identificatie van de schijfimage verkregen met Packer
gebruikersnaam и wachtwoord — gebruikersnaam en wachtwoord voor toegang tot beide databases en de Grafana-webserver
dbnaam — databasenaam binnen CH- en MySQL-clusters
openbare_sleutel_pad — pad naar het bestand met uw openbare ssh-sleutel, waarmee u verbinding kunt maken onder de naam ubuntu naar virtuele machines met webservers
Aanbieder instellen
Nu moet je de Terraform-provider configureren - 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 zult merken dat we hier de hierboven gedefinieerde variabelen gebruiken.
Netwerk en clusters
Nu zullen we een netwerk creëren waarin elementen van onze infrastructuur zullen communiceren, drie subnetten (één in elke regio) en CH- en MySQL-clusters zullen verhogen.
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
}
}Zoals u kunt zien, is elk van de twee clusters behoorlijk fouttolerant gemaakt omdat ze zich in drie beschikbaarheidszones bevinden.
Webservers
Het lijkt erop dat we in dezelfde geest verder kunnen gaan, maar ik kwam in de problemen. Voordien heb ik eerst een MySQL-cluster grootgebracht en pas daarna, terwijl ik de ID kende, verzamelde ik een schijfkopie met de vereiste configuratie, waarbij ik de host voor het cluster specificeerde. Maar nu kennen we de cluster-ID niet voordat we Terraform lanceerden, ook niet op het moment dat de image werd gebouwd. Daarom moest ik mijn toevlucht nemen tot het volgende .
Met behulp van de metadataservice van Amazon zullen we enkele parameters doorgeven aan de virtuele machine, die deze zal accepteren en verwerken. We hebben de machine nodig om na het starten naar de metadata achter de MySQL-clusterhost en gebruikersnaam-wachtwoord te gaan, die de gebruiker heeft opgegeven in het Terraform-bestand. Laten we de inhoud van het bestand enigszins wijzigen setup.sh, dat wordt uitgevoerd wanneer de virtuele machine wordt ingeschakeld.
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 restartIntancegroep en balancer
Nadat we een nieuwe schijfkopie opnieuw hebben opgebouwd, kunnen we eindelijk ons bestand voor Terraform toevoegen.
Laten we aangeven dat we een bestaande schijfkopie willen gebruiken:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Laten we nu een instantiegroep maken:
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"
}
}Het is de moeite waard om aandacht te besteden aan de manier waarop we dit in de metadata hebben verwerkt cluster_uri, username и password. Het zijn deze die de virtuele machine bij het opstarten zal verwijderen en in de Grafana-configuratie zal plaatsen.
Het is aan de balancer.
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
}
}
}
}Een beetje suiker
Er is nog maar een klein beetje over. Nadat de infrastructuur is geïmplementeerd, moet u naar de Grafana UI gaan en handmatig het CH-cluster (waarvan de ID nog moet worden verkregen) toevoegen als gegevensbron. Maar Terraform kent de cluster-ID. Laten we hem de taak toevertrouwen om de zaak tot een goed einde te brengen.
Laten we een nieuwe provider toevoegen: Grafana, en haar het IP-adres van de balancer als host geven. Alle wijzigingen die Terraform aanbrengt op de machine waarvan de balancer bepaalt, zullen groeien in MySQL, en dus op alle andere machines.
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"
}Laten we ons haar kammen
Laten we het IP-adres van de balancer en de host van het ClickHouse-cluster weergeven
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 rennen
Alle! Ons configuratiebestand is klaar en we kunnen, door de variabelen in te stellen, Terraform vertellen alles te verhogen wat we hierboven hebben beschreven. Het hele proces kostte me ongeveer 15 minuten.
Aan het einde zie je een mooie boodschap:
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 de cloud zullen elementen van de verhoogde infrastructuur zichtbaar zijn:
Opsommen
Als we nu Grafana als voorbeeld nemen, kan ieder van jullie applicaties implementeren met een uitgebreide cloudarchitectuur op het Yandex.Cloud-platform. Handige tools van HashiCorp zoals Packer en Terraform kunnen je hierbij helpen. Ik hoop dat iemand dit artikel nuttig vindt :)
PS Hieronder zal ik een link bijvoegen naar de repository waar je kant-en-klare recepten voor Packer en Terraform kunt vinden, waarvan ik fragmenten in dit artikel heb verstrekt.
Bron: www.habr.com