Zabbix

Zabbix की समस्याएं Status200 को भेजें, ताकि हर समस्या एक घटना बने जो आपकी ऑन-कॉल टीम को पेज करे, और Zabbix के ठीक होने पर सुलझ जाए। तैयार वर्कफ़्लो टेम्पलेट दोनों तरफ़ को एक साथ रखते हैं: लोग Zabbix में जो करते हैं वह घटना पर दर्ज होता है, और घटना को स्वीकार करने या सुलझाने से Zabbix में समस्या स्वीकार या बंद हो जाती है। Zabbix हर समस्या को वेबहुक मीडिया टाइप के ज़रिए भेजता है, इसलिए किसी भी तरफ़ कुछ इंस्टॉल नहीं करना पड़ता।

यह कैसे काम करता है#

Zabbix किसी समस्या को एक यूज़र को, उस यूज़र के मीडिया के ज़रिए भेजता है। यहां मीडिया Status200 नाम का एक वेबहुक मीडिया टाइप है: उसकी स्क्रिप्ट हर समस्या के लिए, उसके ठीक होने के लिए, और Zabbix में उस पर किसी के हर अपडेट के लिए Status200 को एक छोटा JSON दस्तावेज़ भेजती है, जिसमें समस्या का इवेंट ID, नाम, होस्ट और गंभीरता होती है। इवेंट ID से ही Status200 उस घटना को ढूंढता है जो किसी समस्या ने खोली।

शुरू करने से पहले#

• एक Zabbix सर्वर जिसका एडमिनिस्ट्रेशन आप करते हैं। यह गाइड Zabbix 6.0 LTS और 7.0 LTS के लिए लिखी गई है। वेबहुक मीडिया टाइप Zabbix 5.0 से इसी तरह काम करते हैं। Zabbix के API को कॉल करने वाले टेम्पलेट के लिए Zabbix 6.4 या उसके बाद का वर्शन चाहिए, या Zabbix 6.0 पर एक बदलाव।
• एक Zabbix सर्वर जो HTTPS पर आपके Status200 तक पहुंच सके, और Zabbix को कॉल करने वाले टेम्पलेट के लिए, एक Status200 जो Zabbix तक पहुंच सके।
• Status200 में वर्कफ़्लो बनाने का अधिकार, या अगर आप वह रास्ता चुनते हैं तो मॉनिटर बनाने का। Status200 Cloud पर वर्कफ़्लो के लिए Growth प्लान या उससे ऊपर का प्लान चाहिए।

चुनें कि Status200 समस्याएं कैसे पाए#

पहले Status200 सेट करें: वही आपको वह URL देता है जिस पर Zabbix भेजता है।

दोनों को एक ही मीडिया टाइप से एक जैसा JSON मिलता है, इसलिए आप एक से शुरू करके बाद में Zabbix में एक URL बदलकर दूसरे पर जा सकते हैं।

टेम्पलेट से शुरू करें#

एक वर्कफ़्लो बनाएं डायलॉग में छह Zabbix टेम्पलेट हैं, उसकी कैटेगरी सूची में Zabbix के नीचे: तीन घटनाओं के लिए, फिर वही तीन अलर्ट के लिए।

Declare an incident for each Zabbix problem से शुरू करें, या अलर्ट के लिए Create an alert for each Zabbix problem से: यह जो घटना या अलर्ट खोलता है वह समस्या का इवेंट ID अपनी कस्टम फ़ील्ड zabbixEventId में रखता है, और बाकी दो टेम्पलेट उसी से समस्या ढूंढते हैं।

टेम्पलेट क्या मांगते हैं#

• Zabbix URL: वह पता जिस पर आप Zabbix खोलते हैं, जैसे https://zabbix.example.com, या https://example.com/zabbix जब Zabbix किसी पाथ के नीचे चलता है। किसी समस्या के लिंक वहीं जाते हैं, और Zabbix को कॉल करने वाले टेम्पलेट अपने अनुरोध उसके api_jsonrpc.php पर भेजते हैं। यह फ़ील्ड Zabbix के अंदर के किसी पेज का पता नहीं मानती।
• Zabbix API Token: उस Zabbix यूज़र का API टोकन जिसके रूप में वर्कफ़्लो काम करता है। API टोकन बनाएं बताता है कैसे। इसे एक सीक्रेट वैरिएबल के रूप में सहेजा जाता है, और यह सिर्फ़ Authorization हेडर में भेजा जाता है।

टेम्पलेट से समस्याएं पाएं#

फिर Zabbix कॉन्फ़िगर करें ताकि वह अपनी समस्याएं उस URL पर भेजे।

वर्कफ़्लो क्या करता है#

Webhook ट्रिगर के बाद, एक Switch / Case ब्लॉक मीडिया टाइप के भेजे हर event के लिए एक रास्ता लेता है:

बाकी सब कुछ, जैसे किसी दूसरे टूल का अनुरोध, जैसा है वैसा छोड़ दिया जाता है, और रन का आख़िरी चरण बताता है क्यों। हर रन एक Log चरण पर ख़त्म होता है जो बताता है क्या हुआ: ✅ उसने अपना काम किया, ℹ️ उसने इवेंट जानबूझकर छोड़ा, ❌ कोई चरण विफल हुआ और रन लॉग बताता है क्यों।

गंभीरताएं#

नए प्रोजेक्ट में, टेम्पलेट Zabbix की छह गंभीरताओं को इन घटना और अलर्ट गंभीरताओं पर मैप करता है:

अपनी गंभीरताओं के साथ, Disaster और High आपकी सबसे गंभीर पर जाती हैं, Average और Warning बीच वाली पर, और Information और Not classified आपकी सबसे कम गंभीर पर। Zabbix अपनी गंभीरताओं को 0 (Not classified) से 5 (Disaster) तक नंबर देता है, और टेम्पलेट नंबर पढ़ता है, इसलिए Zabbix में किसी गंभीरता का नाम बदलने से कुछ नहीं बदलता।

• किसी गंभीरता को नाम से अपनी किसी गंभीरता पर मैप करने के लिए, SEVERITY_BY_NAME को read-event-1 चरण में संपादित करें, जैसे Warning के लिए { 2: 'Minor Incident' }।
• Average समस्याओं के लिए भी पेज करने हेतु, if-page-1 If / Else चरण का Compare with 3 पर सेट करें।

स्वीकृतियां और नोट Zabbix को वापस भेजें#

स्थिति वाला टेम्पलेट पहले Zabbix से समस्या के बारे में पूछता है, इसलिए जिस समस्या को Zabbix पहले ही स्वीकार कर चुका है या सुलझा चुका है, उसे जैसा है वैसा छोड़ दिया जाता है। किसी समस्या को बंद करने के लिए, Zabbix में उसके ट्रिगर पर Allow manual close होना चाहिए। उसके बिना, समस्या बंद होने के बजाय स्वीकार की जाती है, एक संदेश के साथ कि घटना सुलझ गई, और Zabbix उसके ठीक होने पर उसे बंद करता है। जिन घटनाओं को किसी Zabbix समस्या ने नहीं खोला, और निजी घटना के रूप में चिह्नित घटनाएं, कभी Zabbix को नहीं भेजी जातीं।

API टोकन बनाएं#

Zabbix 6.0 पर#

Zabbix 6.0 API टोकन को अनुरोध की बॉडी से पढ़ता है, उसके Authorization हेडर से नहीं। Zabbix को कॉल करने वाले टेम्पलेट के हर API चरण में, Request Body में "auth": "{{local.variables.zabbixApiToken}}", को "jsonrpc": "2.0", के बाद जोड़ें, और हेडर हटा दें। Zabbix 7.2 और उसके बाद के वर्शन auth को अस्वीकार करते हैं, इसलिए अपग्रेड करने पर इसे फिर से हटा दें।

मॉनिटर से समस्याएं पाएं#

एक Incoming Request मॉनिटर आपको एक URL देता है, और उसके मानदंड तय करते हैं कि हर अनुरोध क्या करे।

1. मॉनिटर बनाएं#

   मॉनिटर पर जाएं और मॉनिटर बनाएं पर क्लिक करें। मॉनिटर प्रकार में Incoming Request चुनें, इसका नाम Zabbix रखें, और अगला पर क्लिक करें।

2. हर समस्या के लिए घटना घोषित करें#

   मानदंड चरण में पहला मानदंड खोलें, वह जो मॉनिटर को ऑफ़लाइन चिह्नित करता है। उसका फ़िल्टर अनुरोध बॉडी, शामिल है, "status":"1" पर सेट करें। फ़िल्टर मेल खाने पर यह मानदंड पहले से ही घटना घोषित करता है। घटना भरें:

   • घटना शीर्षक: Zabbix: {{requestBody.name}} on {{requestBody.host}}।
   • गंभीरता: वह घटना गंभीरता जो Zabbix समस्याओं की होनी चाहिए।
   • ऑन-कॉल के नीचे ऑन-कॉल नीतियां: पेज की जाने वाली नीतियां।
   • और फ़ील्ड के नीचे घटना स्वतः सुलझाएं: इसे चालू रहने दें, जैसा यह शुरू में होता है। इसके बिना रिकवरी को अनदेखा किया जाता है और घटनाएं खुली रहती हैं।

3. हर समस्या पर एक घटना खोलें#

   उसी मानदंड में सेटिंग्स खोलें और Group incidents and alerts by a payload field चालू करें। इसे नीचे की तरह भरें, ताकि हर समस्या की अपनी घटना हो, और उसकी रिकवरी उसे सुलझाए:

   फ़ील्ड	मान
   Open a separate incident for each…	requestBody.event_id
   Field that signals recovery	requestBody.status
   Value that means recovered	0

4. मॉनिटर को वापस ऑनलाइन लाएं#

   दूसरा मानदंड खोलें, वह जो मॉनिटर को ऑनलाइन चिह्नित करता है, और उसका फ़िल्टर अनुरोध बॉडी, शामिल है, "status":"0" पर सेट करें।

5. URL कॉपी करें#

   मॉनिटर बनाएं पर क्लिक करें। मॉनिटर का अवलोकन पेज उसका Heartbeat URL दिखाता है। उसे Zabbix के लिए कॉपी करें:

   https://status200.ru/heartbeat/<secret key>

   सेल्फ़-होस्टेड इंस्टॉलेशन में status200.ru की जगह उसका अपना होस्ट होता है।

मॉनिटर अनुरोध के JSON को जैसा लिखा है वैसा ही पढ़ता है: "status":"1", बिना स्पेस के। हर सेटिंग क्या करती है, यह जानने के लिए दूसरे सिस्टम से अलर्ट पाना देखें। Zabbix में किया गया अपडेट भी "status":"1" के साथ भेजा जाता है, जिसे मॉनिटर फिर से समस्या के रूप में पढ़ता है, और दूसरी घटना नहीं खोलता।

Zabbix कॉन्फ़िगर करें#

Zabbix को तीन चीज़ें चाहिए: Status200 पर भेजने वाला एक मीडिया टाइप, जिसे भेजना है वह यूज़र, और एक एक्शन जो समस्याएं उस यूज़र को भेजे।

1. Status200 मीडिया टाइप बनाएं#

   1. Alerts → Media types पर जाएं, या Zabbix 6.0 पर Administration → Media types पर, और Create media type पर क्लिक करें।

   2. Name को Status200 और Type को Webhook पर सेट करें।

   3. ये Parameters जोड़ें। हर एक किसी Zabbix मैक्रो को अनुरोध में डालता है:

      नाम	मान
      url	{ALERT.SENDTO}
      event_id	{EVENT.ID}
      event_name	{EVENT.NAME}
      event_value	{EVENT.VALUE}
      event_severity	{EVENT.SEVERITY}
      event_nseverity	{EVENT.NSEVERITY}
      host	{HOST.NAME}
      event_date	{EVENT.DATE}
      event_time	{EVENT.TIME}
      event_opdata	{EVENT.OPDATA}
      event_tags	{EVENT.TAGSJSON}
      trigger_id	{TRIGGER.ID}
      event_update_status	{EVENT.UPDATE.STATUS}
      event_update_action	{EVENT.UPDATE.ACTION}
      event_update_message	{EVENT.UPDATE.MESSAGE}
      event_update_user	{USER.FULLNAME}

   4. इसे Script में पेस्ट करें:

      JavaScript

      var params = JSON.parse(value);
      
      // Zabbix leaves a macro it has no value for as it is written, such as
      // {EVENT.UPDATE.MESSAGE} on a problem: it is sent as nothing.
      function given(text) {
        var written = String(text === undefined || text === null ? "" : text);
        return /^\{[A-Z0-9_.]+\}$/.test(written) || written === "*UNKNOWN*"
          ? ""
          : written;
      }
      
      var isUpdate = given(params.event_update_status) === "1";
      var payload = {
        source: "zabbix",
        // "problem", "recovery" or "update".
        event: isUpdate
          ? "update"
          : params.event_value === "0"
            ? "recovery"
            : "problem",
        event_id: params.event_id,
        name: params.event_name,
        host: params.host,
        severity: params.event_severity,
        // 0 Not classified, 1 Information, 2 Warning, 3 Average, 4 High, 5 Disaster.
        severity_number: params.event_nseverity,
        // "1" for a problem, "0" for its recovery.
        status: params.event_value,
        date: params.event_date,
        time: params.event_time,
        opdata: given(params.event_opdata),
        tags: [],
        trigger_id: params.trigger_id,
      };
      
      try {
        var tags = JSON.parse(given(params.event_tags) || "[]");
        payload.tags = Array.isArray(tags) ? tags : [];
      } catch (error) {
        payload.tags = [];
      }
      
      if (isUpdate) {
        payload.update = {
          action: given(params.event_update_action),
          message: given(params.event_update_message),
          user: given(params.event_update_user),
        };
      }
      
      var request = new HttpRequest();
      request.addHeader("Content-Type: application/json");
      
      var response = request.post(params.url, JSON.stringify(payload));
      
      if (request.getStatus() < 200 || request.getStatus() >= 300) {
        throw (
          "Status200 responded with HTTP " + request.getStatus() + ": " + response
        );
      }
      
      return "OK";

   5. Message templates टैब पर Problem के लिए एक टेम्पलेट, Problem recovery के लिए एक और Problem update के लिए एक टेम्पलेट जोड़ें। उनका टेक्स्ट खाली छोड़ें: अनुरोध स्क्रिप्ट बनाती है। Zabbix किसी मीडिया टाइप का इस्तेमाल सिर्फ़ उन्हीं तरह के इवेंट के लिए करता है जिनका उसके पास टेम्पलेट है।

   6. Add पर क्लिक करें।

2. समस्याएं पाने वाला यूज़र बनाएं#

   1. Users → Users पर जाएं, या Zabbix 6.0 पर Administration → Users पर, और Create user पर क्लिक करें। इसका नाम Status200 रखें, और इसे एक यूज़र ग्रुप और ऐसी भूमिका दें जो सूचनाएं पा सके, जैसे User role।
   2. Media टैब पर Add पर क्लिक करें। Type को Status200 पर, और Send to को Status200 से कॉपी किए गए URL पर सेट करें। When active और गंभीरताओं को जैसा है वैसा छोड़ दें, या उन गंभीरताओं से टिक हटा दें जो Status200 को नहीं मिलनी चाहिए।
   3. Add पर क्लिक करें, फिर यूज़र सहेजने के लिए दोबारा Add पर।

3. एक्शन से समस्याएं Status200 को भेजें#

   1. Alerts → Actions → Trigger actions पर जाएं, या Zabbix 6.0 पर Configuration → Actions पर, और Create action पर क्लिक करें। इसका नाम Notify Status200 रखें।
   2. चाहें तो Conditions में इसे सीमित करें, जैसे Trigger severity is greater than or equals Warning। बिना शर्तों के हर समस्या भेजी जाती है।
   3. Operations टैब पर एक ऑपरेशन जोड़ें जो Status200 मीडिया टाइप के ज़रिए Status200 यूज़र को भेजे।
   4. वही ऑपरेशन Recovery operations में भी जोड़ें, ताकि रिकवरी भी भेजी जाए, और Update operations में भी, ताकि Zabbix में की गई स्वीकृतियां और टिप्पणियां भेजी जाएं।
   5. Add पर क्लिक करें, और जांचें कि एक्शन चालू है।

कुछ समस्याएं घटना टेम्पलेट को और बाकी अलर्ट टेम्पलेट को भेजने के लिए, Status200 यूज़र को Status200 टाइप के दो मीडिया दें: हर एक किसी एक वर्कफ़्लो के URL पर भेजता है, उन गंभीरताओं के साथ जो उसे मिलनी चाहिए।

इसे टेस्ट करें#

1. Zabbix में Alerts → Media types खोलें और Status200 के पास Test पर क्लिक करें। कॉपी किया गया URL भरें, और नमूना मान, जैसे event_id 12345, event_name Test problem, host web-1, event_nseverity 4 और event_value 1। Test पर क्लिक करें: Zabbix स्क्रिप्ट का जवाब OK, या उसकी फेंकी गई त्रुटि दिखाता है।
2. Status200 में वर्कफ़्लो का लॉग → रन खोलें और रन जांचें, या मॉनिटर खोलें और जांचें कि घटना खुली।
3. event_value 0 और उसी event_id के साथ दोबारा टेस्ट करें। घटना सुलझ जाती है।

फिर किसी असली ट्रिगर को चलने दें, जैसे थोड़ी देर के लिए कोई थ्रेशोल्ड कम करके, और समस्या को आते देखें। अपडेट आज़माने के लिए, Zabbix में समस्या को एक संदेश के साथ स्वीकार करें: घटना को एक निजी नोट मिलता है, और वह स्वीकार हो जाती है।

Zabbix गंभीरताओं को मैप करें#

Zabbix अपनी गंभीरता टेक्स्ट के रूप में भेजता है: Not classified, Information, Warning, Average, High या Disaster।

• टेम्पलेट के साथ, गंभीरताएं आपके लिए मैप होती हैं: गंभीरताएं देखें।
• मॉनिटर के साथ, गंभीरताओं के हर समूह के लिए मानदंड जोड़ें पर क्लिक करें, और नए मानदंड को पहले वाले के ऊपर खींचें: मानदंड ऊपर से जांचे जाते हैं, और जो पहले मेल खाता है वही तय करता है। हर एक को दो फ़िल्टर दें, "status":"1" और एक गंभीरता जैसे "severity":"Disaster", और मिलान शर्त को सभी पर रखें। हर एक को एक घटना दें जिसकी अपनी गंभीरता और घटना स्वतः सुलझाएं हो, और वही ग्रुपिंग सेटिंग।

समस्या निवारण#

सुरक्षा#

• URL को पासवर्ड की तरह रखें। जिसके पास भी यह है, वह घटनाएं खोल सकता है। अगर यह लीक हो जाए, तो इसे रीसेट करें: वर्कफ़्लो के Webhook ट्रिगर में URL रीसेट करें, या मॉनिटर के सेटिंग्स पेज पर इनकमिंग अनुरोध सीक्रेट कुंजी रीसेट करें। फिर Zabbix यूज़र के मीडिया में Send to अपडेट करें।
• लिंक आपके Zabbix पर जाते हैं। टेम्पलेट किसी समस्या का लिंक उसी साइट पर देता है जिसका नाम उसका Zabbix URL लेता है, अनुरोध चाहे जो कहे, और Zabbix ने जो भेजा उसे टेक्स्ट के रूप में लिखता है।
• API टोकन को वर्कफ़्लो के काम तक सीमित रखें। यह एक सीक्रेट वैरिएबल है, रन लॉग में छिपाया जाता है, और सिर्फ़ Authorization हेडर में भेजा जाता है। उसके यूज़र को ऐसी भूमिका दें जिसमें ऊपर की कार्रवाइयों से ज़्यादा कुछ न हो, और अगर टोकन लीक हो जाए तो उसे Users → API tokens में हटा दें।
• सिर्फ़ वही भेजें जिसे घटना चाहिए। कम गंभीरता वाली समस्याओं को Zabbix में रखने के लिए एक्शन की शर्तें, या यूज़र के मीडिया की गंभीरताएं इस्तेमाल करें।
• सेल्फ़-होस्टेड? अपने Zabbix सर्वर को अपने फ़ायरवॉल से होकर HTTPS पर अपने Status200 तक पहुंचने दें। किसी निजी नेटवर्क पर Zabbix को कॉल करने के लिए, वर्कफ़्लो को आउटबाउंड नेटवर्क एक्सेस चाहिए।

अगले कदम#