Disvolviĝo de distribuitaj servoj en Yandex.Cloud uzante Grafana kiel ekzemplon

Saluton al ĉiuj! Kadre de mia kurslaboro, mi esploris la kapablojn de tia hejma nuba platformo kiel Yandex.Cloud. La platformo ofertas diversajn servojn por solvi praktikajn problemojn. Tamen, foje vi devas agordi vian propran nuban aplikaĵon kun sufiĉe ampleksa infrastrukturo bazita sur ĉi tiuj servoj. En ĉi tiu artikolo mi volas kunhavigi mian sperton pri deplojado de tia aplikaĵo.

Kion vi volas ricevi?

grafana — potenca ilo por solvi analizajn problemojn aŭ monitori problemojn de iuj sistemoj. En ĝia baza agordo, ĉi tio estas virtuala maŝino kun Grafana retservilo, same kiel datumbazo (ClickHouse, InfluxDB, ktp.) kun datumaro sur kiu analizo baziĝos.

Post lanĉo de virtuala maŝino kun retservilo, vi povas iri al ĝia gastiganto kaj akiri belan UI, specifi datumbazojn kiel fontojn por plua laboro, krei panelojn kaj grafikaĵojn.

La baza versio havas unu gravan malavantaĝon - ĝi tute ne estas tolerema al misfunkciadoj. Tio estas, la tuta funkcieco de la aplikaĵo dependas de la daŭrigebleco de unu virtuala maŝino. Se ĝi rifuzas aŭ 10 homoj malfermas la UI samtempe, tiam aperos problemoj.

Ili povas esti solvitaj simple: vi nur bezonas... disfaldi multajn identajn virtualajn maŝinojn kun retservilo kaj meti ilin sub L3-balancilon. Sed ne ĉio estas tiel klara ĉi tie. Grafana stokas uzantajn agordojn (vojoj al datumbazoj, paneloj, grafikaĵoj, ktp.) rekte sur la disko de sia virtuala maŝino. Tiel, se ni ŝanĝas iujn agordojn en la UI, ĉi tiuj ŝanĝoj estos reflektitaj nur sur la virtuala maŝino, kie la ekvilibristo sendis nin. Ĉi tio kondukos al malkonsekvencaj agordoj por nia aplikaĵo, kaŭzante problemojn kun lanĉo kaj uzo.

Ĉi tie alia datumbazo venos al la savo, ekzemple, MySQL aŭ ĝia ekvivalento. Ni diras al Grafana, ke ŝi konservu uzantajn agordojn en ĉi tiu "rezerva" datumbazo. Poste, sufiĉos specifi la vojon al ĉi tiu datumbazo unufoje sur ĉiu maŝino, kaj redakti ĉiujn aliajn uzantajn agordojn sur iu ajn el la virtualaj maŝinoj; ili etendiĝos al la aliaj.

Jen diagramo de la fina aplika infrastrukturo:

Ni lernu levi per niaj manoj

MySQL kaj ClickHouse

Antaŭ ol deploji tian aplikaĵon per la klako de butono, estis necese lerni kiel manipuli ĉiun el ĝiaj komponantoj kaj integri ilin unu kun la alia.

Ĉi tie Yandex.Cloud helpos nin, kiu provizas L3-balancilojn, ClickHouse kaj MySQL kiel administritajn servojn. La uzanto nur bezonas specifi la parametrojn kaj atendi ĝis la platformo alportas ĉion en funkciado.

Mi registris, kreis nubon kaj pagkonton. Post tio, mi iris al la nubo kaj starigis MySQL kaj ClickHouse-grupojn kun minimumaj agordoj. Mi atendis ĝis ili aktiviĝis.

Vi ankaŭ devas memori krei datumbazon en ĉiu areto kaj agordi aliron al ĝi uzante ensaluton kaj pasvorton. Mi ne eniros detalojn ĉi tie - ĉio estas sufiĉe evidenta en la interfaco.

La ne-evidenteca detalo estis, ke ĉi tiuj datumbazoj havas multajn gastigantojn, kiuj certigas ilian misfunkciadon. Tamen, Grafana postulas ekzakte unu gastiganton por ĉiu datumbazo kun kiu ĝi funkcias. Longa legado dokumentado La nuboj venigis min al decido. Rezultas, ke la gastiganto de la specio c-<cluster_id>.rw.mdb.yandexcloud.net mapita al la nuna aktiva majstra gastiganto de la areto kun la responda ID. Jen kion ni donos al Grafana.

TTT-servilo

Nun ĝi dependas de la retservilo. Ni altigu regulan virtualan maŝinon kun Linukso kaj permane agordu Grafana sur ĝi.

Ni konektu per ssh kaj instalu la necesajn pakaĵojn.

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 

Post tio, ni rulu Grafana sub systemctl kaj instalu la kromprogramon por labori kun ClickHouse (jes, ĝi ne estas provizita en la baza pako).

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

Jen ĝi, post tio kun simpla komando

sudo service grafana-server start

ni komencos la retservilon. Nun vi povas enigi la eksteran IP-adreson de la virtuala maŝino en la retumilo, specifi pordon 3000 kaj vidi la belan Grafana UI.

Sed ne rapidu, antaŭ ol agordi Grafana, vi devas memori diri al ĝi la vojon al MySQL por konservi la agordojn tie.

La tuta agordo de la retservilo Grafana estas en la dosiero /etc/grafana/grafana.ini. La postulata linio aspektas jene:

;url =

Ni starigis la gastiganton al la MySQL-grupo. La sama dosiero enhavas la ensaluton kaj pasvorton por aliri Grafana en la supra bildo, kiuj defaŭlte ambaŭ estas egalaj admin.

Vi povas uzi sed-komandojn:

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

Estas tempo rekomenci la retservilon!

sudo service grafana-server restart

Nun en la Grafana UI ni specifos ClickHouse kiel DataSource.

Mi povis atingi funkciantan agordon kun la jenaj agordoj:

Mi specifis kiel la URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

Ĉiuj! Ni havas unu funkciantan virtualan maŝinon kun retservilo konektita al CH kaj MySQL. Vi jam povas alŝuti la datumaron al ClickHouse kaj konstrui panelojn. Tamen, ni ankoraŭ ne atingis nian celon kaj ne deplojis plenrajtan infrastrukturon.

Pakisto

Yandex.Cloud permesas krei diskon de ekzistanta virtuala maŝino, kaj sur ĝia bazo - ajna nombro da maŝinoj identaj unu al la alia. Ĝuste ĉi tio ni uzos. Por komforte kunmeti la bildon, prenu la ilon Pakisto de HashiCorp. Ĝi prenas kiel enigo json-dosieron kun instrukcioj por kunmeti la bildon.

Nia json-dosiero konsistos el du blokoj: konstruantoj kaj provizantoj. La unua bloko priskribas la parametrojn de la bildo mem kiel ento, kaj la dua bloko priskribas instrukciojn por plenigi ĝin per la necesa enhavo.

konstruantoj

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

En ĉi tiu ŝablono, vi devas agordi la identigilon de la sekcio en la nubo, kie vi volas krei la bildon, kaj ankaŭ la vojon al la dosiero kun la ŝlosiloj de la servokonto antaŭe kreita en ĉi tiu sekcio. Vi povas legi pli pri kreado de servokontoj kaj ŝlosiloj en formo de dosiero en la responda sekcio dokumentado.

Ĉi tiu agordo diras, ke la disko bildo estos konstruita surbaze de la platformo ubuntu-1804-lts, metita en la taŭgan uzantsekcion en la bildfamilio GRAFANA sub la nomo grafana-{{timestamp}}.

Provizantoj

Nun venas la pli interesa parto de la agordo. Ĝi priskribos la sekvencon de agoj, kiuj devos esti faritaj sur la virtuala maŝino antaŭ ol frostigi ĝian staton en diska bildo.

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

Ĉi tie ĉiuj agoj estas dividitaj en 3 etapoj. En la unua etapo, simpla skripto estas ekzekutita, kiu kreas helpan dosierujon.

prepari-ctg.sh:

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

En la sekva etapo, ni metas skripton en ĉi tiun dosierujon, kiu devos esti lanĉita tuj post ekfunkciigo de la virtuala maŝino. Ĉi tiu skripto metos la uzantajn variablojn, kiuj devas esti registritaj en la agordo de Grafana kaj rekomencos la retservilon.

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

Post ĉi tio restas 3 aferoj por fari:
1) instali pakaĵojn
2) rulu Grafana sub systemctl kaj instalu la aldonaĵon ClickHouse
3) metu la setup.sh-skripton en la lanĉan vicon tuj post ŝaltado de la virtuala maŝino.

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;

Nun restas nur ruli Packer kaj akiri la eligbildon metita en la specifita sekcio. Kiam vi kreas virtualan maŝinon, vi povas elekti ĝin kiel lanĉan diskon kaj post lanĉo vi ricevos pretan Grafana retservilon.

Kaza grupo kaj ekvilibristo

Post kiam ni havas diskobildon, kiu ebligas al ni krei multajn identajn retservilojn de Grafana, ni povas krei instangrupon. Sur la platformo Yandex.Cloud, ĉi tiu termino rilatas al la kuniĝo de virtualaj maŝinoj, kiuj havas la samajn karakterizaĵojn. Kreante ekzistan grupon, la prototipo de ĉiuj maŝinoj en ĉi tiu grupo estas agordita, kaj tiam la karakterizaĵoj de la grupo mem (ekzemple, la minimuma kaj maksimuma nombro de aktivaj maŝinoj). Se la nuna nombro ne plenumas ĉi tiujn kriteriojn, tiam la instanca grupo mem forigos nenecesajn maŝinojn aŭ kreos novajn en sia propra bildo.

Kiel parto de nia tasko, ni kreos ekzemplan grupon de retserviloj, kiuj estos generitaj de la antaŭe kreita diskbildo.

Kio estas vere rimarkinda estas la lasta instanca grupo-aranĝo. La celgrupo en integriĝo kun Load Balancer helpos vin agordi L3-balancilon super la virtualaj maŝinoj de ĉi tiu grupo alklakante kelkajn butonojn.

Kiam mi agordis la ekvilibron, mi efektivigis du gravajn punktojn:

1. Mi igis la ekvilibriston akcepti uzanttrafikon sur la haveno 80 kaj redirekti ĝin al la haveno 3000 de la virtualaj maŝinoj, ĝuste kie Grafana loĝas.
2. Mi agordis kontroli la viveblecon de maŝinoj pingante ilin al haveno 3000.

Mini resumo

Fine, ni povis mane deploji la deziratan aplikan infrastrukturon, kaj nun ni havas tre rezisteman servon Grafana. Vi nur bezonas scii la IP-adreson de la ekvilibristo kiel la enirpunkto al la aplikaĵo kaj la gastiganto de la ClickHouse-grupo por ŝargi la datumaron en ĝi.

Ŝajnus kiel venko? Jes, venko. Sed io ankoraŭ konfuzas min. La tuta procezo supre postulas multajn manajn paŝojn kaj tute ne estas skalebla; mi ŝatus aŭtomatigi ĝin se eble. Jen al kio la sekva sekcio estos dediĉita.

Terforma integriĝo

Ni denove uzos ilon de HashiCorp nomita Terraform. Ĝi helpos vin disfaldi la tutan aplikan infrastrukturon per la klako de butono, surbaze de pluraj variabloj pasitaj de la uzanto. Ni skribu recepton, kiu povas esti rulita plurfoje en malsamaj sekcioj de malsamaj uzantoj.

Ĉiu laboro kun Terraform signifas verki agordan dosieron (*.tf) kaj la kreado de infrastrukturo bazita sur ĝi.

Variabloj

Je la komenco de la dosiero, ni inkludos variablojn, kiuj determinas kie kaj kiel la estonta infrastrukturo estos deplojita.

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

La tuta procezo de deplojo de aplikaĵo venos al konstruado de diskobildo kaj agordo de ĉi tiuj variabloj. Mi klarigu pri kio ili respondecas:

oauth_token — ĵetono por aliro al la nubo. Povas esti akirita per ligilo.
cloud_id — nuba identigilo kie ni disfaldi la aplikaĵon
dosierujo_id — sekcia identigilo, kie ni deplojos la aplikaĵon
servo_konto_id — serva konto-identigilo en la responda sekcio de la nubo.
bildo_id — identigilo de la diskbildo akirita per Packer
uzantonomo и pasvorto — uzantnomo kaj pasvorto por aliri ambaŭ datumbazojn kaj la retservilon Grafana
dbname - datumbaza nomo ene de CH kaj MySQL-grupoj
publika_ŝlosilo_vojo — vojo al la dosiero kun via publika ssh-ŝlosilo, kiun vi povas uzi por konekti sub la nomo ubuntu al virtualaj maŝinoj kun retserviloj

Agordo de provizanto

Nun vi devas agordi la Terraform-provizanton - en nia kazo, Yandex:

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

Vi rimarkos, ke ĉi tie ni uzas la supre difinitajn variablojn.

Reto kaj aretoj

Nun ni kreos reton en kiu elementoj de nia infrastrukturo komunikiĝos, tri subretoj (unu en ĉiu regiono) kaj altigos CH kaj MySQL-grupojn.

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

Kiel vi povas vidi, ĉiu el la du aretoj estas kreita sufiĉe tolerema al misfunkciado, estante metita en tri havebleczonojn.

Retaj serviloj

Ŝajnus, ke ni povus daŭrigi en la sama spirito, sed mi renkontis malfacilaĵojn. Antaŭ tio, mi unue levis MySQL-grupon kaj nur post tio, sciante ĝian ID, mi kolektis diskobildon kun la bezonata agordo, kie mi specifis la gastiganton al la areto. Sed nun ni ne konas la cluster-ID antaŭ lanĉi Terraform, inkluzive en la momento de konstruado de la bildo. Tial, mi devis recurri al la sekvanta ruzo.

Uzante la metadatuman servon de Amazon, ni transdonos kelkajn parametrojn al la virtuala maŝino, kiun ĝi akceptos kaj prilaboros. Ni bezonas, ke la maŝino iri al la metadatumoj malantaŭ la gastiganto kaj uzantnomo-pasvorto de MySQL, kiujn la uzanto specifis en la Terraform-dosiero, post komenci. Ni ŝanĝu iomete la enhavon de la dosiero setup.sh, kiu funkcias kiam la virtuala maŝino estas ŝaltita.

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

Intancgrupo kaj ekvilibristo

Rekonstruinte novan diskobildon, ni povas finfine aldoni nian dosieron por Terraform.

Ni indiku, ke ni volas uzi ekzistantan diskobildon:

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

Nun ni kreu ekzistadgrupon:

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

Indas atenti kiel ni pasigis ĝin en la metadatumojn cluster_uri, username и password. Estas ĉi tiuj, kiujn la virtuala maŝino elprenos ĉe ekfunkciigo kaj enmetos la agordon de Grafana.

Dependas de la ekvilibristo.

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

Iom da sukero

Restas nur malmulte. Post kiam la infrastrukturo estas deplojita, vi devos iri al la Grafana UI kaj permane aldoni la CH-grupon (kies ID ankoraŭ devas esti akirita) kiel Datumfonto. Sed Terraform konas la cluster-ID. Ni konfidu al li realigi la aferon.

Ni aldonu novan provizanton - Grafana, kaj donu al ŝi la IP-adreson de la ekvilibristo kiel gastiganto. Ĉiuj ŝanĝoj, kiujn Terraform faras sur la maŝino, kie ĝia ekvilibristo determinas, kreskos en MySQL, kaj do sur ĉiuj aliaj maŝinoj.

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

Ni kombu niajn harojn

Ni montru la ekvilibran IP-adreson kaj la gastiganton de la ClickHouse-areto

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

Povas kuri

Ĉiuj! Nia agorda dosiero estas preta kaj ni povas, fiksante la variablojn, diri al Terraform levi ĉion, kion ni priskribis supre. La tuta procezo daŭris al mi ĉirkaŭ 15 minutojn.
Fine vi povas vidi belan mesaĝon:

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.25

Kaj en la nubo, elementoj de la altigita infrastrukturo estos videblaj:

Ni sumigu la rezultojn

Nun, uzante Grafana kiel ekzemplon, ĉiu el vi povas disfaldi aplikaĵojn kun vasta nuba arkitekturo sur la platformo Yandex.Cloud. Helpemaj iloj de HashiCorp kiel Packer kaj Terraform povas helpi vin pri tio. Mi esperas, ke iu trovos ĉi tiun artikolon utila :)

PS Malsupre mi aldonos ligilon al la deponejo kie vi povas trovi pretajn receptojn por Packer kaj Terraform, fragmentojn de kiuj mi disponigis en ĉi tiu artikolo.

deponejo

fonto: www.habr.com