Hej allihopa! Som en del av mina kurser undersökte jag möjligheterna hos en sådan inhemsk molnplattform som . Plattformen erbjuder olika tjänster för att lösa praktiska problem. Ibland är det dock nödvändigt att sätta upp en egen molnapplikation med en ganska omfattande infrastruktur baserad på dessa tjänster. I den här artikeln vill jag dela med mig av mina erfarenheter av att driftsätta en sådan applikation.
Vad vill du få?
— ett kraftfullt verktyg för att lösa analytiska problem eller övervaka problem i alla system. I sin grundkonfiguration är detta en virtuell maskin med en Grafana-webbserver, samt en databas (ClickHouse, InfluxDB, etc.) med en datauppsättning, enligt vilken analyser kommer att byggas.
Efter att du har startat en virtuell maskin med en webbserver kan du gå till dess värd och få ett snyggt användargränssnitt, ange databaser som källor för vidare arbete, skapa dashboards och grafer.
Grundversionen har en betydande nackdel - den är inte alls feltolerant. Det vill säga att hela applikationens funktionalitet beror på en virtuell maskins livskraft. Om det misslyckas eller om 10 personer öppnar användargränssnittet samtidigt kommer problem att uppstå.
De löses enkelt: du behöver bara… driftsätta många identiska virtuella maskiner med en webbserver och placera dem under en L3-balanserare. Men allt är inte så självklart här. Grafana lagrar användarinställningar (sökvägar till databaser, dashboards, grafer etc.) direkt på disken i sin virtuella maskin. Således, om du ändrar några inställningar i användargränssnittet, kommer dessa ändringar bara att visas på den virtuella maskin dit balanseraren skickade oss. Detta kommer att leda till inkonsekventa inställningar i vår applikation, och problem med att starta och använda den kommer att uppstå.
Här kommer en annan databas till undsättning, till exempel MySQL eller motsvarande. Vi säger till Grafana att den ska lagra användarinställningar i denna "reserv"-databas. Efteråt räcker det att ange sökvägen till den här databasen en gång på varje maskin och redigera alla andra användarinställningar på vilken som helst av de virtuella maskinerna; de kommer att sprida sig till de andra.
Här är ett diagram över den slutliga applikationsinfrastrukturen:
Låt oss lära oss att lyfta med händerna
MySQL och ClickHouse
Innan man kunde driftsätta en sådan applikation med en knapptryckning var man tvungen att lära sig hur man lyfter var och en av dess komponenter med handtagen och integrerar dem med varandra.
Här kommer vi att få hjälp av Yandex.Cloud, som tillhandahåller L3-balanserare, ClickHouse och MySQL som hanterade tjänster. Användaren behöver bara ange parametrarna och vänta tills plattformen får allt att fungera.
Jag registrerade mig, skapade ett moln och ett betalkonto. Efter det gick jag ut i molnet och konfigurerade MySQL- och ClickHouse-kluster med minimala inställningar. Väntade tills de blev aktiva.
Du måste också komma ihåg att skapa en databas i varje kluster och konfigurera åtkomst till den med hjälp av inloggning och lösenord. Jag kommer inte att gå in på detaljer här – allt är ganska uppenbart i gränssnittet.
Den mindre uppenbara detaljen var att dessa databaser har flera värdar, vilket säkerställer deras feltolerans. Grafana kräver dock exakt en värd för varje databas den arbetar med. Långläsning Molnen ledde mig till en lösning. Det visar sig att värden är av arten c-<cluster_id>.rw.mdb.yandexcloud.net mappad till den aktuella aktiva klustermastervärden med motsvarande ID. Det här är precis vad vi kommer att ge Grafana.
webbserver
Nu är det dags för webbservern. Låt oss konfigurera en vanlig virtuell maskin med Linux och vi ska sätta upp Grafana på den med våra händer.
Låt oss ansluta via ssh och installera de nödvändiga paketen.
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
Efter det startar vi Grafana under systemctl och installerar ett plugin för att arbeta med ClickHouse (ja, det ingår inte i grundpaketet).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceDet var allt, efter detta enkla kommando
sudo service grafana-server startVi kommer att lansera en webbserver. Nu kan du ange den virtuella maskinens externa IP-adress i webbläsaren, ange port 3000 och se det vackra Grafana-gränssnittet.
Men skynda dig inte, innan du konfigurerar Grafana måste du komma ihåg att ange sökvägen till MySQL för att lagra inställningarna där.
Hela konfigurationen av Grafana webbserver finns i filen /etc/grafana/grafana.ini. Raden du behöver ser ut så här:
;url =Vi exponerar värden för MySQL-klustret. Samma fil innehåller inloggning och lösenord för åtkomst till Grafana i bilden ovan, vilka båda är lika som standard. admin.
Du kan använda sed-kommandon:
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
Det är dags att starta om webbservern!
sudo service grafana-server restartNu i Grafana-gränssnittet kommer vi att ange ClickHouse som datakälla.
Jag lyckades få till en fungerande konfiguration med följande inställningar:
Som en URL jag angav https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Alla! Vi har en fungerande virtuell dator med en webbserver ansluten till CH och MySQL. Du kan redan ladda upp datasetet till ClickHouse och bygga dashboards. Vi har dock ännu inte uppnått vårt mål och driftsatt en fullfjädrad infrastruktur.
Packer
Yandex.Cloud låter dig skapa en diskavbildning av en befintlig virtuell maskin, och baserat på den - valfritt antal identiska maskiner. Det är precis detta vi kommer att dra nytta av. För att enkelt montera bilden, låt oss ta verktyget från HashiCorp. Den tar en json-fil som indata med instruktioner för att montera bilden.
Vår json-fil kommer att bestå av två block: builders och provisioners. Det första blocket beskriver parametrarna för själva bilden som en enhet, och det andra beskriver instruktionerna för att fylla den med nödvändigt innehåll.
byggare
{
"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"
}
],
...
}I den här mallen måste du ange identifieraren för den sektion i molnet där du vill skapa avbildningen, samt sökvägen till filen med nycklarna från det tjänstkonto som tidigare skapades i den här sektionen. Du kan läsa mer om att skapa servicekonton och nycklar i filform i motsvarande avsnitt. .
Den här konfigurationen säger att diskavbildningen kommer att byggas baserat på plattformen ubuntu-1804-lts, placerad i motsvarande användarsektion i bildfamiljen GRAFANA under namnet grafana-{{timestamp}}.
Proviantörer
Nu kommer den mer intressanta delen av konfigurationen. Den beskriver sekvensen av åtgärder som måste utföras på den virtuella maskinen innan dess tillstånd fryses till en diskavbildning.
{
...,
"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"
]
}
]
}Här är alla åtgärder indelade i 3 steg. Det första steget är att köra ett enkelt skript som skapar en hjälpkatalog.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaI nästa steg placerar vi ett skript i den här katalogen som måste köras omedelbart efter att den virtuella maskinen har startats. Det här skriptet lägger in användarvariablerna som behöver skrivas i Grafana-konfigurationen och startar om webbservern.
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 restartEfter detta finns det 3 saker kvar att göra:
1) installera paket
2) kör Grafana under systemctl och installera ClickHouse-pluginet
3) placera setup.sh-skriptet i körkön omedelbart efter att du har startat den virtuella maskinen.
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-datasourcekör-setup-vid-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 återstår bara att köra Packer och få bilden placerad i den angivna sektionen som utdata. När du skapar en virtuell maskin kan du välja den som startdisk och efter att du har startat den får du en färdig Grafana-webbserver.
Instansgrupp och balanserare
När vi har en diskavbildning som låter oss skapa flera identiska Grafana-webbservrar kan vi skapa en instansgrupp. På Yandex.Cloud-plattformen hänvisar denna term till en kombination av virtuella maskiner med samma egenskaper. När en instansgrupp skapas konfigureras en prototyp av alla maskiner i gruppen, och sedan själva gruppens egenskaper (till exempel det minsta och högsta antalet aktiva maskiner). Om det nuvarande antalet inte uppfyller dessa kriterier kommer instansgruppen själv att ta bort onödiga maskiner eller skapa nya med samma avbildning och likhet.
Som en del av vår uppgift kommer vi att skapa en instansgrupp av webbservrar som kommer att skapas från den tidigare skapade diskavbildningen.
Den sista instansgruppens inställning är verkligen anmärkningsvärd. Målgruppen som är integrerad med Load Balancer hjälper dig att konfigurera L3-balanseraren ovanpå de virtuella maskinerna i den här gruppen med några få klick.
När jag installerade balansblocket implementerade jag två viktiga punkter:
- Jag gjorde det så att balanseraren skulle ta emot användartrafik på port 80 och omdirigera den till port 3000 på de virtuella maskinerna, exakt där Grafana finns.
- Konfigurerade en hälsokontroll för maskiner genom att pinga dem på port 3000.
Minisammanfattning
Slutligen kunde vi manuellt driftsätta den önskade applikationsinfrastrukturen, och nu har vi en mycket stabil Grafana-tjänst. Du behöver bara veta balanserarens IP-adress som ingångspunkt till applikationen och ClickHouse-klustervärden för att läsa in datasetet i den.
Det skulle kännas som en seger? Ja, seger. Men något stör mig fortfarande. Hela processen ovan kräver många manuella åtgärder och är inte skalbar alls, jag skulle vilja automatisera den om möjligt. Det är detta som nästa avsnitt kommer att ägnas åt.
Terraform-integration
Vi kommer återigen att använda ett verktyg från HashiCorp som heter . Det hjälper dig att distribuera hela applikationsinfrastrukturen med ett klick, baserat på ett fåtal variabler som användaren anger. Låt oss skriva ett recept som kan köras flera gånger i olika avsnitt för olika användare.
Allt arbete med Terraform handlar om att skriva en konfigurationsfil (*.tf) och skapandet av infrastruktur baserad på det.
variabler
Alldeles i början av filen placerar vi variablerna som avgör var och hur den framtida infrastrukturen kommer att driftsättas.
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>"
}Hela processen att distribuera en applikation kommer att reduceras till att montera en diskavbildning och ställa in dessa variabler. Låt mig förklara vad de är ansvariga för:
oauth_token — en token för åtkomst till molnet. Du kan få det genom att .
moln_id — identifieraren för det moln där vi kommer att driftsätta applikationen
mapp-id — identifieraren för den sektion där vi kommer att driftsätta applikationen
service_account_id — identifierare för tjänstekontot i motsvarande del av molnet.
bild-id — identifierare för diskavbildningen som erhållits med Packer
Användarnamn и Lösenord — användarnamn och lösenord för åtkomst till både databaser och Grafana webbserver
dbnamn — namnet på databasen inom CH- och MySQL-klustren
offentlig_nyckel_sökväg — sökvägen till filen med din publika SSH-nyckel, som du kan använda för att ansluta under namnet ubuntu till virtuella maskiner med webbservrar
Konfigurera din leverantör
Nu behöver du konfigurera Terraform-leverantören - i vårt fall Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Du kan se att vi här använder de variabler som definierats ovan.
Nätverk och kluster
Nu ska vi skapa ett nätverk där elementen i vår infrastruktur ska kommunicera, tre subnät (ett i varje region) och skapa CH- och MySQL-kluster.
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
}
}Som ni kan se är vart och ett av de två klustren ganska feltoleranta genom att de placeras i tre tillgänglighetszoner.
Webbservrar
Det verkade som att jag kunde fortsätta i samma anda, men jag stötte på en svårighet. Innan detta konfigurerade jag först ett MySQL-kluster och först därefter, med vetskap om dess ID, monterade jag en diskavbildning med den erforderliga konfigurationen, där jag specificerade värden för klustret. Men nu vet vi inte kluster-ID:t innan Terraform lanseras, inklusive vid tidpunkten för avbildningssammansättningen. Därför var vi tvungna att tillgripa följande .
Med hjälp av Amazons metadatatjänst skickar vi några parametrar till den virtuella maskinen, som den kommer att acceptera och bearbeta. Vi behöver att maskinen går till metadata för MySQL-klustervärden och användarnamnet-lösenordet som användaren angav i Terraform-filen efter start. Låt oss ändra innehållet i filen något setup.sh, som startar när den virtuella maskinen slås på.
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 restartIntrance-grupp och balanserare
Efter att ha återskapat den nya diskavbildningen kan vi äntligen avsluta skrivningen av vår fil för Terraform.
Låt oss ange att vi vill använda en befintlig diskavbildning:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Nu ska vi skapa en instansgrupp:
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"
}
}Det är värt att uppmärksamma hur vi överförde till metadata cluster_uri, username и password. Det är dessa som den virtuella maskinen extraherar vid start och placerar i Grafana-konfigurationen.
Det är upp till balansmakaren.
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
}
}
}
}Lite socker
Det är bara lite kvar. När infrastrukturen har driftsatts måste du gå till Grafana-gränssnittet och manuellt lägga till CH-klustret (vars ID fortfarande behöver hämtas) som en datakälla. Men Terraform känner till kluster-ID:t. Låt oss anförtro honom att slutföra jobbet.
Låt oss lägga till en ny leverantör - Grafana, och ge den balanserarens IP-adress som värd. Alla ändringar som Terraform gör på den maskin där balanseraren tilldelar den kommer att växa in i MySQL, och därmed på alla andra maskiner.
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"
}Låt oss kamma det
Vi kommer att mata ut IP-adressen för balanseraren och värden för ClickHouse-klustret
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"
}Du kan starta den
Alla! Vår konfigurationsfil är klar och vi kan ställa in variablerna för att instruera Terraform att höja allt vi beskrivit ovan. Hela processen tog mig ungefär 15 minuter.
I slutet kan du se ett vackert meddelande:
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.25Och i molnet kommer delar av den upphöjda infrastrukturen att vara synliga:
Summera
Nu, med Grafana som exempel, kan var och en av er distribuera applikationer med en vidsträckt molnarkitektur på Yandex.Cloud-plattformen. Användbara verktyg från HashiCorp, som Packer och Terraform, kan hjälpa dig med detta. Jag hoppas att den här artikeln kommer att vara användbar för någon 🙂
P.S. Nedan bifogar jag en länk till ett arkiv där du kan hitta färdiga recept för Packer och Terraform, fragment av vilka jag har tillhandahållit i den här artikeln.
Källa: will.com
