Monitoring Microservices with Prometheus and Grafana

Navendu Pottekkat

Navendu Pottekkat

June 8, 2023

Ecosystem

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

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

यह लेख बताएगा कि आप अपने माइक्रोसर्विस एप्लिकेशन पर मॉनिटरिंग कैसे सेट कर सकते हैं, इस क्षेत्र में लोकप्रिय दो टूल्स, Prometheus और Grafana का उपयोग करके।

इस ट्यूटोरियल के लिए स्रोत कोड और Docker Compose फ़ाइल pottekkat/monitoring-101 में उपलब्ध है।

Prometheus Basics

Prometheus एक ओपन-सोर्स मॉनिटरिंग और अलर्टिंग टूल है। यह माइक्रोसर्विसेज से मेट्रिक्स (माप) को HTTP अनुरोध भेजकर "खींचता" है और परिणामों को एक टाइम-सीरीज़ डेटाबेस में संग्रहीत करता है।

आप Prometheus द्वारा प्रदान किए गए क्लाइंट लाइब्रेरीज़ का उपयोग करके अपनी सेवाओं को इंस्ट्रूमेंट कर सकते हैं। यह आपको अपनी सेवाओं से कस्टम मेट्रिक्स बनाने और एकत्र करने में सक्षम बनाएगा।

Prometheus में एक्सपोर्टर्स भी हैं जो आपको उन मेट्रिक्स को खींचने देते हैं जो Prometheus फॉर्मेट में नहीं हैं। एक एक्सपोर्टर एक मध्यस्थ के रूप में कार्य करता है और निर्यात किए गए डेटा को Prometheus पठनीय फॉर्मेट में बदलता है।

1-prometheus-architecture.png

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

मेट्रिक्स खींचने के अलावा, Prometheus सेट थ्रेशोल्ड्स के उल्लंघन होने पर अलर्ट्स भी ट्रिगर कर सकता है। अलर्टिंग मैकेनिज्म अत्यधिक कॉन्फ़िगरेबल है और Slack या ईमेल जैसे स्थानों पर नोटिफिकेशन भेज सकता है।

Prometheus में एक GUI है जो आपको एकत्र किए गए मेट्रिक्स को आसानी से विज़ुअलाइज़ करने देता है। यह Grafana जैसे अन्य उन्नत विज़ुअलाइज़ेशन टूल्स के साथ भी इंटीग्रेट होता है।

prometheus-dashboard.png

मेट्रिक प्रकार

Prometheus चार मुख्य मेट्रिक प्रकार प्रदान करता है:

  1. काउंटर: एक एकल मोनोटोनिकली बढ़ने वाला काउंटर दर्शाता है। इसका मान बढ़ सकता है या रीस्टार्ट पर शून्य पर रीसेट हो सकता है। आप इसे सेव किए गए अनुरोधों की संख्या जैसे मेट्रिक्स को दर्शाने के लिए उपयोग कर सकते हैं।
  2. गेज: एक संख्यात्मक मान दर्शाता है जो ऊपर या नीचे जा सकता है। आप इसे मेमोरी उपयोग या प्रति सेकंड अनुरोधों की संख्या जैसे मानों को दर्शाने के लिए उपयोग कर सकते हैं।
  3. हिस्टोग्राम: डेटा को कॉन्फ़िगरेबल बकेट्स में सैंपल करता है। इसका उपयोग अनुरोध अवधि या प्रतिक्रिया आकार जैसे मानों को दर्शाने के लिए करें।
  4. सारांश: हिस्टोग्राम के समान, यह भी एक स्लाइडिंग टाइम विंडो पर कॉन्फ़िगरेबल मानों की गणना करता है।

आप इन मेट्रिक प्रकारों और उनका उपयोग करने के बारे में आधिकारिक दस्तावेज़ीकरण से अधिक जान सकते हैं।

सैंपल एप्लिकेशन

हमारा सैंपल एप्लिकेशन एक API गेटवे, एक Go ऐप और एक Python ऐप से मिलकर बनेगा।

2-sample-app-flowchart.png

एप्लिकेशन आपके द्वारा चुनी गई भाषा में "Hello <name>!" लौटाएगा, जहां <name> आपके द्वारा प्रदान किया गया है। Apache APISIX API गेटवे होगा जो आपकी सेवाओं को ट्रैफ़िक निर्देशित करेगा।

नीचे दिया गया डायग्राम दिखाता है कि सिस्टम कैसे काम करता है।

3-sample-app-sequence.png

  1. उपयोगकर्ता APISIX को एक GET अनुरोध भेजता है, जो एप्लिकेशन का प्रवेश बिंदु है।
  2. APISIX अनुरोध को Go सेवा को आगे भेजता है।
  3. Go सेवा Python सेवा को "Hello" का अनुवाद प्राप्त करने के लिए एक GET अनुरोध भेजती है।
  4. Python सेवा "Hello" का आवश्यक अनुवाद के साथ प्रतिक्रिया देती है।
  5. Go सेवा क्वेरी में प्रदान किए गए नाम का उपयोग करके आवश्यक प्रतिक्रिया बनाती है और इसे APISIX को भेजती है।
  6. APISIX प्रतिक्रिया को उपयोगकर्ता को वापस भेजता है।

Prometheus को मेट्रिक्स एकत्र करने के लिए कॉन्फ़िगर करना

हम अपने एप्लिकेशन की सभी सेवाओं से मेट्रिक्स को इंस्ट्रूमेंट और एक्सपोर्ट करेंगे और उन्हें Prometheus में एकत्र करेंगे। हम अपने API गेटवे, Apache APISIX से शुरू करेंगे।

APISIX से मेट्रिक्स एक्सपोर्ट करना

Apache APISIX एक ओपन-सोर्स, क्लाउड-नेटिव API गेटवे है।

आपको APISIX के बारे में जानने की आवश्यकता नहीं है, और आप प्रदान किए गए Docker Compose फ़ाइल का उपयोग करके सब कुछ सेट कर सकते हैं। APISIX के बारे में अधिक जानने के लिए, api7.ai/apisix पर जाएं।

APISIX एक prometheus प्लगइन प्रदान करता है जो आसानी से मेट्रिक्स को Prometheus फॉर्मेट में एक्सपोर्ट करता है। आप इस प्लगइन को अपनी APISIX कॉन्फ़िगरेशन फ़ाइल में कॉन्फ़िगर कर सकते हैं:

apisix:
  enable_admin: false # APISIX को स्टैंडअलोन मोड में चलाएं
  config_center: yaml # कॉन्फ़िगरेशन को etcd में संग्रहीत करने के बजाय YAML फ़ाइल का उपयोग करें
plugin_attr:
  prometheus:
    export_uri: /prometheus/metrics # prometheus प्लगइन को सक्षम करें और मेट्रिक्स को इस URI पर एक्सपोर्ट करें
    enable_export_server: false # मेट्रिक्स को डिफ़ॉल्ट डेटा-प्लेन पोर्ट पर एक्सपोर्ट करें

अब हम हर रूट पर प्लगइन को सक्षम कर सकते हैं इसे ग्लोबल रूल बनाकर:

routes:
  # /hello/* के अनुरोधों को go-app को भेजें
  - uri: /hello/*
    upstream:
      type: roundrobin
      nodes:
        "go-app:8080": 1
    plugins:
      # अनुरोध को go-app को आगे भेजने से पहले प्रीफ़िक्स "/hello" को हटाएं
      proxy-rewrite:
        regex_uri:
          - "/hello/(.*)"
          - "/$1"
  # निर्दिष्ट URI पर Prometheus मेट्रिक्स को एक्सपोर्ट करें
  - uri: /prometheus/metrics
    plugins:
      public-api:
# सभी रूट्स पर Prometheus प्लगइन को ग्लोबली सक्षम करें
global_rules:
  - id: 1
    plugins:
      prometheus:
        prefer_name: true
#END

यह Apache APISIX में /prometheus/metrics एंडपॉइंट पर मेट्रिक्स को एक्सपोर्ट करेगा।

आप उपलब्ध मेट्रिक्स के बारे में दस्तावेज़ीकरण से अधिक जान सकते हैं।

Go सेवा से मेट्रिक्स को इंस्ट्रूमेंट और एक्सपोर्ट करना

Prometheus में Go एप्लिकेशन को इंस्ट्रूमेंट करने के लिए एक आधिकारिक Go क्लाइंट लाइब्रेरी है।

डिफ़ॉल्ट रूप से, Prometheus डिफ़ॉल्ट Go मेट्रिक्स को एक्सपोर्ट करेगा। आप अपने स्वयं के एप्लिकेशन-विशिष्ट मेट्रिक्स भी बना सकते हैं।

हमारी सेवा में, हम डिफ़ॉल्ट मेट्रिक्स को एक्सपोर्ट करेंगे और अनुरोधों की संख्या को ट्रैक करने के लिए अपना स्वयं का काउंटर मेट्रिक बनाएंगे:

package main

import (
  "encoding/json"
  "fmt"
  "io/ioutil"
  "log"
  "net/http"
  "os"

  // Prometheus पैकेज
  "github.com/prometheus/client_golang/prometheus"
  "github.com/prometheus/client_golang/prometheus/promauto"
  "github.com/prometheus/client_golang/prometheus/promhttp"
)

// Response python-app से प्राप्त संदेश को संग्रहीत करता है
type Response struct {
  Message string `json:"message"`
}

// डिफ़ॉल्ट भाषा और नाम
var (
  lang = "en"
  name = "John"
)

// एक नया कस्टम Prometheus काउंटर मेट्रिक बनाएं
var pingCounter = promauto.NewCounter(
  prometheus.CounterOpts{
    Name: "go_app_request_count",
    Help: "go-app द्वारा संभाले गए अनुरोधों की संख्या",
  },
)

// HelloHandler go-app के अनुरोधों को संभालता है
func HelloHandler(w http.ResponseWriter, r *http.Request) {
  lang = r.URL.String()
  name = r.URL.Query()["name"][0]
  
  fmt.Println("Request for", lang, "with name", name)
  pingCounter.Inc()
  
  pUrl := os.Getenv("PYTHON_APP_URL")
  if len(pUrl) == 0 {
    pUrl = "localhost"
  }

  // python-app को अनुवाद प्राप्त करने के लिए कॉल करें
  resp, err := http.Get("http://" + pUrl + ":8000" + lang)
  if err != nil {
    log.Fatalln(err)
  }

  body, err := ioutil.ReadAll(resp.Body)
  if err != nil {
    log.Fatalln(err)
  }

  resp.Body.Close()

  var m Response
  json.Unmarshal(body, &m)

  // निर्दिष्ट भाषा में "Hello name!" के साथ प्रतिक्रिया भेजें
  fmt.Fprintf(w, "%s %s!", m.Message, name)
}

func main() {
  // Prometheus मेट्रिक्स को एक्सपोर्ट करें
  http.Handle("/metrics", promhttp.Handler())
  http.HandleFunc("/", HelloHandler)
  
  http.ListenAndServe(":8080", nil)
}

यह मेट्रिक्स को /metrics एंडपॉइंट पर एक्सपोर्ट करेगा। आप Go क्लाइंट लाइब्रेरी के बारे में अधिक जानने के लिए इसके GitHub रेपो पर जा सकते हैं।

Python सेवा से मेट्रिक्स को इंस्ट्रूमेंट और एक्सपोर्ट करना

Prometheus में एक आधिकारिक Python क्लाइंट लाइब्रेरी भी है। विशिष्ट उपयोग के मामलों के लिए तैयार किए गए तृतीय-पक्ष लाइब्रेरीज़ भी हैं।

हमारी सेवा FastAPI का उपयोग करती है, और हम इसे इंस्ट्रूमेंट करने के लिए prometheus_fastapi_instrumentator लाइब्रेरी का उपयोग करेंगे:

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

from prometheus_fastapi_instrumentator import Instrumentator

app = FastAPI()

hello = {"en": "Hello", "fr": "Bonjour", "es": "Hola", "ml": "ഹലോ"}

# डिफ़ॉल्ट Python मेट्रिक्स को /metrics एंडपॉइंट पर एक्सपोर्ट करें
Instrumentator().instrument(app).expose(app)

@app.get("/{lang}")
async def get_hello(lang):
    return {"message": hello[lang]}

आप कस्टम मेट्रिक्स बनाने के बारे में दस्तावेज़ीकरण से अधिक जान सकते हैं।

Prometheus को कॉन्फ़िगर करना

अब हम इन मेट्रिक्स को Prometheus में स्क्रैप और एकत्र कर सकते हैं।

आप Prometheus को प्रत्येक सेवा से मेट्रिक्स एकत्र करने के लिए कॉन्फ़िगर कर सकते हैं। डिफ़ॉल्ट रूप से, Prometheus /metrics पथ में मेट्रिक्स की जांच करता है:

global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]
  
  - job_name: "go-app"
    static_configs:
      - targets: ["go-app:8080"]

  - job_name: "python-app"
    static_configs:
      - targets: ["python-app:8000"]

  - job_name: "apisix"
    static_configs:
      - targets: ["apisix:9080"]
    metrics_path: "/prometheus/metrics"

बस! अब, यदि आप Prometheus डैशबोर्ड (डिफ़ॉल्ट पोर्ट 9090) खोलते हैं और नेवबार से "Status" और "Targets" पर क्लिक करते हैं, तो आप अपनी सेवाओं से स्क्रैप किए जा रहे मेट्रिक्स की स्थिति देख सकते हैं।

prometheus-target-status.png

Prometheus में मेट्रिक्स को क्वेरी और विज़ुअलाइज़ करना

अब, आप Prometheus डैशबोर्ड का उपयोग करके क्वेरी और जटिल एक्सप्रेशन चला सकते हैं।

prometheus-query.png

आप Prometheus को क्वेरी करने के बारे में आधिकारिक दस्तावेज़ीकरण से अधिक जान सकते हैं।

Prometheus को क्वेरी करने के लिए Grafana का उपयोग करना

Grafana एक ओपन-सोर्स डेटा विज़ुअलाइज़ेशन प्लेटफ़ॉर्म है जो Prometheus के साथ काम करता है ताकि मेट्रिक्स को एकत्र, क्वेरी और विज़ुअलाइज़ करने के लिए एक व्यापक टूल प्रदान कर सके।

Prometheus मेट्रिक्स एकत्र करने और क्वेरी करने में अच्छा है लेकिन सार्थक विज़ुअलाइज़ेशन बनाने के लिए टूलिंग की कमी है। Grafana इस सीमा को पार करता है और एकत्र किए गए मेट्रिक्स को विज़ुअलाइज़ेशन में बदलता है।

Grafana Prometheus के अलावा कई अन्य डेटा स्रोतों के साथ भी संगत है।

एक बार जब आप Grafana को डिप्लॉय कर लेते हैं, तो आप वेब UI (डिफ़ॉल्ट पोर्ट 3000) खोल सकते हैं।

सबसे पहले, आपको Prometheus को डेटा स्रोत के रूप में जोड़ना होगा। ऐसा करने के लिए, /datasources या "Configuration" और "Data sources" पर जाएं। "Add data source" पर क्लिक करें और Prometheus का चयन करें। निर्दिष्ट करें कि Prometheus कहाँ डिप्लॉय किया गया है, कनेक्शन को सेव और टेस्ट करें।

grafana-add-prometheus.png

पूर्व-निर्मित Grafana डैशबोर्ड का उपयोग करना

Grafana एक सार्वजनिक डैशबोर्ड रिपॉजिटरी होस्ट करता है जिसमें पूर्व-निर्मित Grafana डैशबोर्ड शामिल हैं। आप इन्हें अपने Grafana इंस्टेंस में उपयोग करके प्रासंगिक मेट्रिक्स को तेज़ी से विज़ुअलाइज़ कर सकते हैं।

हम Go Processes डैशबोर्ड का उपयोग करेंगे जो Prometheus Go क्लाइंट लाइब्रेरी द्वारा प्रकाशित प्रक्रिया स्थिति को प्रोसेस और विज़ुअलाइज़ करेगा।

इस टेम्पलेट को आयात करने के लिए, पहले इसकी ID (6671) को डैशबोर्ड रिपॉजिटरी से कॉपी करें। अपने Grafana UI में, "Dashboards" पर जाएं और "Import" का चयन करें। आपके द्वारा कॉपी की गई ID को पेस्ट करें और "Load" पर क्लिक करें।

grafana-dashboard.png

आप अन्य पूर्व-निर्मित डैशबोर्ड का अन्वेषण भी कर सकते हैं या अपने स्वयं के बना सकते हैं। इसके बारे में अधिक जानने के लिए दस्तावेज़ीकरण देखें।

आगे क्या?

यह इस ट्यूटोरियल के लिए है!

यह लेख केवल यह बताने के लिए था कि आप अपनी सेवाओं पर मॉनिटरिंग कैसे सेट कर सकते हैं, और मैं आपको नीचे दिए गए संसाधनों से Prometheus और Grafana के बारे में अधिक जानने के लिए प्रोत्साहित करता हूं:

इस ट्यूटोरियल के लिए पूरा कोड और Docker Compose फ़ाइल pottekkat/monitoring-101 में उपलब्ध है।

Tags:
Monitoring
Prometheus
Grafana