Hej alla! Som en del av mitt kursarbete 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 behöver du dock sätta upp din egen molnapplikation med en ganska omfattande infrastruktur baserad på dessa tjänster. I den här artikeln vill jag dela med mig av min erfarenhet av att distribuera 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 som analyser kommer att baseras på.
Efter att ha lanserat en virtuell maskin med en webbserver kan du gå till dess värd och få ett vackert användargränssnitt, ange databaser som källor för vidare arbete, skapa instrumentpaneler 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 den vägrar eller 10 personer öppnar användargränssnittet samtidigt, kommer problem att uppstå.
De kan enkelt lösas: du behöver bara... distribuera många identiska virtuella maskiner med en webbserver och placera dem under en L3-balanserare. Men allt är inte så tydligt här. Grafana lagrar användarinställningar (sökvägar till databaser, instrumentpaneler, grafer, etc.) direkt på disken på sin virtuella maskin. Således, om vi ändrar några inställningar i användargränssnittet, kommer dessa ändringar endast att återspeglas på den virtuella maskinen dit balanseraren skickade oss. Detta kommer att leda till inkonsekventa inställningar för vår applikation, vilket orsakar problem med start och användning.
Här kommer ytterligare en databas till undsättning, till exempel MySQL eller motsvarande. Vi säger till Grafana att hon ska lagra användarinställningar i denna "reserv"-databas. Efteråt kommer det att räcka att ange sökvägen till denna databas en gång på varje maskin, och redigera alla andra användarinställningar på någon av de virtuella maskinerna; de kommer att sträcka 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 distribuerar en sådan applikation med ett knapptryck var det nödvändigt att lära sig hur man hanterar var och en av dess komponenter och integrerar dem med varandra.
Här kommer Yandex.Cloud att hjälpa oss, som tillhandahåller L3-balanserare, ClickHouse och MySQL som hanterade tjänster. Användaren behöver bara specificera parametrarna och vänta tills plattformen bringar allt i fungerande skick.
Jag registrerade mig, skapade ett moln och ett betalkonto. Efter det gick jag till molnet och satte upp MySQL och ClickHouse-kluster med minimala inställningar. Jag 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 inloggning och lösenord. Jag kommer inte att gå in på detaljer här - allt är ganska uppenbart i gränssnittet.
Den icke-uppenbara detaljen var att dessa databaser har många värdar, som säkerställer deras feltolerans. Grafana kräver dock exakt en värd för varje databas som den arbetar med. Lång läsning Molnen förde mig till ett beslut. Det visar sig att artens värd c-<cluster_id>.rw.mdb.yandexcloud.net mappad till den aktuella aktiva huvudvärden för klustret med motsvarande ID. Detta är vad vi kommer att ge till Grafana.
webbserver
Nu är det upp till webbservern. Låt oss skapa en vanlig virtuell maskin med Linux och manuellt konfigurera Grafana på den.
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, låt oss köra Grafana under systemctl och installera 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 är det, efter det med ett enkelt kommando
sudo service grafana-server startvi startar webbservern. Nu kan du ange den externa IP-adressen för den virtuella maskinen i webbläsaren, ange port 3000 och se det vackra Grafana-gränssnittet.
Men skynda dig inte, innan du ställer in Grafana måste du komma ihåg att berätta 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. Den obligatoriska raden ser ut så här:
;url =Vi ställer in värden till MySQL-klustret. Samma fil innehåller login och lösenord för att komma åt Grafana i bilden ovan, som som standard båda är lika 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 UI kommer vi att ange ClickHouse som en datakälla.
Jag kunde uppnå en fungerande konfiguration med följande inställningar:
Jag angav som URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Allt! Vi har en fungerande virtuell maskin med en webbserver ansluten till CH och MySQL. Du kan redan ladda upp datamängden till ClickHouse och bygga instrumentpaneler. Men vi har ännu inte uppnått vårt mål och har inte installerat en fullfjädrad infrastruktur.
Packer
Yandex.Cloud låter dig skapa en diskbild av en befintlig virtuell maskin, och på grundval av det - valfritt antal maskiner som är identiska med varandra. Detta är precis vad vi kommer att använda. För att enkelt sätta ihop bilden, ta verktyget från HashiCorp. Den tar som indata en json-fil med instruktioner för att montera bilden.
Vår json-fil kommer att bestå av två block: byggare och provisioner. Det första blocket beskriver parametrarna för själva bilden som en enhet, och det andra blocket beskriver instruktioner för att fylla den med det nödvändiga innehållet.
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 ställa in identifieraren för avsnittet i molnet där du vill skapa bilden, samt sökvägen till filen med nycklarna från tjänstekontot som tidigare skapats i detta avsnitt. Du kan läsa mer om att skapa tjänstekonton och nycklar i form av en fil i motsvarande avsnitt .
Denna konfiguration säger att diskavbildningen kommer att byggas baserat på plattformen ubuntu-1804-lts, placerad i lämplig användarsektion i bildfamiljen GRAFANA under namnet grafana-{{timestamp}}.
Proviantörer
Nu kommer den mer intressanta delen av konfigurationen. Den kommer att beskriva 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 uppdelade i 3 steg. I det första steget exekveras ett enkelt skript som skapar en extra katalog.
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 startas omedelbart efter att den virtuella maskinen har startat. Detta skript kommer att placera användarvariablerna som behöver registreras i Grafana-konfigurationen och starta 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-plugin
3) placera setup.sh-skriptet i startkön direkt efter att du har slagit på 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-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 återstår bara att köra Packer och få utdatabilden placerad i den angivna sektionen. När du skapar en virtuell maskin kan du välja den som startdisk och efter lanseringen får du en färdig Grafana webbserver.
Instansgrupp och balanserare
När vi har en diskavbildning som gör att vi kan skapa många identiska Grafana-webbservrar kan vi skapa en instansgrupp. På Yandex.Cloud-plattformen hänvisar denna term till föreningen av virtuella maskiner som har samma egenskaper. När du skapar en instansgrupp konfigureras prototypen för alla maskiner i denna grupp, och sedan egenskaperna för själva gruppen (till exempel minsta och maximala antalet aktiva maskiner). Om det aktuella numret inte uppfyller dessa kriterier kommer instansgruppen själv att ta bort onödiga maskiner eller skapa nya i sin egen bild.
Som en del av vår uppgift kommer vi att skapa en instansgrupp av webbservrar som kommer att genereras från den tidigare skapade diskavbildningen.
Det som verkligen är anmärkningsvärt är den sista instansgruppens inställning. Målgruppen i integration med Load Balancer hjälper dig att konfigurera en L3-balanserare ovanpå de virtuella maskinerna i denna grupp genom att klicka på ett par knappar.
När jag satte upp balanseraren implementerade jag två viktiga punkter:
- Jag fick balanseraren att acceptera användartrafik på port 80 och omdirigera den till port 3000 på de virtuella maskinerna, exakt där Grafana bor.
- Jag ställer in att kontrollera maskiners livsduglighet genom att pinga dem till port 3000.
Mini sammanfattning
Slutligen kunde vi manuellt distribuera den önskade applikationsinfrastrukturen, och nu har vi en mycket motståndskraftig Grafana-tjänst. Du behöver bara veta balanseringsenhetens IP-adress som ingångspunkt till applikationen och värden för ClickHouse-klustret för att kunna ladda datamängden till den.
Det verkar som en seger? Ja, seger. Men något förvirrar mig fortfarande. Hela processen ovan kräver många manuella steg och är inte skalbar alls, jag skulle vilja automatisera den om möjligt. Detta är vad 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 på en knapp, baserat på flera variabler som skickas av användaren. Låt oss skriva ett recept som kan köras flera gånger i olika delar av olika användare.
Allt arbete med Terraform handlar om att skriva en konfigurationsfil (*.tf) och skapandet av infrastruktur baserad på den.
variabler
Allra i början av filen kommer vi att inkludera variabler som avgör var och hur den framtida infrastrukturen kommer att distribueras.
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 applikationsdistributionsprocessen kommer att handla om att bygga 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. Kan erhållas av .
cloud_id — molnidentifierare där vi kommer att distribuera applikationen
folder_id — avsnittsidentifierare där vi kommer att distribuera applikationen
service_account_id — tjänstkontoidentifierare 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 att komma åt både databaser och Grafana webbserver
dbnamn — databasnamn inuti CH- och MySQL-kluster
public_key_path — sökväg till filen med din offentliga ssh-nyckel, som du kan använda för att ansluta under namnet ubuntu till virtuella maskiner med webbservrar
Leverantörsinställningar
Nu måste 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 kommer att märka att vi här använder variablerna definierade ovan.
Nätverk och kluster
Nu ska vi skapa ett nätverk där delar av vår infrastruktur kommer att 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 du kan se är vart och ett av de två klustren skapade ganska feltoleranta genom att vara placerade i tre tillgänglighetszoner.
Webbservrar
Det verkar som att vi kunde fortsätta i samma anda, men jag stötte på svårigheter. Innan detta tog jag först upp ett MySQL-kluster och först efter det, med kännedom om dess ID, samlade jag en diskavbildning med den nödvändiga konfigurationen, där jag angav värden för klustret. Men nu vet vi inte kluster-ID:t innan vi lanserade Terraform, inklusive när bilden byggdes. Därför var jag tvungen att ta till följande .
Med hjälp av Amazons metadatatjänst kommer vi att skicka några parametrar till den virtuella maskinen, som den kommer att acceptera och bearbeta. Vi behöver maskinen för att gå till metadata bakom MySQL-klustervärden och användarnamn-lösenord, som användaren angav i Terraform-filen, efter start. Låt oss ändra innehållet i filen något setup.sh, som körs när den virtuella maskinen är påslagen.
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 restartIntansgrupp och balanserare
Efter att ha byggt om en ny diskavbildning kan vi äntligen lägga till vår fil för Terraform.
Låt oss indikera att vi vill använda en befintlig diskavbildning:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Låt oss nu 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 skickade det till metadata cluster_uri, username и password. Det är dessa som den virtuella maskinen kommer att ta ut vid start och sätta i Grafana-konfigurationen.
Det är upp till balansören.
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. Efter att infrastrukturen har distribuerats måste du gå till Grafana-gränssnittet och manuellt lägga till CH-klustret (vars ID fortfarande måste erhållas) som en datakälla. Men Terraform känner till kluster-ID:t. Låt oss anförtro honom att få saken att förverkligas.
Låt oss lägga till en ny leverantör - Grafana, och ge henne balanserarens IP-adress som värd. Alla ändringar som Terraform gör på maskinen där dess balansör bestämmer kommer att växa i MySQL, och därför 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 vårt hår
Låt oss visa balanserarens IP-adress 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"
}Kan springa
Allt! Vår konfigurationsfil är klar och vi kan, genom att ställa in variablerna, säga åt Terraform att höja allt som vi beskrev ovan. Hela processen tog mig cirka 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 någon tycker att den här artikeln är användbar :)
PS Nedan kommer jag att bifoga en länk till förvaret där du kan hitta färdiga recept för Packer och Terraform, fragment av vilka jag tillhandahållit i den här artikeln.
Källa: will.com