IoT डिवाइस

Status200 IoT डिवाइस के फ़्लीट — सेंसर, गेटवे, कंट्रोलर और एज बॉक्स — की निगरानी उनके भेजे iot_* मेट्रिक्स के एक छोटे सेट से करता है। यह डिवाइसों को फ़्लीट में समूहित करता है, हर फ़्लीट के डिवाइसों की इन्वेंटरी रखता है, और उनकी बैटरी, सिग्नल, तापमान, CPU, मेमोरी और उपलब्धता के चार्ट बनाता है। किसी डिवाइस पर इंस्टॉल करने के लिए कोई Status200 एजेंट नहीं है: डिवाइस मानक OpenTelemetry भेजते हैं, या Status200 के MQTT एंडपॉइंट पर प्रकाशित करते हैं। IoT डिवाइस मॉनिटर उनके भेजे डेटा पर अलर्ट करते हैं।

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

हर रीडिंग किसी फ़्लीट और डिवाइस की होती है। Status200 पहली रीडिंग से फ़्लीट बनाता है, हर नए डिवाइस को फ़्लीट की इन्वेंटरी में जोड़ता है, और उसके बाद हर रीडिंग के साथ डिवाइस के नवीनतम मान अपडेट करता है। OpenTelemetry और MQTT पर भेजी गई रीडिंग एक ही फ़्लीट, इन्वेंटरी, चार्ट और मॉनिटर भरती हैं।

Status200 IoT को कैसे मॉडल करता है#

• फ़्लीट: डिवाइसों का एक समूह, जैसे building-a-sensors या field-gateways। यह iot.fleet.name रिसोर्स एट्रिब्यूट से आता है, और Status200 में टेलीमेट्री सेवा iot/<fleet> के रूप में दिखता है। service.name=iot/<fleet> भी सेट करें, ताकि लॉग और मेट्रिक्स एक ही सेवा के अंतर्गत मिलें।
• डिवाइस: किसी फ़्लीट का एक डिवाइस, जिसका नाम हर डेटापॉइंट पर device.id एट्रिब्यूट से आता है। फ़्लीट की इन्वेंटरी device.id पर आधारित है।

MQTT पर टॉपिक आपके लिए फ़्लीट और डिवाइस सेट करता है।

चुनें कि कैसे भेजना है#

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

• एक इंजेशन कुंजी। प्रोजेक्ट सेटिंग्स → टेलीमेट्री और APM → इंजेशन कुंजियाँ के अंतर्गत एक बनाएँ और उसका मान कॉपी करें। डिवाइस इसे x-status200-token हेडर में, या MQTT पासवर्ड के रूप में भेजते हैं।
• डिवाइस या गेटवे से आपके Status200 URL तक नेटवर्क पहुँच।
• डिवाइसों के हर समूह के लिए एक फ़्लीट नाम, और हर डिवाइस के लिए एक स्थिर ID।

OpenTelemetry SDK के माध्यम से मेट्रिक्स भेजना#

1. SDK को Status200 की ओर इंगित करें#

   डिवाइस पर मानक OpenTelemetry एनवायरनमेंट वेरिएबल सेट करें। कुंजी, फ़्लीट नाम और डिवाइस ID को अपने मानों से बदलें:

   Bash

   export OTEL_EXPORTER_OTLP_ENDPOINT=https://status200.ru/otlp
   export OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
   export OTEL_EXPORTER_OTLP_HEADERS=x-status200-token=YOUR_TELEMETRY_INGESTION_TOKEN
   export OTEL_RESOURCE_ATTRIBUTES=iot.fleet.name=building-a-sensors,device.id=sensor-001,service.name=iot/building-a-sensors

   iot.fleet.name स्थिर रखें: इसे बदलने से एक नया फ़्लीट रजिस्टर होता है।

2. रीडिंग को IoT मेट्रिक्स के रूप में दर्ज करें#

   हर रीडिंग को पारंपरिक नामों में से किसी एक के साथ मेट्रिक के रूप में भेजें, और हर डेटापॉइंट को एक device.id एट्रिब्यूट दें:

   मेट्रिक	मान	डेटापॉइंट एट्रिब्यूट
   iot_device_up	1	device.id=sensor-001
   iot_battery_percent	87	device.id=sensor-001
   iot_temperature_celsius	21.5	device.id=sensor-001

   इन्वेंटरी डेटापॉइंट के device.id पर आधारित है, रिसोर्स के नहीं, इसलिए इसे हर माप पर और साथ ही OTEL_RESOURCE_ATTRIBUTES में सेट करें।

फिर जाँचें कि फ़्लीट दिखता है।

OpenTelemetry Collector के माध्यम से मेट्रिक्स भेजना#

जब कई डिवाइस एक गेटवे के ज़रिए रिपोर्ट करते हैं, तो गेटवे पर एक OpenTelemetry Collector चलाएँ। यह आपके डिवाइसों से OTLP प्राप्त करता है, हर रीडिंग पर फ़्लीट लगाता है और उन्हें Status200 तक आगे भेजता है।

1. गेटवे का कॉन्फ़िगरेशन सहेजें#

   इसे गेटवे पर config.yaml के रूप में सहेजें:

   config.yamlYAML

   receivers:
     otlp:
       protocols:
         grpc:
           endpoint: 0.0.0.0:4317
         http:
           endpoint: 0.0.0.0:4318
   
   processors:
     batch:
       send_batch_size: 512
       timeout: 5s
     resource:
       attributes:
         - key: iot.fleet.name
           value: field-gateways
           action: upsert
         - key: service.name
           value: iot/field-gateways
           action: upsert
   
   exporters:
     otlphttp:
       endpoint: "https://status200.ru/otlp"
       headers:
         "x-status200-token": "YOUR_TELEMETRY_INGESTION_TOKEN"
   
   service:
     pipelines:
       metrics:
         receivers: [otlp]
         processors: [resource, batch]
         exporters: [otlphttp]

   • otlp आपके डिवाइसों से gRPC (4317) और HTTP (4318) पर प्राप्त करता है। कलेक्टर जिस किसी भी दूसरे तरीके को समर्थित करता है (एक MQTT ब्रिज, फ़ाइल लॉग) उससे रीडिंग प्राप्त करें और उन्हें उसी पाइपलाइन से भेजें।
   • resource हर रीडिंग पर फ़्लीट लगाता है। हर गेटवे के लिए iot.fleet.name, और उससे मेल खाता service.name=iot/<fleet>, सेट करें, ताकि हर गेटवे के डिवाइस अपने फ़्लीट में पहुँचें।
   • हर डेटापॉइंट पर device.id, और iot.device.kind, iot.device.type और iot.device.firmware में से जो भी हो, रखें, ताकि Status200 फ़्लीट के डिवाइसों को अलग पहचान सके।
   • otlphttp इंजेशन कुंजी के साथ HTTPS पर Status200 को भेजता है। डिफ़ॉल्ट protobuf एन्कोडिंग और encoding: json दोनों स्वीकार होते हैं।

2. गेटवे पर कलेक्टर चलाएँ#

   Dockerotelcol-contrib

   Docker

   इसे उस फ़ोल्डर से चलाएँ जिसमें config.yaml है:

   Bash

   docker run -d \
     --name otel-collector \
     --restart unless-stopped \
     -p 4317:4317 \
     -p 4318:4318 \
     -v $(pwd)/config.yaml:/etc/otelcol-contrib/config.yaml:ro \
     otel/opentelemetry-collector-contrib:0.161.0 \
     --config /etc/otelcol-contrib/config.yaml

   otelcol-contrib

   अगर गेटवे पर पहले से otelcol-contrib है, तो उसे इस फ़ाइल की ओर इंगित करें:

   Bash

   otelcol-contrib --config config.yaml

   फिर डिवाइस गेटवे को OTLP भेजते हैं, उदाहरण के लिए हर डिवाइस के SDK में OTEL_EXPORTER_OTLP_ENDPOINT=http://<gateway-host>:4318 के साथ।

फिर जाँचें कि फ़्लीट दिखता है।

MQTT के माध्यम से मेट्रिक्स भेजना#

Status200 का अपना MQTT एंडपॉइंट है, इसलिए MQTT बोलने वाले डिवाइस बिना किसी SDK, कलेक्टर या ब्रिज के सीधे उस पर रीडिंग प्रकाशित करते हैं। MQTT पर आने वाला डेटा OTLP वाली ही पाइपलाइन से गुज़रता है: फ़्लीट बनते हैं, इन्वेंटरी अपडेट होती है, और हर IoT मॉनिटर और अलर्ट टेम्पलेट उसी तरह काम करता है।

एंडपॉइंट#

प्रमाणीकरण#

• इंजेशन कुंजी के साथ: इसे MQTT पासवर्ड के रूप में भेजें। उपयोगकर्ता नाम अनदेखा होता है; अगर आपके क्लाइंट में सिर्फ़ उपयोगकर्ता नाम का फ़ील्ड है, तो कुंजी वहीं रखें। यह ऐसे गेटवे के लिए ठीक है जो कई डिवाइसों के लिए प्रकाशित करता है।
• हर डिवाइस के क्रेडेंशियल के साथ: सीधे कनेक्ट होने वाले डिवाइसों के लिए सुझाया गया। फ़्लीट का Device Registry पेज खोलें और डिवाइस को उस Device ID के साथ रजिस्टर करें जिसे वह device.id के रूप में उपयोग करता है। डिवाइस का MQTT Username उसका उपयोगकर्ता नाम है और उसका MQTT Password (Secret) उसका पासवर्ड।

डिवाइस का क्रेडेंशियल सिर्फ़ उसके अपने oneuptime/<fleet>/<device>/ टॉपिक के अंतर्गत प्रकाशित कर सकता है। आप बाकी फ़्लीट को छुए बिना एक डिवाइस को रद्द कर सकते हैं: उसका सक्षम स्विच बंद करें, या उसे हटाएँ, और कनेक्टेड डिवाइस लगभग एक मिनट में काट दिया जाता है। जो रजिस्टर्ड डिवाइस चुप हो जाता है वह इन्वेंटरी में ऑफ़लाइन के रूप में बना रहता है, और उसके लिए Device Offline अलर्ट टेम्पलेट चलता है, भले वह Last Will के बिना बंद हो।

Status200 गलत क्रेडेंशियल को CONNECT पर रिटर्न कोड 4 (गलत उपयोगकर्ता नाम या पासवर्ड) के साथ अस्वीकार करता है, इसलिए गलत कॉन्फ़िगर किया गया डिवाइस साफ़ तौर पर विफल होता है। MQTT पर ब्राउज़र कुंजियाँ अस्वीकार होती हैं।

टॉपिक और पेलोड#

तय oneuptime/ उपसर्ग के अंतर्गत प्रकाशित करें। फ़्लीट और डिवाइस सेगमेंट में /, + या # नहीं होने चाहिए, वे $ से शुरू नहीं होने चाहिए, और अधिकतम 100 वर्ण लंबे होते हैं।

टेलीमेट्री पेलोड में "attributes" भी हो सकता है, स्ट्रिंग का एक मैप जो हर डेटापॉइंट पर लगाया जाता है (इसे iot.device.kind, iot.device.type, iot.device.firmware या अपने लेबल के लिए उपयोग करें), और "timestamp", ISO 8601 में या unix सेकंड या मिलीसेकंड में। दोनों वैकल्पिक हैं: timestamp के बिना वह समय उपयोग होता है जब Status200 रीडिंग प्राप्त करता है।

Last Will के साथ ऑफ़लाइन पहचान#

oneuptime/<fleet>/<device>/status पर offline पेलोड के साथ एक MQTT Last Will रजिस्टर करें। अगर डिवाइस बंद हो जाए या नेटवर्क से गिर जाए, तो उसका सत्र खत्म होते ही Status200 उसके लिए iot_device_up = 0 प्रकाशित करता है, जो तैयार Device Offline अलर्ट टेम्पलेट चलाता है और इन्वेंटरी में डिवाइस को डाउन चिह्नित करता है, बिना किसी पोलिंग के। कनेक्ट होने के बाद उसी टॉपिक पर online प्रकाशित करें, ताकि डिवाइस फिर से अप दिखे।

उदाहरण#

mosquitto_pub -h YOUR-ONEUPTIME-APP-HOST -p 1883 \
  -u oneuptime -P "YOUR_TELEMETRY_INGESTION_TOKEN" \
  -t "oneuptime/building-a-sensors/sensor-001/telemetry" \
  -m '{"metrics":{"iot_device_up":1,"iot_battery_percent":87,"iot_temperature_celsius":21.5},"attributes":{"iot.device.type":"temp-sensor","iot.device.firmware":"1.4.2"}}'

const mqtt = require("mqtt");

const client = mqtt.connect("wss://status200.ru/mqtt", {
  username: "oneuptime", // ignored — the token below is what authenticates
  password: "YOUR_TELEMETRY_INGESTION_TOKEN",
  will: {
    topic: "oneuptime/building-a-sensors/sensor-001/status",
    payload: "offline",
  },
});

client.on("connect", () => {
  client.publish("oneuptime/building-a-sensors/sensor-001/status", "online");
  setInterval(() => {
    client.publish(
      "oneuptime/building-a-sensors/sensor-001/telemetry",
      JSON.stringify({
        metrics: {
          iot_device_up: 1,
          iot_battery_percent: readBattery(),
          iot_temperature_celsius: readTemperature(),
        },
      }),
    );
  }, 60 * 1000);
});

import json
import paho.mqtt.client as mqtt

client = mqtt.Client(transport="websockets")
client.username_pw_set("oneuptime", "YOUR_TELEMETRY_INGESTION_TOKEN")
client.tls_set()
client.will_set("oneuptime/building-a-sensors/sensor-001/status", "offline")
client.ws_set_options(path="/mqtt")
client.connect("status200.ru", 443)

client.publish("oneuptime/building-a-sensors/sensor-001/status", "online")
client.publish(
    "oneuptime/building-a-sensors/sensor-001/telemetry",
    json.dumps({"metrics": {"iot_device_up": 1, "iot_temperature_celsius": 21.5}}),
)

सीमाएँ और डिलीवरी#

• एंडपॉइंट सिर्फ़ रीडिंग लेता है: सब्सक्रिप्शन अस्वीकार होते हैं (एक SUBACK विफलता), और retained संदेश नहीं रखे जाते।
• इंजेशन कम से कम एक बार होता है। Status200 से हर प्रकाशन की पावती पाने के लिए QoS 1 उपयोग करें; खोई हुई पावती के बाद QoS 1 या 2 पर दोबारा भेजने से दोहरे डेटापॉइंट बन सकते हैं।
• 128 KB से बड़ा, या 100 से ज़्यादा मेट्रिक्स वाला प्रकाशन हटा दिया जाता है, और उससे ज़्यादा घोषित करने वाला पैकेट कनेक्शन बंद कर देता है।
• इन टॉपिक के बाहर, या गलत बने पेलोड वाला प्रकाशन स्वीकार करके हटा दिया जाता है, क्योंकि MQTT 3.1.1 में हर संदेश की कोई त्रुटि नहीं होती। Status200 कारण के साथ एक चेतावनी लॉग करता है (MQTT: dropped publish to …)।
• WebSocket एंडपॉइंट पर MQTT keepalive 5 मिनट से कम रखें। इंग्रेस 300 सेकंड तक निष्क्रिय रहने वाला WebSocket बंद कर देता है, जिससे Last Will और एक गलत Device Offline अलर्ट चलता है। क्लाइंट लाइब्रेरी के डिफ़ॉल्ट (mqtt और paho-mqtt के लिए 60 सेकंड) ठीक हैं, और TCP एंडपॉइंट पर ऐसी कोई सीमा नहीं है।

मेट्रिक परंपराएँ#

Status200 ये iot_* मेट्रिक नाम पहचानता है। सिर्फ़ वे भेजें जो आपके डिवाइस के लिए मायने रखते हैं: जो नहीं भेजे जाते उनके चार्ट नहीं बनते। हर डेटापॉइंट में डिवाइस का device.id होता है (MQTT पर टॉपिक डिवाइस का नाम देता है)।

जाँचें कि फ़्लीट दिखता है#

1. जाँचें कि डिवाइस, गेटवे का कलेक्टर या MQTT क्लाइंट बिना त्रुटियों के भेजता है: उसके लॉग में एक्सपोर्ट विफलताएँ और HTTP 401 या 422 जवाब देखें, या रिटर्न कोड 4 के साथ अस्वीकार हुआ कनेक्शन।
2. उत्पाद → बुनियादी ढांचा → IoT → All Fleets खोलें। फ़्लीट अपनी पहली रीडिंग के लगभग एक मिनट में iot/<fleet> के रूप में दिखता है।
3. फ़्लीट का Devices पेज खोलें। आपने जिस भी डिवाइस से भेजा, वह अपनी नवीनतम बैटरी, सिग्नल, तापमान, CPU, मेमोरी और अप या डाउन स्थिति के साथ सूचीबद्ध होना चाहिए।
4. किसी भी iot_* सीरीज़ का चार्ट बनाने के लिए फ़्लीट का मेट्रिक्स पेज खोलें।

सेल्फ़-होस्टेड Status200#

एंडपॉइंट को अपने इंस्टेंस की ओर इंगित करें:

export OTEL_EXPORTER_OTLP_ENDPOINT=https://your-status200-host.example.com/otlp

या, किसी कलेक्टर में:

exporters:
  otlphttp:
    endpoint: https://your-status200-host.example.com/otlp
    headers:
      "x-status200-token": "YOUR_TELEMETRY_INGESTION_TOKEN"

MQTT के लिए wss://your-status200-host.example.com/mqtt से कनेक्ट करें, या WebSocket उपयोग न कर पाने वाले डिवाइसों के लिए ऐप सेवा का रॉ MQTT TCP पोर्ट (MQTT_INGEST_PORT, डिफ़ॉल्ट 1883) उजागर करें। दोनों MQTT लिसनर बंद करने के लिए ऐप सेवा पर MQTT_INGEST_ENABLED=false सेट करें। अगर इंस्टेंस सिर्फ़ HTTP पर है, तो http:// (और MQTT के लिए ws://) और उसका पोर्ट उपयोग करें।

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

अगले कदम#