अपना पहला रियलटाइम इवेंट भेजें

Realtime इवेंट को WebSockets के ज़रिए पहुँचाता है। आपका सर्वर किसी चैनल पर प्रकाशित करता है, और उस चैनल पर सब्सक्राइब किया हुआ हर कनेक्टेड क्लाइंट इवेंट प्राप्त करता है। यह गाइड एक ही रास्ता अपनाती है: ऐप बनाना, क्लाइंट को सब्सक्राइब करना, और अपने सर्वर से प्रकाशित करना।

फ़्री प्लान में एक वर्कस्पेस के सभी ऐप्स को मिलाकर 100 समवर्ती कनेक्शन और प्रति दिन 200,000 संदेश शामिल हैं। पेड प्लान ये दोनों सीमाएँ बढ़ाते हैं; देखें Realtime मूल्य निर्धारण।

1. ऐप बनाएँ

ऐप एक अलग-थलग परिवेश है, जिसके अपने क्रेडेंशियल और चैनल होते हैं। ऐप बनाते समय आप उसका क्षेत्र चुनते हैं, और बाद में उस क्षेत्र को बदला नहीं जा सकता।

1. डैशबोर्ड में Realtime > Apps खोलें।
2. Create app चुनें।
3. Name में एक नाम दर्ज करें।
4. एक Region चुनें: United States (us1) या Europe (eu1)।
5. Create app चुनें।

इसके बाद Save your app credentials तीन मान दिखाता है, केवल एक बार:

• App ID एक rap_… id है, जो Bird API कॉल में ऐप की पहचान करती है।
• Key सार्वजनिक है। क्लाइंट इसी से कनेक्ट होते हैं, और इसे क्लाइंट कोड में शामिल करना सुरक्षित है।
• Secret कुंजी के साथ मिलकर सर्वर-साइड कॉल को प्रमाणित करता है और चैनल प्राधिकरण पर हस्ताक्षर करता है। इसे पासवर्ड की तरह सुरक्षित रखें।

I've saved my secret चुनने से पहले तीनों मान कॉपी कर लें, क्योंकि सीक्रेट दोबारा नहीं दिखाया जाता। फिर Platform tools > API keys पेज पर realtime स्कोप वाली एक Bird API कुंजी बनाएँ, और अगले चरणों के लिए ज़रूरी मान एक्सपोर्ट करें:

export BIRD_API_KEY="bk_us1_..."
export BIRD_REALTIME_KEY="your-app-key"
export BIRD_REALTIME_SECRET="your-app-secret"

2. क्लाइंट से सब्सक्राइब करें

तीन क्लाइंट में से चुनें, हर प्लेटफ़ॉर्म के लिए एक, और तीनों एक ही प्रोटोकॉल इस्तेमाल करते हैं: ब्राउज़र के लिए @messagebird/realtime, Apple प्लेटफ़ॉर्म के लिए BirdRealtime, और Android तथा सर्वर JVM के लिए com.messagebird:bird-realtime।

npm install @messagebird/realtime

// Package.swift, or Xcode's File › Add Package Dependencies
dependencies: [
    .package(url: "https://github.com/messagebird/bird-sdk-swift.git", from: "0.1.1")
]

// build.gradle.kts
dependencies {
    implementation("com.messagebird:bird-realtime:0.1.4")
}

क्लाइंट ऐप को उसकी कुंजी से पहचानता है और क्षेत्र के आधार पर एज चुनता है, इसलिए आपको होस्ट कॉन्फ़िगर नहीं करना पड़ता:

import { BirdRealtime } from "@messagebird/realtime";

const bird = new BirdRealtime({
  appKey: "your-app-key",
  region: "us1",
});

const orders = bird.subscribe("orders");
orders.bind("order-updated", (data) => {
  console.log("order changed", data);
});

import BirdRealtime

let bird = BirdRealtime(options: .init(
    appKey: "your-app-key",
    region: "us1"
))

let orders = bird.subscribe("orders")
orders.bind("order-updated") { data in
    print("order changed", data ?? "")
}

import com.messagebird.realtime.BirdRealtime
import com.messagebird.realtime.BirdRealtimeOptions

val bird = BirdRealtime(
    BirdRealtimeOptions(
        appKey = "your-app-key",
        region = "us1",
    )
)

val orders = bird.subscribe("orders")
orders.bind("order-updated") { data ->
    println("order changed: $data")
}

तीनों क्लाइंट बनते ही सॉकेट खोल देते हैं, इसलिए आप अलग कनेक्शन कॉल के बिना सब्सक्राइब कर सकते हैं। सॉकेट तैयार होने से पहले सब्सक्राइब करना भी ठीक है: चैनल स्थानीय रूप से दर्ज होते हैं और कनेक्शन बनते ही भेज दिए जाते हैं, और हर रीकनेक्ट के बाद फिर से भेजे जाते हैं।

orders एक सार्वजनिक चैनल है, इसलिए ऐप कुंजी वाला कोई भी क्लाइंट इसे सब्सक्राइब कर सकता है। private-… या presence-… नाम वाले चैनलों में हर सब्सक्रिप्शन को आपके सर्वर से प्राधिकृत करना ज़रूरी है। चैनलों को प्राधिकृत करना देखें।

चैनल कहीं बनाए या कॉन्फ़िगर नहीं किए जाते। चैनल तब तक मौजूद रहता है जब तक कम से कम एक कनेक्शन उसे सब्सक्राइब किए रहता है, और आख़िरी कनेक्शन के हटते ही वह समाप्त हो जाता है।

3. अपने सर्वर से प्रकाशित करें

प्रकाशित करना सर्वर-साइड कॉल है। यह आपकी Bird API कुंजी से प्रमाणित होता है और ऐप की कुंजी और सीक्रेट साथ भेजता है, ताकि एज इसे स्वीकार करे। क्लाइंट से कभी प्रकाशित न करें, क्योंकि तब आपको सीक्रेट क्लाइंट कोड में भेजना पड़ेगा।

import { BirdClient } from "@messagebird/sdk";

const bird = new BirdClient({
  apiKey: process.env.BIRD_API_KEY,
  realtime: {
    key: process.env.BIRD_REALTIME_KEY,
    secret: process.env.BIRD_REALTIME_SECRET,
  },
});

await bird.realtime.publish("rap_01krdgeqcxet5s7t44vh8rt9mg", {
  event: "order-updated",
  channels: ["orders"],
  data: { id: 42, status: "shipped" },
});

import os

from bird import Bird

client = Bird(
    api_key=os.environ["BIRD_API_KEY"],
    realtime_key=os.environ["BIRD_REALTIME_KEY"],
    realtime_secret=os.environ["BIRD_REALTIME_SECRET"],
)

client.realtime.publish(
    "rap_01krdgeqcxet5s7t44vh8rt9mg",
    event="order-updated",
    channels=["orders"],
    data={"id": 42, "status": "shipped"},
)

client, err := bird.NewClient(
	option.WithAPIKey(os.Getenv("BIRD_API_KEY")),
	option.WithRealtimeCredentials(os.Getenv("BIRD_REALTIME_KEY"), os.Getenv("BIRD_REALTIME_SECRET")),
)
if err != nil {
	log.Fatal(err)
}

_, err = client.Realtime.Publish(context.Background(), "rap_01krdgeqcxet5s7t44vh8rt9mg", bird.RealtimePublishParams{
	Event:    "order-updated",
	Channels: []string{"orders"},
	Data:     map[string]any{"id": 42, "status": "shipped"},
})
if err != nil {
	log.Fatal(err)
}

use MessageBird\Bird;
use MessageBird\RealtimeOptions;
use MessageBird\Wire\Model\RealtimePublish;

$bird = new Bird(
    getenv('BIRD_API_KEY') ?: '',
    realtime: new RealtimeOptions(
        key: getenv('BIRD_REALTIME_KEY') ?: '',
        secret: getenv('BIRD_REALTIME_SECRET') ?: '',
    ),
);

$bird->realtime->publish('rap_01krdgeqcxet5s7t44vh8rt9mg', (new RealtimePublish())
    ->setEvent('order-updated')
    ->setChannels(['orders'])
    ->setData(['id' => 42, 'status' => 'shipped']));

curl -X POST https://us1.platform.bird.com/v1/realtime/apps/rap_01krdgeqcxet5s7t44vh8rt9mg/events \
  -H "Authorization: Bearer $BIRD_API_KEY" \
  -H "X-Realtime-Key: $BIRD_REALTIME_KEY" \
  -H "X-Realtime-Secret: $BIRD_REALTIME_SECRET" \
  -H "Content-Type: application/json" \
  -d '{
    "event": "order-updated",
    "channels": ["orders"],
    "data": { "id": 42, "status": "shipped" }
  }'

एज द्वारा इवेंट डिलीवर होने के बाद, सब्सक्राइब किया गया क्लाइंट order changed { id: 42, status: 'shipped' } प्रिंट करता है। अगर कुछ नहीं आता, तो जाँचें कि क्लाइंट कुंजी और सर्वर क्रेडेंशियल एक ही ऐप के हैं और चैनल के नाम बिल्कुल मेल खाते हैं। एक बार प्रकाशित करने में अधिकतम 100 चैनल दिए जा सकते हैं। एक ही अनुरोध में अधिकतम 10 अलग-अलग इवेंट भेजने के लिए, बैच प्रकाशित करें।

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

4. इसे डैशबोर्ड में देखें

Realtime > Metrics प्रति ऐप या पूरे वर्कस्पेस में अधिकतम और औसत समवर्ती कनेक्शन और संदेश दिखाता है। चार्ट दैनिक उपयोग के आँकड़े दिखाते हैं, इसलिए इवेंट आते ही उसकी पुष्टि के लिए चरण 3 के क्लाइंट आउटपुट का उपयोग करें।

अगले चरण

• चैनलों को प्राधिकृत करना में प्राइवेट और प्रेज़ेंस चैनल, और आपके बैकएंड द्वारा लौटाया जाने वाला सिग्नेचर शामिल है।
• इवेंट प्रकाशित करें में पूरा अनुरोध और प्रतिक्रिया है, जिसमें प्रकाशित करते समय हर चैनल की स्थिति भी शामिल है।
• वेबहुक और इवेंट बताता है कि अपने एंडपॉइंट पर realtime.* इवेंट कैसे प्राप्त करें, जैसे किसी चैनल का सक्रिय होना या किसी सदस्य का जुड़ना।