Nasazení distribuovaných služeb v Yandex.Cloud na příkladu Grafana

Ahoj všem! V rámci své seminární práce jsem se zabýval výzkumem možností domácí cloudové platformy, jako je Yandex.Cloud. Tato platforma nabízí různé služby pro řešení praktických úkolů. Někdy je však potřeba nastavit vlastní cloudovou aplikaci s poměrně komplexní infrastrukturou na základě těchto služeb. V tomto článku se chci podělit o zkušenosti s nasazením takové aplikace.

Co bychom chtěli získat?

Grafana — mocný nástroj pro analýzu dat nebo monitoring různých systémů. V základní konfiguraci to je virtuální stroj s webovým serverem Grafana, a také databáze (ClickHouse, InfluxDB atd.) s datasety, na kterých bude analýza založena.

Po spuštění virtuálního stroje s webovým serverem bude možné se přihlásit na jeho hostitele a získat pěkné UI, zadat databáze jako zdroje pro další práci, vytvořit dashboardy a grafy.

Základní verze má jeden zásadní nedostatek — není vůbec vysoce dostupná. To znamená, že veškerá funkčnost aplikace závisí na životaschopnosti jednoho virtuálního stroje. Pokud dojde k jeho selhání, nebo pokud UI otevře současně 10 lidí, mohou nastat problémy.

Řešení je jednoduché: stačí… nasadit více stejných virtuálních strojů s webovým serverem a umístit je pod L3 vyvažovač zátěže. Ale ani tady to není tak jednoznačné. Grafana ukládá uživatelské nastavení (cesty k databázím, dashboardy, grafy atd.) přímo na disk svého virtuálního stroje. Pokud tedy změníte nějaké nastavení v UI, tyto změny se projeví pouze na tom virtuálním stroji, na který nás vyvažovač nasměroval. To povede k nekonzistentním nastavením naší aplikace a vyvstanou problémy při spuštění a používání.

Na pomoc přijde další databáze, například MySQL nebo její ekvivalent. Řekneme Grafaně, že by měla ukládat uživatelská nastavení právě v této "rezervní" databázi. Stačí jednou na každém stroji zadat cestu k této DB a všechna ostatní uživatelská nastavení upravovat na libovolném z virtuálních strojů, která se budou promítat na ostatní.

Toto je schéma konečné infrastruktury aplikace:

Naučíme se ručně zprovoznit

MySQL a ClickHouse

Než začnete používat aplikaci stisknutím tlačítka, musíte se nejprve naučit ručně spouštět každý komponent a integrovat je navzájem.

Zde nám pomůže Yandex.Cloud, který poskytuje L3 vyvážení zátěže, ClickHouse a MySQL jako spravované služby. Uživatel musí pouze zadat parametry a počkat, až platforma vše uvede do funkčního stavu.

Zaregistroval jsem se, vytvořil si cloud a platební účet. Poté jsem se přihlásil do cloudu a spustil klastery MySQL a ClickHouse s minimálním nastavením. Počkal jsem, až se aktivují.

Také nesmíme zapomenout vytvořit v každém klastru databázi a nastavit k ní přístup pomocí uživatelského jména a hesla. Do detailů se zde nebudu pouštět — v rozhraní je vše dost přehledné.

Nejasný detail spočíval v tom, že tyto databáze mají mnoho hostitelů, kteří zajišťují jejich odolnost proti poruchám. Nicméně Grafana vyžaduje přesně jednoho hostitele pro každou databázi, se kterou pracuje. Dlouhé čtení. dokumentaci Cloud mě přivedl k řešení. Ukazuje se, že host typu c-<cluster_id>.rw.mdb.yandexcloud.net se mapuje na aktuální aktivní hlavní hostitele klastru se odpovídajícím ID. Právě jeho poskytneme Grafaně.

Webový server

Teď je na řadě webový server. Spustíme běžnou virtuální mašinu s Linuxem a manuálně na ní nastavíme Grafanu.

Připojíme se přes ssh a nainstalujeme potřebné balíčky.

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 

Po tomto příkazu spustíme Grafanu pod systemctl a nainstalujeme plugin pro práci s ClickHouse (ano, v základní výbavě není dodáván).

sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasource

To je ono, nyní jednoduchým příkazem

sudo service grafana-server start

spustíme webový server. Nyní můžete do prohlížeče zadat externí IP adresu virtuální mašiny, zadat port 3000 a uvidíte krásné uživatelské rozhraní Grafany.

Ale nespěchejte, než začnete nastavovat Grafanu, nezapomeňte jí zadat cestu k MySQL, aby tam mohla ukládat nastavení.

Celá konfigurace webového serveru Grafany je uložena v souboru /etc/grafana/grafana.ini. Potřebný řádek vypadá takto:

;url =

Nastavujeme hostitele pro MySQL klastr. V tomto souboru se nachází uživatelské jméno a heslo pro přístup k Grafaně na obrázku výše, které jsou ve výchozím nastavení oba rovny admin.

Můžete použít příkazy 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

Je čas restartovat webový server!

sudo service grafana-server restart

Nyní v uživatelském rozhraní Grafany nastavíme ClickHouse jako DataSource.

Podařilo se mi dosáhnout funkční konfigurace s následujícími nastaveními:

Jako URL jsem uvedl https://c-.rw.mdb.yandexcloud.net:8443

Hotovo! Máme jednu funkční virtuální mašinu s webovým serverem připojeným k CH a MySQL. Již nyní můžeme nahrávat datové soubory do ClickHouse a vytvářet dashboardy. Nicméně jsme ještě nedosáhli našeho cíle a nevybudovali plnohodnotnou infrastrukturu.

Packer

Yandex.Cloud umožňuje vytvořit obraz disku stávající virtuální mašiny, a na jeho základě - kolik jen chcete identických strojů. Přesně toho se využijeme. Abychom si pohodlně vytvořili obraz, vezmeme si nástroj Packer od HashiCorp. Ten přijímá jako vstup json-soubor s pokyny k vytvoření obrazu.

Náš json-soubor se bude skládat ze dvou bloků: builders a provisioners. První blok popisuje parametry samotného obrazu jako entity, druhý pak instrukce k jeho naplnění potřebným obsahem.

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"
    }
  ],
...
}

V této šabloně je třeba nastavit identifikátor oddílu v cloudu, kde chcete vytvořit obraz, stejně jako cestu k souboru s klíči od služebního účtu, který byl předtím vytvořen v tomto oddílu. Podrobněji o vytváření služebních účtů a klíčů ve formě souboru se můžete dočíst v odpovídající sekci dokumentaci.

Taková konfigurace říká, že obraz disku bude sestaven na základě platformy ubuntu-1804-lts, uložené ve správném oddílu uživatele v rodině obrazů GRAFANA pod názvem grafana-{{timestamp}}.

Provisioners

Nyní přichází zajímavější část konfigurace. Popíše postup, který bude třeba provést na virtuálním stroji, než se jeho stav zmrazí do obrazu disku.

{
..., 
"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"
        ]
        }
  ]
}

Všechny kroky jsou rozděleny do 3 etap. V první fázi se provede jednoduchý skript, který vytvoří pomocný adresář.

prepare-ctg.sh:

#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafana

V další fázi umístíme do tohoto adresáře skript, který bude třeba spustit hned po zapnutí virtuálního stroje. Tento skript vloží uživatelské proměnné, které je třeba zapsat, do konfigurace Grafany a restartuje webový 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 restart

Poté zbývá dokončit 3 úkoly:
1) nainstalovat balíčky
2) zprovoznit Grafanu pomocí systemctl a nainstalovat plugin ClickHouse
3) přidat skript setup.sh do fronty spuštění hned po zapnutí virtuálního stroje.

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-datasource

run-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;

Nyní stačí spustit Packer a získat obraz umístěný ve zvoleném oddílu. Při vytvoření virtuálního stroje si jej lze zvolit jako spouštěcí disk a po spuštění získat hotový webový server Grafany.

Skupina instancí a vyrovnávač zátěže

Jakmile je vytvořen obraz disku, který umožňuje vytvářet spoustu stejných webových serverů Grafany, můžeme vytvořit skupinu instancí. Na platformě Yandex.Cloud tento termín označuje soubor virtuálních strojů se stejnými charakteristikami. Při vytváření skupiny instancí se konfiguruje prototyp všech strojů v této skupině a poté i vlastnosti samotné skupiny (například minimální a maximální počet aktivních strojů). Pokud aktuální počet nebude odpovídat těmto kritériím, skupina instancí sama odstraní nepotřebné stroje nebo vytvoří nové podle daného vzoru.

V rámci našeho úkolu vytvoříme skupinu instancí webových serverů, které budou generovány z dříve vytvořeného obrazu disku.

Opravu zvlášť pozoruhodná je poslední konfigurace instance skupiny. Cílová skupina v integraci s Load Balancerem usnadní nastavení L3-balanceru nad virtuálními stroji této skupiny stisknutím několika tlačítek.

Při konfiguraci balanceru jsem realizoval dva důležité momenty:

1. Nastavil jsem balancer tak, aby přijímal uživatelský provoz na 80. portu a přesměrovával ho na 3000. port virtuálních strojů, právě tam, kde běží Grafana.
2. Nastavil jsem kontrolu životaschopnosti strojů pingováním na 3000. port.

Krátký závěr

Nakonec jsme byli schopni ručně nasadit požadovanou infrastrukturu aplikace a nyní máme vysoce dostupnou službu Grafana. Stačí znát IP adresu balanceru jako vstupní bod do aplikace a hostitele clusteru ClickHouse, abychom do něj nahráli datový soubor.

Zdálo by se, vítězství? Ano, vítězství. Ale něco pořád vyrušuje. Celý proces výše vyžaduje velmi mnoho ručních činností a vůbec se nedá škálovat, chtělo by to ho co možná nejvíce automatizovat. Tomu se bude věnovat další sekce.

Integrace s Terraf orm

Opět využijeme nástroj od společnosti HashiCorp nazvaný Terraform. Pomůže stisknutím tlačítka nasazovat celou infrastrukturu aplikace na základě několika proměnných předaných uživatelským vstupem. Pišme recept, který bude možné spouštět opakovaně v různých sekcích různých uživatelů.

Celá práce s Terraformem se soustředí na psaní konfiguračního souboru (*.tf) a vytváření infrastruktury na jeho základě.

Proměnné

Na začátek souboru umístíme proměnné, od kterých závisí, kde a jak bude budoucí infrastruktura nasazena.

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 = ""
}

Celý proces nasazení aplikace se omezí na sestavení diskového obrazu a nastavení těchto proměnných. Vysvětlím, co za ně odpovídá:

oauth_token — token pro přístup k cloudu. Lze jej získat přes odkazu.
cloud_id — identifikátor cloudu, kde budeme nasazovat aplikaci
folder_id — identifikátor sekce, kde budeme nasazovat aplikaci
service_account_id — identifikátor service účtu v příslušné části cloudu.
image_id — identifikátor obrazového disku, získaného pomocí Packer
uživatelské jméno a heslo — uživatelské jméno a heslo pro přístup k oběma databázím a webovému serveru Grafany
dbname — název databáze uvnitř clusterů CH a MySQL
public_key_path — cesta k souboru s vaším veřejným ssh klíčem, podle kterého se budete moci připojit pod názvem ubuntu k virtuálním strojům s webovými servery

Nastavení poskytovatele

Nyní je třeba nastavit poskytovatele Terraformu — v našem případě Yandex:

provider "yandex" {
  token     = var.oauth_token
  cloud_id  = var.cloud_id
  folder_id = var.folder_id
  zone      = "ru-central1-a"
}

Můžete si všimnout, že zde používáme proměnné, které byly definovány výše.

Síť a clustery

Nyní vytvoříme síť, ve které budou komunikovat prvky naší infrastruktury, tři subnety (po jednom v každém regionu) a zprovozníme clustery CH a 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
  }
}

Jak je možné si všimnout, každý z těchto dvou klastrů byl vytvořen poměrně odolný díky umístění ve třech dostupnostních zónách.

Webové servery

Mohlo by se zdát, že můžeme pokračovat stejným způsobem, ale narazil jsem na komplikaci. Dříve jsem nejprve vytvářel klastr MySQL a teprve poté, s jeho ID, vytvářel obraz disku s požadovanou konfigurací, kde jsem uváděl hostitele k clastru. Ale teď neznáme ID klastru před spuštěním Terraformu, včetně času tvorby obrazu. Proto jsem musel přijít s tímto trikem.

Použitím služby metadat od Amazonu předáme do virtuálního stroje některé parametry, které stroj přijme a zpracuje. Potřebujeme, aby po spuštění šel stroj pro metadata k hostiteli clusteru MySQL a pro uživatelské jméno-heslo, které uživatel uvedl v souboru Terraform. Mírně pozměníme obsah souboru setup.sh, který se spouští při zapnutí virtuálního stroje.

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 restart

Instance skupina a vyvažovač

Po přebudování nového obrazu disku můžeme konečně dokončit náš soubor pro Terraform.

Uvedeme, že chceme použít existující obraz disku:

data "yandex_compute_image" "grafana_image" {
  image_id = var.image_id
}

Nyní vytvoříme instanční skupinu:

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"
  }
}

Je dobré si všimnout, jak jsme předali do metadata cluster_uri, uživatelské jméno a heslo. Právě je virtuální stroj při spuštění vyhledá a vloží do konfigurace Grafany.

Nyní přichází na řadu vyvažovač.

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
      }
    }
  }
}

Trochu cukru

Zbývá už jen málo. Jakmile se infrastruktura nasadí, bude třeba jít do UI Grafany a ručně přidat cluster CH (jehož ID je potřeba ještě zjistit) jako zdroj dat. Ale ID clusteru zná Terraform. Pověříme ho, aby dotáhl věc do konce.

Přidáme nového poskytovatele — Grafanu, a jako hostitele ji dodáme IP adresu load balanceru. Všechny změny, které Terraform provede na stroji, na který ho určí load balancer, se projeví v MySQL, což znamená i na všech ostatních strojích.

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"
}

Učešeme

Získáme IP adresu load balanceru a hostitele clusteru 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"
}

Můžeme spustit

Hotovo! Náš konfigurační soubor je připraven a můžeme, po nastavení proměnných, říct Terraformu, aby zprovoznil vše, co jsme popsali výše. Celý proces mi zabral asi 15 minut.
Na konci uvidíte hezkou zprávu:

Aplikace byla dokončena! Zdroje: 9 přidáno, 0 změněno, 0 zničeno.
Výstupy:

clickhouse_cluster_host = https://c-c9q14ipa2ngadqsbp2iq.rw.mdb.yandexcloud.net:8443
grafana_balancer_ip_address = 130.193.50.25

A v cloudu budou viditelné prvky spuštěné infrastruktury:

Shrnujeme

Nyní na příkladu Grafany umí každý z vás rozšiřovat aplikace s komplexní cloudovou architekturu na platformě Yandex.Cloud. Mohou vám pomoci užitečné nástroje od HashiCorp, jako Packer a Terraform. Doufám, že tato stránka bude někomu užitečná 🙂

P.S. Níže přiložím odkaz na repozitář, ve kterém můžete najít hotové recepty pro Packera a Terraform, z nichž jsem některé uvedl v tomto článku.

Repozitář

Zdroj: habr.com