Hallo zusammen! Im Rahmen meiner Studienarbeit habe ich die Möglichkeiten einer inländischen Cloud-Plattform untersucht, wie . Die Plattform bietet verschiedene Dienste zur Lösung praktischer Aufgaben an. Manchmal ist es jedoch notwendig, auf der Grundlage dieser Dienste eine eigene Cloud-Anwendung mit einer umfangreichen Infrastruktur einzurichten. In diesem Artikel möchte ich meine Erfahrungen bei der Bereitstellung einer solchen Anwendung teilen.
Was möchten wir erreichen?
— ein leistungsstarkes Werkzeug zur Lösung analytischer Aufgaben oder zur Überwachung bestimmter Systeme. In seiner Grundausstattung handelt es sich um eine virtuelle Maschine mit einem Grafana-Webserver sowie einer Datenbank (ClickHouse, InfluxDB usw.) mit einem Datensatz, auf dessen Grundlage die Analytik aufgebaut wird.
Nach dem Start der virtuellen Maschine mit dem Webserver kann auf dessen Host zugegriffen werden, um eine ansprechende Benutzeroberfläche zu erhalten, Datenbanken als Quellen für die weitere Arbeit anzugeben und Dashboards sowie Grafiken zu erstellen.
Die Basisversion hat einen erheblichen Nachteil – sie ist vollständig nicht fehlertolerant. Das bedeutet, dass die gesamte Funktionsfähigkeit der Anwendung von der Lebensfähigkeit einer einzelnen virtuellen Maschine abhängt. Wenn diese ausfällt oder zehn Personen gleichzeitig die Benutzeroberfläche öffnen, treten Probleme auf.
Diese Probleme lassen sich jedoch einfach lösen: Man muss lediglich mehrere identische virtuelle Maschinen mit einem Webserver bereitstellen und diese hinter einen L3-Lastausgleich setzen. Doch es ist nicht ganz so einfach. Grafana speichert die Benutzereinstellungen (Datenbankpfade, Dashboards, Grafiken usw.) direkt auf der Festplatte seiner virtuellen Maschine. Wenn also einige Einstellungen in der Benutzeroberfläche geändert werden, wirken sich diese Änderungen nur auf die virtuelle Maschine aus, auf die der Lastausgleich uns gelenkt hat. Dies führt zu inkonsistenten Einstellungen in unserer Anwendung und kann Probleme beim Start und der Nutzung verursachen.
Hier kommt eine weitere Datenbank ins Spiel, zum Beispiel MySQL oder ein entsprechendes Pendant. Wir geben Grafana den Befehl, die Benutzereinstellungen in dieser "Backup"-Datenbank zu speichern. Anschließend genügt es, auf jeder Maschine einmal den Pfad zu dieser DB anzugeben, während alle anderen Benutzereinstellungen auf jeder der virtuellen Maschinen bearbeitet werden können und auf die restlichen durchschlagen.
Hier ist das Schema der endgültigen Anwendungsinfrastruktur:
Lernen wir, es manuell aufzubauen
MySQL und ClickHouse
Bevor wir eine solch Anwendung mit einem einzigen Klick bereitstellen, mussten wir lernen, jedes ihrer Komponenten manuell zu installieren und sie miteinander zu integrieren.
Dazu nutzen wir Yandex.Cloud, das L3-Lastverteilern, ClickHouse und MySQL als Managed-Services anbietet. Der Benutzer muss lediglich die Parameter angeben und warten, bis die Plattform alles betriebsbereit macht.
Ich habe mich registriert, eine Cloud und ein Zahlungsprofil erstellt. Danach bin ich in die Cloud gegangen und habe Cluster für MySQL und ClickHouse mit minimalen Einstellungen hochgezogen. Ich habe gewartet, bis sie aktiv wurden.
Es ist auch wichtig, in jedem Cluster eine Datenbank zu erstellen und den Zugriff darauf mit Benutzername und Passwort einzurichten. Ich werde hier nicht ins Detail gehen – im Interface ist alles ziemlich offensichtlich.
Ein weniger offensichtlicher Aspekt war, dass diese Datenbanken über mehrere Hosts verfügen, die ihre Ausfallsicherheit gewährleisten. Allerdings benötigt Grafana genau einen Host für jede Datenbank, mit der sie arbeitet. Längeres Lesen. Die Cloud hat mich zur Lösung geführt. Es stellt sich heraus, dass ein Host vom Typ c-<cluster_id>.rw.mdb.yandexcloud.net auf den aktuellen aktiven Master-Host des Clusters mit der entsprechenden ID gemappt wird. Genau diesen werden wir Grafana übergeben.
Webserver
Jetzt liegt es am Webserver. Lassen Sie uns eine herkömmliche virtuelle Maschine mit Linux hochfahren und Grafana manuell einrichten.
Wir verbinden uns per SSH und installieren die benötigten Pakete.
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
Anschließend lassen wir Grafana über systemctl starten und installieren das Plugin für die Arbeit mit ClickHouse (ja, es wird in der Basisversion nicht mitgeliefert).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceNachdem wir das erledigt haben, starten wir den Webserver mit dem einfachen Befehl
sudo service grafana-server start. Jetzt können Sie die öffentliche IP-Adresse der virtuellen Maschine und den Port 3000 in den Browser eingeben, um die ansprechende Benutzeroberfläche von Grafana zu sehen.
Aber eilen Sie nicht, bevor Sie Grafana konfigurieren, denken Sie daran, den Pfad zu MySQL anzugeben, damit die Einstellungen dort gespeichert werden.
Die gesamte Konfiguration des Grafana-Webservers befindet sich in der Datei /etc/grafana/grafana.ini. Die benötigte Zeile sieht so aus:
;url =Wir setzen den Host des MySQL-Clusters. In dieser Datei befinden sich auch der Benutzername und das Passwort für den Zugriff auf Grafana, die standardmäßig beide gleich sind admin.
Sie können sed-Befehle verwenden:
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
Es ist jetzt an der Zeit, den Webserver neu zu starten!
sudo service grafana-server restartJetzt geben wir im UI von Grafana ClickHouse als Datenquelle an.
Ich habe eine funktionierende Konfiguration mit den folgenden Einstellungen erreicht:
Als URL habe ich angegeben https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Alles ist bereit! Wir haben eine funktionsfähige virtuelle Maschine mit einem Webserver, der mit ClickHouse und MySQL verbunden ist. Jetzt können wir den Datensatz in ClickHouse hochladen und Dashboards erstellen. Dennoch haben wir unser Ziel noch nicht erreicht und die vollständige Infrastruktur noch nicht bereitgestellt.
Packer
Yandex.Cloud ermöglicht es, ein Image der bestehenden virtuellen Maschine zu erstellen, und darauf basierend beliebig viele identische Maschinen zu erzeugen. Genau das werden wir nutzen. Um das Image bequem zu erstellen, verwenden wir das Tool von HashiCorp. Es erwartet eine JSON-Datei mit den Anweisungen zur Erstellung des Images.
Unsere JSON-Datei wird aus zwei Blöcken bestehen: Builders und Provisioners. Der erste Block beschreibt die Parameter des Images als Entität, während der zweite die Anweisungen zur Befüllung mit dem erforderlichen Inhalt enthält.
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 dieser Vorlage müssen Sie die ID des Cloud-Bereichs angeben, in dem Sie das Abbild erstellen möchten, sowie den Pfad zur Datei mit den Schlüsseln des zuvor in diesem Bereich eingerichteten Dienstkontos. Weitere Informationen zur Erstellung von Dienstkonten und Schlüsseln im Dateiformat finden Sie im entsprechenden Abschnitt. .
Diese Konfiguration gibt an, dass das Disk-Image auf Grundlage der Plattform ubuntu-1804-ltserzeugt wird, und im entsprechenden Bereich des Nutzers in der Bildfamilie gespeichert wird. GRAFANA unter dem Namen grafana-{{timestamp}}.
Bereitstellungseinheiten
Jetzt kommt der interessantere Teil der Konfiguration. Hier wird die Reihenfolge der Schritte beschrieben, die auf der virtuellen Maschine ausgeführt werden müssen, bevor ihr Zustand in ein Disk-Image eingefroren wird.
{
...,
"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"
]
}
]
}Alle Aktionen sind in 3 Phasen unterteilt. In der ersten Phase wird ein einfaches Skript ausgeführt, das ein Hilfsverzeichnis erstellt.
prepare-ctg.sh:
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaIn der nächsten Phase platzieren wir in diesem Verzeichnis ein Skript, das sofort nach dem Start der virtuellen Maschine ausgeführt werden muss. Dieses Skript wird benutzerdefinierte Variablen, die in die Grafana-Konfiguration eingetragen werden müssen, hinzufügen und den Webserver neu starten.
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 restartDanach sind noch 3 Dinge zu erledigen:
1) Pakete installieren
2) Grafana unter systemctl einrichten und das ClickHouse-Plugin installieren
3) Das Skript setup.sh in die Startwarteschlange nach dem Einschalten der virtuellen Maschine einfügen.
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;Jetzt bleibt noch, Packer zu starten und das Image zu erhalten, das im angegebenen Verzeichnis gespeichert ist. Bei der Erstellung der virtuellen Maschine kann dieses als Bootlaufwerk ausgewählt werden, um anschließend einen funktionsbereiten Grafana-Webserver zu erhalten.
Instanzgruppe und Load Balancer
Nachdem das Disk-Image erstellt wurde, das es ermöglicht, mehrere identische Grafana-Webserver zu erzeugen, können wir eine Instanzgruppe erstellen. Auf der Yandex.Cloud-Plattform bezeichnet dieser Begriff eine Zusammenstellung von virtuellen Maschinen mit identischen Eigenschaften. Bei der Erstellung einer Instanzgruppe wird ein Prototyp aller Maschinen in dieser Gruppe konfiguriert, gefolgt von den Eigenschaften der Gruppe selbst (zum Beispiel die minimale und maximale Anzahl aktiver Maschinen). Wenn die aktuelle Anzahl nicht den Kriterien entspricht, entfernt die Instanzgruppe selbst die überflüssigen Maschinen oder erstellt neue nach dem gegebenen Modell.
Im Rahmen unserer Aufgabe werden wir eine Instanzgruppe von Webservern erstellen, die aus dem zuvor erstellten Disk-Image hervorgehen.
Besonders bemerkenswert ist die letzte Einstellung der Instanzgruppe. Die Zielgruppe in der Integration mit dem Load Balancer ermöglicht es, mit nur wenigen Klicks den L3-Lastenausgleich über den virtuellen Maschinen dieser Gruppe zu konfigurieren.
Bei der Konfiguration des Lastenausgleichs habe ich zwei wichtige Punkte umgesetzt:
- Ich habe den Load Balancer so konfiguriert, dass er den benutzerdefinierten Traffic auf Port 80 entgegen nimmt und diesen an Port 3000 der virtuellen Maschinen weiterleitet, wo Grafana läuft.
- Ich habe die Überprüfung der Lebensfähigkeit der Maschinen eingerichtet, indem ich sie auf Port 3000 anpinge.
Kurzes Fazit
Endlich haben wir die gewünschte Anwendungsinfrastruktur manuell bereitgestellt, und jetzt haben wir einen hochverfügbaren Grafana-Service. Man muss nur die IP-Adresse des Load Balancers als Einstiegspunkt zur Anwendung und den Host-Cluster von ClickHouse kennen, um das Datenset hochzuladen.
Könnte man sagen, ein Sieg? Ja, ein Sieg. Aber irgendetwas stört. Der gesamte Prozess oben erfordert sehr viele manuelle Schritte und ist überhaupt nicht skalierbar, weshalb ich ihn so gut wie möglich automatisieren möchte. Dies wird das Thema des nächsten Abschnitts sein.
Integration mit Terraform
Wir werden wieder das Tool von HashiCorp nutzen, das heißt. Damit können wir auf Knopfdruck die gesamte Anwendungsinfrastruktur basierend auf mehreren vom Benutzer übergebenen Variablen bereitstellen. Lassen Sie uns ein Rezept schreiben, das wiederholt in verschiedenen Bereichen verschiedener Benutzer ausgeführt werden kann.
Alle Arbeiten mit Terraform bestehen aus dem Schreiben einer Konfigurationsdatei (*.tf) und dem Erstellen einer darauf basierenden Infrastruktur.
Variablen
Zu Beginn der Datei definieren wir die Variablen, von denen abhängt, wo und wie die zukünftige Infrastruktur bereitgestellt wird.
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 = ""
}Der gesamte Prozess der Bereitstellung der Anwendung besteht darin, ein Disk-Image zu erstellen und diese Variablen zu setzen. Ich erläutere, wofür sie verantwortlich sind:
oauth_token — Token für den Zugang zur Cloud. Kann erhalten werden über .
cloud_id — die ID der Cloud, in der wir die Anwendung bereitstellen werden
folder_id — die ID des Verzeichnisses, in dem wir die Anwendung bereitstellen werden
service_account_id — die ID des Servicekontos im entsprechenden Abschnitt der Cloud.
image_id — die ID des Disk-Images, das mit Packer erstellt wurde.
Benutzername und password — Benutzername und Passwort für den Zugriff auf beide Datenbanken und den Grafana-Webserver
dbname — Name der Datenbank innerhalb der CH- und MySQL-Cluster
public_key_path — Pfad zur Datei mit Ihrem öffentlichen SSH-Schlüssel, um sich unter dem Namen ubuntu mit virtuellen Maschinen mit Webservern zu verbinden
Provider-Konfiguration
Nun müssen wir den Terraform-Provider konfigurieren – in unserem Fall Yandex:
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Es ist zu beachten, dass wir hier die oben definierten Variablen verwenden.
Netzwerk und Cluster
Jetzt erstellen wir ein Netzwerk, in dem die Elemente unserer Infrastruktur kommunizieren, drei Subnetze (je eines in jeder Region) und starten die Cluster CH und 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
}
}Wie zu erkennen ist, wurden beide Cluster ausreichend ausfallsicher gestaltet, indem sie in drei Verfügbarkeitszonen platziert wurden.
Webserver
Es könnte den Anschein haben, dass man so weitermachen kann, doch ich stieß auf ein Problem. Zuvor habe ich immer zuerst einen MySQL-Cluster eingerichtet und danach, mit dessen ID, das Disk-Image mit der benötigten Konfiguration erstellt, wobei ich den Host des Clusters angegeben habe. Aber jetzt wissen wir die ID des Clusters vor dem Start von Terraform nicht, selbst nicht zum Zeitpunkt der Erstellung des Images. Daher mussten wir auf den folgenden .
Zur Verwendung des Metadatenservices von Amazon werden wir der virtuellen Maschine einige Parameter übergeben, die sie annehmen und verarbeiten wird. Wir müssen sicherstellen, dass die Maschine nach dem Start die Metadaten für den MySQL-Cluster-Host sowie für den Benutzernamen und das Passwort abruft, die der Benutzer in der Terraform-Datei angegeben hat. Wir werden den Inhalt der Datei setup.sh, die beim Start der virtuellen Maschine ausgeführt wird, leicht anpassen.
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 restartInstanzgruppe und Lastenausgleich
Nachdem wir das neue Disk-Image erstellt haben, können wir endlich unsere Datei für Terraform ergänzen.
Wir geben an, dass wir ein bestehendes Disk-Image verwenden möchten:
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Jetzt erstellen wir eine Instanzgruppe:
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"
}
}Es ist wichtig, wie wir in die Metadaten übergeben haben cluster_uri, Benutzername und password. Diese Informationen wird die virtuelle Maschine beim Starten abrufen und in die Konfiguration von Grafana einfügen.
Jetzt ist der Load Balancer dran.
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
}
}
}
}Ein wenig Zucker
Es ist nur noch ein kleiner Schritt. Nachdem die Infrastruktur bereitgestellt ist, müssen wir in das Grafana-UI gehen und manuell den CH-Cluster (dessen ID wir noch herausfinden müssen) als Datenquelle hinzufügen. Aber die ID des Clusters kennt Terraform. Lassen Sie uns ihm die Aufgabe übertragen, dies abzuschließen.
Wir fügen einen neuen Anbieter hinzu – Grafana, und übergeben ihr die IP-Adresse des Load Balancers als Host. Alle Änderungen, die Terraform auf der Maschine vornimmt, die es durch den Load Balancer bestimmt, werden in MySQL gespeichert, was bedeutet, dass sie auch auf allen anderen Maschinen wirksam sind.
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"
}Wir machen es ordentlich
Wir werden die IP-Adresse des Load Balancers und den Host des ClickHouse-Clusters ausgeben.
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"
}Kann gestartet werden.
Fertig! Unsere Konfigurationsdatei ist bereit, und nachdem wir die Variablen festgelegt haben, können wir Terraform sagen, alles hochzufahren, was wir oben beschrieben haben. Der gesamte Prozess hat etwa 15 Minuten gedauert.
Am Ende können wir eine schöne Nachricht sehen:
Anwendung abgeschlossen! Ressourcen: 9 hinzugefügt, 0 geändert, 0 gelöscht.
Ausgaben:
clickhouse_cluster_host = https://c-c9q14ipa2ngadqsbp2iq.rw.mdb.yandexcloud.net:8443
grafana_balancer_ip_address = 130.193.50.25Und in der Cloud werden die Elemente der aufgebauten Infrastruktur sichtbar sein:
Fassen wir zusammen
Jetzt weiß jeder von euch, wie man Anwendungen mit einer komplexen Cloud-Architektur auf der Yandex.Cloud-Plattform bereitstellt, am Beispiel von Grafana. Dabei können hilfreiche Werkzeuge von HashiCorp, wie Packer und Terraform, unterstützen. Ich hoffe, dieser Artikel ist für jemanden nützlich 🙂
P.S. Unten füge ich einen Link zu dem Repository hinzu, in dem fertige Rezepte für Packer und Terraform zu finden sind, von denen ich in diesem Artikel Auszüge gebracht habe.
Quelle: habr.com
