🥇การปรับใช้บริการแบบกระจายใน Yandex.Cloud โดยใช้ Grafana เป็นตัวอย่าง

สวัสดีทุกคน! ในส่วนหนึ่งของงานในหลักสูตร ฉันได้ค้นคว้าความสามารถของแพลตฟอร์มระบบคลาวด์ในประเทศเช่น Yandex.Cloud. แพลตฟอร์มนี้นำเสนอบริการที่หลากหลายสำหรับการแก้ปัญหาเชิงปฏิบัติ อย่างไรก็ตาม บางครั้งคุณจำเป็นต้องตั้งค่าแอปพลิเคชันระบบคลาวด์ของคุณเองด้วยโครงสร้างพื้นฐานที่ค่อนข้างกว้างขวางตามบริการเหล่านี้ ในบทความนี้ ฉันต้องการแบ่งปันประสบการณ์ของฉันในการปรับใช้แอปพลิเคชันดังกล่าว

คุณต้องการรับอะไร?

กราฟาน่า — เครื่องมืออันทรงพลังสำหรับการแก้ปัญหาเชิงวิเคราะห์หรือติดตามปัญหาของระบบใดๆ ในการกำหนดค่าพื้นฐาน นี่คือเครื่องเสมือนที่มีเว็บเซิร์ฟเวอร์ Grafana รวมถึงฐานข้อมูล (ClickHouse, InfluxDB ฯลฯ ) พร้อมชุดข้อมูลที่จะใช้การวิเคราะห์

หลังจากเปิดตัวเครื่องเสมือนด้วยเว็บเซิร์ฟเวอร์ คุณสามารถไปที่โฮสต์และรับ UI ที่สวยงาม ระบุฐานข้อมูลเป็นแหล่งที่มาสำหรับการทำงานต่อไป สร้างแดชบอร์ดและกราฟ

เวอร์ชันพื้นฐานมีข้อเสียเปรียบที่สำคัญประการหนึ่ง - มันไม่ทนทานต่อข้อผิดพลาดเลย นั่นคือฟังก์ชันการทำงานทั้งหมดของแอปพลิเคชันขึ้นอยู่กับความมีชีวิตของเครื่องเสมือนเครื่องเดียว หากปฏิเสธหรือมีคน 10 คนเปิด UI พร้อมกัน ปัญหาก็จะเกิดขึ้น

สามารถแก้ไขได้ง่ายๆ: คุณเพียงแค่ต้อง... ปรับใช้เครื่องเสมือนที่เหมือนกันหลายเครื่องกับเว็บเซิร์ฟเวอร์ และวางไว้ใต้บาลานเซอร์ L3 แต่ไม่ใช่ทุกอย่างจะง่ายนักที่นี่ Grafana จัดเก็บการตั้งค่าผู้ใช้ (เส้นทางไปยังฐานข้อมูล แดชบอร์ด กราฟ ฯลฯ) ไว้บนดิสก์ของเครื่องเสมือนโดยตรง ดังนั้น หากเราเปลี่ยนการตั้งค่าบางอย่างใน UI การเปลี่ยนแปลงเหล่านี้จะมีผลเฉพาะบนเครื่องเสมือนที่บาลานเซอร์ส่งมาให้เราเท่านั้น ซึ่งจะทำให้การตั้งค่าแอปพลิเคชันของเราไม่สอดคล้องกัน ทำให้เกิดปัญหาในการเปิดและใช้งาน

ที่นี่ฐานข้อมูลอื่นจะมาช่วยเหลือเช่น MySQL หรือเทียบเท่า เราบอก Grafana ว่าเธอควรเก็บการตั้งค่าผู้ใช้ไว้ในฐานข้อมูล "สำรอง" นี้ หลังจากนั้น การระบุเส้นทางไปยังฐานข้อมูลนี้หนึ่งครั้งในแต่ละเครื่องก็เพียงพอแล้ว และแก้ไขการตั้งค่าผู้ใช้อื่นๆ ทั้งหมดในเครื่องเสมือนเครื่องใดก็ได้ โดยจะขยายไปยังเครื่องอื่นๆ

นี่คือแผนภาพของโครงสร้างพื้นฐานแอปพลิเคชันขั้นสุดท้าย:

มาเรียนรู้การยกด้วยมือของเรากันเถอะ

MySQL และ ClickHouse

ก่อนที่จะปรับใช้แอปพลิเคชันดังกล่าวด้วยการคลิกปุ่มเพียงปุ่มเดียว จำเป็นต้องเรียนรู้วิธีจัดการแต่ละส่วนประกอบและรวมเข้าด้วยกัน

ที่นี่ Yandex.Cloud จะช่วยเรา ซึ่งให้บริการ L3 balancer, ClickHouse และ MySQL เป็นบริการที่ได้รับการจัดการ ผู้ใช้เพียงแค่ต้องระบุพารามิเตอร์และรอจนกว่าแพลตฟอร์มจะนำทุกอย่างเข้าสู่ลำดับการทำงาน

ฉันลงทะเบียน สร้างคลาวด์และบัญชีการชำระเงิน หลังจากนั้น ฉันไปที่ระบบคลาวด์และตั้งค่าคลัสเตอร์ MySQL และ ClickHouse ด้วยการตั้งค่าขั้นต่ำ ฉันรอจนกว่าพวกเขาจะเริ่มทำงาน

คุณต้องอย่าลืมสร้างฐานข้อมูลในแต่ละคลัสเตอร์และกำหนดค่าการเข้าถึงโดยใช้ข้อมูลเข้าสู่ระบบและรหัสผ่าน ฉันจะไม่ลงรายละเอียดที่นี่ - ทุกอย่างค่อนข้างชัดเจนในอินเทอร์เฟซ

รายละเอียดที่ไม่ชัดเจนคือฐานข้อมูลเหล่านี้มีโฮสต์จำนวนมาก ซึ่งรับประกันความทนทานต่อข้อผิดพลาด อย่างไรก็ตาม Grafana ต้องการโฮสต์เดียวสำหรับแต่ละฐานข้อมูลที่ใช้งานได้ อ่านนาน เอกสาร เมฆทำให้ฉันตัดสินใจ ปรากฎว่าเจ้าบ้านของเผ่าพันธุ์ c-<cluster_id>.rw.mdb.yandexcloud.net แมปกับโฮสต์หลักที่ใช้งานปัจจุบันของคลัสเตอร์ด้วย ID ที่เกี่ยวข้อง นี่คือสิ่งที่เราจะมอบให้กับ Grafana

เว็บเซิร์ฟเวอร์

ตอนนี้ก็ขึ้นอยู่กับเว็บเซิร์ฟเวอร์แล้ว มาสร้างเครื่องเสมือนปกติด้วย 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 และติดตั้งปลั๊กอินสำหรับการทำงานกับ 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 คุณต้องจำไว้ว่าต้องบอกเส้นทางไปยัง 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 เป็นแหล่งข้อมูล

ฉันสามารถบรรลุการกำหนดค่าการทำงานด้วยการตั้งค่าต่อไปนี้:

ฉันระบุเป็น URL 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

ในขั้นตอนต่อไป เราจะวางสคริปต์ไว้ในไดเร็กทอรีนี้ ซึ่งจะต้องเปิดใช้งานทันทีหลังจากเริ่มเครื่องเสมือน สคริปต์นี้จะใส่ตัวแปรผู้ใช้ที่ต้องลงทะเบียนในการกำหนดค่า 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) เรียกใช้ Grafana ภายใต้ systemctl และติดตั้งปลั๊กอิน ClickHouse
3) ใส่สคริปต์ setup.sh ลงในคิวการเปิดตัวทันทีหลังจากเปิดเครื่องเสมือน

ติดตั้ง 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

รัน-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 ที่เหมือนกันจำนวนมากได้ เราก็สามารถสร้างกลุ่มอินสแตนซ์ได้ บนแพลตฟอร์ม Yandex.Cloud คำนี้หมายถึงการรวมเครื่องเสมือนที่มีลักษณะเหมือนกัน เมื่อสร้างกลุ่มอินสแตนซ์ จะมีการกำหนดค่าต้นแบบของเครื่องทั้งหมดในกลุ่มนี้ จากนั้นจึงกำหนดค่าคุณลักษณะของกลุ่มเอง (เช่น จำนวนขั้นต่ำและจำนวนสูงสุดของเครื่องที่ใช้งานอยู่) หากจำนวนปัจจุบันไม่ตรงตามเกณฑ์เหล่านี้ กลุ่มอินสแตนซ์จะลบเครื่องที่ไม่จำเป็นออกหรือสร้างเครื่องใหม่ในอิมเมจของตัวเอง

ในส่วนหนึ่งของงานของเรา เราจะสร้างกลุ่มอินสแตนซ์ของเว็บเซิร์ฟเวอร์ที่จะสร้างขึ้นจากดิสก์อิมเมจที่สร้างขึ้นก่อนหน้านี้

สิ่งที่น่าทึ่งอย่างแท้จริงคือการตั้งค่ากลุ่มอินสแตนซ์ครั้งล่าสุด กลุ่มเป้าหมายที่ผสานรวมกับ Load Balancer จะช่วยคุณกำหนดค่า L3 balancer ที่ด้านบนของเครื่องเสมือนของกลุ่มนี้โดยคลิกปุ่มสองสามปุ่ม

เมื่อตั้งค่าบาลานเซอร์ ฉันใช้ประเด็นสำคัญสองประการ:

ฉันทำให้บาลานเซอร์ยอมรับการรับส่งข้อมูลของผู้ใช้บนพอร์ต 80 และเปลี่ยนเส้นทางไปยังพอร์ต 3000 ของเครื่องเสมือนซึ่งเป็นที่ที่ Grafana อาศัยอยู่
ฉันตั้งค่าการตรวจสอบความมีชีวิตของเครื่องโดยส่ง Ping ไปยังพอร์ต 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 — โทเค็นสำหรับการเข้าถึงคลาวด์ สามารถรับได้โดย ลิงค์.
cloud_id — ตัวระบุคลาวด์ที่เราจะปรับใช้แอปพลิเคชัน
โฟลเดอร์_id — ตัวระบุส่วนที่เราจะปรับใช้แอปพลิเคชัน
service_account_id — ตัวระบุบัญชีบริการในส่วนที่เกี่ยวข้องของระบบคลาวด์
อิมเมจ_ไอดี — ตัวระบุของดิสก์อิมเมจที่ได้รับโดยใช้ Packer
ชื่อผู้ใช้ и รหัสผ่าน — ชื่อผู้ใช้และรหัสผ่านเพื่อเข้าถึงทั้งฐานข้อมูลและเว็บเซิร์ฟเวอร์ Grafana
ชื่อฐานข้อมูล — ชื่อฐานข้อมูลภายในคลัสเตอร์ CH และ MySQL
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 เป็นครั้งแรก และหลังจากนั้นเมื่อทราบ ID ของคลัสเตอร์ ฉันจึงรวบรวมดิสก์อิมเมจที่มีการกำหนดค่าที่จำเป็น โดยที่ฉันระบุโฮสต์ให้กับคลัสเตอร์ แต่ตอนนี้เราไม่ทราบ ID คลัสเตอร์ก่อนที่จะเปิดตัว Terraform รวมถึงในขณะที่สร้างอิมเมจด้วย ดังนั้นฉันจึงต้องหันไปใช้สิ่งต่อไปนี้ เล่ห์เหลี่ยม.

เมื่อใช้บริการเมตาดาต้าของ Amazon เราจะส่งพารามิเตอร์บางอย่างไปยังเครื่องเสมือน ซึ่งจะยอมรับและประมวลผล เราต้องการให้เครื่องไปที่ข้อมูลเมตาด้านหลังโฮสต์คลัสเตอร์ MySQL และชื่อผู้ใช้-รหัสผ่านซึ่งผู้ใช้ระบุไว้ในไฟล์ Terraform หลังจากเริ่มต้น มาเปลี่ยนเนื้อหาของไฟล์กันเล็กน้อย 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

กลุ่ม Intance และบาลานเซอร์

หลังจากสร้างดิสก์อิมเมจใหม่แล้ว ในที่สุดเราก็สามารถเพิ่มไฟล์ของเราสำหรับ 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 ด้วยตนเอง (ซึ่งยังต้องได้รับ ID) เป็นแหล่งข้อมูลด้วยตนเอง แต่ Terraform รู้รหัสคลัสเตอร์ ให้เราวางใจเขาในการทำให้เรื่องนี้บรรลุผล

มาเพิ่มผู้ให้บริการใหม่ - 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"
}

มาหวีผมกันเถอะ

มาแสดงที่อยู่ 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 สามารถช่วยคุณได้ ฉันหวังว่าบางคนพบว่าบทความนี้มีประโยชน์ :)

ป.ล. ด้านล่างฉันจะแนบลิงก์ไปยังพื้นที่เก็บข้อมูลซึ่งคุณสามารถค้นหาสูตรอาหารสำเร็จรูปสำหรับ Packer และ Terraform ซึ่งเป็นชิ้นส่วนที่ฉันให้ไว้ในบทความนี้

ที่เก็บ

ที่มา: will.com

การปรับใช้บริการแบบกระจายใน Yandex.Cloud โดยใช้ Grafana เป็นตัวอย่าง

คุณต้องการรับอะไร?

มาเรียนรู้การยกด้วยมือของเรากันเถอะ

MySQL และ ClickHouse

เว็บเซิร์ฟเวอร์

เครื่องบรรจุหีบห่อ

ผู้สร้าง

ผู้จัดเตรียม

กลุ่มอินสแตนซ์และบาลานเซอร์

สรุปมินิ

บูรณาการ Terraform

ตัวแปร

การตั้งค่าผู้ให้บริการ

เครือข่ายและคลัสเตอร์

เว็บเซิร์ฟเวอร์

กลุ่ม Intance และบาลานเซอร์

น้ำตาลเล็กน้อย

มาหวีผมกันเถอะ

วิ่งได้

สรุปผล

เพิ่มความคิดเห็น ยกเลิกการตอบ