Witajcie! W ramach pracy zaliczeniowej zajmowałem się badaniem możliwości krajowej platformy chmurowej, takiej jak . Platforma oferuje różne usługi do rozwiązywania praktycznych problemów. Czasami jednak trzeba dostosować swoje chmurowe aplikacje na podstawie tych usług z dość rozbudowaną infrastrukturą. W tym artykule chcę podzielić się doświadczeniem wdrażania takiej aplikacji.
Czego chcemy osiągnąć?
— potężne narzędzie do rozwiązywania zadań analitycznych lub monitorowania różnych systemów. W swojej podstawowej wersji jest to maszyna wirtualna z serwerem WWW Grafany oraz baza danych (ClickHouse, InfluxDB itp.) z zestawem danych, na podstawie którego będzie tworzona analiza.
Po uruchomieniu maszyny wirtualnej z serwerem WWW można zalogować się na jej adres i uzyskać ładny interfejs użytkownika, wskazać bazy danych jako źródła do dalszej pracy, tworzyć pulpity i wykresy.
W podstawowej wersji istnieje jeden istotny niedobór — jest całkowicie nieodporna na awarie. Oznacza to, że całkowita funkcjonalność aplikacji zależy od wytrzymałości jednej maszyny wirtualnej. Jeśli ta maszyna ulegnie awarii lub 10 osób jednocześnie otworzy interfejs użytkownika, mogą wystąpić problemy.
Problemy te można łatwo rozwiązać: wystarczy… wdrożyć wiele identycznych maszyn wirtualnych z serwerem WWW i umieścić je pod równoważnikiem L3. Ale nie wszystko jest takie proste. Grafana przechowuje ustawienia użytkowników (ścieżki do baz danych, pulpity, wykresy itp.) bezpośrednio na dysku swojej maszyny wirtualnej. Tak więc, jeśli zmienisz jakieś ustawienia w interfejsie użytkownika, te zmiany będą widoczne tylko na tej maszynie wirtualnej, na którą wysłał nas równoważnik. To spowoduje niespójne ustawienia naszej aplikacji, co skutkuje problemami z uruchomieniem i użytkowaniem.
Tutaj z pomocą przychodzi kolejna baza danych, na przykład MySQL lub jej odpowiednik. Mówimy Grafanie, że powinna przechowywać ustawienia użytkowników właśnie w tej "zapasu" bazie. Wystarczy raz na każdej maszynie wskazać ścieżkę do tej bazy, a wszystkie inne ustawienia użytkownika edytować na dowolnej z maszyn wirtualnych, będą one propagować się na pozostałe.
Oto schemat końcowej infrastruktury aplikacji:
Nauczymy się ręcznie uruchamiać
MySQL i ClickHouse
Zanim uruchomisz taką aplikację za pomocą jednego kliknięcia, musisz nauczyć się samodzielnie wznosić każdy jej komponent i integrować je ze sobą.
W tym pomoże nam Yandex.Cloud, który oferuje L3 balancery, ClickHouse i MySQL jako usługi zarządzane. Użytkownik musi tylko określić parametry i poczekać, aż platforma wszystko przygotuje do działania.
Zarejestrowałem się, stworzyłem swoje chmurę i konto płatności. Po tym wszedłem do chmury i uruchomiłem klastry MySQL i ClickHouse z minimalnymi ustawieniami. Poczekałem, aż staną się aktywne.
Nie zapomnij również stworzyć bazy danych w każdym klastrze i skonfigurować do niej dostęp za pomocą loginu i hasła. Nie będę się tutaj zagłębiać w szczegóły — w interfejsie wszystko jest dość oczywiste.
Nieoczywistym szczegółem było to, że te bazy danych mają wiele hostów, które zapewniają ich odporność na awarie. Jednak Grafana wymaga dokładnie jednego hosta dla każdej bazy danych, z którą pracuje. Długie czytanie Chmura doprowadziła mnie do rozwiązania. Okazuje się, że host w formie c-<cluster_id>.rw.mdb.yandexcloud.net mapuje się na aktualnego aktywnego master-hosta klastra z odpowiednim identyfikatorem. To właśnie jego przekażemy Grafanie.
Serwer WWW
Teraz sprawa leży po stronie serwera www. Uruchomimy zwykłą maszynę wirtualną z Linuxem i ręcznie skonfigurujemy na niej Grafanę.
Podłączymy się przez ssh i zainstalujemy potrzebne pakiety.
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 tym uruchomimy Grafanę za pomocą systemctl i zainstalujemy wtyczkę do pracy z ClickHouse (tak, w podstawowej wersji nie jest dostarczana).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceWszystko, po tym po prostu uruchamiamy komendą
sudo service grafana-server starturuchomimy serwer www. Teraz możemy w przeglądarce wpisać zewnętrzny adres IP maszyny wirtualnej, wskazać port 3000 i zobaczyć piękny UI Grafany.
Ale nie ma co się śpieszyć, zanim skonfigurujesz Grafanę, nie zapomnij podać jej ścieżki do MySQL, aby przechowywać tam ustawienia.
Cała konfiguracja serwera www Grafany znajduje się w pliku /etc/grafana/grafana.ini. Potrzebny wiersz wygląda tak:
;url =Ustawiamy hosting do klastra MySQL. W tym samym pliku znajdują się login i hasło do Grafany na powyższym zdjęciu, które domyślnie są równe. admin.
Można skorzystać z komend 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
Czas na ponowne uruchomienie serwera WWW!
sudo service grafana-server restartTeraz w interfejsie użytkownika Grafany ustawimy ClickHouse jako źródło danych.
Uzyskałem działającą konfigurację przy następujących ustawieniach:
Jako URL podałem https://c-.rw.mdb.yandexcloud.net:8443
To wszystko! Mamy jedną działającą maszynę wirtualną z serwerem WWW podłączonym do CH i MySQL. Już można ładować zestaw danych do ClickHouse i budować pulpit nawigacyjny. Jednak jeszcze nie osiągnęliśmy naszego celu i nie wdrożyliśmy pełnoprawnej infrastruktury.
Packer
Yandex.Cloud pozwala utworzyć obraz dysku istniejącej maszyny wirtualnej, a na jego podstawie — dowolną liczbę identycznych maszyn. Skorzystamy z tego. Aby wygodnie zbudować obraz, weźmiemy narzędzie od HashiCorp. Przyjmuje ono plik json z instrukcją dotyczącą budowy obrazu.
Nasz plik json będzie składał się z dwóch bloków: builders i provisioners. Pierwszy blok opisuje parametry samego obrazu jako encji, a drugi – instrukcję dotyczącą wypełnienia go potrzebną zawartością.
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"
}
],
...
}W tym szablonie należy ustawić identyfikator sekcji w chmurze, w której chcesz utworzyć obraz, a także ścieżkę do pliku z kluczami konta usługowego, które wcześniej zostało założone w tej sekcji. Więcej o tworzeniu kont usługowych i kluczach w formie pliku można przeczytać w odpowiedniej sekcji. .
Taka konfiguracja oznacza, że obraz dysku zostanie zbudowany na podstawie platformy ubuntu-1804-lts, umieszczony w odpowiedniej sekcji użytkownika w rodzinie obrazów GRAFANA pod nazwą grafana-{{timestamp}}.
Provisioners
Teraz bardziej interesująca część konfiguracji. Opisze ona sekwencję działań, które należy wykonać na maszynie wirtualnej przed zamrożeniem jej stanu w obrazie dysku.
{
...,
"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"
]
}
]
}Wszystkie działania zostały podzielone na 3 etapy. W pierwszym etapie wykonuje się prosty skrypt, który tworzy pomocniczy folder.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaW następnym etapie umieszczamy w tym folderze skrypt, który należy uruchomić zaraz po uruchomieniu maszyny wirtualnej. Skrypt ten umieści zmienne użytkownika, które trzeba zapisać, w konfiguracji Grafany i zrestartuje serwer WWW.
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 restartPo tym pozostaje zrobić 3 rzeczy:
1) zainstalować pakiety
2) uruchomić Grafanę za pomocą systemctl i zainstalować wtyczkę ClickHouse
3) dodać skrypt setup.sh do kolejki uruchamiania zaraz po włączeniu maszyny wirtualnej.
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;Teraz pozostaje uruchomić Packer i uzyskać obraz umieszczony w wskazanej lokalizacji. Podczas tworzenia maszyny wirtualnej można wybrać go jako dysk rozruchowy i po uruchomieniu otrzymać gotowy serwer WWW Grafany.
Grupa instancji i load balancer
Po utworzeniu obrazu dysku, który pozwala tworzyć wiele identycznych serwerów WWW Grafany, możemy stworzyć grupę instancji. Na platformie Yandex.Cloud termin ten odnosi się do zbioru maszyn wirtualnych o identycznych charakterystykach. Podczas tworzenia grupy instancji konfigurowany jest prototyp wszystkich maszyn w tej grupie, a następnie same parametry grupy (na przykład minimalna i maksymalna liczba aktywnych maszyn). Jeśli bieżąca liczba nie będzie odpowiadać tym kryteriom, grupa instancji sama usunie niepotrzebne maszyny lub stworzy nowe na podstawie wzoru.
W ramach naszego zadania stworzymy grupę instancji serwerów WWW, które będą powstawać z wcześniej utworzonego obrazu dysku.
Naprawdę godna uwagi jest ostatnia konfiguracja grupy instancji. Docelowa grupa w integracji z Load Balancerem pomoże w prosty sposób skonfigurować balancer L3 na maszynach wirtualnych tej grupy.
Podczas konfigurowania balancera wprowadziłem dwa ważne aspekty:
- Ustawiłem balancer, aby przyjmował ruch użytkowników na porcie 80, a przekierowywał go na port 3000 maszyn wirtualnych, dokładnie tam, gdzie znajduje się Grafana.
- Skonfigurowałem sprawdzanie żywotności maszyn, pingując je na porcie 3000.
Mini-podsumowanie
W końcu udało nam się ręcznie wdrożyć pożądaną infrastrukturę aplikacji, a teraz mamy wysoko dostępny serwis Grafana. Wystarczy znać adres IP balancera jako punkt wejścia do aplikacji oraz host klastra ClickHouse, aby załadować zestaw danych.
Wygląda na to, że mamy zwycięstwo? Tak, to prawda. Ale coś wciąż niepokoi. Cały powyższy proces wymaga bardzo wielu działań ręcznych i zupełnie się nie skalują, chcemy go zautomatyzować w miarę możliwości. Temu poświęcimy następny dział.
Integracja z Terraform
Ponownie skorzystamy z narzędzia od firmy HashiCorp o nazwie . Pomoże nam w prosty sposób wdrożyć całą infrastrukturę aplikacji, opierając się na kilku zmiennych przekazanych przez użytkownika. Napiszmy przepis, który będzie mógł być wielokrotnie uruchamiany w różnych sekcjach różnych użytkowników.
Cała praca z Terraform sprowadza się do napisania pliku konfiguracyjnego (*.tf) i utworzenia infrastruktury na jego podstawie.
Zmienne
Na samym początku pliku umieścimy zmienne, od których zależy, gdzie i jak będzie wdrożona przyszła infrastruktura.
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 = ""
}Cały proces wdrożenia aplikacji będzie sprowadzać się do zbudowania obrazu dysku i ustawienia tych zmiennych. Wyjaśnię, za co odpowiadają:
oauth_token — token dostępu do chmury. Można go uzyskać poprzez .
cloud_id — identyfikator chmury, w której będziemy wdrażać aplikację
folder_id — identyfikator sekcji, w której będziemy rozwijać aplikację
service_account_id — identyfikator konta usługi w odpowiedniej sekcji chmury.
image_id — identyfikator obrazu dysku, uzyskanego za pomocą Packer
nazwa użytkownika i hasło — nazwa użytkownika i hasło do obu baz danych oraz serwera WWW Grafany
dbname — nazwa bazy danych w obrębie klastrów CH i MySQL
public_key_path — ścieżka do pliku z Twoim publicznym kluczem ssh, przy użyciu którego można będzie łączyć się pod nazwą ubuntu do maszyn wirtualnych z serwerami WWW
Konfiguracja dostawcy
Teraz musimy skonfigurować dostawcę Terraform — w naszym przypadku Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Można zauważyć, że tutaj używamy zmiennych zdefiniowanych powyżej.
Sieć i klastry
Teraz utworzymy sieć, w której będą komunikować się elementy naszej infrastruktury, trzy podsieci (po jednej w każdym regionie) oraz uruchomimy klastry CH i 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 można zauważyć, każdy z dwóch klastrów został stworzony z wystarczającą odpornością na awarie dzięki umiejscowieniu w trzech strefach dostępności.
Serwery webowe
Mogłoby się wydawać, że można kontynuować w tym samym duchu, ale napotkałem na trudności. Wcześniej najpierw uruchamiałem klaster MySQL, a dopiero potem, znając jego ID, budowałem obraz dysku z potrzebną konfiguracją, gdzie wskazywałem hosta do klastra. Teraz jednak nie znamy ID klastra przed uruchomieniem Terraform, w tym w momencie budowy obrazu. W związku z tym musiałem sięgnąć po następujący .
Korzystając z metadanych Amazon, przekażemy do maszyny wirtualnej kilka parametrów, które ona przyjmie i przetworzy. Musimy, aby po uruchomieniu maszyna zasięgnęła metadanych dla hosta klastra MySQL oraz dla nazwy użytkownika i hasła, które użytkownik podał w pliku Terraform. Niewiele zmienimy w zawartości pliku setup.sh, który uruchamia się przy włączeniu maszyny wirtualnej.
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 restartGrupa instancji i zrównoważony ruch
Po odbudowaniu nowego obrazu dysku, w końcu możemy dopisać nasz plik dla Terraform.
Określimy, że chcemy użyć istniejącego obrazu dysku:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Teraz stworzymy grupę instancji:
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"
}
}Warto zwrócić uwagę na to, jak przekazaliśmy do metadanych cluster_uri, nazwa użytkownika i hasło. To właśnie te dane maszyna wirtualna pobierze przy uruchomieniu i umieści w konfiguracji Grafany.
Teraz czas na zrównoważony ruch.
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
}
}
}
}Trochę cukru
Zostało już niewiele. Po tym, jak infrastruktura będzie rozwinięta, trzeba będzie wejść do UI Grafany i ręcznie dodać klaster CH (którego ID trzeba jeszcze zdobyć) jako Źródło Danich. Ale Terraform zna ID klastra. Powierzymy mu doprowadzenie sprawy do końca.
Dodamy nowego dostawcę — Grafanę, a jako host podsunę jej adres IP balansatora. Wszystkie zmiany, które Terraform wprowadzi na maszynie, do której skieruje go balansator, będą odzwierciedlone w MySQL, a więc również na wszystkich pozostałych maszynach.
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"
}Uczeszemy
Wyciągniemy adres IP balansatora oraz hosta klastra 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"
}Można uruchamiać
To wszystko! Nasz plik konfiguracyjny jest gotowy i można, ustawiając zmienne, powiedzieć Terraformowi, żeby uruchomił wszystko, co opisaliśmy powyżej. Cały proces zajął mi około 15 minut.
Na końcu można zobaczyć ładny komunikat:
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.25A w chmurze będą widoczne elementy podniesionej infrastruktury:
Podsumujmy
Teraz na przykładzie Grafany każdy z was potrafi wdrażać aplikacje z rozbudowaną architekturą chmurową na platformie Yandex.Cloud. W tym mogą pomóc takie przydatne narzędzia od HashiCorp, jak Packer i Terraform. Mam nadzieję, że artykuł okaże się przydatny dla kogoś 🙂
P.S. Poniżej zamieszczę link do repozytorium, w którym można znaleźć gotowe przepisy dla Packera i Terraform, fragmenty których przytaczałem w tym artykule.
Źródło: habr.com
