Hello everyone! As part of my coursework, I researched the capabilities of a domestic cloud platform such as . The platform offers various services for practical tasks. However, sometimes it's necessary to configure your cloud application based on these services with a sufficiently complex infrastructure. In this article, I want to share my experience in deploying such an application.
What do we want to achieve?
— a powerful tool for solving analytical or monitoring tasks for various systems. In its basic configuration, this includes a virtual machine with a Grafana web server, as well as a database (ClickHouse, InfluxDB, etc.) with a dataset that will be used for analytics.
After launching the virtual machine with the web server, you will be able to access its host and enjoy a beautiful UI, specify databases as sources for further work, and create dashboards and graphs.
La versione base presenta un grave svantaggio: non è affatto ridondante. Ciò significa che l'intera funzionalità dell'applicazione dipende dalla vita di una singola macchina virtuale. Se questa dovesse guastarsi o se dieci persone aprissero l'interfaccia utente contemporaneamente, si verificherebbero dei problemi.
Fortunatamente, questi problemi possono essere risolti facilmente: è sufficiente... implementare diverse macchine virtuali identiche con un server web e metterle sotto un bilanciatore L3. Ma le cose non sono così semplici. Grafana memorizza le impostazioni utente (i percorsi ai database, i dashboard, i grafici, ecc.) direttamente sul disco della sua macchina virtuale. Di conseguenza, se si modificano delle impostazioni nell'interfaccia utente, tali modifiche si rifletteranno solo sulla macchina virtuale a cui ci ha indirizzato il bilanciatore. Questo porterà a impostazioni non coerenti della nostra applicazione, causando problemi di avvio e utilizzo.
Qui qui ci darà una mano è un altro database, come MySQL o un suo equivalente. Diciamo a Grafana che deve memorizzare le impostazioni degli utenti proprio in questo 'database di riserva'. Successivamente, sarà sufficiente indicare una sola volta su ciascuna macchina il percorso a questo database e tutte le altre impostazioni degli utenti potranno essere modificate su una qualsiasi delle macchine virtuali, propagandosi su tutte le altre.
Ecco lo schema dell'infrastruttura finale dell'applicazione:
Impareremo a sollevare a mano
MySQL e ClickHouse
Prima di lanciare un'applicazione del genere con un solo pulsante, è necessario imparare a sollevare manualmente ogni componente e integrarli tra loro.
Qui ci aiuterà Yandex.Cloud, che fornisce bilanciatori L3, ClickHouse e MySQL come servizi gestiti. L'utente deve solo specificare i parametri e aspettare che la piattaforma metta tutto in uno stato operativo.
Mi sono registrato, ho creato un cloud e un account di pagamento. Dopo di che sono entrato nel cloud e ho sollevato i cluster MySQL e ClickHouse con impostazioni minime. Ho atteso finché non sono diventati attivi.
In ogni cluster, è necessario anche ricordarsi di creare un database e configurare l'accesso con login e password. Non entrerò nei dettagli - nell'interfaccia tutto è abbastanza ovvio.
Un aspetto non immediato era che questi database avevano molti host, che garantivano la loro resilienza. Tuttavia, Grafana richiede esattamente un host per ogni database con cui interagisce. Lettura prolungata Il cloud mi ha portato alla soluzione. Risulta che l'host di tipo c-<cluster_id>.rw.mdb.yandexcloud.net viene mappato sul master host attivo corrente del cluster con l'identificativo corrispondente. Proprio questo lo daremo a Grafana.
Server web
Ora tocca al server web. Creiamo una comune macchina virtuale con Linux e configuriamo Grafana manualmente.
Colleghiamoci via ssh e installiamo i pacchetti necessari.
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
Dopo di ciò, avvieremo Grafana tramite systemctl e installeremo il plugin per lavorare con ClickHouse (sì, nella configurazione base non è incluso).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceBene, dopo questo con un semplice comando
sudo service grafana-server startavvieremo il server web. Adesso possiamo inserire l'indirizzo IP esterno della macchina virtuale nel browser, specificare la porta 3000 e vedere l'interfaccia utente di Grafana.
Ma non bisogna avere fretta, prima di configurare Grafana, non scordiamoci di specificare il percorso verso MySQL per memorizzare le impostazioni lì.
Tutta la configurazione del server web di Grafana si trova nel file /etc/grafana/grafana.ini. La riga che ci interessa è questa:
;url =Impostiamo l'host al cluster MySQL. Nello stesso file si trovano il nome utente e la password per accedere a Grafana, che nell'immagine sopra sono entrambi uguali a admin.
Possiamo utilizzare i comandi sed:
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
È il momento di riavviare il server web!
sudo service grafana-server restartOra nell'interfaccia di Grafana indichiamo ClickHouse come DataSource.
Sono riuscito ad ottenere una configurazione funzionante con le seguenti impostazioni:
Come URL ho indicato https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Tutto! Abbiamo una macchina virtuale funzionante con un server web collegato a CH e MySQL. È già possibile caricare il dataset in ClickHouse e costruire dashboard. Tuttavia, non abbiamo ancora raggiunto il nostro obiettivo e non abbiamo distribuito un'infrastruttura completa.
Packer
Yandex.Cloud consente di creare un'immagine del disco di una macchina virtuale esistente, e su essa—quante più macchine identiche possibile. È proprio a questo che ci affideremo. Per creare comodamente l'immagine, utilizzeremo lo strumento di HashiCorp. Accetta come input un file json con le istruzioni per costruire l'immagine.
Il nostro file json sarà composto da due sezioni: builders e provisioners. La prima sezione descrive i parametri dell'immagine stessa come entità, mentre la seconda fornisce le istruzioni per riempirla con il contenuto necessario.
Builders
{
"builders": [
{
"type": "yandex",
"endpoint": "{{user `endpoint`}}",
"folder_id": "",
"subnet_id": "{{user `subnet_id`}}",
"zone": "{{user `zone`}}",
"labels": {},
"use_ipv4_nat": true,
"use_internal_ip": false,
"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 questo template, è necessario specificare l'ID della sezione nel cloud dove si desidera creare l'immagine, nonché il percorso del file contenente le chiavi dell'account di servizio, precedentemente impostato in questa sezione. Per saperne di più su come creare account di servizio e chiavi in formato file, si può leggere nella sezione corrispondente. .
Questa configurazione indica che l'immagine del disco sarà creata sulla base della piattaforma ubuntu-1804-lts, collocata nella sezione appropriata dell'utente nella famiglia delle immagini GRAFANA con il nome grafana-{{timestamp}}.
Provisioners
Ora passiamo alla parte più interessante della configurazione. Qui verrà descritta la sequenza di azioni da eseguire sulla macchina virtuale prima di congelare il suo stato nell'immagine del disco.
{
...,
"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"
]
}
]
}Qui tutte le operazioni sono suddivise in 3 fasi. Nella prima fase, viene eseguito un semplice script che crea una directory ausiliaria.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaNella fase successiva, mettiamo in questa directory lo script che dovrà essere eseguito immediatamente dopo l'avvio della macchina virtuale. Questo script inserirà le variabili utente, necessarie da configurare, nel file di configurazione di Grafana e riavvierà il server web.
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 restartDopo di ciò, rimangono 3 cose da fare:
1) installare i pacchetti
2) avviare Grafana con systemctl e installare il plugin ClickHouse
3) mettere lo script setup.sh nella coda di avvio immediatamente dopo l'accensione della macchina virtuale.
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;Ora non resta che avviare Packer e ottenere un'immagine, posizionata nella sezione specificata. Quando si crea la macchina virtuale, è possibile selezionarla come disco di avvio e ottenere un server web Grafana pronto dopo l'avvio.
Gruppo di istanze e bilanciatore
Dopo la creazione dell'immagine del disco, che consente di generare numerosi server web identici di Grafana, possiamo creare un gruppo di istanze. Sulla piattaforma Yandex.Cloud, questo termine si riferisce a un insieme di macchine virtuali con caratteristiche identiche. Durante la creazione del gruppo di istanze, viene configurato il prototipo di tutte le macchine in quel gruppo, e successivamente anche le caratteristiche del gruppo stesso (ad esempio, il numero minimo e massimo di macchine attive). Se il numero corrente non soddisfa questi criteri, il gruppo di istanze eliminerà autonomamente le macchine non necessarie o ne creerà di nuove secondo il prototipo.
Nell'ambito del nostro compito, creeremo un gruppo di istanze di server web, che saranno generati dall'immagine del disco creata in precedenza.
È particolarmente notevole l'ultima impostazione del gruppo di istanze. Il gruppo target, integrato con il Load Balancer, faciliterà la configurazione di un bilanciatore L3 sopra le macchine virtuali di questo gruppo con solo un paio di clic.
Nella configurazione del bilanciatore, ho implementato due aspetti importanti:
- Ho configurato il bilanciatore per accettare il traffico degli utenti sulla porta 80, reindirizzandolo alla porta 3000 delle macchine virtuali, esattamente dove risiede Grafana.
- Ho impostato il controllo di disponibilità delle macchine, pinguando la porta 3000.
Mini-risultato
Finalmente siamo riusciti a implementare manualmente l'infrastruttura dell'applicazione desiderata e ora abbiamo un servizio Grafana altamente disponibile. È necessario conoscere solo l'indirizzo IP del bilanciatore come punto di accesso all'applicazione e l'hosting del cluster ClickHouse per caricarvi il dataset.
Sembra una vittoria? Sì, una vittoria. Ma qualcosa continua a preoccupare. L'intero processo richiede molte operazioni manuali e non è affatto scalabile, desideriamo automatizzarlo il più possibile. Questa sarà la prossima sezione.
Integrazione con Terraform
Utilizzeremo di nuovo lo strumento dell'azienda HashiCorp chiamato . Questo ci aiuterà a implementare l'intera infrastruttura dell'applicazione premendo un pulsante, basandosi su alcune variabili fornite dall'utente. Scriviamo una ricetta che può essere eseguita ripetutamente in diverse sezioni di diversi utenti.
Tutto il lavoro con Terraform consiste nello scrivere un file di configurazione (*.tf) e nella creazione dell'infrastruttura basata su di esso.
Variabili
All'inizio del file, definiremo le variabili da cui dipende dove e come verrà distribuita l'infrastruttura futura.
variable "oauth_token" {
type = string
default = ""
}
variable "cloud_id" {
type = string
default = ""
}
variable "folder_id" {
type = string
default = ""
}
variable "service_account_id" {
type = string
default = ""
}
variable "image_id" {
type = string
default = ""
}
variable "username" {
type = string
default = ""
}
variable "password" {
type = string
default = ""
}
variable "dbname" {
type = string
default = ""
}
variable "public_key_path" {
type = string
default = ""
}L'intero processo di distribuzione dell'applicazione consisterà nella creazione dell'immagine del disco e nella configurazione di queste variabili. Spiegherò cosa rappresentano:
oauth_token — il token per accedere al cloud. Può essere ottenuto da .
cloud_id — l'identificatore del cloud in cui distribuiamo l'applicazione
folder_id — l'identificatore della sezione in cui distribuiamo l'applicazione
service_account_id — l'identificatore dell'account di servizio nella rispettiva sezione del cloud.
image_id — l'identificatore dell'immagine del disco, ottenuto tramite Packer.
username e password — nome utente e password per accedere a entrambe le basi di dati e al server web Grafana
dbname — nome della base di dati all'interno dei cluster CH e MySQL
public_key_path — percorso del file contenente la tua chiave ssh pubblica, per poterti connettere usando il nome ubuntu alle macchine virtuali con server web
Configurazione del provider
Ora è necessario configurare il provider Terraform — nel nostro caso Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Si può notare che qui stiamo utilizzando le variabili definite in precedenza.
Rete e cluster
Ora creeremo una rete in cui gli elementi della nostra infrastruttura comunicheranno, tre sottoreti (una in ciascuna regione) e avvieremo i cluster CH e MySQL.
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
}
}Come si può notare, ciascuno dei due cluster è stato creato con un'adeguata resilienza grazie alla distribuzione su tre zone di disponibilità.
Server web
Potrebbe sembrare possibile continuare così, ma ho incontrato una difficoltà. In precedenza, avevo prima creato un cluster MySQL e solo dopo, conoscendo il suo ID, costruivo l'immagine del disco con la configurazione necessaria, specificando l'host per il cluster. Ma ora non conosciamo l'ID del cluster prima di avviare Terraform, anche al momento della creazione dell'immagine. Pertanto, sono stato costretto a ricorrere al seguente .
Utilizzando il servizio di metadati di Amazon, passeremo alla macchina virtuale alcuni parametri che essa accetterà e elaborerà. È necessario che, dopo l'avvio, la macchina acceda ai metadati per l'host del cluster MySQL e per il nome utente e la password che l'utente ha fornito nel file Terraform. Cambieremo leggermente il contenuto del file setup.sh, che viene eseguito all'accensione della macchina virtuale.
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 restartGruppo di istanze e bilanciatore
Ricostruendo una nuova immagine del disco, possiamo finalmente completare il nostro file per Terraform.
Specificheremo che vogliamo utilizzare un'immagine di disco esistente:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Adesso creiamo un gruppo di istanze:
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"
}
}È importante notare come abbiamo passato nei metadati cluster_uri, username e password. La loro macchina virtuale, al momento dell'avvio, li recupererà e li inserirà nella configurazione di Grafana.
La palla passa al bilanciatore.
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
}
}
}
}Un po' di zucchero
Rimane solo un passo. Una volta che l'infrastruttura sarà implementata, dovremo andare nell'interfaccia di Grafana e aggiungere manualmente il cluster CH (di cui dobbiamo ancora recuperare l'ID) come Data Source. Ma l'ID del cluster è conosciuto da Terraform. Affidiamogli il compito di completare l'operazione.
Aggiungiamo un nuovo provider – Grafana, e come host le forniremo l'indirizzo IP del bilanciatore. Tutte le modifiche che Terraform farà sulla macchina che il bilanciatore determinerà si rifletteranno in MySQL, e quindi anche su tutte le altre macchine.
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"
}Sistemiamo
Mostreremo l'indirizzo IP del bilanciatore e l'host del cluster ClickHouse
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"
}È possibile avviare
Tutto! Il nostro file di configurazione è pronto e, impostando le variabili, possiamo dire a Terraform di avviare tutto ciò che abbiamo descritto sopra. L'intero processo ha richiesto circa 15 minuti.
Alla fine, si potrà vedere un bel messaggio:
Apply complete! Risorse: 9 aggiunte, 0 modificate, 0 distrutte.
Output:
clickhouse_cluster_host = https://c-c9q14ipa2ngadqsbp2iq.rw.mdb.yandexcloud.net:8443
grafana_balancer_ip_address = 130.193.50.25E nel cloud sarà visibile l'elemento dell'infrastruttura avviata:
Ricapitoliamo
Ora, grazie all'esempio di Grafana, ognuno di voi sa come implementare applicazioni con un'architettura cloud distribuita sulla piattaforma Yandex.Cloud. Strumenti utili di HashiCorp come Packer e Terraform possono esservi di grande aiuto. Spero che questo articolo risulti utile a qualcuno 🙂
P.S. Qui sotto vi lascerò un link al repository, dove potete trovare ricette pronte per Packer e Terraform, di cui ho fornito frammenti in questo articolo.
Fonte: habr.com
