🥇उदाहरण के रूप में ग्राफाना का उपयोग करके Yandex.Cloud में वितरित सेवाओं को तैनात करना

नमस्ते! अपने पाठ्यक्रम के एक भाग के रूप में, मैं ऐसे घरेलू क्लाउड प्लेटफ़ॉर्म की क्षमताओं पर शोध कर रहा था यांडेक्स.क्लाउड. यह मंच व्यावहारिक समस्याओं के समाधान के लिए विभिन्न सेवाएं प्रदान करता है। हालाँकि, कभी-कभी इन सेवाओं पर आधारित काफी व्यापक बुनियादी ढांचे के साथ अपना स्वयं का क्लाउड एप्लिकेशन स्थापित करना आवश्यक होता है। इस लेख में मैं ऐसे ही एक एप्लिकेशन को तैनात करने के अपने अनुभव को साझा करना चाहता हूं।

आप क्या पाना चाहते हैं?

ग्राफाना — विश्लेषणात्मक समस्याओं को सुलझाने या किसी भी प्रणाली की समस्याओं की निगरानी के लिए एक शक्तिशाली उपकरण। अपने मूल विन्यास में, यह एक ग्राफाना वेब सर्वर के साथ एक वर्चुअल मशीन है, साथ ही एक डाटासेट के साथ एक डेटाबेस (क्लिकहाउस, इन्फ्लक्सडीबी, आदि) है, जिसके अनुसार एनालिटिक्स का निर्माण किया जाएगा।

वेब सर्वर के साथ वर्चुअल मशीन लॉन्च करने के बाद, आप इसके होस्ट पर जा सकते हैं और एक अच्छा यूआई प्राप्त कर सकते हैं, आगे के काम के लिए डेटाबेस को स्रोत के रूप में निर्दिष्ट कर सकते हैं, डैशबोर्ड और ग्राफ बना सकते हैं।

मूल संस्करण में एक महत्वपूर्ण कमी है - यह बिल्कुल भी दोष-सहिष्णु नहीं है। अर्थात्, अनुप्रयोग की सम्पूर्ण कार्यक्षमता एक वर्चुअल मशीन की व्यवहार्यता पर निर्भर करती है। यदि यह विफल हो जाए या 10 लोग एक ही समय में यूआई खोलें, तो समस्या उत्पन्न हो जाएगी।

इनका समाधान सरलता से किया जा सकता है: आपको बस एक वेब सर्वर के साथ कई समान वर्चुअल मशीनों को तैनात करना होगा और उन्हें L3 बैलेंसर के अंतर्गत रखना होगा। लेकिन यहां सब कुछ इतना स्पष्ट नहीं है। ग्राफाना उपयोगकर्ता सेटिंग्स (डेटाबेस, डैशबोर्ड, ग्राफ आदि के पथ) को सीधे अपनी वर्चुअल मशीन की डिस्क पर संग्रहीत करता है। इस प्रकार, यदि आप UI में कोई सेटिंग बदलते हैं, तो ये परिवर्तन केवल उस वर्चुअल मशीन पर प्रदर्शित होंगे जहां बैलेंसर ने हमें भेजा है। इससे हमारे एप्लिकेशन की सेटिंग्स असंगत हो जाएंगी, इसे लॉन्च करने और उपयोग करने में समस्याएं आएंगी।

यहां एक अन्य डाटाबेस बचाव के लिए आएगा, उदाहरण के लिए, MySQL या इसके समकक्ष। हम ग्राफाना को बताते हैं कि उसे उपयोगकर्ता सेटिंग्स को इस "अतिरिक्त" डेटाबेस में संग्रहीत करना चाहिए। इसके बाद, प्रत्येक मशीन पर एक बार इस डेटाबेस का पथ निर्दिष्ट करना और किसी भी वर्चुअल मशीन पर अन्य सभी उपयोगकर्ता सेटिंग्स को संपादित करना पर्याप्त होगा; वे दूसरों तक फैल जायेंगे।

अंतिम अनुप्रयोग अवसंरचना का आरेख यहां दिया गया है:

आइये अपने हाथों से उठाना सीखें

MySQL और ClickHouse

बटन दबाकर इस तरह के अनुप्रयोग को क्रियान्वित करने से पहले, यह सीखना पड़ता था कि इसके प्रत्येक घटक को हैंडल से कैसे उठाया जाए और उन्हें एक दूसरे के साथ कैसे एकीकृत किया जाए।

यहां हमें Yandex.Cloud से सहायता मिलेगी, जो प्रबंधित सेवाओं के रूप में L3 बैलेंसर्स, ClickHouse और MySQL प्रदान करता है। उपयोगकर्ता को केवल पैरामीटर निर्दिष्ट करने और तब तक प्रतीक्षा करने की आवश्यकता होती है जब तक कि प्लेटफॉर्म सब कुछ कार्यशील स्थिति में न ले आए।

मैंने पंजीकरण कराया, एक क्लाउड और एक भुगतान खाता बनाया। इसके बाद, मैं क्लाउड पर गया और न्यूनतम सेटिंग्स के साथ MySQL और ClickHouse क्लस्टर स्थापित किया। उनके सक्रिय होने तक इंतजार किया गया।

आपको यह भी याद रखना होगा कि प्रत्येक क्लस्टर में एक डेटाबेस बनाएं और लॉगिन और पासवर्ड का उपयोग करके उस तक पहुंच स्थापित करें। मैं यहां विस्तार में नहीं जाऊंगा - इंटरफ़ेस में सब कुछ स्पष्ट है।

कम स्पष्ट विवरण यह था कि इन डेटाबेस में एकाधिक होस्ट होते हैं, जो उनकी गलती सहनशीलता सुनिश्चित करते हैं। हालाँकि, ग्राफाना को प्रत्येक डाटाबेस के लिए एक ही होस्ट की आवश्यकता होती है। लंबा पढें प्रलेखन बादलों ने मुझे समाधान तक पहुंचाया। इससे पता चलता है कि मेजबान उस प्रजाति का है c-<cluster_id>.rw.mdb.yandexcloud.net वर्तमान सक्रिय क्लस्टर मास्टर होस्ट को संगत आईडी के साथ मैप किया गया। यह वही है जो हम ग्राफाना को देंगे।

वेब सर्वर

अब वेब सर्वर की बारी है। चलिए एक सामान्य वर्चुअल मशीन सेटअप करते हैं। Linux और हम अपने हाथों से इस पर ग्राफाना स्थापित करेंगे।

आइए 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

उसके बाद, हम systemctl के अंतर्गत Grafana शुरू करेंगे और ClickHouse के साथ काम करने के लिए एक प्लगइन स्थापित करेंगे (हां, यह मूल पैकेज में शामिल नहीं है)।

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

बस इतना ही, इस सरल आदेश के बाद

sudo service grafana-server start

हम एक वेब सर्वर लॉन्च करेंगे। अब आप ब्राउज़र में वर्चुअल मशीन का बाहरी आईपी पता दर्ज कर सकते हैं, पोर्ट 3000 निर्दिष्ट कर सकते हैं और सुंदर ग्राफाना यूआई देख सकते हैं।

लेकिन जल्दबाजी न करें, ग्राफाना को स्थापित करने से पहले, आपको सेटिंग्स को संग्रहीत करने के लिए MySQL का पथ निर्दिष्ट करना याद रखना होगा।

ग्राफ़ाना वेब सर्वर का संपूर्ण कॉन्फ़िगरेशन फ़ाइल में स्थित है /etc/grafana/grafana.ini. आपको जिस लाइन की आवश्यकता है वह इस प्रकार है:

;url =

हम होस्ट को MySQL क्लस्टर के समक्ष प्रस्तुत करते हैं। इसी फ़ाइल में ऊपर चित्र में ग्राफाना तक पहुंचने के लिए लॉगिन और पासवर्ड है, जो दोनों डिफ़ॉल्ट रूप से बराबर हैं। 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

अब ग्राफाना यूआई में हम ClickHouse को डेटा स्रोत के रूप में निर्दिष्ट करेंगे।

मैं निम्नलिखित सेटिंग्स के साथ एक कार्यशील कॉन्फ़िगरेशन प्राप्त करने में सक्षम था:

मैंने जो URL निर्दिष्ट किया है https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

सभी! हमारे पास एक कार्यशील VM है जिसका वेब सर्वर CH और MySQL से जुड़ा हुआ है। आप पहले से ही ClickHouse पर डेटासेट अपलोड कर सकते हैं और डैशबोर्ड बना सकते हैं। हालाँकि, हम अभी तक अपना लक्ष्य हासिल नहीं कर पाए हैं और पूर्ण विकसित बुनियादी ढांचा स्थापित नहीं कर पाए हैं।

पैकर

Yandex.Cloud आपको किसी मौजूदा वर्चुअल मशीन की डिस्क छवि बनाने की अनुमति देता है, और इसके आधार पर - किसी भी संख्या में समान मशीनें। हम वास्तव में इसी बात का लाभ उठाएंगे। छवि को सुविधाजनक ढंग से संयोजित करने के लिए, आइए उपकरण लें पैकर हाशिकॉर्प से. यह छवि को संयोजित करने के निर्देशों के साथ एक 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

अगले चरण में, हम इस निर्देशिका में एक स्क्रिप्ट रखते हैं जिसे वर्चुअल मशीन शुरू करने के तुरंत बाद चलाना होगा। यह स्क्रिप्ट उन उपयोगकर्ता वेरिएबल्स को डाल देगी जिन्हें ग्राफाना कॉन्फ़िगरेशन में लिखा जाना आवश्यक है और वेब सर्वर को पुनः आरंभ करेगी।

सेटअप.श:

#!/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) systemctl के अंतर्गत Grafana चलाएँ और ClickHouse प्लगइन स्थापित करें
3) वर्चुअल मशीन चालू करने के तुरंत बाद setup.sh स्क्रिप्ट को रन कतार में डालें।

इंस्टॉल-पैकेज.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

रन-सेटअप-एट-रिबूट.श:

#!/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;

अब बस पैकर को चलाना है और छवि को आउटपुट के रूप में निर्दिष्ट अनुभाग में रखना है। वर्चुअल मशीन बनाते समय, आप इसे बूट डिस्क के रूप में चुन सकते हैं और इसे लॉन्च करने के बाद, आपको एक तैयार ग्राफाना वेब सर्वर मिलेगा।

इंस्टेंस समूह और बैलेंसर

एक बार जब हमारे पास एक डिस्क छवि होती है जो हमें कई समान ग्राफाना वेब सर्वर बनाने की अनुमति देती है, तो हम एक इंस्टेंस समूह बना सकते हैं। यांडेक्स.क्लाउड प्लेटफॉर्म पर, यह शब्द समान विशेषताओं वाली वर्चुअल मशीनों के संयोजन को संदर्भित करता है। जब एक इंस्टैंस समूह बनाया जाता है, तो समूह में सभी मशीनों का एक प्रोटोटाइप कॉन्फ़िगर किया जाता है, और फिर समूह की विशेषताओं (उदाहरण के लिए, सक्रिय मशीनों की न्यूनतम और अधिकतम संख्या) को कॉन्फ़िगर किया जाता है। यदि वर्तमान संख्या इन मानदंडों को पूरा नहीं करती है, तो इंस्टैंस समूह अनावश्यक मशीनों को हटा देगा या उसी छवि और समानता में नई मशीनें बना देगा।

हमारे कार्य के एक भाग के रूप में, हम वेब सर्वरों का एक इंस्टेंस समूह बनाएंगे, जो पहले से निर्मित डिस्क छवि से उत्पन्न होगा।

अंतिम उदाहरण समूह सेटिंग वास्तव में उल्लेखनीय है। लोड बैलेंसर के साथ एकीकृत लक्ष्य समूह आपको कुछ क्लिक के साथ इस समूह की वर्चुअल मशीनों के शीर्ष पर L3 बैलेंसर को कॉन्फ़िगर करने में मदद करेगा।

बैलेंसर की स्थापना करते समय, मैंने दो महत्वपूर्ण बिंदुओं को लागू किया:

मैंने इसे इस प्रकार बनाया कि बैलेंसर पोर्ट 80 पर उपयोगकर्ता ट्रैफिक प्राप्त करेगा और उसे वर्चुअल मशीन के पोर्ट 3000 पर रीडायरेक्ट करेगा, ठीक उसी स्थान पर जहां ग्राफाना रहता है।
पोर्ट 3000 पर मशीनों को पिंग करके उनके लिए स्वास्थ्य जांच कॉन्फ़िगर की गई।

लघु सारांश

अंततः, हम वांछित अनुप्रयोग अवसंरचना को मैन्युअल रूप से तैनात करने में सक्षम हुए, और अब हमारे पास अत्यधिक स्थिर ग्राफाना सेवा है। आपको केवल एप्लिकेशन के प्रवेश बिंदु के रूप में बैलेंसर आईपी पता और उसमें डेटासेट लोड करने के लिए ClickHouse क्लस्टर होस्ट जानने की आवश्यकता है।

यह तो जीत जैसा लगेगा? हाँ, विजय. लेकिन कुछ बात अभी भी मुझे परेशान करती है। उपरोक्त पूरी प्रक्रिया में बहुत सारे मैनुअल कार्य करने पड़ते हैं और यह बिल्कुल भी स्केलेबल नहीं है, यदि संभव हो तो मैं इसे स्वचालित करना चाहूंगा। अगला भाग इसी पर समर्पित होगा।

टेराफॉर्म एकीकरण

हम फिर से HashiCorp के एक उपकरण का उपयोग करेंगे जिसका नाम है 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_टोकन — क्लाउड तक पहुंचने के लिए एक टोकन। आप इसे प्राप्त कर सकते हैं लिंक.
क्लाउड_आईडी — उस क्लाउड का पहचानकर्ता जहां हम एप्लिकेशन को तैनात करेंगे
फ़ोल्डर_आईडी — उस अनुभाग का पहचानकर्ता जहां हम एप्लिकेशन को तैनात करेंगे
सेवा_खाता_आईडी — क्लाउड के संबंधित अनुभाग में सेवा खाते का पहचानकर्ता.
छवि_आईडी — पैकर का उपयोग करके प्राप्त डिस्क छवि का पहचानकर्ता
उपयोगकर्ता नाम и पासवर्ड — डेटाबेस और ग्राफाना वेब सर्वर दोनों तक पहुंच के लिए उपयोगकर्ता नाम और पासवर्ड
dbname — CH और MySQL क्लस्टर के भीतर डेटाबेस का नाम
सार्वजनिक_कुंजी_पथ — आपकी सार्वजनिक ssh कुंजी वाली फ़ाइल का पथ, जिसका उपयोग आप नाम के अंतर्गत कनेक्ट करने के लिए कर सकते हैं ubuntu वेब सर्वर के साथ वर्चुअल मशीनों के लिए

अपना प्रदाता सेट अप करना

अब आपको टेराफॉर्म प्रदाता को कॉन्फ़िगर करने की आवश्यकता है - हमारे मामले में यांडेक्स:

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 क्लस्टर स्थापित किया और उसके बाद ही, इसकी आईडी जानने के बाद, मैंने आवश्यक कॉन्फ़िगरेशन के साथ एक डिस्क इमेज को इकट्ठा किया, जहां मैंने क्लस्टर के लिए होस्ट निर्दिष्ट किया। लेकिन अब हम टेराफॉर्म के लॉन्च होने से पहले क्लस्टर आईडी नहीं जानते हैं, जिसमें इमेज असेंबली के समय भी शामिल है। इसलिए, हमें निम्नलिखित उपाय अपनाने पड़े चाल.

अमेज़न की मेटाडेटा सेवा का उपयोग करते हुए, हम वर्चुअल मशीन को कुछ पैरामीटर्स देंगे, जिन्हें वह स्वीकार करेगी और संसाधित करेगी। हमें मशीन को MySQL क्लस्टर होस्ट के लिए मेटाडेटा और उपयोगकर्ता नाम-पासवर्ड तक जाने की आवश्यकता है, जिसे उपयोगकर्ता ने स्टार्टअप के बाद टेराफॉर्म फ़ाइल में निर्दिष्ट किया था। आइए फ़ाइल की सामग्री को थोड़ा बदलें 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

इंट्रांस समूह और बैलेंसर

नई डिस्क छवि को पुनः निर्मित करने के बाद, हम अंततः टेराफॉर्म के लिए अपनी फ़ाइल लिखना समाप्त कर सकते हैं।

आइए निर्दिष्ट करें कि हम मौजूदा डिस्क छवि का उपयोग करना चाहते हैं:

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. वर्चुअल मशीन स्टार्टअप पर इन्हें निकालेगी और ग्राफाना कॉन्फ़िगरेशन में रखेगी।

यह संतुलनकर्ता पर निर्भर है।

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

थोड़ी सी चीनी

अभी थोड़ा सा बाकी है. बुनियादी ढांचे की तैनाती के बाद, आपको ग्राफाना यूआई पर जाना होगा और मैन्युअल रूप से सीएच क्लस्टर (जिसकी आईडी अभी भी प्राप्त करने की आवश्यकता है) को डेटा स्रोत के रूप में जोड़ना होगा। लेकिन टेराफॉर्म क्लस्टर आईडी जानता है। चलो, हम उसे काम पूरा करने का जिम्मा सौंपते हैं।

आइए एक नया प्रदाता - ग्राफाना जोड़ें, और इसे होस्ट के रूप में बैलेंसर का आईपी पता दें। टेराफॉर्म द्वारा उस मशीन पर किए गए सभी परिवर्तन, जहां बैलेंसर इसे निर्दिष्ट करता है, 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"
}

चलो इसे कंघी करें

हम बैलेंसर का आईपी पता और क्लिकहाउस क्लस्टर के होस्ट का आउटपुट देंगे

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

आप इसे लॉन्च कर सकते हैं

सभी! हमारी कॉन्फ़िगरेशन फ़ाइल तैयार है और हम टेराफ़ॉर्म को यह बताने के लिए वेरिएबल सेट कर सकते हैं कि हमने ऊपर जो कुछ भी वर्णित किया है, वह सब कुछ उठाए। पूरी प्रक्रिया में मुझे लगभग 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

और क्लाउड में, उभरे हुए बुनियादी ढांचे के तत्व दिखाई देंगे:

संक्षेप करने के लिए

अब, ग्राफाना को उदाहरण के रूप में उपयोग करते हुए, आप में से प्रत्येक यैंडेक्स.क्लाउड प्लेटफॉर्म पर विस्तृत क्लाउड आर्किटेक्चर वाले अनुप्रयोगों को तैनात कर सकते हैं। हाशिकॉर्प के उपयोगी उपकरण जैसे पैकर और टेराफॉर्म आपकी इसमें मदद कर सकते हैं। मुझे उम्मीद है कि यह लेख किसी के लिए उपयोगी होगा 🙂

पी.एस. नीचे मैं एक रिपोजिटरी का लिंक संलग्न कर रहा हूँ, जहाँ आप पैकर और टेराफॉर्म के लिए तैयार रेसिपी पा सकते हैं, जिसके कुछ अंश मैंने इस लेख में दिए हैं।

कोष

स्रोत: www.habr.com