ການນຳໃຊ້ບໍລິການແຈກຢາຍຢູ່ໃນ Yandex.Cloud ໂດຍໃຊ້ Grafana ເປັນຕົວຢ່າງ

ສະບາຍດີທຸກຄົນ! ເປັນສ່ວນຫນຶ່ງຂອງການເຮັດວຽກຫຼັກສູດຂອງຂ້ອຍ, ຂ້ອຍໄດ້ຄົ້ນຄວ້າຄວາມສາມາດຂອງເວທີຟັງພາຍໃນປະເທດເຊັ່ນ: Yandex.Cloud. ເວທີການສະຫນອງການບໍລິການຕ່າງໆສໍາລັບການແກ້ໄຂບັນຫາພາກປະຕິບັດ. ຢ່າງໃດກໍ່ຕາມ, ບາງຄັ້ງທ່ານຈໍາເປັນຕ້ອງຕັ້ງຄ່າແອັບພລິເຄຊັນຄລາວຂອງຕົນເອງດ້ວຍໂຄງສ້າງພື້ນຖານທີ່ກວ້າງຂວາງໂດຍອີງໃສ່ການບໍລິການເຫຼົ່ານີ້. ໃນບົດຄວາມນີ້ຂ້ອຍຢາກແບ່ງປັນປະສົບການຂອງຂ້ອຍໃນການນໍາໃຊ້ຄໍາຮ້ອງສະຫມັກດັ່ງກ່າວ.

ເຈົ້າຢາກໄດ້ຫຍັງ?

ກຣາຟານາ — ເປັນ​ເຄື່ອງ​ມື​ທີ່​ມີ​ອໍາ​ນາດ​ສໍາ​ລັບ​ການ​ແກ້​ໄຂ​ບັນ​ຫາ​ການ​ວິ​ເຄາະ​ຫຼື​ການ​ຕິດ​ຕາມ​ກວດ​ກາ​ຂອງ​ລະ​ບົບ​ໃດ​ຫນຶ່ງ​. ໃນການຕັ້ງຄ່າພື້ນຖານຂອງມັນ, ນີ້ແມ່ນເຄື່ອງ virtual ທີ່ມີເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ Grafana, ເຊັ່ນດຽວກັນກັບຖານຂໍ້ມູນ (ClickHouse, InfluxDB, ແລະອື່ນໆ) ທີ່ມີຊຸດຂໍ້ມູນທີ່ການວິເຄາະຈະອີງໃສ່.

ຫຼັງຈາກເປີດຕົວເຄື່ອງ virtual ກັບເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌, ທ່ານສາມາດໄປຫາເຈົ້າພາບຂອງມັນແລະໄດ້ຮັບ UI ທີ່ສວຍງາມ, ລະບຸຖານຂໍ້ມູນເປັນແຫຼ່ງສໍາລັບການເຮັດວຽກຕໍ່ໄປ, ສ້າງ dashboards ແລະກາຟ.

ສະ​ບັບ​ພື້ນ​ຖານ​ມີ​ຈຸດ​ອ່ອນ​ທີ່​ສໍາ​ຄັນ​ຫນຶ່ງ - ມັນ​ບໍ່​ແມ່ນ​ຄວາມ​ຜິດ​ທົນ​ທານ​ຕໍ່​ທັງ​ຫມົດ​. ນັ້ນແມ່ນ, ການເຮັດວຽກທັງຫມົດຂອງຄໍາຮ້ອງສະຫມັກແມ່ນຂຶ້ນກັບຄວາມເປັນໄປໄດ້ຂອງເຄື່ອງຈັກ virtual ຫນຶ່ງ. ຖ້າມັນປະຕິເສດຫຼື 10 ຄົນເປີດ UI ໃນເວລາດຽວກັນ, ຫຼັງຈາກນັ້ນບັນຫາຈະເກີດຂື້ນ.

ພວກເຂົາສາມາດແກ້ໄຂໄດ້ງ່າຍໆ: ທ່ານພຽງແຕ່ຕ້ອງການ ... ນໍາໃຊ້ເຄື່ອງຈັກ virtual ທີ່ຄ້າຍຄືກັນຫຼາຍກັບເຄື່ອງແມ່ຂ່າຍເວັບແລະວາງພວກມັນພາຍໃຕ້ຕົວດຸ່ນດ່ຽງ L3. ແຕ່ບໍ່ແມ່ນທຸກຢ່າງຈະແຈ້ງຢູ່ທີ່ນີ້. Grafana ເກັບຮັກສາການຕັ້ງຄ່າຜູ້ໃຊ້ (ເສັ້ນທາງໄປຫາຖານຂໍ້ມູນ, dashboards, graphs, ແລະອື່ນໆ) ໂດຍກົງໃນແຜ່ນຂອງເຄື່ອງ virtual ຂອງມັນ. ດັ່ງນັ້ນ, ຖ້າພວກເຮົາປ່ຽນບາງການຕັ້ງຄ່າໃນ UI, ການປ່ຽນແປງເຫຼົ່ານີ້ຈະສະທ້ອນໃຫ້ເຫັນພຽງແຕ່ໃນເຄື່ອງ virtual ທີ່ balancer ສົ່ງໃຫ້ພວກເຮົາ. ນີ້ຈະນໍາໄປສູ່ການຕັ້ງຄ່າທີ່ບໍ່ສອດຄ່ອງສໍາລັບຄໍາຮ້ອງສະຫມັກຂອງພວກເຮົາ, ເຊິ່ງກໍ່ໃຫ້ເກີດບັນຫາກັບການເປີດຕົວແລະການນໍາໃຊ້.

ທີ່ນີ້ຖານຂໍ້ມູນອື່ນຈະມາເຖິງກູ້ໄພ, ຕົວຢ່າງ, MySQL ຫຼືທຽບເທົ່າຂອງມັນ. ພວກເຮົາບອກ Grafana ວ່ານາງຄວນເກັບຮັກສາການຕັ້ງຄ່າຜູ້ໃຊ້ຢູ່ໃນຖານຂໍ້ມູນ " spare" ນີ້. ຫຼັງຈາກນັ້ນ, ມັນຈະພຽງພໍທີ່ຈະລະບຸເສັ້ນທາງໄປຫາຖານຂໍ້ມູນນີ້ຄັ້ງດຽວໃນແຕ່ລະເຄື່ອງ, ແລະແກ້ໄຂການຕັ້ງຄ່າຜູ້ໃຊ້ອື່ນໆທັງຫມົດໃນເຄື່ອງ virtual; ພວກມັນຈະຂະຫຍາຍໄປຫາເຄື່ອງອື່ນໆ.

ນີ້ແມ່ນແຜນວາດຂອງໂຄງສ້າງພື້ນຖານຂອງແອັບພລິເຄຊັນສຸດທ້າຍ:

ໃຫ້ເຮົາຮຽນຮູ້ທີ່ຈະຍົກດ້ວຍມືຂອງພວກເຮົາ

MySQL ແລະ ClickHouse

ກ່ອນທີ່ຈະນໍາໃຊ້ຄໍາຮ້ອງສະຫມັກດັ່ງກ່າວດ້ວຍການກົດປຸ່ມ, ມັນຈໍາເປັນຕ້ອງໄດ້ຮຽນຮູ້ວິທີການຈັດການແຕ່ລະອົງປະກອບຂອງມັນແລະປະສົມປະສານກັບກັນແລະກັນ.

ທີ່ນີ້ Yandex.Cloud ຈະຊ່ວຍໃຫ້ພວກເຮົາ, ເຊິ່ງສະຫນອງ L3 balancers, ClickHouse ແລະ MySQL ເປັນບໍລິການຄຸ້ມຄອງ. ຜູ້ໃຊ້ພຽງແຕ່ຕ້ອງການກໍານົດພາລາມິເຕີແລະລໍຖ້າຈົນກ່ວາເວທີນໍາເອົາທຸກສິ່ງທຸກຢ່າງເຂົ້າໄປໃນຄໍາສັ່ງ.

ຂ້ອຍລົງທະບຽນ, ສ້າງເມຄ ແລະບັນຊີການຈ່າຍເງິນ. ຫຼັງຈາກນັ້ນ, ຂ້າພະເຈົ້າໄດ້ໄປຫາຄລາວແລະຕັ້ງກຸ່ມ MySQL ແລະ ClickHouse ດ້ວຍການຕັ້ງຄ່າຫນ້ອຍ. ຂ້າພະເຈົ້າໄດ້ລໍຖ້າຈົນກ່ວາພວກເຂົາກາຍເປັນການເຄື່ອນໄຫວ.

ນອກນັ້ນທ່ານຍັງຈໍາເປັນຕ້ອງຈື່ຈໍາເພື່ອສ້າງຖານຂໍ້ມູນໃນແຕ່ລະກຸ່ມແລະກໍານົດການເຂົ້າເຖິງມັນໂດຍໃຊ້ເຂົ້າສູ່ລະບົບແລະລະຫັດຜ່ານ. ຂ້າພະເຈົ້າຈະບໍ່ເຂົ້າໄປໃນລາຍລະອຽດທີ່ນີ້ - ທຸກສິ່ງທຸກຢ່າງແມ່ນຂ້ອນຂ້າງຈະແຈ້ງໃນການໂຕ້ຕອບ.

ລາຍລະອຽດທີ່ບໍ່ຊັດເຈນແມ່ນວ່າຖານຂໍ້ມູນເຫຼົ່ານີ້ມີຫຼາຍໂຮດ, ເຊິ່ງຮັບປະກັນຄວາມທົນທານຕໍ່ຄວາມຜິດພາດຂອງພວກເຂົາ. ຢ່າງໃດກໍຕາມ, Grafana ຮຽກຮ້ອງໃຫ້ມີເຈົ້າພາບຫນຶ່ງຢ່າງແທ້ຈິງສໍາລັບແຕ່ລະຖານຂໍ້ມູນທີ່ມັນເຮັດວຽກກັບ. ອ່ານຍາວ ເອກະສານ ເມກໄດ້ນໍາຂ້ອຍໄປສູ່ການຕັດສິນໃຈ. ມັນ turns ໃຫ້ ເຫັນ ວ່າ ເຈົ້າ ພາບ ຂອງ ຊະ ນິດ c-<cluster_id>.rw.mdb.yandexcloud.net ແຜນທີ່ກັບແມ່ບ້ານທີ່ເຮັດວຽກໃນປັດຈຸບັນຂອງກຸ່ມທີ່ມີ ID ທີ່ສອດຄ້ອງກັນ. ນີ້ແມ່ນສິ່ງທີ່ພວກເຮົາຈະໃຫ້ Grafana.

ເຊີບເວີເວັບ

ໃນປັດຈຸບັນມັນຂຶ້ນກັບເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌. ໃຫ້ຍົກເຄື່ອງ virtual ປົກກະຕິກັບ Linux ແລະຕັ້ງຄ່າ Grafana ດ້ວຍຕົນເອງ.

ໃຫ້ເຊື່ອມຕໍ່ຜ່ານ ssh ແລະຕິດຕັ້ງແພັກເກັດທີ່ຈໍາເປັນ.

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 

ຫຼັງຈາກນັ້ນ, ໃຫ້ດໍາເນີນການ Grafana ພາຍໃຕ້ systemctl ແລະຕິດຕັ້ງ plugin ສໍາລັບການເຮັດວຽກກັບ ClickHouse (ແມ່ນແລ້ວ, ມັນບໍ່ໄດ້ຖືກສະຫນອງໃນຊຸດພື້ນຖານ).

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

ນັ້ນແມ່ນ, ຫຼັງຈາກນັ້ນດ້ວຍຄໍາສັ່ງງ່າຍໆ

sudo service grafana-server start

ພວກເຮົາຈະເລີ່ມຕົ້ນເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌. ຕອນນີ້ທ່ານສາມາດໃສ່ທີ່ຢູ່ IP ພາຍນອກຂອງ virtual machine ໃນ browser, ລະບຸ port 3000 ແລະເບິ່ງ Grafana UI ທີ່ສວຍງາມ.

ແຕ່ຢ່າຟ້າວ, ກ່ອນທີ່ຈະຕັ້ງ Grafana, ທ່ານຕ້ອງຈື່ຈໍາທີ່ຈະບອກມັນໄປສູ່ MySQL ເພື່ອເກັບຮັກສາການຕັ້ງຄ່າຢູ່ທີ່ນັ້ນ.

ການຕັ້ງຄ່າທັງຫມົດຂອງເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ Grafana ແມ່ນຢູ່ໃນໄຟລ໌ /etc/grafana/grafana.ini. ເສັ້ນ​ທີ່​ຕ້ອງ​ການ​ເບິ່ງ​ຄື​ນີ້​:

;url =

ພວກເຮົາຕັ້ງໂຮດໃຫ້ກັບກຸ່ມ MySQL. ໄຟລ໌ດຽວກັນປະກອບມີການເຂົ້າສູ່ລະບົບແລະລະຫັດຜ່ານສໍາລັບການເຂົ້າເຖິງ Grafana ໃນຮູບຂ້າງເທິງ, ເຊິ່ງໂດຍຄ່າເລີ່ມຕົ້ນທັງສອງແມ່ນເທົ່າທຽມກັນ admin.

ທ່ານສາມາດນໍາໃຊ້ຄໍາສັ່ງ 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

ຮອດເວລາປິດເປີດເວັບເຊີບເວີແລ້ວ!

sudo service grafana-server restart

ຕອນນີ້ຢູ່ໃນ Grafana UI ພວກເຮົາຈະລະບຸ ClickHouse ເປັນ DataSource.

ຂ້ອຍສາມາດບັນລຸການຕັ້ງຄ່າທີ່ເຮັດວຽກດ້ວຍການຕັ້ງຄ່າຕໍ່ໄປນີ້:

ຂ້ອຍລະບຸເປັນ URL https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

ທັງໝົດ! ພວກເຮົາມີເຄື່ອງ virtual ທີ່ເຮັດວຽກກັບເຄື່ອງແມ່ຂ່າຍເວັບທີ່ເຊື່ອມຕໍ່ກັບ CH ແລະ MySQL. ທ່ານສາມາດອັບໂຫລດຊຸດຂໍ້ມູນໃສ່ ClickHouse ແລະສ້າງ dashboards ໄດ້ແລ້ວ. ​ເຖິງ​ຢ່າງ​ໃດ​ກໍ​ຕາມ, ພວກ​ເຮົາ​ຍັງ​ບໍ່​ທັນ​ບັນລຸ​ເປົ້າ​ໝາຍ​ຂອງ​ພວກ​ເຮົາ​ເທື່ອ ​ແລະ ຍັງ​ບໍ່​ທັນ​ໄດ້​ນຳ​ໃຊ້​ພື້ນຖານ​ໂຄງ​ລ່າງ​ຢ່າງ​ຄົບ​ຊຸດ.

Packer

Yandex.Cloud ອະນຸຍາດໃຫ້ທ່ານສ້າງຮູບພາບແຜ່ນຂອງເຄື່ອງ virtual ທີ່ມີຢູ່ແລ້ວ, ແລະບົນພື້ນຖານຂອງມັນ - ຈໍານວນເຄື່ອງທີ່ຄ້າຍຄືກັບກັນແລະກັນ. ນີ້ແມ່ນສິ່ງທີ່ພວກເຮົາຈະໃຊ້ແທ້ໆ. ເພື່ອສະດວກໃນການປະກອບຮູບພາບ, ເອົາເຄື່ອງມື Packer ຈາກ HashiCorp. ມັນໃຊ້ເວລາເປັນການປ້ອນໄຟລ໌ json ພ້ອມກັບຄໍາແນະນໍາສໍາລັບການປະກອບຮູບພາບ.

ໄຟລ໌ json ຂອງພວກເຮົາຈະປະກອບດ້ວຍສອງຕັນ: builders ແລະ provisioners. ບລັອກທໍາອິດອະທິບາຍພາລາມິເຕີຂອງຮູບພາບຕົວມັນເອງເປັນຫນ່ວຍງານ, ແລະບລັອກທີສອງອະທິບາຍຄໍາແນະນໍາສໍາລັບການຕື່ມຂໍ້ມູນໃສ່ກັບເນື້ອຫາທີ່ຈໍາເປັນ.

ຜູ້ກໍ່ສ້າງ

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

ໃນແມ່ແບບນີ້, ທ່ານຈໍາເປັນຕ້ອງກໍານົດຕົວກໍານົດຂອງສ່ວນທີ່ຢູ່ໃນເມຄທີ່ທ່ານຕ້ອງການທີ່ຈະສ້າງຮູບພາບ, ເຊັ່ນດຽວກັນກັບເສັ້ນທາງໄປຫາໄຟລ໌ທີ່ມີກະແຈຈາກບັນຊີບໍລິການທີ່ສ້າງຂຶ້ນໃນເມື່ອກ່ອນໃນພາກນີ້. ທ່ານສາມາດອ່ານເພີ່ມເຕີມກ່ຽວກັບການສ້າງບັນຊີການບໍລິການແລະລະຫັດໃນຮູບແບບຂອງໄຟລ໌ໃນພາກທີ່ສອດຄ້ອງກັນ ເອກະສານ.

ການຕັ້ງຄ່ານີ້ບອກວ່າຮູບພາບແຜ່ນຈະຖືກສ້າງຂື້ນໂດຍອີງໃສ່ເວທີ ubuntu-1804-lts, ຖືກຈັດໃສ່ໃນພາກສ່ວນຜູ້ໃຊ້ທີ່ເຫມາະສົມໃນຄອບຄົວຮູບພາບ GRAFANA ພາຍໃຕ້ຊື່ grafana-{{timestamp}}.

ຜູ້ສະໜອງ

ໃນປັດຈຸບັນມາສ່ວນທີ່ຫນ້າສົນໃຈຫຼາຍຂອງການຕັ້ງຄ່າ. ມັນຈະອະທິບາຍລໍາດັບຂອງການປະຕິບັດທີ່ຈະຕ້ອງໄດ້ຮັບການປະຕິບັດໃນ virtual machine ກ່ອນທີ່ຈະ freezing ລັດຂອງຕົນເຂົ້າໄປໃນຮູບພາບແຜ່ນ.

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

ທີ່ນີ້ການປະຕິບັດທັງຫມົດແບ່ງອອກເປັນ 3 ຂັ້ນຕອນ. ໃນຂັ້ນຕອນທໍາອິດ, script ງ່າຍດາຍຖືກປະຕິບັດທີ່ສ້າງໄດເລກະທໍລີ auxiliary.

ກະກຽມ-ctg.sh:

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

ໃນຂັ້ນຕອນຕໍ່ໄປ, ພວກເຮົາວາງສະຄິບໃນໄດເລກະທໍລີນີ້, ເຊິ່ງຈະຕ້ອງເປີດຕົວທັນທີຫຼັງຈາກເລີ່ມຕົ້ນເຄື່ອງ virtual. script ນີ້ຈະເຮັດໃຫ້ຕົວແປຜູ້ໃຊ້ທີ່ຕ້ອງການລົງທະບຽນໃນການຕັ້ງຄ່າ Grafana ແລະ restart web server.

setup.sh:

#!/bin/bash
CLUSTER_ID="<cluster_id>"
USERNAME="<username>"
PASSWORD="<password>"
sudo sed -i "s#.*;url =.*#url = mysql://${USERNAME}:${PASSWORD}@c-${CLUSTER_ID}.rw.mdb.yandexcloud.net#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${PASSWORD}#" /etc/grafana/grafana.ini
sudo service grafana-server restart

ຫຼັງ​ຈາກ​ນີ້​ຍັງ​ມີ 3 ສິ່ງ​ທີ່​ຈະ​ເຮັດ​ໄດ້​:
1) ຕິດຕັ້ງຊຸດ
2) ແລ່ນ Grafana ພາຍໃຕ້ systemctl ແລະຕິດຕັ້ງ plugin ClickHouse
3) ໃສ່ script setup.sh ໃນແຖວເປີດຕົວທັນທີຫຼັງຈາກທີ່ເປີດເຄື່ອງ virtual.

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;

ໃນປັດຈຸບັນທັງຫມົດທີ່ຍັງເຫຼືອແມ່ນເພື່ອດໍາເນີນການ Packer ແລະເອົາຮູບພາບຜົນຜະລິດທີ່ວາງໄວ້ໃນພາກທີ່ກໍານົດ. ເມື່ອສ້າງເຄື່ອງ virtual, ທ່ານສາມາດເລືອກມັນເປັນ boot disk ແລະຫຼັງຈາກເປີດຕົວທ່ານຈະໄດ້ຮັບເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ Grafana ທີ່ກຽມພ້ອມ.

ກຸ່ມຕົວຢ່າງ ແລະຕົວດຸ່ນດ່ຽງ

ເມື່ອພວກເຮົາມີຮູບພາບແຜ່ນທີ່ອະນຸຍາດໃຫ້ພວກເຮົາສ້າງເຄື່ອງແມ່ຂ່າຍເວັບ Grafana ທີ່ຄ້າຍຄືກັນຫຼາຍ, ພວກເຮົາສາມາດສ້າງກຸ່ມຕົວຢ່າງ. ໃນເວທີ Yandex.Cloud, ຄໍາສັບນີ້ຫມາຍເຖິງສະຫະພັນຂອງເຄື່ອງຈັກ virtual ທີ່ມີລັກສະນະດຽວກັນ. ເມື່ອສ້າງກຸ່ມຕົວຢ່າງ, ຕົ້ນແບບຂອງເຄື່ອງຈັກທັງຫມົດໃນກຸ່ມນີ້ແມ່ນຖືກຕັ້ງຄ່າ, ແລະຫຼັງຈາກນັ້ນລັກສະນະຂອງກຸ່ມຕົວມັນເອງ (ຕົວຢ່າງ, ຈໍານວນເຄື່ອງຈັກທີ່ມີການເຄື່ອນໄຫວຕໍ່າສຸດແລະສູງສຸດ). ຖ້າຕົວເລກປະຈຸບັນບໍ່ກົງກັບເງື່ອນໄຂເຫຼົ່ານີ້, ກຸ່ມຕົວຢ່າງຕົວມັນເອງຈະເອົາເຄື່ອງຈັກທີ່ບໍ່ຈໍາເປັນອອກຫຼືສ້າງໃຫມ່ໃນຮູບພາບຂອງຕົນເອງ.

ເປັນສ່ວນຫນຶ່ງຂອງວຽກງານຂອງພວກເຮົາ, ພວກເຮົາຈະສ້າງກຸ່ມຕົວຢ່າງຂອງເຄື່ອງແມ່ຂ່າຍເວັບໄຊຕ໌ທີ່ຈະຖືກສ້າງຂື້ນຈາກຮູບພາບແຜ່ນດິດທີ່ສ້າງຂຶ້ນກ່ອນຫນ້ານີ້.

ສິ່ງທີ່ໂດດເດັ່ນແທ້ໆແມ່ນການຕິດຕັ້ງກຸ່ມຕົວຢ່າງສຸດທ້າຍ. ກຸ່ມເປົ້າຫມາຍໃນການປະສົມປະສານກັບ Load Balancer ຈະຊ່ວຍໃຫ້ທ່ານສາມາດຕັ້ງຄ່າຕົວດຸ່ນດ່ຽງ L3 ຢູ່ເທິງເຄື່ອງ virtual ຂອງກຸ່ມນີ້ໂດຍການຄລິກສອງສາມປຸ່ມ.

ເມື່ອຕັ້ງຕົວດຸ່ນດ່ຽງ, ຂ້າພະເຈົ້າໄດ້ປະຕິບັດສອງຈຸດສໍາຄັນ:

1. ຂ້າພະເຈົ້າໄດ້ເຮັດໃຫ້ຜູ້ດຸ່ນດ່ຽງຍອມຮັບການຈະລາຈອນຂອງຜູ້ໃຊ້ໃນພອດ 80 ແລະປ່ຽນເສັ້ນທາງໄປຫາພອດ 3000 ຂອງເຄື່ອງຈັກ virtual, ແນ່ນອນວ່າບ່ອນທີ່ Grafana ອາໄສຢູ່.
2. ຂ້າ​ພະ​ເຈົ້າ​ໄດ້​ຕັ້ງ​ຄ່າ​ການ​ກວດ​ສອບ​ຄວາມ​ເປັນ​ໄປ​ໄດ້​ຂອງ​ເຄື່ອງ​ຈັກ​ໂດຍ​ການ ping ໃຫ້​ເຂົາ​ເຈົ້າ port 3000.

ສະຫຼຸບຫຍໍ້

ສຸດທ້າຍ, ພວກເຮົາສາມາດນຳໃຊ້ໂຄງສ້າງພື້ນຖານຂອງແອັບພລິເຄຊັນທີ່ຕ້ອງການໄດ້ດ້ວຍຕົນເອງ, ແລະຕອນນີ້ພວກເຮົາມີບໍລິການ Grafana ທີ່ມີຄວາມຢືດຢຸ່ນສູງ. ທ່ານພຽງແຕ່ຕ້ອງການຮູ້ທີ່ຢູ່ IP ຂອງຜູ້ດຸ່ນດ່ຽງເປັນຈຸດເຂົ້າສູ່ຄໍາຮ້ອງສະຫມັກແລະເຈົ້າພາບຂອງກຸ່ມ ClickHouse ເພື່ອໂຫລດຊຸດຂໍ້ມູນເຂົ້າໄປໃນມັນ.

ມັນເບິ່ງຄືວ່າເປັນໄຊຊະນະ? ແມ່ນແລ້ວ, ໄຊຊະນະ. ແຕ່ບາງສິ່ງບາງຢ່າງຍັງເຮັດໃຫ້ຂ້ອຍສັບສົນ. ຂະ​ບວນ​ການ​ທັງ​ຫມົດ​ຂ້າງ​ເທິງ​ນີ້​ຮຽກ​ຮ້ອງ​ໃຫ້​ມີ​ຫຼາຍ​ຂັ້ນ​ຕອນ​ຄູ່​ມື​ແລະ​ບໍ່​ສາ​ມາດ​ຂະ​ຫຍາຍ​ຕົວ​ໄດ້​ທັງ​ຫມົດ​; ຂ້າ​ພະ​ເຈົ້າ​ຢາກ​ຈະ​ເຮັດ​ໃຫ້​ມັນ​ອັດ​ຕະ​ໂນ​ມັດ​ຖ້າ​ເປັນ​ໄປ​ໄດ້​. ນີ້ແມ່ນສິ່ງທີ່ພາກຕໍ່ໄປຈະຖືກອຸທິດໃຫ້.

ການເຊື່ອມໂຍງ Terraform

ອີກເທື່ອຫນຶ່ງພວກເຮົາຈະນໍາໃຊ້ເຄື່ອງມືຈາກ HashiCorp ເອີ້ນວ່າ Terraform. ມັນຈະຊ່ວຍໃຫ້ທ່ານປັບໃຊ້ໂຄງສ້າງພື້ນຖານຂອງແອັບພລິເຄຊັນທັງຫມົດດ້ວຍການຄລິກປຸ່ມຫນຶ່ງ, ໂດຍອີງໃສ່ຕົວແປຈໍານວນຫນຶ່ງທີ່ຜ່ານໂດຍຜູ້ໃຊ້. ໃຫ້ຂຽນສູດທີ່ສາມາດດໍາເນີນການໄດ້ຫຼາຍຄັ້ງໃນສ່ວນຕ່າງໆຂອງຜູ້ໃຊ້ທີ່ແຕກຕ່າງກັນ.

ການເຮັດວຽກທັງໝົດກັບ Terraform ມາເຖິງການຂຽນໄຟລ໌ການຕັ້ງຄ່າ (*.tf) ແລະການສ້າງພື້ນຖານໂຄງລ່າງໂດຍອີງໃສ່ມັນ.

ຕົວແປ

ໃນຕອນເລີ່ມຕົ້ນຂອງໄຟລ໌, ພວກເຮົາຈະລວມເອົາຕົວແປທີ່ກໍານົດບ່ອນທີ່ແລະວິທີການໂຄງສ້າງພື້ນຖານໃນອະນາຄົດຈະຖືກນໍາໄປໃຊ້.

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

ຂະ​ບວນ​ການ​ການ​ນໍາ​ໃຊ້​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ທັງ​ຫມົດ​ຈະ​ລົງ​ມາ​ໃນ​ການ​ສ້າງ​ຮູບ​ພາບ​ແຜ່ນ​ແລະ​ການ​ຕັ້ງ​ຄ່າ​ຕົວ​ແປ​ເຫຼົ່າ​ນີ້​. ໃຫ້ຂ້ອຍອະທິບາຍສິ່ງທີ່ເຂົາເຈົ້າຮັບຜິດຊອບ:

oauth_token — token ສໍາ​ລັບ​ການ​ເຂົ້າ​ເຖິງ​ຟັງ​ໄດ້​. ສາ​ມາດ​ໄດ້​ຮັບ​ໂດຍ​ ການເຊື່ອມຕໍ່.
cloud_id — cloud identifier ທີ່​ພວກ​ເຮົາ​ຈະ​ນໍາ​ໃຊ້​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​
folder_id — ຕົວ​ລະ​ບຸ​ພາກ​ສ່ວນ​ທີ່​ພວກ​ເຮົາ​ຈະ​ນໍາ​ໃຊ້​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​
service_account_id — ຕົວລະບຸບັນຊີການບໍລິການຢູ່ໃນພາກສ່ວນທີ່ສອດຄ້ອງກັນຂອງຄລາວ.
image_id — ຕົວລະບຸຂອງຮູບພາບແຜ່ນທີ່ໄດ້ຮັບໂດຍໃຊ້ Packer
ຊື່ຜູ້ໃຊ້ и ລະຫັດຜ່ານ — ຊື່​ຜູ້​ໃຊ້​ແລະ​ລະ​ຫັດ​ຜ່ານ​ເພື່ອ​ເຂົ້າ​ເຖິງ​ຖານ​ຂໍ້​ມູນ​ທັງ​ສອງ​ແລະ Grafana web server
dbname — ຊື່ຖານຂໍ້ມູນພາຍໃນກຸ່ມ CH ແລະ MySQL
public_key_path — ເສັ້ນທາງໄປຫາໄຟລ໌ດ້ວຍລະຫັດ ssh ສາທາລະນະຂອງທ່ານ, ທີ່ທ່ານສາມາດນໍາໃຊ້ເພື່ອເຊື່ອມຕໍ່ພາຍໃຕ້ຊື່ ubuntu ກັບເຄື່ອງ virtual ກັບເຄື່ອງແມ່ຂ່າຍເວັບ

ການຕັ້ງຄ່າຜູ້ໃຫ້ບໍລິການ

ຕອນນີ້ທ່ານຕ້ອງການຕັ້ງຄ່າຜູ້ໃຫ້ບໍລິການ Terraform - ໃນກໍລະນີຂອງພວກເຮົາ, Yandex:

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

ທ່ານຈະສັງເກດເຫັນວ່າໃນທີ່ນີ້ພວກເຮົາກໍາລັງໃຊ້ຕົວແປທີ່ກໍານົດໄວ້ຂ້າງເທິງ.

ເຄືອຂ່າຍ ແລະກຸ່ມ

ໃນປັດຈຸບັນພວກເຮົາຈະສ້າງເຄືອຂ່າຍທີ່ອົງປະກອບຂອງໂຄງສ້າງພື້ນຖານຂອງພວກເຮົາຈະສື່ສານ, ສາມ subnets (ຫນຶ່ງໃນແຕ່ລະພາກພື້ນ) ແລະຍົກສູງກຸ່ມ CH ແລະ 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
  }
}

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້, ແຕ່ລະກຸ່ມຂອງສອງກຸ່ມຖືກສ້າງຂື້ນຂ້ອນຂ້າງທົນທານຕໍ່ຄວາມຜິດໂດຍການຕັ້ງຢູ່ໃນສາມເຂດທີ່ມີ.

ເຊີບເວີ

ມັນເບິ່ງຄືວ່າພວກເຮົາສາມາດສືບຕໍ່ຢູ່ໃນຈິດໃຈດຽວກັນ, ແຕ່ຂ້ອຍໄດ້ປະສົບກັບຄວາມຫຍຸ້ງຍາກ. ກ່ອນຫນ້ານີ້, ຂ້າພະເຈົ້າໄດ້ຍົກຂຶ້ນມາເປັນກຸ່ມ MySQL ທໍາອິດແລະພຽງແຕ່ຫຼັງຈາກນັ້ນ, ຮູ້ ID ຂອງມັນ, ຂ້າພະເຈົ້າໄດ້ລວບລວມຮູບພາບຂອງແຜ່ນທີ່ມີການຕັ້ງຄ່າທີ່ຕ້ອງການ, ບ່ອນທີ່ຂ້ອຍໄດ້ກໍານົດໂຮດໃຫ້ກັບກຸ່ມ. ແຕ່ຕອນນີ້ພວກເຮົາບໍ່ຮູ້ cluster ID ກ່ອນທີ່ຈະເປີດຕົວ Terraform, ລວມທັງໃນເວລາສ້າງຮູບພາບ. ເພາະສະນັ້ນ, ຂ້າພະເຈົ້າຕ້ອງໄດ້ resort ກັບດັ່ງຕໍ່ໄປນີ້ trick.

ການນໍາໃຊ້ການບໍລິການ metadata ຂອງ Amazon, ພວກເຮົາຈະຜ່ານຕົວກໍານົດການບາງຢ່າງໃຫ້ກັບເຄື່ອງ virtual, ເຊິ່ງມັນຈະຍອມຮັບແລະດໍາເນີນການ. ພວກເຮົາຕ້ອງການເຄື່ອງໄປຫາ metadata ທີ່ຢູ່ເບື້ອງຫຼັງ MySQL cluster host ແລະ username-password, ທີ່ຜູ້ໃຊ້ລະບຸໄວ້ໃນໄຟລ໌ Terraform, ຫຼັງຈາກເລີ່ມຕົ້ນ. ໃຫ້ປ່ຽນເນື້ອໃນຂອງໄຟລ໌ເລັກນ້ອຍ setup.sh, ເຊິ່ງເຮັດວຽກໃນເວລາທີ່ເຄື່ອງ virtual ເປີດ.

setup.sh:

#!/bin/bash
CLUSTER_URI="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/mysql_cluster_uri)"
USERNAME="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/username)"
PASSWORD="$(curl -H 'Metadata-Flavor:Google' http://169.254.169.254/computeMetadata/v1/instance/attributes/password)"
sudo sed -i "s#.*;url =.*#url = mysql://${USERNAME}:${PASSWORD}@${CLUSTER_URI}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_user =.*#admin_user = ${USERNAME}#" /etc/grafana/grafana.ini
sudo sed -i "s#.*;admin_password =.*#admin_password = ${PASSWORD}#" /etc/grafana/grafana.ini
sudo service grafana-server restart

ກຸ່ມ instance ແລະ balancer

ມີການສ້າງຮູບພາບແຜ່ນໃຫມ່, ໃນທີ່ສຸດພວກເຮົາສາມາດເພີ່ມໄຟລ໌ຂອງພວກເຮົາສໍາລັບ Terraform.

ໃຫ້ຊີ້ບອກວ່າພວກເຮົາຕ້ອງການໃຊ້ຮູບພາບແຜ່ນທີ່ມີຢູ່ແລ້ວ:

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

ຕອນນີ້ໃຫ້ພວກເຮົາສ້າງກຸ່ມຕົວຢ່າງ:

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

ມັນເປັນມູນຄ່າທີ່ຈະເອົາໃຈໃສ່ກັບວິທີທີ່ພວກເຮົາສົ່ງມັນເຂົ້າໄປໃນ metadata cluster_uri, username и password. ມັນແມ່ນສິ່ງເຫຼົ່ານີ້ທີ່ເຄື່ອງ virtual ຈະອອກໃນເວລາເລີ່ມຕົ້ນແລະໃສ່ໃນການຕັ້ງຄ່າ Grafana.

ມັນຂຶ້ນກັບຜູ້ດຸ່ນດ່ຽງ.

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

້ໍາຕານເລັກນ້ອຍ

ເຫຼືອພຽງໜ້ອຍດຽວ. ຫຼັງຈາກໂຄງສ້າງພື້ນຖານຖືກນໍາໄປໃຊ້ແລ້ວ, ທ່ານຈະຕ້ອງໄປທີ່ Grafana UI ແລະເພີ່ມກຸ່ມ CH ດ້ວຍຕົນເອງ (ID ທີ່ຍັງຕ້ອງໄດ້ຮັບ) ເປັນແຫລ່ງຂໍ້ມູນ. ແຕ່ Terraform ຮູ້ ID ກຸ່ມ. ຂໍ​ໃຫ້​ລາວ​ວາງ​ໃຈ​ນຳ​ເລື່ອງ​ນີ້​ໃຫ້​ເກີດ​ຜົນ.

ໃຫ້ເພີ່ມຜູ້ໃຫ້ບໍລິການໃຫມ່ - Grafana, ແລະໃຫ້ນາງທີ່ຢູ່ IP ຂອງຜູ້ດຸ່ນດ່ຽງເປັນເຈົ້າພາບ. ການປ່ຽນແປງທັງຫມົດທີ່ Terraform ເຮັດຢູ່ໃນເຄື່ອງທີ່ຕົວກໍານົດການດຸ່ນດ່ຽງຂອງມັນຈະເຕີບໂຕໃນ MySQL, ແລະດັ່ງນັ້ນໃນເຄື່ອງຈັກອື່ນໆທັງຫມົດ.

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

ໃຫ້ comb ຜົມຂອງພວກເຮົາ

ໃຫ້ສະແດງທີ່ຢູ່ IP balancer ແລະເຈົ້າພາບຂອງກຸ່ມ 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"
}

ສາມາດແລ່ນໄດ້

ທັງໝົດ! ໄຟລ໌ການຕັ້ງຄ່າຂອງພວກເຮົາແມ່ນພ້ອມແລ້ວ ແລະພວກເຮົາສາມາດ, ໂດຍການຕັ້ງຄ່າຕົວແປ, ບອກ Terraform ໃຫ້ຍົກທຸກສິ່ງທີ່ພວກເຮົາໄດ້ອະທິບາຍຂ້າງເທິງ. ຂະບວນການທັງຫມົດໃຊ້ເວລາຂ້າພະເຈົ້າປະມານ 15 ນາທີ.
ໃນທີ່ສຸດເຈົ້າສາມາດເຫັນຂໍ້ຄວາມທີ່ສວຍງາມ:

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

ແລະຢູ່ໃນຄລາວ, ອົງປະກອບຂອງໂຄງສ້າງພື້ນຖານທີ່ຍົກຂຶ້ນມາຈະເຫັນໄດ້:

ໃຫ້ສະຫຼຸບຜົນໄດ້ຮັບ

ໃນປັດຈຸບັນ, ການນໍາໃຊ້ Grafana ເປັນຕົວຢ່າງ, ແຕ່ລະຄົນສາມາດນໍາໄປໃຊ້ຄໍາຮ້ອງສະຫມັກທີ່ມີສະຖາປັດຕະຍະກໍາເມຄທີ່ກວ້າງຂວາງໃນເວທີ Yandex.Cloud. ເຄື່ອງມືທີ່ເປັນປະໂຫຍດຈາກ HashiCorp ເຊັ່ນ Packer ແລະ Terraform ສາມາດຊ່ວຍທ່ານໄດ້. ຂ້ອຍຫວັງວ່າບາງຄົນເຫັນວ່າບົດຄວາມນີ້ເປັນປະໂຫຍດ :)

PS ຂ້າງລຸ່ມນີ້ຂ້າພະເຈົ້າຈະຄັດຕິດການເຊື່ອມຕໍ່ກັບ repository ບ່ອນທີ່ທ່ານສາມາດຊອກຫາສູດທີ່ກຽມພ້ອມສໍາລັບ Packer ແລະ Terraform, fragments ທີ່ຂ້າພະເຈົ້າສະຫນອງໃຫ້ໃນບົດຄວາມນີ້.

ຄັງເກັບມ້ຽນ

ແຫຼ່ງຂໍ້ມູນ: www.habr.com