ការដាក់ឱ្យប្រើប្រាស់សេវាកម្មចែកចាយនៅក្នុង Yandex.Cloud ដោយប្រើ Grafana ជាឧទាហរណ៍

សួស្តី​អ្នក​ទាំងអស់គ្នា! ជាផ្នែកមួយនៃការងារវគ្គសិក្សារបស់ខ្ញុំ ខ្ញុំកំពុងស្រាវជ្រាវពីលទ្ធភាពនៃវេទិកាពពកក្នុងស្រុកដូចជា Yandex.Cloud. វេទិកាផ្តល់ជូននូវសេវាកម្មផ្សេងៗសម្រាប់ការដោះស្រាយបញ្ហាជាក់ស្តែង។ ទោះយ៉ាងណាក៏ដោយ ពេលខ្លះវាចាំបាច់ដើម្បីកំណត់រចនាសម្ព័ន្ធកម្មវិធីពពករបស់អ្នកជាមួយនឹងហេដ្ឋារចនាសម្ព័ន្ធទូលំទូលាយដោយផ្អែកលើសេវាកម្មទាំងនេះ។ នៅក្នុងអត្ថបទនេះ ខ្ញុំចង់ចែករំលែកបទពិសោធន៍នៃការដាក់ពង្រាយកម្មវិធីបែបនេះ។

តើអ្នកចង់ទទួលបានអ្វី?

ហ្គ្រេណាណា - ឧបករណ៍ដ៏មានអានុភាពសម្រាប់ដោះស្រាយបញ្ហាវិភាគ ឬត្រួតពិនិត្យបញ្ហានៃប្រព័ន្ធណាមួយ។ នៅក្នុងការកំណត់រចនាសម្ព័ន្ធមូលដ្ឋានរបស់វា នេះគឺជាម៉ាស៊ីននិម្មិតដែលមានម៉ាស៊ីនមេគេហទំព័រ Grafana ក៏ដូចជាមូលដ្ឋានទិន្នន័យ (ClickHouse, InfluxDB ។ល។) ជាមួយនឹងសំណុំទិន្នន័យដែលនឹងត្រូវបានប្រើដើម្បីបង្កើតការវិភាគ។

បន្ទាប់ពីចាប់ផ្តើមម៉ាស៊ីននិម្មិតជាមួយម៉ាស៊ីនមេគេហទំព័រ អ្នកអាចចូលទៅកាន់ម៉ាស៊ីនរបស់វា ហើយទទួលបាន UI ដ៏ស្រស់ស្អាត បញ្ជាក់មូលដ្ឋានទិន្នន័យជាប្រភពសម្រាប់ការងារបន្ថែម បង្កើតផ្ទាំងគ្រប់គ្រង និងក្រាហ្វ។

កំណែមូលដ្ឋានមានគុណវិបត្តិសំខាន់មួយ - វាមិនមានភាពអត់ធ្មត់ទាល់តែសោះ។ នោះ​គឺ​ការ​អនុវត្ត​កម្មវិធី​ទាំងមូល​អាស្រ័យ​លើ​លទ្ធភាព​ជោគជ័យ​នៃ​ម៉ាស៊ីន​និម្មិត​មួយ។ ប្រសិនបើនាងបដិសេធ ឬប្រសិនបើមនុស្ស 10 នាក់បើក UI ក្នុងពេលតែមួយនោះបញ្ហានឹងកើតឡើង។

ពួកវាត្រូវបានដោះស្រាយយ៉ាងសាមញ្ញ៖ អ្នកគ្រាន់តែត្រូវដាក់ឱ្យប្រើប្រាស់ម៉ាស៊ីននិម្មិតដែលដូចគ្នាបេះបិទជាច្រើនជាមួយម៉ាស៊ីនមេគេហទំព័រ ហើយដាក់វានៅក្រោមតុល្យភាព L3 ។ ប៉ុន្តែមិនមែនអ្វីៗទាំងអស់គឺច្បាស់ណាស់នៅទីនេះ។ Grafana រក្សាទុកការកំណត់អ្នកប្រើប្រាស់ (ផ្លូវទៅកាន់មូលដ្ឋានទិន្នន័យ ផ្ទាំងគ្រប់គ្រង ក្រាហ្វិក។ល។) ដោយផ្ទាល់នៅលើថាសនៃម៉ាស៊ីននិម្មិតរបស់វា។ ដូច្នេះ ប្រសិនបើអ្នកផ្លាស់ប្តូរការកំណត់មួយចំនួននៅក្នុង UI នោះការផ្លាស់ប្តូរទាំងនេះនឹងត្រូវបានបង្ហាញតែនៅលើម៉ាស៊ីននិម្មិតដែលអ្នកតុល្យភាពបានផ្ញើមកយើង។ វានឹងនាំឱ្យមានការកំណត់មិនស៊ីសង្វាក់គ្នាសម្រាប់កម្មវិធីរបស់យើង បញ្ហាជាមួយនឹងការបើកដំណើរការ និងការប្រើប្រាស់។

នៅទីនេះ មូលដ្ឋានទិន្នន័យមួយផ្សេងទៀតនឹងមកជួយសង្គ្រោះ ឧទាហរណ៍ MySQL ឬសមមូលរបស់វា។ យើងប្រាប់ Grafana ថានាងគួរតែរក្សាទុកការកំណត់អ្នកប្រើប្រាស់នៅក្នុងមូលដ្ឋានទិន្នន័យ "ទំនេរ" នេះ។ បន្ទាប់ពីនោះ វានឹងគ្រប់គ្រាន់ដើម្បីបញ្ជាក់ផ្លូវទៅកាន់មូលដ្ឋានទិន្នន័យនេះនៅលើម៉ាស៊ីននីមួយៗម្តង ហើយកែសម្រួលការកំណត់អ្នកប្រើប្រាស់ផ្សេងទៀតទាំងអស់នៅលើម៉ាស៊ីននិម្មិតណាមួយ ពួកគេនឹងរីកចម្រើននៅលើអ្វីដែលនៅសល់។

នេះគឺជាដ្យាក្រាមនៃរចនាសម្ព័ន្ធកម្មវិធីចុងក្រោយ៖

រៀនលើកដៃរបស់អ្នក

MySQL និង ClickHouse

មុនពេលដាក់ឱ្យប្រើប្រាស់កម្មវិធីបែបនេះដោយចុចប៊ូតុងមួយ វាចាំបាច់ត្រូវរៀនពីរបៀបលើកសមាសធាតុនីមួយៗរបស់វាដោយប្រើចំណុចទាញ ហើយបញ្ចូលពួកវាជាមួយគ្នា។

Yandex.Cloud នឹងជួយយើងនៅទីនេះ ដែលផ្តល់ L3 balancers, ClickHouse និង MySQL ជាសេវាកម្មគ្រប់គ្រង។ អ្នកប្រើប្រាស់គ្រាន់តែត្រូវការបញ្ជាក់ប៉ារ៉ាម៉ែត្រ ហើយរង់ចាំរហូតដល់វេទិកានាំអ្វីៗគ្រប់យ៉ាងចូលទៅក្នុងស្ថានភាពដំណើរការ។

ខ្ញុំបានចុះឈ្មោះ បង្កើតពពក និងគណនីវិក្កយបត្រសម្រាប់ខ្លួនខ្ញុំ។ បន្ទាប់ពីនោះ ខ្ញុំបានចូលទៅក្នុងពពក ហើយបានលើកឡើងនូវ MySQL និង ClickHouse clusters ជាមួយនឹងការកំណត់តិចតួចបំផុត។ រង់ចាំរហូតដល់ពួកគេសកម្ម។

អ្នកក៏ត្រូវចងចាំផងដែរ ដើម្បីបង្កើតមូលដ្ឋានទិន្នន័យនៅក្នុងចង្កោមនីមួយៗ ហើយកំណត់រចនាសម្ព័ន្ធការចូលប្រើវាដោយការចូល និងពាក្យសម្ងាត់។ ខ្ញុំនឹងមិនចូលទៅក្នុងព័ត៌មានលម្អិតនៅទីនេះទេ - អ្វីគ្រប់យ៉ាងគឺជាក់ស្តែងនៅក្នុងចំណុចប្រទាក់។

ព័ត៌មានលម្អិតមិនច្បាស់គឺថា មូលដ្ឋានទិន្នន័យទាំងនេះមានម៉ាស៊ីនជាច្រើនដែលផ្តល់នូវការអត់ឱនចំពោះកំហុសរបស់ពួកគេ។ ទោះយ៉ាងណាក៏ដោយ Grafana ត្រូវការម៉ាស៊ីនមួយយ៉ាងពិតប្រាកដសម្រាប់មូលដ្ឋានទិន្នន័យនីមួយៗដែលវាធ្វើការជាមួយ។ ការអានយូរ ឯកសារ ពពកនាំខ្ញុំទៅរកការសម្រេចចិត្ត។ វាប្រែថាម៉ាស៊ីននៃទម្រង់មួយ។ c-<cluster_id>.rw.mdb.yandexcloud.net ផែនទីទៅកាន់ម៉ាស៊ីនមេចង្កោមសកម្មបច្ចុប្បន្នជាមួយនឹងលេខសម្គាល់ដែលត្រូវគ្នា។ នោះហើយជាអ្វីដែលយើងនឹងផ្តល់ឱ្យ Grafana ។

ម៉ាស៊ីនមេបណ្តាញ

ឥឡូវនេះវាអាស្រ័យលើម៉ាស៊ីនមេគេហទំព័រ។ ចូរលើកម៉ាស៊ីននិម្មិតធម្មតាជាមួយលីនុច ហើយដំឡើង 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 ហើយដំឡើងកម្មវិធីជំនួយសម្រាប់ធ្វើការជាមួយ 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 ខាងក្រៅរបស់ម៉ាស៊ីននិម្មិតនៅក្នុងកម្មវិធីរុករក បញ្ជាក់ច្រក 3000 និងមើល UI grafana ដ៏ស្រស់ស្អាត។

ប៉ុន្តែកុំប្រញាប់ប្រញាល់មុនពេលដំឡើង 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

ទាំងអស់! យើង​មាន​ម៉ាស៊ីន​និម្មិត​មួយ​ដែល​ធ្វើ​ការ​ជាមួយ​នឹង web server ដែល​បាន​តភ្ជាប់​ទៅ CH និង MySQL ។ អ្នកអាចបង្ហោះសំណុំទិន្នន័យទៅ ClickHouse និងបង្កើតផ្ទាំងគ្រប់គ្រងរួចហើយ។ ទោះជាយ៉ាងណាក៏ដោយ យើងមិនទាន់បានទៅដល់គោលដៅរបស់យើង និងមិនទាន់បានប្រើប្រាស់ហេដ្ឋារចនាសម្ព័ន្ធពេញលេញនៅឡើយ។

ផាកកឺ

Yandex.Cloud អនុញ្ញាតឱ្យអ្នកបង្កើតរូបភាពថាសនៃម៉ាស៊ីននិម្មិតដែលមានស្រាប់ ហើយផ្អែកលើវា អ្នកអាចបង្កើតម៉ាស៊ីនដូចគ្នាបេះបិទបានច្រើនតាមដែលអ្នកចូលចិត្ត។ នេះគឺជាអ្វីដែលយើងនឹងប្រើ។ ដើម្បីផ្គុំរូបភាពបានយ៉ាងងាយស្រួល សូមយកឧបករណ៍ ផាកកឺ ពី HashiCorp ។ វាត្រូវការពេលបញ្ចូលឯកសារ json ជាមួយនឹងការណែនាំសម្រាប់បង្កើតរូបភាព។

ឯកសារ json របស់យើងនឹងមានប្លុកពីរ៖ អ្នកសាងសង់និងអ្នកផ្តល់។ ប្លុកទីមួយពិពណ៌នាអំពីប៉ារ៉ាម៉ែត្រនៃរូបភាពខ្លួនវាថាជាអង្គភាពមួយ ហើយប្លុកទីពីរពិពណ៌នាអំពីការណែនាំសម្រាប់ការបំពេញវាជាមួយនឹងមាតិកាចាំបាច់។

ក្រុមហ៊ុនសាងសង់

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

អ្នកផ្តល់សេវា

ឥឡូវនេះសម្រាប់ផ្នែកគួរឱ្យចាប់អារម្មណ៍បន្ថែមទៀតនៃការកំណត់រចនាសម្ព័ន្ធ។ វានឹងពិពណ៌នាអំពីលំដាប់នៃសកម្មភាពដែលនឹងត្រូវអនុវត្តនៅលើម៉ាស៊ីននិម្មិត មុនពេលបង្កកស្ថានភាពរបស់វាទៅជារូបភាពឌីស។

{
...,
"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 ដំណាក់កាល។ នៅដំណាក់កាលដំបូង ស្គ្រីបសាមញ្ញមួយត្រូវបានប្រតិបត្តិដែលបង្កើតបញ្ជីជំនួយ។

រៀបចំ-ctg.sh៖

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

នៅដំណាក់កាលបន្ទាប់ យើងដាក់ស្គ្រីបនៅក្នុងថតនេះ ដែលនឹងត្រូវដំណើរការភ្លាមៗបន្ទាប់ពីចាប់ផ្តើមម៉ាស៊ីននិម្មិត។ ស្គ្រីបនេះនឹងដាក់អថេរអ្នកប្រើប្រាស់ដែលត្រូវកំណត់ក្នុងការកំណត់របស់ Grafana ហើយចាប់ផ្តើមម៉ាស៊ីនមេគេហទំព័រឡើងវិញ។

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

បន្ទាប់​មក​មាន​កិច្ចការ​៣​ដែល​ត្រូវ​ធ្វើ៖
1) ដំឡើងកញ្ចប់
2) ចាប់ផ្តើម Grafana នៅក្រោម systemctl ហើយដំឡើងកម្មវិធីជំនួយ ClickHouse
3) ដាក់ស្គ្រីប setup.sh ក្នុងជួរដើម្បីដំណើរការភ្លាមៗបន្ទាប់ពីបើកម៉ាស៊ីននិម្មិត។

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 និងទទួលបានរូបភាពលទ្ធផលដែលដាក់ក្នុងភាគថាសដែលបានបញ្ជាក់។ នៅពេលបង្កើតម៉ាស៊ីននិម្មិត អ្នកអាចជ្រើសរើសវាជាថាសចាប់ផ្ដើម ហើយបន្ទាប់ពីចាប់ផ្តើម ទទួលបានម៉ាស៊ីនមេគេហទំព័រ Grafana ដែលត្រៀមរួចជាស្រេច។

ក្រុមឧទាហរណ៍ និងសមតុល្យ

នៅពេលដែលមានរូបភាពឌីសដែលអនុញ្ញាតឱ្យអ្នកបង្កើតម៉ាស៊ីនមេបណ្តាញ Grafana ដូចគ្នាជាច្រើន យើងអាចបង្កើតក្រុម instance មួយ។ នៅលើវេទិកា Yandex.Cloud ពាក្យនេះសំដៅទៅលើការរួបរួមនៃម៉ាស៊ីននិម្មិតដែលមានលក្ខណៈដូចគ្នា។ នៅពេលបង្កើតក្រុម instance គំរូនៃម៉ាស៊ីនទាំងអស់នៅក្នុងក្រុមនេះត្រូវបានកំណត់រចនាសម្ព័ន្ធ ហើយបន្ទាប់មកលក្ខណៈនៃក្រុមខ្លួនវា (ឧទាហរណ៍ ចំនួនអប្បបរមា និងអតិបរមានៃម៉ាស៊ីនសកម្ម)។ ប្រសិនបើលេខបច្ចុប្បន្នមិនបំពេញតាមលក្ខណៈវិនិច្ឆ័យនេះទេ នោះក្រុមឧទាហរណ៍ខ្លួនឯងនឹងដកម៉ាស៊ីនដែលមិនចាំបាច់ចេញ ឬបង្កើតថ្មីក្នុងរូបភាព និងរូបរាង។

ជាផ្នែកនៃកិច្ចការរបស់យើង យើងនឹងបង្កើតក្រុម instance នៃ web servers ដែលនឹងត្រូវបានបង្កើតចេញពីរូបភាពឌីសដែលបានបង្កើតពីមុន។

ការកំណត់ក្រុមឧទាហរណ៍ចុងក្រោយគឺពិតជាគួរឱ្យកត់សម្គាល់។ ក្រុមគោលដៅក្នុងការរួមបញ្ចូលជាមួយ Load Balancer នឹងជួយអ្នករៀបចំ L3 Balancer នៅផ្នែកខាងលើនៃម៉ាស៊ីននិម្មិតនៃក្រុមនេះដោយចុចប៊ូតុងពីរបី។

នៅពេលដំឡើងឧបករណ៍តុល្យភាព ខ្ញុំបានអនុវត្តចំណុចសំខាន់ពីរ៖

1. ខ្ញុំបានធ្វើវាដើម្បីឱ្យសមតុល្យទទួលយកចរាចរអ្នកប្រើប្រាស់នៅលើច្រក 80 ហើយបានប្តូរទិសវាទៅច្រក 3000 នៃម៉ាស៊ីននិម្មិត ជាកន្លែងដែល Grafana រស់នៅ។
2. ដំឡើងការត្រួតពិនិត្យសុខភាពរបស់ម៉ាស៊ីនដោយ ping ពួកវានៅលើច្រក 3000។

សរុបតូច

ទីបំផុត យើងអាចដាក់ពង្រាយហេដ្ឋារចនាសម្ព័ន្ធកម្មវិធីដែលចង់បានដោយដៃ ហើយឥឡូវនេះយើងមានសេវាកម្ម Grafana ដែលអាចធន់ទ្រាំបានខ្ពស់។ វាគ្រាន់តែជាការចាំបាច់ដើម្បីដឹងពីអាសយដ្ឋាន IP របស់ Balancer ដែលជាចំណុចចូលទៅកាន់កម្មវិធី និងម៉ាស៊ីនរបស់ ClickHouse cluster ដើម្បីផ្ទុកសំណុំទិន្នន័យទៅក្នុងវា។

វាហាក់ដូចជាជ័យជំនះ? បាទ ជ័យជំនះ។ ប៉ុន្តែមានអ្វីមួយនៅតែរំខានខ្ញុំ។ ដំណើរការទាំងមូលខាងលើតម្រូវឱ្យមានសកម្មភាពដោយដៃច្រើន ហើយមិនធ្វើមាត្រដ្ឋានទាល់តែសោះ ខ្ញុំចង់ធ្វើឱ្យវាដោយស្វ័យប្រវត្តិប្រសិនបើអាចធ្វើទៅបាន។ នេះនឹងជាការផ្តោតអារម្មណ៍នៃផ្នែកបន្ទាប់។

ការរួមបញ្ចូលជាមួយ 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>"
}

ដំណើរការទាំងមូលនៃការដាក់ពង្រាយកម្មវិធីនឹងចុះមកដើម្បីបង្កើតរូបភាពថាស និងកំណត់អថេរទាំងនេះ។ ខ្ញុំសូមពន្យល់ពីអ្វីដែលពួកគេទទួលខុសត្រូវ៖

outh_token - សញ្ញាសម្ងាត់សម្រាប់ការចូលទៅកាន់ពពក។ អាចទទួលបានដោយ តំណភ្ជាប់.
cloud_id - ការកំណត់អត្តសញ្ញាណនៃពពកដែលយើងនឹងដាក់ពង្រាយកម្មវិធី
folder_id - ការកំណត់អត្តសញ្ញាណនៃផ្នែកដែលយើងនឹងដាក់ឱ្យប្រើប្រាស់កម្មវិធី
service_account_id - ការកំណត់អត្តសញ្ញាណគណនីសេវាកម្មនៅក្នុងផ្នែកដែលត្រូវគ្នានៃពពក។
image_id - ការកំណត់អត្តសញ្ញាណនៃរូបភាពថាសដែលទទួលបានដោយប្រើ Packer
username и ពាក្យសម្ងាត់ - ឈ្មោះអ្នកប្រើនិងពាក្យសម្ងាត់ដើម្បីចូលប្រើមូលដ្ឋានទិន្នន័យទាំងពីរនិងម៉ាស៊ីនមេបណ្តាញ Grafana
dbname - ឈ្មោះមូលដ្ឋានទិន្នន័យនៅខាងក្នុង CH និង MySQL clusters
public_key_path - ផ្លូវទៅកាន់ឯកសារដោយប្រើសោសាធារណៈ ssh របស់អ្នក ដែលអ្នកអាចភ្ជាប់នៅក្រោមឈ្មោះ ubuntu ទៅម៉ាស៊ីននិម្មិតជាមួយម៉ាស៊ីនមេគេហទំព័រ

ការកំណត់អ្នកផ្តល់សេវា

ឥឡូវអ្នកត្រូវកំណត់រចនាសម្ព័ន្ធអ្នកផ្តល់សេវា Terraform - ក្នុងករណីរបស់យើង Yandex៖

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

អ្នកអាចមើលឃើញថានៅទីនេះយើងកំពុងប្រើអថេរដែលបានកំណត់ខាងលើ។

បណ្តាញ និងចង្កោម

ឥឡូវនេះ ចូរយើងបង្កើតបណ្តាញមួយដែលធាតុនៃហេដ្ឋារចនាសម្ព័ន្ធរបស់យើងនឹងទាក់ទងគ្នា បណ្តាញរងចំនួនបី (មួយក្នុងតំបន់នីមួយៗ) និងបង្កើនចង្កោម 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 ជាមុនសិន ហើយបន្ទាប់ពីនោះដោយដឹងពីលេខសម្គាល់របស់វា ខ្ញុំបានប្រមូលរូបភាពថាសជាមួយនឹងការកំណត់ដែលចង់បាន ដែលខ្ញុំបញ្ជាក់ម៉ាស៊ីនទៅចង្កោម។ ប៉ុន្តែឥឡូវនេះយើងមិនដឹងអំពីលេខសម្គាល់ចង្កោមមុនពេលចាប់ផ្តើមនៃ Terraform រួមទាំងនៅពេលបង្កើតរូបភាពផងដែរ។ ដូច្នេះខ្ញុំត្រូវងាកទៅរកចំណុចខាងក្រោម ល្បិច.

ដោយប្រើសេវាកម្មទិន្នន័យមេតាពី Amazon យើងនឹងបញ្ជូនប៉ារ៉ាម៉ែត្រមួយចំនួនទៅកាន់ម៉ាស៊ីននិម្មិត ដែលវានឹងទទួលយក និងដំណើរការ។ យើងត្រូវការម៉ាស៊ីនដើម្បីចូលទៅកាន់ទិន្នន័យមេតាសម្រាប់ម៉ាស៊ីន MySQL នៃចង្កោម និងសម្រាប់ឈ្មោះអ្នកប្រើប្រាស់-ពាក្យសម្ងាត់ដែលអ្នកប្រើប្រាស់បានបញ្ជាក់នៅក្នុងឯកសារ Terraform បន្ទាប់ពីចាប់ផ្តើម។ ផ្លាស់ប្តូរមាតិកានៃឯកសារបន្តិច setup.shដែលដំណើរការនៅពេលដែលម៉ាស៊ីននិម្មិតត្រូវបានបើក។

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

វាគួរអោយយកចិត្តទុកដាក់ចំពោះរបៀបដែលយើងបានឆ្លងទៅទិន្នន័យមេតា cluster_uri, username и password. វាគឺជាម៉ាស៊ីននិម្មិតរបស់ពួកគេ ដែលនឹងទទួលបានវានៅពេលចាប់ផ្តើម ហើយដាក់វានៅក្នុងការកំណត់រចនាសម្ព័ន្ធ 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 ដោយដៃ (លេខសម្គាល់ដែលអ្នកនៅតែត្រូវការដើម្បីទទួលបាន) ជាប្រភពទិន្នន័យ។ ប៉ុន្តែ Terraform ស្គាល់អត្តសញ្ញាណចង្កោម។ សូម​ឲ្យ​គាត់​បញ្ចប់​ការងារ។

តោះបន្ថែមអ្នកផ្តល់សេវាថ្មី - Grafana ហើយរអិល IP របស់ Balancer ជាម៉ាស៊ីន។ ការផ្លាស់ប្តូរទាំងអស់ដែល 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"
}

តោះសិតសក់

បង្ហាញ IP ដែលមានតុល្យភាព និងម៉ាស៊ីនចង្កោម 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 ខាងក្រោមនេះខ្ញុំនឹងភ្ជាប់តំណភ្ជាប់ទៅកាន់ឃ្លាំង ដែលអ្នកអាចស្វែងរករូបមន្តដែលត្រៀមរួចជាស្រេចសម្រាប់ Packer និង Terraform ដែលជាបំណែកដែលខ្ញុំបានលើកឡើងនៅក្នុងអត្ថបទនេះ។

ឃ្លាំង

ប្រភព: www.habr.com