Hej alle! Som en del af mit kursusarbejde undersøgte jeg mulighederne for en sådan indenlandsk cloud-platform som . Platformen tilbyder forskellige tjenester til løsning af praktiske problemer. Nogle gange er det dog nødvendigt at konfigurere din cloud-applikation med en ret omfattende infrastruktur baseret på disse tjenester. I denne artikel vil jeg dele erfaringerne med at implementere en sådan applikation.
Hvad vil du have?
- et kraftfuldt værktøj til at løse analytiske problemer eller overvåge problemer i ethvert system. I sin grundlæggende konfiguration er dette en virtuel maskine med Grafana-webserveren, samt en database (ClickHouse, InfluxDB osv.) med et datasæt, der skal bruges til at bygge analyser.
Efter at have startet en virtuel maskine med en webserver, kan du gå til dens vært og få en smuk brugergrænseflade, angive databaser som kilder til videre arbejde, oprette dashboards og grafer.
Grundversionen har en væsentlig ulempe - den er slet ikke fejltolerant. Det vil sige, at hele applikationens ydeevne afhænger af levedygtigheden af en virtuel maskine. Hvis hun nægter, eller hvis 10 personer åbner brugergrænsefladen på samme tid, vil der opstå problemer.
De løses enkelt: du skal bare installere mange identiske virtuelle maskiner med en webserver og placere dem under en L3 balancer. Men ikke alt er så entydigt her. Grafana gemmer brugerindstillinger (stier til databaser, dashboards, grafik osv.) direkte på disken på sin virtuelle maskine. Således, hvis du ændrer nogle indstillinger i brugergrænsefladen, vil disse ændringer kun blive vist på den virtuelle maskine, hvor balanceren sendte os. Dette vil føre til inkonsistente indstillinger for vores applikation, problemer med lancering og brug.
Her vil en anden database komme til undsætning, for eksempel MySQL eller tilsvarende. Vi fortæller Grafana, at hun skal gemme brugerindstillinger i denne "reserve"-database. Derefter vil det være nok at angive stien til denne database på hver maskine én gang, og redigere alle andre brugerindstillinger på nogen af de virtuelle maskiner, de vil vokse på resten.
Her er et diagram over den endelige applikationsinfrastruktur:
Lær at hæve med dine hænder
MySQL og ClickHouse
Før du implementerer en sådan applikation med et klik på en knap, var det nødvendigt at lære at løfte hver af dens komponenter med håndtag og integrere dem med hinanden.
Yandex.Cloud vil hjælpe os her, som leverer L3 balancerer, ClickHouse og MySQL som administrerede tjenester. Brugeren behøver kun at specificere parametrene og vente, indtil platformen bringer alt i en fungerende tilstand.
Jeg registrerede mig, oprettede en sky og en faktureringskonto til mig selv. Derefter gik jeg ind i skyen og rejste MySQL- og ClickHouse-klynger med minimale indstillinger. Vent, indtil de bliver aktive.
Du skal også huske at oprette en database i hver klynge og konfigurere adgangen til den ved hjælp af login og adgangskode. Jeg vil ikke gå i detaljer her - alt er ret tydeligt i grænsefladen.
Den ikke-indlysende detalje var, at disse databaser har mange værter, der giver deres fejltolerance. Grafana kræver dog præcis én vært for hver database, den arbejder med. Lang læsning Skyerne førte mig til en beslutning. Det viser sig, at en vært af formen c-<cluster_id>.rw.mdb.yandexcloud.net Maps til den aktuelle aktive klyngemastervært med det tilsvarende id. Det er, hvad vi vil give til Grafana.
Webserver
Nu er det op til webserveren. Lad os rejse en almindelig virtuel maskine med Linux og sætte Grafana op på den med vores hænder.
Lad os oprette forbindelse via ssh og installere de nødvendige pakker.
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
Derefter starter vi Grafana under systemctl og installerer plugin'et til at arbejde med ClickHouse (ja, det er ikke inkluderet i grundpakken).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceAlt efter det med en simpel kommando
sudo service grafana-server startvi starter webserveren. Nu vil det være muligt at køre i den eksterne IP-adresse på den virtuelle maskine i browseren, angive port 3000 og se den smukke UI grafana.
Men skynd dig ikke, før du opsætter Grafana, må du ikke glemme at angive stien til MySQL, så den kan gemme indstillingerne der.
Hele konfigurationen af Grafana-webserveren er i filen /etc/grafana/grafana.ini. Den påkrævede linje ser sådan ud:
;url =Vi udsætter værten for MySQL-klyngen. Den samme fil indeholder login og adgangskode for at få adgang til Grafana på billedet ovenfor, som begge er ens som standard admin.
Du kan bruge sed-kommandoer:
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 er tid til at genstarte webserveren!
sudo service grafana-server restartNu i Grafana UI, vil vi specificere ClickHouse som DataSource.
Det lykkedes mig at opnå en fungerende konfiguration med følgende indstillinger:
Jeg har givet som URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Alle! Vi har én fungerende virtuel maskine med en webserver forbundet til CH og MySQL. Du kan allerede uploade datasættet til ClickHouse og bygge dashboards. Vi har dog endnu ikke nået vores mål og har ikke implementeret en fuldgyldig infrastruktur.
Packer
Yandex.Cloud giver dig mulighed for at oprette et diskbillede af en eksisterende virtuel maskine, og baseret på det kan du oprette så mange identiske maskiner, som du vil. Det er præcis, hvad vi vil bruge. For bekvemt at samle billedet, tag værktøjet fra HashiCorp. Det tager som input en json-fil med instruktioner til opbygning af billedet.
Vores json-fil vil bestå af to blokke: builders og provisioners. Den første blok beskriver parametrene for selve billedet som en enhed, og den anden beskriver instruktionerne til at fylde det med det nødvendige indhold.
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"
}
],
...
}I denne skabelon skal du angive identifikatoren for den sektion i skyen, hvor du vil oprette et billede, samt stien til filen med nøglerne fra tjenestekontoen, der tidligere er oprettet i dette afsnit. Du kan læse mere om oprettelse af servicekonti og nøgler i form af en fil i det tilsvarende afsnit. .
Denne konfiguration siger, at diskbilledet vil blive bygget baseret på platformen ubuntu-1804-lts, placeret i den relevante brugersektion i billedfamilien GRAFANA under navnet grafana-{{timestamp}}.
Forsørgere
Nu til den mere interessante del af konfigurationen. Den vil beskrive rækkefølgen af handlinger, der skal udføres på en virtuel maskine, før dens tilstand fryses til et diskbillede.
{
...,
"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"
]
}
]
}Her er alle handlinger opdelt i 3 stadier. I det første trin udføres et simpelt script, der opretter en hjælpemappe.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaPå næste trin placerer vi et script i denne mappe, som skal køres umiddelbart efter start af den virtuelle maskine. Dette script vil sætte de brugervariabler, der skal indstilles, i Grafanas konfiguration og genstarte webserveren.
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 restartDerefter er der 3 ting at gøre:
1) installer pakker
2) start Grafana under systemctl og installer ClickHouse plugin
3) sæt setup.sh-scriptet i køen for at køre umiddelbart efter at have tændt den virtuelle maskine.
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;Nu er det tilbage at køre Packer og få outputbilledet placeret i den angivne partition. Når du opretter en virtuel maskine, kan du vælge den som opstartsdisk og efter start få en færdiglavet Grafana-webserver.
Instansgruppe og balancer
Når der er et diskbillede, der giver dig mulighed for at oprette mange identiske Grafana-webservere, kan vi oprette en instansgruppe. På Yandex.Cloud-platformen refererer dette udtryk til foreningen af virtuelle maskiner, der har de samme egenskaber. Når du opretter en instansgruppe, konfigureres prototypen for alle maskiner i denne gruppe, og derefter egenskaberne for selve gruppen (f.eks. minimum og maksimum antal aktive maskiner). Hvis det nuværende antal ikke opfylder dette kriterium, vil instansgruppen selv fjerne unødvendige maskiner eller oprette nye i billedet og ligheden.
Som en del af vores opgave vil vi oprette en forekomstgruppe af webservere, der vil blive skabt fra det tidligere oprettede diskbillede.
Den sidste instans gruppeindstilling er virkelig bemærkelsesværdig. Målgruppen i integration med Load Balancer hjælper dig med at sætte en L3 balancer op oven på de virtuelle maskiner i denne gruppe ved at trykke på et par knapper.
Da jeg satte balanceren op, implementerede jeg to vigtige punkter:
- Jeg gjorde det sådan, at balanceren accepterede brugertrafik på port 80, og omdirigerede den til port 3000 på virtuelle maskiner, lige hvor Grafana bor.
- Konfigurer maskinsundhedstjek ved at pinge dem på port 3000.
mini-total
Endelig var vi i stand til manuelt at implementere den ønskede applikationsinfrastruktur, og nu har vi en yderst robust Grafana-tjeneste. Det er kun nødvendigt at kende balancerens IP-adresse som indgangspunkt til applikationen og værten for ClickHouse-klyngen for at indlæse datasættet i det.
Det ser ud til at være en sejr? Ja, sejr. Men noget generer mig stadig. Hele processen ovenfor kræver mange manuelle handlinger og skalerer slet ikke, jeg vil gerne automatisere den hvis det er muligt. Dette vil være fokus i næste afsnit.
Integration med Terraform
Vi vil igen bruge et værktøj fra HashiCorp kaldet . Det vil hjælpe med at implementere hele applikationsinfrastrukturen ved et klik på en knap, baseret på nogle få variabler, der er videregivet af brugeren. Lad os skrive en opskrift, der kan køres flere gange i forskellige sektioner af forskellige brugere.
Alt arbejde med Terraform kommer ned til at skrive en konfigurationsfil (*.tf) og skabelsen af infrastruktur baseret på det.
Variabler
Allerede i begyndelsen af filen vil vi tage de variable ud, der bestemmer, hvor og hvordan den fremtidige infrastruktur vil blive implementeret.
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>"
}Hele processen med at implementere en applikation kommer ned til at bygge et diskbillede og indstille disse variabler. Lad mig forklare, hvad de er ansvarlige for:
oauth_token — et token for adgang til skyen. Kan fås pr .
cloud_id - identifikator for skyen, hvor vi vil implementere applikationen
mappe_id — identifikator for den sektion, hvor vi vil implementere applikationen
service_account_id — identifikator for tjenestekontoen i den tilsvarende del af skyen.
image_id - identifikator for diskbilledet opnået ved hjælp af Packer
brugernavn и adgangskode - brugernavn og adgangskode for at få adgang til både databaser og Grafana-webserveren
dbnavn - databasenavn inde i CH- og MySQL-klynger
offentlig_nøglesti - stien til filen med din offentlige ssh-nøgle, som kan bruges til at forbinde under navnet ubuntu til virtuelle maskiner med webservere
Udbyderindstilling
Nu skal du konfigurere Terraform-udbyderen - i vores tilfælde Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Du kan se, at vi her bruger variablerne defineret ovenfor.
Netværk og klynger
Lad os nu skabe et netværk, hvor elementer af vores infrastruktur vil kommunikere, tre undernet (et i hver region) og hæve CH- og MySQL-klyngerne.
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 du kan se, er hver af de to klynger bygget til at være ret fejltolerante ved at være placeret i tre tilgængelighedszoner.
Webservere
Det ser ud til, at du kan fortsætte i samme ånd, men jeg løb ind i vanskeligheder. Før det rejste jeg først MySQL-klyngen, og først efter det, ved at kende dets ID, samlede jeg et diskbillede med den ønskede konfiguration, hvor jeg specificerede værten til klyngen. Men nu kender vi ikke klynge-id'et før lanceringen af Terraform, herunder på tidspunktet for billedopbygningen. Så jeg måtte ty til følgende .
Ved at bruge metadatatjenesten fra Amazon sender vi nogle parametre til den virtuelle maskine, som den accepterer og behandler. Vi skal bruge maskinen til at gå til metadataene for klyngens MySQL-vært og til det brugernavn-adgangskode, som brugeren specificerede i Terraform-filen efter start. Ændre lidt indholdet af filen setup.sh, som kører, når den virtuelle maskine er tændt.
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 restartIntance gruppe og balancer
Efter at have genopbygget det nye diskbillede, kan vi endelig tilføje vores fil til Terraform.
Vi angiver, at vi ønsker at bruge et eksisterende diskbillede:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Lad os nu oprette en instansgruppe:
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 er værd at være opmærksom på, hvordan vi gik videre til metadataene cluster_uri, username и password. Det er deres virtuelle maskine, der får den ved opstart og sætter den i Grafana-konfigurationen.
Det handler om balanceren.
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
}
}
}
}Lidt sukker
Der var meget lidt tilbage. Efter at infrastrukturen er implementeret, skal du gå til Grafana UI og manuelt tilføje CH-klyngen (hvis ID du stadig skal have) som en datakilde. Men Terraform kender klynge-id'et. Lad os få ham til at gøre arbejdet færdigt.
Lad os tilføje en ny udbyder - Grafana, og smide balancer-IP'en som vært. Alle ændringer, som Terraform foretager på den maskine, hvor dens balancer bestemmer, vil vokse i MySQL, og derfor på alle andre 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"
}Lad os kæmme
Display balancer IP og ClickHouse klynge vært
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 løbe
Alle! Vores konfigurationsfil er klar, og vi kan ved at indstille variabler bede Terraform om at hæve alt, hvad vi beskrev ovenfor. Hele processen tog mig omkring 15 minutter.
Til sidst kan du se en smuk besked:
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.25Og i skyen vil elementer af den hævede infrastruktur være synlige:
Opsummere
Nu, ved at bruge eksemplet med Grafana, kan I hver især implementere applikationer med vidtstrakt skyarkitektur på Yandex.Cloud-platformen. Nyttige værktøjer fra HashiCorp som Packer og Terraform kan hjælpe dig med dette. Jeg håber nogen finder denne artikel nyttig 🙂
PS Nedenfor vil jeg vedhæfte et link til depotet, hvor du kan finde færdige opskrifter på Packer og Terraform, som jeg citerede fragmenter af i denne artikel.
Kilde: www.habr.com