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

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

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

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

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

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

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

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

यहां अंतिम एप्लिकेशन बुनियादी ढांचे का एक चित्र दिया गया है:

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

MySQL और क्लिकहाउस

एक बटन के क्लिक के साथ इस तरह के एप्लिकेशन को तैनात करने से पहले, यह सीखना आवश्यक था कि इसके प्रत्येक घटक को कैसे संभालना है और उन्हें एक दूसरे के साथ एकीकृत करना है।

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

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

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

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

वेब सर्वर

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

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

हम वेब सर्वर शुरू करेंगे. अब आप ब्राउज़र में वर्चुअल मशीन का बाहरी आईपी पता दर्ज कर सकते हैं, पोर्ट 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 को डेटासोर्स के रूप में निर्दिष्ट करेंगे।

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

मैंने यूआरएल के रूप में निर्दिष्ट किया है https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

सभी! हमारे पास 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

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

सेटअप.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) 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 

ग्राफाना-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;

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

उदाहरण समूह और बैलेंसर

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

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

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

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

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

लघु सारांश

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

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

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

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

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

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

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

आप देखेंगे कि यहां हम ऊपर परिभाषित वेरिएबल्स का उपयोग कर रहे हैं।

नेटवर्क और क्लस्टर

अब हम एक नेटवर्क बनाएंगे जिसमें हमारे बुनियादी ढांचे के तत्व संचार करेंगे, तीन सबनेट (प्रत्येक क्षेत्र में एक) और सीएच और माईएसक्यूएल क्लस्टर बढ़ाएंगे।

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, जो वर्चुअल मशीन चालू होने पर चलता है।

सेटअप.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

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

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

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

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

कोष

स्रोत: www.habr.com