Mindenki üdvözletét küldi! A szakmai munkám keretében a hazai felhőplatform, lehetőségeit kutattam. A platform különböző szolgáltatásokat kínál gyakorlati feladatok megoldására. Néha azonban szükséges lehet, hogy ezeken a szolgáltatásokon alapulva saját felhős alkalmazást állítsunk be egy elég összetett infrastruktúrával. Ebben a cikkben szeretném megosztani a tapasztalataimat egy ilyen alkalmazás telepítéséről.
Mit szeretnénk elérni?
— egy erőteljes eszközt analitikai feladatok vagy bizonyos rendszerek monitorozásához. Alapértelmezés szerint ez egy virtuális gép Grafana webkiszolgálóval, valamint egy adatbázis (ClickHouse, InfluxDB, stb.) egy adathalmazon, amely alapján az analitika épül.
A webkiszolgálóval rendelkező virtuális gép elindítása után be lehet lépni a hosztra, és egy szép UI-t látni, megadni az adatbázisokat forrásként a további munkához, dashboardokat és grafikákat létrehozni.
Az alap verziónak van egy jelentős hátránya — teljesen nem hibabiztos. Vagyis az alkalmazás működése egyetlen virtuális gép életképességétől függ. Ha az meghibásodik, vagy ha 10 ember egyszerre megnyitja a UI-t, akkor problémák lépnek fel.
Ezeket egyszerűen megoldhatjuk: mindössze… nagyon sok azonos virtuális gépet kell telepíteni webkiszolgálóval, és elhelyezni őket egy L3 terheléselosztó alatt. De itt nem minden olyan egyértelmű. A Grafana tárolja a felhasználói beállításokat (adatbázisok elérési útja, dashboardok, grafikák stb.) közvetlenül a virtuális gépe lemezén. Így ha valamilyen beállítást változtatunk meg a UI-ban, azok a változtatások csak azon a virtuális gépen lesznek érvényesek, ahová a terheléselosztó irányított minket. Ez következetlenséghez vezet a mi alkalmazásunk beállításaiban, problémák merülnek fel a futtatás során és a használat során.
Itt egy másik adatbázis segítségünkre jöhet, például MySQL vagy annak megfelelője. Megmondjuk a Grafanának, hogy a felhasználói beállításokat ebben a "tartalék" adatbázisban kell tárolnia. Ezután elegendő egyszer megadni ezen a gépen az adatbázis elérési útját, és minden más felhasználói beállítást bármelyik virtuális gépen szerkeszteni, azok a többi gépen is meg fognak jelenni.
Íme a végleges alkalmazás infrastruktúrájának tervrajza:
Tanuljuk meg kézzel elindítani
MySQL és ClickHouse
Mielőtt egy ilyen alkalmazást egy gombnyomással telepítenénk, meg kellett tanulnunk kézzel elindítani minden egyes alkotóelemét és integrálni őket egymással.
Ebben segít a Yandex.Cloud, amely L3 terheléselosztókat, ClickHouse-t és MySQL-t kínál managed szolgáltatásként. A felhasználónak csak meg kell adnia a paramétereket és meg kell várnia, amíg a platform mindent működő állapotba hoz.
Regisztráltam, létrehoztam egy felhőt és egy fizetési fiókot. Ezután beléptem a felhőbe, és a minimális beállításokkal elindítottam a MySQL és ClickHouse klasztereket. Megvártam, amíg aktívak lesznek.
Ne felejtsd el létrehozni egy adatbázist minden klaszterben, és beállítani a hozzáférést felhasználónévvel és jelszóval. A részletekbe nem merülnék bele — a felületen minden eléggé nyilvánvaló.
Egy nem nyilvánvaló részlet az volt, hogy ezeknek az adatbázisoknak számos hosztjuk van, amelyek biztosítják a megbízhatóságukat. Azonban a Grafana pontosan egy hosztot igényel minden adatbázisból, amellyel dolgozik. Hosszú olvasás A felhő megoldáshoz vezetett engem. Kiderült, hogy egy olyan hoszt, mint c-<cluster_id>.rw.mdb.yandexcloud.net leképeződik a klaszter aktuális aktív fő hosztjára a megfelelő azonosítóval. Ezt fogjuk átadni a Grafanának.
Webszerver
Most jöhet a webszerver. Indítsunk el egy hagyományos Linux virtuális gépet, és kézzel állítsuk be rajta a Grafanát.
Csatlakozunk SSH-n, és telepítjük a szükséges csomagokat.
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
Ezután a Grafanát elindítjuk a systemctl segítségével, és telepítjük a ClickHouse-szal való együttműködéshez szükséges plugint (igen, az alapcsomagban nem elérhető).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceMinden, ezután egyszerű parancs segítségével
sudo service grafana-server startelindítjuk a webszervert. Most már a böngészőbe beírhatjuk a virtuális gép külső IP-címét, megadhatjuk a 3000-es portot, és láthatjuk a Grafana szép felhasználói felületét.
De nem érdemes sietni, mielőtt beállítanánk a Grafanát, ne felejtsük el megadni neki az utat a MySQL-hez, hogy ott tárolja a beállításokat.
A Grafana webszerver konfigurációja a következő fájlban található /etc/grafana/grafana.ini. A szükséges sor így néz ki:
;url =A MySQL cluster host has been set up. In this file, you will find the login and password for accessing Grafana in the image above, both of which are set to default values. admin.
You can use the sed commands:
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
Now it's time to restart the web server!
sudo service grafana-server restartNow, in the Grafana UI, we will specify ClickHouse as the DataSource.
I managed to achieve a working configuration with the following settings:
I specified the URL as https://c-.rw.mdb.yandexcloud.net:8443
That's it! We have one functional virtual machine with a web server connected to CH and MySQL. You can already upload the dataset to ClickHouse and create dashboards. However, we have not yet reached our goal and deployed a complete infrastructure.
Csomagoló
Yandex.Cloud allows creating a disk image of an existing virtual machine, and based on it, as many identical machines as needed. This is exactly what we will take advantage of. To conveniently gather the image, we will use the tool from HashiCorp. It takes a json file as input with the instructions for building the image.
Our json file will consist of two blocks: builders and provisioners. The first block describes the parameters of the image as an entity, while the second provides instructions for filling it with the necessary content.
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 this template, you need to specify the section identifier in the cloud where you want to create the image, as well as the path to the file with the keys from the service account that has already been set up in this section. You can read more about creating service accounts and keys in file form in the corresponding section. .
This configuration states that the disk image will be built based on the platform ubuntu-1804-lts, placed in the user's corresponding section in the image family GRAFANA under the name grafana-{{timestamp}}.
Provisioners
Most interesting part of the configuration follows. It describes the sequence of actions that need to be taken on the virtual machine before freezing its state into a disk image.
{
...,
"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"
]
}
]
}Here, all actions are divided into 3 stages. The first stage executes a simple script that creates a helper directory.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaIn the next stage, we place a script into this directory that needs to be run immediately after starting the virtual machine. This script will write the user variables into the Grafana configuration and restart the web server.
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 restartAfter that, there are 3 things left to do:
1) install packages
2) set up Grafana under systemctl and install the ClickHouse plugin
3) queue the setup.sh script to run immediately after the virtual machine starts.
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;Now, we need to run Packer and obtain the image placed in the specified section. When creating a virtual machine, it can be selected as the boot disk, allowing us to get a ready Grafana web server after launch.
Instance group and load balancer
Once the disk image has been created to allow for multiple identical Grafana web servers, we can create an instance group. On the Yandex Cloud platform, this term refers to a collection of virtual machines with identical characteristics. When creating an instance group, the prototype of all machines in the group is configured, and then the characteristics of the group itself (for example, the minimum and maximum number of active machines). If the current number does not meet these criteria, the instance group will automatically remove unnecessary machines or create new ones in their stead.
In our task, we will create an instance group of web servers that will be spawned from the previously created disk image.
A legutóbbi példánycsoport beállítása igazán figyelemre méltó. A Load Balancer-rel való integráció célcsoportja lehetővé teszi, hogy néhány gombnyomással beállítsuk az L3 balancert a csoport virtuális gépei fölött.
A balancer beállítása során két fontos dolgot valósítottam meg:
- Úgy alakítottam, hogy a balancer a felhasználói forgalmat a 80-as porton fogadja és azt a virtuális gépek 3000-es portjára irányítsa, ott, ahol a Grafana található.
- Beállítottam a gépek állapotellenőrzését, pingelve őket a 3000-es porton.
Mini összegzés
Végre sikerült kézzel telepítenünk a kívánt alkalmazás-infrastruktúrát, és most már van egy magas rendelkezésre állású Grafana szolgáltatásunk. Csak tudnunk kell a balancer IP-címét, mint belépési pontot az alkalmazásba és a ClickHouse klaszter hosztját, hogy betölthessük az adatállományt.
Úgy tűnik, győzelem? Igen, győzelem. De mégis, valami zavar. Az egész folyamat rengeteg kézi műveletet igényel, és egyáltalán nem skálázható, szeretnénk azt lehetőség szerint automatizálni. Ennek szenteljük a következő részt.
Integráció a Terraformmal
Ismét elővesszük a HashiCorp cég eszközét, amelynek neve . Segítségével egy gombnyomással telepíthetjük az egész alkalmazás-infrastruktúrát, a felhasználó által átadott néhány változó alapján. Írjunk egy receptet, amelyet többször is futtathatunk különböző felhasználók különböző részein.
A Terraformmal végzett összes munka egy konfigurációs fájl (*.tf) megírására és az alapján lévő infrastruktúra létrehozására korlátozódik.
Változók
A fájl elejére kiemeljük a változókat, amelyektől függ, hogy hol és hogyan lesz telepítve a jövőbeli infrastruktúra.
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 = ""
}Az alkalmazás telepítési folyamata a lemezkép összeállítására és e változók kiállítására korlátozódik. Elmagyarázom, hogy mire szolgálnak:
oauth_token — token a felhőhöz való hozzáféréshez. Ezt lehet beszerezni .
cloud_id — a felhő azonosítója, ahol az alkalmazást telepítjük
folder_id — a rész azonosítója, ahol az alkalmazást elindítjuk
service_account_id — a szolgáltatási fiók azonosítója a megfelelő felhőrészben.
image_id — a lemezkép azonosítója, amelyet a Packer segítségével kaptunk
username és password — a felhasználónév és jelszó az adatbázisok és a Grafana webszerver eléréséhez
dbname — az adatbázis neve a CH és MySQL klasztereken belül
public_key_path — a fájl elérési útja, amely az Ön nyilvános ssh-kulcsával rendelkezik, amelyen keresztül csatlakozhat ubuntu a webszerverekkel rendelkező virtuális gépekhez
Szolgáltató konfigurálása
Most be kell állítanunk a Terraform szolgáltatót — a mi esetünkben a Yandexet:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Megjegyezhetjük, hogy itt a fent megadott változókat használjuk.
Hálózat és klaszterek
Most létrehozunk egy hálózatot, amelyben az infrastruktúránk elemei kommunikálnak, három alhálózatot (egy-egy minden régióban), és elindítjuk a CH és MySQL klasztereket.
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
}
}Amint látható, mindkét klaszter meglehetősen hibamentes, mivel három elérhetőségi zónába van telepítve.
Webszerverek
Úgy tűnik, lehetne folytatni ugyanígy, de nehézségbe ütköztem. Korábban először a MySQL klasztert állítottam fel, és csak ezt követően, tudva a klaszter azonosítóját, alakítottam ki a szükséges konfigurációval rendelkező lemezképet, ahol a klaszter hosztját adtam meg. De most nem ismerjük a klaszter azonosítóját a Terraform futtatása előtt, beleértve a lemezkép összeállításának időpontját is. Ezért a következőhöz kellett folyamodnunk .
Az Amazon metaadat-szolgáltatás használatával átadunk néhány paramétert a virtuális gépnek, amelyeket az elfogad és feldolgoz. Szükségünk van arra, hogy a virtuális gép a MySQL klaszter gazdájának és a felhasználónév-jelszónak az adatokat a Terraform fájlban indítás után lekérdezze. Csak enyhén módosítjuk a fájl tartalmát. setup.sh, amely elindul, amikor a virtuális gép bekapcsol.
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 restartPélda csoport és terheléselosztó
Egy új lemezképet létrehozva végre kiegészíthetjük a Terraform fájlunkat.
Meghatározzuk, hogy a meglévő lemezképet szeretnénk használni:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Most létrehozzuk a példacsoportot:
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"
}
}Érdemes figyelni, hogyan adtuk át a metadátában cluster_uri, username és password. Ezt a virtuális gép indításkor kinyeri és beállítja a Grafana konfigurációjában.
Most jön a terheléselosztó.
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
}
}
}
}Egy kis cukor
Már csak egy apróság maradt. Miután az infrastruktúra felállt, el kell menni a Grafana UI-ba, és kézzel hozzáadni a CH klasztert (amelynek ID-jét még be kell szerezni) adatforrásként. De az ID-t a Terraform tudja. Mondjuk meg neki, hogy fejezze be a munkát.
Új szolgáltatót adunk hozzá — Grafanát, és a hosztjaként a terheléselosztó IP-címét illesztjük be. Minden változtatás, amelyet a Terraform a gépen végrehajt, ahová a terheléselosztó irányítja, eljut a MySQL-hez, tehát a többi gépre is.
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"
}Fésülni fogunk
Kilépünk a terheléselosztó IP-címével és a ClickHouse klaszter hosztjával
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"
}Indítható
Kész! A konfigurációs fájlunk készen áll, és a változók beállításával mondhatjuk a Terraformnak, hogy emelje fel az összes fent leírt dolgot. Az egész folyamat körülbelül 15 percet vett igénybe.
A végén láthatunk egy szép üzenetet:
Alkalmazás befejezve! Erőforrások: 9 hozzáadva, 0 megváltoztatva, 0 megsemmisítve.
Kimenetek:
clickhouse_cluster_host = https://c-c9q14ipa2ngadqsbp2iq.rw.mdb.yandexcloud.net:8443
grafana_balancer_ip_address = 130.193.50.25A felhőben láthatóak lesznek a kiemelt infrastruktúra elemei:
Összegzés
Most a Grafana példáján keresztül mindannyian megtanultátok, hogyan kell alkalmazásokat telepíteni a Yandex Felhő platformján, többszintű felhőarchitektúrával. Ebben segíthetnek olyan hasznos eszközök a HashiCorp-tól, mint a Packer és a Terraform. Remélem, hogy ez a cikk valakinek hasznos lesz 🙂
P.S. Lent megosztok egy linket a repozitóriumhoz, ahol kész recepteket találhattok a Packerhez és a Terraformhoz, azokból a részletekből, amiket ebben a cikkben idéztem.
Forrás: habr.com
