Hallo allemaal! Als onderdeel van mijn studie deed ik onderzoek naar de mogelijkheden van een binnenlands cloudplatform als . Het platform biedt verschillende diensten aan om praktische problemen op te lossen. Soms is het echter noodzakelijk om op basis van deze diensten een eigen cloudapplicatie op te zetten met een vrij uitgebreide infrastructuur. In dit artikel wil ik mijn ervaringen delen met het implementeren van een dergelijke applicatie.
Wat wil je krijgen?
— 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 en een database (ClickHouse, InfluxDB, enz.) met een dataset op basis waarvan analyses worden opgebouwd.
Nadat u een virtuele machine met een webserver hebt opgestart, kunt u naar de host gaan en een mooie gebruikersinterface krijgen, databases opgeven als bronnen voor verdere werkzaamheden en dashboards en grafieken maken.
De basisversie heeft één belangrijk nadeel: deze is helemaal niet fouttolerant. Dat wil zeggen dat de volledige functionaliteit van de applicatie afhankelijk is van de levensvatbaarheid van één virtuele machine. Als dit mislukt of als 10 mensen tegelijkertijd de gebruikersinterface openen, ontstaan er problemen.
Ze worden eenvoudig opgelost: u hoeft alleen maar… veel identieke virtuele machines met een webserver te implementeren en deze onder een L3-balancer te plaatsen. Maar hier is niet alles zo eenduidig. Grafana slaat gebruikersinstellingen (paden naar databases, dashboards, grafieken, enz.) rechtstreeks op de schijf van de virtuele machine op. Wanneer u dus instellingen in de gebruikersinterface wijzigt, worden deze wijzigingen alleen weergegeven op de virtuele machine waar de balancer ons naartoe heeft gestuurd. Dit leidt tot inconsistente instellingen van onze applicatie en er kunnen problemen optreden bij het opstarten en gebruiken ervan.
In dit geval kan een andere database uitkomst bieden, bijvoorbeeld MySQL of een equivalent daarvan. We vertellen Grafana dat het de gebruikersinstellingen in deze 'reserve'-database moet opslaan. Hierna is het voldoende om op elke machine eenmalig het pad naar deze database op te geven en alle andere gebruikersinstellingen op alle virtuele machines te bewerken; Ze zullen zich naar de anderen verspreiden.
Hier is een diagram van de uiteindelijke applicatie-infrastructuur:
Laten we leren tillen met onze handen
MySQL en ClickHouse
Voordat je een dergelijke applicatie met één druk op de knop kon implementeren, moest je eerst leren hoe je elk onderdeel aan de handgrepen kon optillen en met elkaar kon integreren.
Hierbij krijgen we hulp van Yandex.Cloud, dat L3 balancers, ClickHouse en MySQL als managed services aanbiedt. De gebruiker hoeft alleen de parameters op te geven en te wachten tot het platform alles werkend krijgt.
Ik heb mij geregistreerd, een cloud en een betaalaccount aangemaakt. Daarna ben ik naar de cloud gegaan en heb ik MySQL- en ClickHouse-clusters ingesteld met minimale instellingen. Wachtte tot ze actief werden.
Vergeet niet om in elk cluster een database aan te maken en de toegang daartoe in te stellen met behulp van een gebruikersnaam en wachtwoord. Ik ga hier niet in op details: alles is vrij duidelijk in de interface.
Een minder voor de hand liggend detail is dat deze databases meerdere hosts hebben, die hun fouttolerantie garanderen. Grafana vereist echter precies één host per database waarmee het werkt. Lang lezen De wolken leidden mij naar een oplossing. Het blijkt dat de gastheer tot de soort behoort c-<cluster_id>.rw.mdb.yandexcloud.net toegewezen aan de huidige actieve clustermasterhost met de bijbehorende ID. Dit is precies wat wij Grafana zullen geven.
web Server
Nu is het tijd voor de webserver. Laten we een gewone virtuele machine instellen met Linux En we zullen Grafana er handmatig op installeren.
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
Daarna starten we Grafana onder systemctl en installeren we een plugin voor het werken met ClickHouse (ja, deze is niet inbegrepen in het basispakket).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceDat is alles, na dit eenvoudige commando
sudo service grafana-server startWe gaan een webserver lanceren. Nu kunt u het externe IP-adres van de virtuele machine in de browser invoeren, poort 3000 opgeven en de prachtige Grafana-gebruikersinterface bekijken.
Maar wees niet te haastig; voordat u Grafana instelt, moet u het pad naar MySQL opgeven waar de instellingen daar worden opgeslagen.
De volledige configuratie van de Grafana-webserver bevindt zich in het bestand /etc/grafana/grafana.ini. De regel die u nodig hebt, ziet er als volgt uit:
;url =We maken de host toegankelijk voor het MySQL-cluster. Hetzelfde bestand bevat de inloggegevens en het wachtwoord voor toegang tot Grafana in de afbeelding hierboven. Deze zijn standaard hetzelfde. admin.
U kunt de volgende 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 te starten!
sudo service grafana-server restartIn de Grafana-gebruikersinterface specificeren we ClickHouse als de gegevensbron.
Ik heb een werkende configuratie kunnen realiseren met de volgende instellingen:
Als URL heb ik opgegeven https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Alle! We hebben één werkende VM 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 beschikken nog niet over een volwaardige infrastructuur.
Packer
Met Yandex.Cloud kunt u een schijfkopie maken van een bestaande virtuele machine en op basis daarvan een willekeurig aantal identieke machines. Dit is precies waar wij gebruik van gaan maken. Om de afbeelding gemakkelijk samen te stellen, nemen we de tool van HashiCorp. Als invoer wordt een JSON-bestand gebruikt met instructies voor het samenstellen van de afbeelding.
Ons JSON-bestand bestaat uit twee blokken: builders en provisioners. Het eerste blok beschrijft de parameters van de afbeelding zelf als entiteit, en het tweede beschrijft de instructies voor het vullen ervan met de benodigde inhoud.
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 identificatie van de sectie in de cloud instellen waar u de afbeelding wilt maken, evenals het pad naar het bestand met de sleutels van het serviceaccount dat eerder in deze sectie is gemaakt. Meer over het aanmaken van serviceaccounts en sleutels in de vorm van een bestand kunt u lezen in de betreffende sectie .
Deze configuratie geeft aan dat het schijfkopiebestand wordt gebouwd op basis van het platform ubuntu-1804-lts, geplaatst in de overeenkomstige gebruikerssectie in de afbeeldingenfamilie 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 vastgelegd.
{
...,
"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 worden alle acties in 3 fasen verdeeld. De eerste stap is het uitvoeren van een eenvoudig script dat een hulpdirectory aanmaakt.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaIn de volgende stap plaatsen we een script in deze directory dat direct na het starten van de virtuele machine moet worden uitgevoerd. Dit script plaatst de gebruikersvariabelen die in de Grafana-configuratie moeten worden geschreven 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 moeten er nog 3 dingen gedaan worden:
1) pakketten installeren
2) Voer Grafana uit onder systemctl en installeer de ClickHouse-plug-in
3) Plaats het script setup.sh direct in de run queue nadat u de virtuele machine hebt ingeschakeld.
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-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;Het enige wat nu nog rest is Packer uit te voeren en de afbeelding in de opgegeven sectie als uitvoer te plaatsen. Bij het aanmaken van een virtuele machine kunt u deze selecteren als opstartschijf. Na het opstarten krijgt u een kant-en-klare Grafana-webserver.
Instantiegroep en balancer
Zodra we een schijfkopie hebben waarmee we meerdere identieke Grafana-webservers kunnen maken, kunnen we een instantiegroep maken. Op het Yandex.Cloud-platform verwijst deze term naar een combinatie van virtuele machines met dezelfde kenmerken. Wanneer een instantiegroep wordt gemaakt, wordt een prototype van alle machines in de 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, verwijdert de instantiegroep onnodige machines of maakt nieuwe machines aan met dezelfde image en gelijkenis.
Als onderdeel van onze taak zullen we een instantiegroep van webservers creëren die wordt gestart vanuit de eerder gemaakte schijfkopie.
De laatste instelling voor de instantiegroep is echt opmerkelijk. De doelgroep die geïntegreerd is met Load Balancer helpt u met een paar klikken de L3-balancer te configureren op de virtuele machines van deze groep.
Bij het instellen van de balancer heb ik twee belangrijke punten geïmplementeerd:
- Ik heb het zo ingesteld dat de balancer het gebruikersverkeer op poort 80 ontvangt en dit omleidt naar poort 3000 van de virtuele machines, precies waar Grafana zich bevindt.
- Er is een gezondheidscontrole voor machines geconfigureerd door ze te pingen op poort 3000.
Mini-samenvatting
Uiteindelijk konden we de gewenste applicatie-infrastructuur handmatig implementeren en nu beschikken we over een uiterst stabiele Grafana-service. U hoeft alleen het IP-adres van de balancer te weten als toegangspunt tot de toepassing en de ClickHouse-clusterhost om de dataset daarin te laden.
Lijkt het een overwinning? Ja, overwinning. Maar er is nog steeds iets dat mij dwarszit. Het hele proces hierboven vereist veel handmatige handelingen en is absoluut niet schaalbaar. Indien mogelijk wil ik het graag automatiseren. Daarover gaat het volgende gedeelte.
Terraform-integratie
We zullen opnieuw een tool van HashiCorp gebruiken genaamd . Hiermee kunt u met één druk op de knop de volledige applicatie-infrastructuur implementeren, op basis van een aantal variabelen die door de gebruiker worden doorgegeven. Laten we een recept schrijven dat meerdere keren in verschillende secties voor verschillende gebruikers kan worden uitgevoerd.
Al het werk met Terraform komt neer op het schrijven van een configuratiebestand (*.tf) en het creëren van infrastructuur op basis daarvan.
variabelen
Helemaal aan het begin van het bestand plaatsen we de variabelen waarvan het afhankelijk is waar en hoe de toekomstige infrastructuur wordt geïmplementeerd.
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 proces voor het implementeren van een applicatie komt neer op het samenstellen van een schijfkopie en het instellen van de variabelen. Laat me uitleggen waar ze verantwoordelijk voor zijn:
oauth_token — een token voor toegang tot de cloud. Je kunt het krijgen door .
cloud_id — de identificatie van de cloud waar we de applicatie zullen implementeren
map_id — de identificatie van de sectie waar we de applicatie zullen implementeren
service_account_id — identificatie van het serviceaccount in het overeenkomstige gedeelte van de cloud.
afbeelding_id — identificatie van de schijfkopie verkregen met Packer
gebruikersnaam и wachtwoord — gebruikersnaam en wachtwoord voor toegang tot beide databases en de Grafana-webserver
dbnaam — de naam van de database binnen de CH- en MySQL-clusters
openbaar_sleutel_pad — pad naar het bestand met uw openbare ssh-sleutel, die u kunt gebruiken om verbinding te maken onder de naam ubuntu naar virtuele machines met webservers
Uw provider instellen
Nu moet u 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"
}
Zoals u kunt zien, gebruiken we hier de hierboven gedefinieerde variabelen.
Netwerk en clusters
Nu gaan we een netwerk creëren waarin de elementen van onze infrastructuur met elkaar communiceren, drie subnetten (één in elke regio) en CH- en MySQL-clusters oprichten.
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, zijn beide clusters redelijk fouttolerant gemaakt doordat ze in drie beschikbaarheidszones zijn geplaatst.
Webservers
Het leek erop dat ik in dezelfde geest verder kon gaan, maar ik stuitte op een moeilijkheid. Hiervoor heb ik eerst een MySQL-cluster opgezet en pas daarna, met de ID van dat cluster in gedachten, heb ik een schijfkopie samengesteld met de vereiste configuratie. Hierbij heb ik de host voor het cluster opgegeven. Maar nu kennen we de cluster-ID niet voordat Terraform wordt gestart, ook niet op het moment dat de afbeelding wordt samengesteld. Daarom moesten we onze toevlucht nemen tot het volgende .
Met behulp van de metadatagegevensservice van Amazon geven we een aantal parameters door aan de virtuele machine. Deze worden vervolgens geaccepteerd en verwerkt. We hebben de machine nodig om naar de metagegevens voor de MySQL-clusterhost te gaan en de gebruikersnaam en het wachtwoord die de gebruiker na het opstarten in het Terraform-bestand heeft opgegeven, te raadplegen. Laten we de inhoud van het bestand enigszins wijzigen setup.sh, die start zodra 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 restartIngangsgroep en balancer
Nadat we de nieuwe schijfkopie hebben herbouwd, kunnen we eindelijk het schrijven van ons bestand voor Terraform afronden.
Laten we specificeren 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 hoe we de metadata hebben overgedragen cluster_uri, username и password. Dit zijn de bestanden die de virtuele machine bij het opstarten extraheert en in de Grafana-configuratie plaatst.
Het hangt af van 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-gebruikersinterface gaan en handmatig het CH-cluster (waarvan de ID nog moet worden verkregen) toevoegen als een gegevensbron. Maar Terraform kent de cluster-ID. Laten we hem de taak toevertrouwen om de klus te klaren.
Laten we een nieuwe provider toevoegen: Grafana, en deze het IP-adres van de balancer als host geven. Alle wijzigingen die Terraform aanbrengt op de machine waaraan de balancer de wijzigingen toewijst, worden doorgevoerd in MySQL en dus ook 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 het kammen
We zullen het IP-adres van de balancer en de host van het ClickHouse-cluster uitgeven
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"
}Je kunt het lanceren
Alle! Ons configuratiebestand is klaar en we kunnen de variabelen instellen om Terraform te vertellen alles wat we hierboven hebben beschreven, op te roepen. Het hele proces duurde ongeveer 15 minuten.
Aan het eind 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 Grafana als voorbeeld nemen, kunnen jullie allebei applicaties implementeren met een uitgebreide cloudarchitectuur op het Yandex.Cloud-platform. Handige tools van HashiCorp zoals Packer en Terraform kunnen u hierbij helpen. Ik hoop dat dit artikel nuttig zal zijn voor iemand 🙂
P.S. Hieronder voeg ik een link toe naar een repository waar je kant-en-klare recepten voor Packer en Terraform kunt vinden. Fragmenten daarvan heb ik in dit artikel opgenomen.
Bron: www.habr.com
