ઉદાહરણ તરીકે Grafana નો ઉપયોગ કરીને Yandex.Cloud માં વિતરિત સેવાઓની જમાવટ

કેમ છો બધા! મારા અભ્યાસક્રમના ભાગ રૂપે, મેં આવા સ્થાનિક ક્લાઉડ પ્લેટફોર્મની ક્ષમતાઓ પર સંશોધન કર્યું Yandex.Cloud. આ પ્લેટફોર્મ વ્યવહારિક સમસ્યાઓના ઉકેલ માટે વિવિધ સેવાઓ પ્રદાન કરે છે. જો કે, કેટલીકવાર તમારે આ સેવાઓ પર આધારિત એકદમ વ્યાપક ઈન્ફ્રાસ્ટ્રક્ચર સાથે તમારી પોતાની ક્લાઉડ એપ્લિકેશન સેટ કરવાની જરૂર છે. આ લેખમાં હું આવી એપ્લિકેશનને જમાવવામાં મારો અનુભવ શેર કરવા માંગુ છું.

તમે શું પ્રાપ્ત કરવા માંગો છો?

ગ્રાફના - કોઈપણ સિસ્ટમોની વિશ્લેષણાત્મક સમસ્યાઓ અથવા મોનિટરિંગ સમસ્યાઓ ઉકેલવા માટેનું એક શક્તિશાળી સાધન. તેના મૂળભૂત રૂપરેખાંકનમાં, આ Grafana વેબ સર્વર સાથેનું વર્ચ્યુઅલ મશીન છે, તેમજ ડેટાબેઝ (ClickHouse, InfluxDB, વગેરે) સાથે ડેટાસેટ છે જેના પર વિશ્લેષણ આધારિત હશે.

વેબ સર્વર સાથે વર્ચ્યુઅલ મશીન લોંચ કર્યા પછી, તમે તેના હોસ્ટ પર જઈ શકો છો અને એક સુંદર UI મેળવી શકો છો, આગળના કામ માટે ડેટાબેસેસનો સ્ત્રોત તરીકે ઉલ્લેખ કરી શકો છો, ડેશબોર્ડ અને ગ્રાફ બનાવી શકો છો.

મૂળભૂત સંસ્કરણમાં એક નોંધપાત્ર ખામી છે - તે દોષ-સહિષ્ણુ બિલકુલ નથી. એટલે કે, એપ્લિકેશનની સંપૂર્ણ કાર્યક્ષમતા એક વર્ચ્યુઅલ મશીનની કાર્યક્ષમતા પર આધારિત છે. જો તે ઇનકાર કરે છે અથવા એક જ સમયે 10 લોકો UI ખોલે છે, તો સમસ્યાઓ ઊભી થશે.

તેઓને સરળ રીતે ઉકેલી શકાય છે: તમારે ફક્ત... વેબ સર્વર સાથે ઘણા સમાન વર્ચ્યુઅલ મશીનો ગોઠવવાની અને તેમને L3 બેલેન્સર હેઠળ મૂકવાની જરૂર છે. પરંતુ અહીં બધું એટલું સ્પષ્ટ નથી. ગ્રાફના તેના વર્ચ્યુઅલ મશીનની ડિસ્ક પર સીધા જ વપરાશકર્તા સેટિંગ્સ (ડેટાબેસેસ, ડેશબોર્ડ્સ, ગ્રાફ, વગેરેના માર્ગો) સ્ટોર કરે છે. આમ, જો આપણે UI માં અમુક સેટિંગ્સ બદલીએ, તો આ ફેરફારો ફક્ત વર્ચ્યુઅલ મશીન પર જ પ્રતિબિંબિત થશે જ્યાં બેલેન્સરે અમને મોકલ્યા છે. આ અમારી એપ્લિકેશન માટે અસંગત સેટિંગ્સ તરફ દોરી જશે, જેના કારણે લોન્ચ અને ઉપયોગમાં સમસ્યા ઊભી થશે.

અહીં અન્ય ડેટાબેઝ બચાવમાં આવશે, ઉદાહરણ તરીકે, MySQL અથવા તેના સમકક્ષ. અમે ગ્રાફનાને કહીએ છીએ કે તેણીએ આ "ફાજલ" ડેટાબેઝમાં વપરાશકર્તા સેટિંગ્સ સંગ્રહિત કરવી જોઈએ. પછીથી, દરેક મશીન પર એકવાર આ ડેટાબેઝનો પાથ સ્પષ્ટ કરવા માટે તે પૂરતું હશે, અને કોઈપણ વર્ચ્યુઅલ મશીન પર અન્ય તમામ વપરાશકર્તા સેટિંગ્સને સંપાદિત કરો; તે અન્ય લોકો સુધી વિસ્તરશે.

અહીં અંતિમ એપ્લિકેશન ઈન્ફ્રાસ્ટ્રક્ચરનો આકૃતિ છે:

ચાલો હાથ વડે ઉપાડતા શીખીએ

MySQL અને ક્લિકહાઉસ

બટનના ક્લિક સાથે આવી એપ્લિકેશનને જમાવતા પહેલા, તેના દરેક ઘટકોને કેવી રીતે હેન્ડલ કરવું અને તેને એકબીજા સાથે કેવી રીતે સંકલિત કરવું તે શીખવું જરૂરી હતું.

અહીં Yandex.Cloud અમને મદદ કરશે, જે L3 બેલેન્સર્સ, ClickHouse અને MySQL ને સંચાલિત સેવાઓ તરીકે પ્રદાન કરે છે. વપરાશકર્તાને ફક્ત પરિમાણોનો ઉલ્લેખ કરવાની જરૂર છે અને પ્લેટફોર્મ બધું કાર્યકારી ક્રમમાં લાવે ત્યાં સુધી રાહ જુઓ.

મેં નોંધણી કરી, ક્લાઉડ અને પેમેન્ટ એકાઉન્ટ બનાવ્યું. તે પછી, હું ક્લાઉડ પર ગયો અને ન્યૂનતમ સેટિંગ્સ સાથે MySQL અને ClickHouse ક્લસ્ટર સેટ કર્યા. તેઓ સક્રિય થાય ત્યાં સુધી મેં રાહ જોઈ.

તમારે દરેક ક્લસ્ટરમાં ડેટાબેઝ બનાવવાનું અને લોગિન અને પાસવર્ડનો ઉપયોગ કરીને તેની ઍક્સેસ ગોઠવવાનું પણ યાદ રાખવાની જરૂર છે. હું અહીં વિગતોમાં જઈશ નહીં - ઇન્ટરફેસમાં બધું એકદમ સ્પષ્ટ છે.

બિન-સ્પષ્ટ વિગત એ હતી કે આ ડેટાબેઝમાં ઘણા યજમાનો છે, જે તેમની ખામી સહિષ્ણુતાને સુનિશ્ચિત કરે છે. જો કે, Grafana ને તે દરેક ડેટાબેઝ માટે બરાબર એક હોસ્ટની જરૂર છે જેની સાથે તે કામ કરે છે. લાંબુ વાંચન દસ્તાવેજીકરણ વાદળો મને નિર્ણય પર લઈ ગયા. તે તારણ આપે છે કે જાતિના યજમાન c-<cluster_id>.rw.mdb.yandexcloud.net અનુરૂપ ID સાથે ક્લસ્ટરના વર્તમાન સક્રિય મુખ્ય હોસ્ટ પર મેપ કરેલ છે. આ તે છે જે આપણે ગ્રાફનાને આપીશું.

વેબ સર્વર

હવે તે વેબ સર્વર પર છે. ચાલો 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 

તે પછી, ચાલો 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 નો ઉલ્લેખ કરી શકો છો અને સુંદર Grafana UI જોઈ શકો છો.

પરંતુ ઉતાવળ કરશો નહીં, Grafana સેટ કરતા પહેલા, તમારે ત્યાં સેટિંગ્સ સ્ટોર કરવા માટે તેને MySQL નો માર્ગ જણાવવાનું યાદ રાખવું જોઈએ.

Grafana વેબ સર્વરનું સમગ્ર રૂપરેખાંકન ફાઇલમાં છે /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

હવે Grafana UI માં આપણે ડેટાસોર્સ તરીકે ClickHouse નો ઉલ્લેખ કરીશું.

હું નીચેની સેટિંગ્સ સાથે કાર્યકારી ગોઠવણી પ્રાપ્ત કરવામાં સક્ષમ હતો:

મેં URL તરીકે ઉલ્લેખ કર્યો છે https://c-<cluster_id>.rw.mdb.yandexcloud.net:8443

બધા! અમારી પાસે CH અને MySQL સાથે જોડાયેલ વેબ સર્વર સાથેનું એક વર્ચ્યુઅલ મશીન છે. તમે પહેલાથી જ ક્લિકહાઉસ પર ડેટાસેટ અપલોડ કરી શકો છો અને ડેશબોર્ડ બનાવી શકો છો. જો કે, અમે હજુ સુધી અમારું લક્ષ્ય હાંસલ કર્યું નથી અને સંપૂર્ણ સુવિધાયુક્ત ઈન્ફ્રાસ્ટ્રક્ચર જમાવ્યું નથી.

પેકર

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

આગળના તબક્કે, અમે આ નિર્દેશિકામાં એક સ્ક્રિપ્ટ મૂકીએ છીએ, જેને વર્ચ્યુઅલ મશીન શરૂ કર્યા પછી તરત જ લોન્ચ કરવાની જરૂર પડશે. આ સ્ક્રિપ્ટ ગ્રાફના રૂપરેખામાં નોંધણી કરવાની અને વેબ સર્વરને પુનઃપ્રારંભ કરવાની જરૂર હોય તેવા વપરાશકર્તા ચલો મૂકશે.

setup.sh:

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

આ પછી 3 વસ્તુઓ કરવાનું બાકી છે:
1) પેકેજો ઇન્સ્ટોલ કરો
2) Systemctl હેઠળ Grafana ચલાવો અને 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;

હવે જે બાકી છે તે પેકર ચલાવવાનું છે અને ઉલ્લેખિત વિભાગમાં આઉટપુટ ઈમેજ મેળવવાનું છે. વર્ચ્યુઅલ મશીન બનાવતી વખતે, તમે તેને બુટ ડિસ્ક તરીકે પસંદ કરી શકો છો અને લોંચ કર્યા પછી તમને તૈયાર Grafana વેબ સર્વર પ્રાપ્ત થશે.

ઉદાહરણ જૂથ અને બેલેન્સર

એકવાર અમારી પાસે ડિસ્ક ઇમેજ હોય ​​કે જે અમને ઘણા સમાન ગ્રાફના વેબ સર્વર બનાવવાની મંજૂરી આપે છે, અમે એક ઉદાહરણ જૂથ બનાવી શકીએ છીએ. Yandex.Cloud પ્લેટફોર્મ પર, આ શબ્દ વર્ચ્યુઅલ મશીનોના યુનિયનનો સંદર્ભ આપે છે જે સમાન લાક્ષણિકતાઓ ધરાવે છે. ઉદાહરણ જૂથ બનાવતી વખતે, આ જૂથમાં તમામ મશીનોનો પ્રોટોટાઇપ ગોઠવવામાં આવે છે, અને પછી જૂથની લાક્ષણિકતાઓ (ઉદાહરણ તરીકે, સક્રિય મશીનોની ન્યૂનતમ અને મહત્તમ સંખ્યા). જો વર્તમાન સંખ્યા આ માપદંડોને પૂર્ણ કરતી નથી, તો ઉદાહરણ જૂથ પોતે જ બિનજરૂરી મશીનો દૂર કરશે અથવા તેની પોતાની છબીમાં નવી બનાવશે.

અમારા કાર્યના ભાગ રૂપે, અમે વેબ સર્વર્સનું એક ઉદાહરણ જૂથ બનાવીશું જે અગાઉ બનાવેલ ડિસ્ક ઈમેજમાંથી જનરેટ થશે.

શું ખરેખર નોંધપાત્ર છે તે છેલ્લું ઉદાહરણ જૂથ સેટઅપ છે. લોડ બેલેન્સર સાથેના એકીકરણમાંનું લક્ષ્ય જૂથ તમને આ જૂથના વર્ચ્યુઅલ મશીનોની ટોચ પર કેટલાક બટનો પર ક્લિક કરીને L3 બેલેન્સરને ગોઠવવામાં મદદ કરશે.

બેલેન્સર સેટ કરતી વખતે, મેં બે મહત્વપૂર્ણ મુદ્દાઓ અમલમાં મૂક્યા:

1. મેં બેલેન્સરને પોર્ટ 80 પર વપરાશકર્તા ટ્રાફિક સ્વીકારવા અને તેને વર્ચ્યુઅલ મશીનોના પોર્ટ 3000 પર રીડાયરેક્ટ કરવા માટે બનાવ્યું, બરાબર જ્યાં Grafana રહે છે.
2. મેં મશીનોને પોર્ટ 3000 પર પિંગ કરીને તેની કાર્યક્ષમતા તપાસવાનું સેટઅપ કર્યું.

મીની સારાંશ

અંતે, અમે ઇચ્છિત એપ્લિકેશન ઇન્ફ્રાસ્ટ્રક્ચરને મેન્યુઅલી જમાવવામાં સક્ષમ હતા, અને હવે અમારી પાસે અત્યંત સ્થિતિસ્થાપક ગ્રાફના સેવા છે. તેમાં ડેટાસેટ લોડ કરવા માટે તમારે ફક્ત એપ્લિકેશનના એન્ટ્રી પોઈન્ટ અને ક્લિકહાઉસ ક્લસ્ટરના હોસ્ટ તરીકે બેલેન્સરનું IP સરનામું જાણવાની જરૂર છે.

તે વિજય જેવું લાગશે? હા, વિજય. પરંતુ કંઈક હજી પણ મને મૂંઝવણમાં મૂકે છે. ઉપરોક્ત સમગ્ર પ્રક્રિયાને ઘણા બધા મેન્યુઅલ પગલાંની જરૂર છે અને તે બિલકુલ માપી શકાય તેવું નથી; જો શક્ય હોય તો હું તેને સ્વચાલિત કરવા માંગુ છું. આ તે છે જેને આગળનો વિભાગ સમર્પિત કરવામાં આવશે.

ટેરાફોર્મ એકીકરણ

અમે ફરીથી HashiCorp નામના ટૂલનો ઉપયોગ કરીશું ટેરાફોર્મ. તે તમને વપરાશકર્તા દ્વારા પસાર કરાયેલા કેટલાક ચલોના આધારે બટનના ક્લિક સાથે સમગ્ર એપ્લિકેશન ઈન્ફ્રાસ્ટ્રક્ચરને જમાવવામાં મદદ કરશે. ચાલો એક રેસીપી લખીએ જે વિવિધ વપરાશકર્તાઓના વિવિધ વિભાગોમાં ઘણી વખત ચલાવી શકાય છે.

ટેરાફોર્મ સાથેનું તમામ કાર્ય રૂપરેખાંકન ફાઇલ લખવા માટે નીચે આવે છે (*.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 - ક્લાઉડ આઇડેન્ટિફાયર જ્યાં અમે એપ્લિકેશનને જમાવીશું
ફોલ્ડર_આઈડી — વિભાગ ઓળખકર્તા જ્યાં અમે એપ્લિકેશનને જમાવીશું
service_account_id - ક્લાઉડના અનુરૂપ વિભાગમાં સેવા એકાઉન્ટ ઓળખકર્તા.
image_id - પેકરનો ઉપયોગ કરીને મેળવેલ ડિસ્ક ઈમેજનું ઓળખકર્તા
વપરાશકર્તા નામ и પાસવર્ડ — ડેટાબેસેસ અને Grafana વેબ સર્વર બંનેને ઍક્સેસ કરવા માટે વપરાશકર્તા નામ અને પાસવર્ડ
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 ક્લસ્ટર ઉભું કર્યું અને તે પછી જ, તેનું ID જાણીને, મેં જરૂરી રૂપરેખાંકન સાથે ડિસ્ક ઇમેજ એકત્રિત કરી, જ્યાં મેં ક્લસ્ટર માટે હોસ્ટનો ઉલ્લેખ કર્યો. પરંતુ હવે અમે ટેરાફોર્મ લોન્ચ કરતા પહેલા ક્લસ્ટર ID જાણતા નથી, જેમાં ઈમેજ બનાવતી વખતે પણ સામેલ છે. તેથી, મારે નીચેનાનો આશરો લેવો પડ્યો યુક્તિ.

એમેઝોનની મેટાડેટા સેવાનો ઉપયોગ કરીને, અમે વર્ચ્યુઅલ મશીનને કેટલાક પરિમાણો પસાર કરીશું, જેને તે સ્વીકારશે અને પ્રક્રિયા કરશે. અમારે MySQL ક્લસ્ટર હોસ્ટ અને વપરાશકર્તાનામ-પાસવર્ડની પાછળના મેટાડેટા પર જવા માટે મશીનની જરૂર છે, જે વપરાશકર્તાએ શરૂ કર્યા પછી ટેરાફોર્મ ફાઇલમાં સ્પષ્ટ કર્યું છે. ચાલો ફાઈલની સામગ્રીમાં થોડો ફેરફાર કરીએ 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

ઇન્ટેન્સ ગ્રુપ અને બેલેન્સર

નવી ડિસ્ક ઈમેજ પુનઃબીલ્ડ કર્યા પછી, અમે છેલ્લે ટેરાફોર્મ માટે અમારી ફાઈલ ઉમેરી શકીએ છીએ.

ચાલો સૂચવીએ કે અમે હાલની ડિસ્ક ઇમેજનો ઉપયોગ કરવા માંગીએ છીએ:

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 હજુ પણ મેળવવાની જરૂર છે) ડેટા સ્ત્રોત તરીકે ઉમેરવું પડશે. પરંતુ ટેરાફોર્મ ક્લસ્ટર ID ને જાણે છે. ચાલો તેને આ બાબતને અમલમાં મૂકવાની જવાબદારી સોંપીએ.

ચાલો એક નવો પ્રદાતા ઉમેરીએ - Grafana, અને તેને હોસ્ટ તરીકે બેલેન્સરનું IP સરનામું આપીએ. તમામ ફેરફારો કે જે ટેરાફોર્મ મશીન પર કરે છે જ્યાં તેનું બેલેન્સર નક્કી કરે છે તે 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 એડ્રેસ અને ક્લિકહાઉસ ક્લસ્ટરના હોસ્ટને પ્રદર્શિત કરીએ

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

અને ક્લાઉડમાં, ઉભેલા ઇન્ફ્રાસ્ટ્રક્ચરના ઘટકો દેખાશે:

ચાલો પરિણામોને સરવાળો કરીએ

હવે, ઉદાહરણ તરીકે Grafana નો ઉપયોગ કરીને, તમારામાંના દરેક Yandex.Cloud પ્લેટફોર્મ પર છૂટાછવાયા ક્લાઉડ આર્કિટેક્ચર સાથે એપ્લિકેશનો જમાવી શકે છે. HashiCorp ના મદદરૂપ સાધનો જેમ કે Packer અને Terraform તમને આમાં મદદ કરી શકે છે. મને આશા છે કે કોઈને આ લેખ ઉપયોગી લાગશે :)

PS નીચે હું રિપોઝીટરીની એક લિંક જોડીશ જ્યાં તમે પેકર અને ટેરાફોર્મ માટે તૈયાર રેસિપી શોધી શકો છો, જેના ટુકડા મેં આ લેખમાં આપ્યા છે.

ભંડાર

સોર્સ: www.habr.com