Salut tout le monde! Dans le cadre de mes cours, j'ai étudié les capacités d'une plate-forme cloud nationale telle que . La plateforme propose divers services pour résoudre des problèmes pratiques. Cependant, vous devez parfois configurer votre propre application cloud avec une infrastructure assez étendue basée sur ces services. Dans cet article, je souhaite partager mon expérience dans le déploiement d'une telle application.
Que souhaitez-vous recevoir ?
— un outil puissant pour résoudre des problèmes analytiques ou des problèmes de surveillance de n'importe quel système. Dans sa configuration de base, il s'agit d'une machine virtuelle avec un serveur web Grafana, ainsi qu'une base de données (ClickHouse, InfluxDB, etc.) avec un ensemble de données sur lequel seront basées les analyses.
Après avoir lancé une machine virtuelle avec un serveur Web, vous pouvez accéder à son hôte et obtenir une belle interface utilisateur, spécifier des bases de données comme sources pour des travaux ultérieurs, créer des tableaux de bord et des graphiques.
La version de base présente un inconvénient majeur : elle n'est pas du tout tolérante aux pannes. Autrement dit, toutes les fonctionnalités de l'application dépendent de la viabilité d'une machine virtuelle. S'il refuse ou si 10 personnes ouvrent l'interface utilisateur en même temps, des problèmes surviendront.
Ils peuvent être résolus simplement : il suffit de… déployer plusieurs machines virtuelles identiques avec un serveur web et de les placer sous un équilibreur L3. Mais tout n’est pas si clair ici. Grafana stocke les paramètres utilisateur (chemins d'accès aux bases de données, tableaux de bord, graphiques, etc.) directement sur le disque de sa machine virtuelle. Ainsi, si nous modifions certains paramètres dans l'interface utilisateur, ces modifications seront reflétées uniquement sur la machine virtuelle où l'équilibreur nous a envoyé. Cela entraînera des paramètres incohérents pour notre application, provoquant des problèmes de lancement et d'utilisation.
Ici, une autre base de données viendra à la rescousse, par exemple MySQL ou son équivalent. Nous disons à Grafana qu'elle doit stocker les paramètres utilisateur dans cette base de données « de rechange ». Ensuite, il suffira de préciser une fois le chemin d'accès à cette base de données sur chaque machine, et d'éditer tous les autres paramètres utilisateur sur n'importe laquelle des machines virtuelles ; ils s'étendront aux autres.
Voici un schéma de l’infrastructure applicative finale :
Apprenons à soulever avec nos mains
MySQL et ClickHouse
Avant de déployer une telle application d’un simple clic, il fallait apprendre à manipuler chacun de ses composants et à les intégrer les uns aux autres.
Ici, Yandex.Cloud nous aidera, qui fournit des équilibreurs L3, ClickHouse et MySQL en tant que services gérés. L'utilisateur n'a qu'à préciser les paramètres et attendre que la plateforme remette tout en état de marche.
Je me suis inscrit, j'ai créé un cloud et un compte de paiement. Après cela, je suis allé dans le cloud et j'ai configuré les clusters MySQL et ClickHouse avec des paramètres minimaux. J'ai attendu qu'ils deviennent actifs.
N'oubliez pas non plus de créer une base de données dans chaque cluster et d'en configurer l'accès à l'aide d'un identifiant et d'un mot de passe. Je n'entrerai pas dans les détails ici, tout est assez évident dans l'interface.
Le détail non évident est que ces bases de données disposent de nombreux hôtes, ce qui garantit leur tolérance aux pannes. Cependant, Grafana nécessite exactement un hôte pour chaque base de données avec laquelle il travaille. Longue lecture Les nuages m'ont amené à prendre une décision. Il s'avère que l'hôte de l'espèce c-<cluster_id>.rw.mdb.yandexcloud.net mappé à l'hôte maître actif actuel du cluster avec l'ID correspondant. C'est ce que nous donnerons à Grafana.
serveur Web
C'est maintenant au serveur Web de décider. Créons une machine virtuelle standard avec Linux et configurons manuellement Grafana dessus.
Connectons-nous via ssh et installons les packages nécessaires.
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
Après cela, exécutons Grafana sous systemctl et installons le plugin pour travailler avec ClickHouse (oui, il n'est pas fourni dans le package de base).
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo grafana-cli plugins install vertamedia-clickhouse-datasourceVoilà, après ça avec une simple commande
sudo service grafana-server startnous allons démarrer le serveur Web. Vous pouvez maintenant saisir l'adresse IP externe de la machine virtuelle dans le navigateur, spécifier le port 3000 et voir la magnifique interface utilisateur Grafana.
Mais ne vous précipitez pas, avant de configurer Grafana, il faut penser à lui indiquer le chemin d’accès à MySQL afin d’y stocker les paramètres.
Toute la configuration du serveur web Grafana est dans le fichier /etc/grafana/grafana.ini. La ligne requise ressemble à ceci :
;url =Nous définissons l'hôte sur le cluster MySQL. Le même fichier contient le login et le mot de passe pour accéder à Grafana dans l'image ci-dessus, qui sont tous deux égaux par défaut admin.
Vous pouvez utiliser les commandes sed :
sudo sed -i "s#.*;url =.*#url = mysql://${MYSQL_USERNAME}:${MYSQL_PASSWORD}@${MYSQL_CLUSTER_URI}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${GRAFANA_USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${GRAFANA_PASSWORD}#" /etc/grafana/grafana.ini
Il est temps de redémarrer le serveur Web !
sudo service grafana-server restartMaintenant, dans l'interface utilisateur de Grafana, nous spécifierons ClickHouse comme DataSource.
J'ai pu obtenir une configuration fonctionnelle avec les paramètres suivants :
J'ai spécifié comme URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443
Tous! Nous avons une machine virtuelle fonctionnelle avec un serveur Web connecté à CH et MySQL. Vous pouvez déjà télécharger l'ensemble de données sur ClickHouse et créer des tableaux de bord. Cependant, nous n’avons pas encore atteint notre objectif et n’avons pas déployé une infrastructure à part entière.
Emballeur
Yandex.Cloud vous permet de créer une image disque d'une machine virtuelle existante et, sur sa base, un nombre quelconque de machines identiques les unes aux autres. C'est exactement ce que nous utiliserons. Pour assembler facilement l'image, prenez l'outil de HashiCorp. Il prend en entrée un fichier json avec des instructions pour assembler l'image.
Notre fichier json sera composé de deux blocs : les constructeurs et les provisionneurs. Le premier bloc décrit les paramètres de l'image elle-même en tant qu'entité, et le deuxième bloc décrit les instructions pour la remplir du contenu nécessaire.
Constructeurs
{
"builders": [
{
"type": "yandex",
"endpoint": "{{user `endpoint`}}",
"folder_id": "<folder_id>",
"subnet_id": "{{user `subnet_id`}}",
"zone": "{{user `zone`}}",
"labels": {},
"use_ipv4_nat": true,
"use_internal_ip": false,
"service_account_key_file": "<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"
}
],
...
}Dans ce modèle, vous devez définir l'identifiant de la section du cloud où vous souhaitez créer l'image, ainsi que le chemin d'accès au fichier avec les clés du compte de service précédemment créé dans cette section. Vous pouvez en savoir plus sur la création de comptes de service et de clés sous forme de fichier dans la section correspondante .
Cette configuration indique que l'image disque sera construite en fonction de la plateforme ubuntu-1804-lts, placé dans la section utilisateur appropriée dans la famille d'images GRAFANA sous le nom grafana-{{timestamp}}.
Fournisseurs
Vient maintenant la partie la plus intéressante de la configuration. Il décrira la séquence d'actions qui devront être effectuées sur la machine virtuelle avant de figer son état dans une image disque.
{
...,
"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"
]
}
]
}Ici, toutes les actions sont divisées en 3 étapes. Dans un premier temps, un simple script est exécuté pour créer un répertoire auxiliaire.
préparer-ctg.sh :
#!/bin/bash
sudo mkdir -p /opt/grafana
sudo chown -R ubuntu:ubuntu /opt/grafanaA l'étape suivante, nous plaçons un script dans ce répertoire, qui devra être lancé immédiatement après le démarrage de la machine virtuelle. Ce script mettra les variables utilisateur qui doivent être enregistrées dans la configuration Grafana et redémarrera le serveur Web.
setup.sh :
#!/bin/bash
CLUSTER_ID="<cluster_id>"
USERNAME="<username>"
PASSWORD="<password>"
sudo sed -i "s#.*;url =.*#url = mysql://${USERNAME}:${PASSWORD}@c-${CLUSTER_ID}.rw.mdb.yandexcloud.net#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${PASSWORD}#" /etc/grafana/grafana.ini
sudo service grafana-server restartAprès cela, il reste 3 choses à faire :
1) installer les packages
2) exécutez Grafana sous systemctl et installez le plugin ClickHouse
3) placez le script setup.sh dans la file d'attente de lancement immédiatement après avoir allumé la machine virtuelle.
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-datasourceexécuter-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;Il ne reste plus qu'à exécuter Packer et à placer l'image de sortie dans la section spécifiée. Lors de la création d'une machine virtuelle, vous pouvez la sélectionner comme disque de démarrage et après le lancement, vous recevrez un serveur Web Grafana prêt à l'emploi.
Groupe d'instances et équilibreur
Une fois que nous disposons d'une image disque qui nous permet de créer de nombreux serveurs Web Grafana identiques, nous pouvons créer un groupe d'instances. Sur la plateforme Yandex.Cloud, ce terme fait référence à l'union de machines virtuelles présentant les mêmes caractéristiques. Lors de la création d'un groupe d'instances, le prototype de toutes les machines de ce groupe est configuré, puis les caractéristiques du groupe lui-même (par exemple, le nombre minimum et maximum de machines actives). Si le nombre actuel ne répond pas à ces critères, le groupe d'instances lui-même supprimera les machines inutiles ou en créera de nouvelles à sa propre image.
Dans le cadre de notre tâche, nous allons créer un groupe d'instances de serveurs Web qui sera généré à partir de l'image disque créée précédemment.
Ce qui est vraiment remarquable, c'est la configuration du groupe de dernière instance. Le groupe cible en intégration avec Load Balancer vous aidera à configurer un équilibreur L3 au-dessus des machines virtuelles de ce groupe en cliquant sur quelques boutons.
Lors de la configuration de l'équilibreur, j'ai mis en œuvre deux points importants :
- J'ai fait en sorte que l'équilibreur accepte le trafic utilisateur sur le port 80 et le redirige vers le port 3000 des machines virtuelles, exactement là où réside Grafana.
- J'ai configuré la vérification de la viabilité des machines en les envoyant une requête ping au port 3000.
Mini résumé
Enfin, nous avons pu déployer manuellement l'infrastructure applicative souhaitée et nous disposons désormais d'un service Grafana hautement résilient. Il vous suffit de connaître l'adresse IP de l'équilibreur comme point d'entrée de l'application et l'hôte du cluster ClickHouse pour y charger l'ensemble de données.
Cela ressemblerait à une victoire ? Oui, la victoire. Mais quelque chose me laisse encore perplexe. L'ensemble du processus ci-dessus nécessite de nombreuses étapes manuelles et n'est pas du tout évolutif ; j'aimerais l'automatiser si possible. C’est à cela que sera consacrée la prochaine section.
Intégration Terraform
Nous utiliserons à nouveau un outil de HashiCorp appelé . Il vous aidera à déployer l'ensemble de l'infrastructure applicative en un clic, en fonction de plusieurs variables transmises par l'utilisateur. Écrivons une recette qui peut être exécutée plusieurs fois dans différentes sections de différents utilisateurs.
Tout travail avec Terraform se résume à écrire un fichier de configuration (*.tf) et la création d'infrastructures basées sur celle-ci.
Variables
Au tout début du dossier, nous inclurons des variables qui déterminent où et comment la future infrastructure sera déployée.
variable "oauth_token" {
type = string
default = "<oauth-token>"
}
variable "cloud_id" {
type = string
default = "<cloud-id>"
}
variable "folder_id" {
type = string
default = "<folder_id>"
}
variable "service_account_id" {
type = string
default = "<service_account_id>"
}
variable "image_id" {
type = string
default = "<image_id>"
}
variable "username" {
type = string
default = "<username>"
}
variable "password" {
type = string
default = "<password>"
}
variable "dbname" {
type = string
default = "<dbname>"
}
variable "public_key_path" {
type = string
default = "<path to ssh public key>"
}L'ensemble du processus de déploiement d'application se résumera à la création d'une image disque et à la définition de ces variables. Laissez-moi vous expliquer de quoi ils sont responsables :
oauth_token — un jeton pour accéder au cloud. Peut être obtenu par .
cloud_id — identifiant du cloud où nous déploierons l'application
folder_id — identifiant de la section où nous allons déployer l'application
service_account_id — identifiant du compte de service dans la section correspondante du cloud.
id_image — identifiant de l'image disque obtenue à l'aide de Packer
Nom d'utilisateur и Mot de passe — nom d'utilisateur et mot de passe pour accéder aux deux bases de données et au serveur Web Grafana
dbname — nom de la base de données dans les clusters CH et MySQL
chemin_clé_public — chemin d'accès au fichier avec votre clé publique ssh, que vous pouvez utiliser pour vous connecter sous le nom ubuntu vers des machines virtuelles avec des serveurs Web
Configuration du fournisseur
Vous devez maintenant configurer le fournisseur Terraform - dans notre cas, Yandex :
provider "yandex" {
token = var.oauth_token
cloud_id = var.cloud_id
folder_id = var.folder_id
zone = "ru-central1-a"
}
Vous remarquerez que nous utilisons ici les variables définies ci-dessus.
Réseau et clusters
Nous allons maintenant créer un réseau dans lequel communiqueront des éléments de notre infrastructure, trois sous-réseaux (un dans chaque région) et élever des clusters CH et 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
}
}Comme vous pouvez le constater, chacun des deux clusters est créé de manière assez tolérante aux pannes en étant situé dans trois zones de disponibilité.
Serveurs Web
Il semblerait que nous puissions continuer dans le même esprit, mais j'ai rencontré des difficultés. Avant cela, j'ai d'abord créé un cluster MySQL et seulement après cela, connaissant son ID, j'ai collecté une image disque avec la configuration requise, où j'ai spécifié l'hôte du cluster. Mais désormais, nous ne connaissons pas l'ID du cluster avant de lancer Terraform, y compris au moment de la construction de l'image. J'ai donc dû recourir à ce qui suit .
À l'aide du service de métadonnées d'Amazon, nous transmettrons certains paramètres à la machine virtuelle, qu'elle acceptera et traitera. Nous avons besoin que la machine accède aux métadonnées derrière l'hôte du cluster MySQL et au nom d'utilisateur-mot de passe, que l'utilisateur a spécifiés dans le fichier Terraform, après le démarrage. Modifions légèrement le contenu du fichier setup.sh, qui s'exécute lorsque la machine virtuelle est allumée.
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 restartGroupe d'instance et équilibreur
Après avoir reconstruit une nouvelle image disque, nous pouvons enfin ajouter notre fichier pour Terraform.
Indiquons que nous souhaitons utiliser une image disque existante :
data "yandex_compute_image" "grafana_image" {
image_id = var.image_id
}Créons maintenant un groupe d'instances :
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"
}
}Cela vaut la peine de prêter attention à la façon dont nous l'avons transmis dans les métadonnées cluster_uri, username и password. Ce sont ceux-ci que la machine virtuelle va retirer au démarrage et mettre dans la config Grafana.
Cela dépend de l'équilibreur.
resource "yandex_lb_network_load_balancer" "grafana_balancer" {
name = "grafana-balancer"
listener {
name = "grafana-listener"
port = 80
target_port = 3000
external_address_spec {
ip_version = "ipv4"
}
}
attached_target_group {
target_group_id = yandex_compute_instance_group.grafana_group.load_balancer.0.target_group_id
healthcheck {
name = "healthcheck"
tcp_options {
port = 3000
}
}
}
}Un peu de sucre
Il n'en reste qu'un peu. Une fois l'infrastructure déployée, vous devrez vous rendre dans l'interface utilisateur de Grafana et ajouter manuellement le cluster CH (dont l'ID doit encore être obtenu) comme source de données. Mais Terraform connaît l'ID du cluster. Confions-lui le soin de mener à bien cette affaire.
Ajoutons un nouveau fournisseur - Grafana, et donnons-lui l'adresse IP de l'équilibreur en tant qu'hôte. Toutes les modifications apportées par Terraform sur la machine déterminée par son équilibreur augmenteront dans MySQL, et donc sur toutes les autres machines.
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"
}Peignons-nous les cheveux
Affichons l'adresse IP de l'équilibreur et l'hôte du cluster ClickHouse
output "grafana_balancer_ip_address" {
value = [for s in yandex_lb_network_load_balancer.grafana_balancer.listener: s.external_address_spec.0.address].0
}
output "clickhouse_cluster_host" {
value = "https://c-${yandex_mdb_clickhouse_cluster.ch_cluster.id}.rw.mdb.yandexcloud.net:8443"
}Peut courir
Tous! Notre fichier de configuration est prêt et nous pouvons, en définissant les variables, dire à Terraform de relancer tout ce que nous avons décrit ci-dessus. L'ensemble du processus m'a pris environ 15 minutes.
À la fin, vous pouvez voir un beau message :
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.25Et dans le cloud, des éléments de l'infrastructure surélevée seront visibles :
Récapituler
Désormais, en prenant Grafana comme exemple, chacun de vous peut déployer des applications avec une architecture cloud tentaculaire sur la plateforme Yandex.Cloud. Des outils utiles de HashiCorp comme Packer et Terraform peuvent vous aider. J'espère que quelqu'un trouvera cet article utile :)
PS Ci-dessous, je joindrai un lien vers le référentiel où vous pourrez trouver des recettes toutes faites pour Packer et Terraform, dont j'ai fourni des fragments dans cet article.
Source: habr.com