अपना पहला realtime इवेंट भेजें
Realtime, WebSockets पर इवेंट डिलीवर करता है। आपका सर्वर एक चैनल पर पब्लिश करता है, और उस चैनल पर सब्सक्राइब किया हुआ हर कनेक्टेड क्लाइंट वह इवेंट प्राप्त करता है। यह गाइड एक रास्ता दिखाती है: ऐप बनाएँ, क्लाइंट सब्सक्राइब करें, और अपने सर्वर से पब्लिश करें।
मुफ़्त प्लान में एक वर्कस्पेस के सभी ऐप्स में 100 समवर्ती कनेक्शन और प्रति दिन 200,000 संदेश शामिल हैं। पेड प्लान $25 प्रति माह से शुरू होते हैं; देखें Realtime मूल्य निर्धारण।
1. ऐप बनाएँ
ऐप एक अलग वातावरण है जिसके अपने क्रेडेंशियल और चैनल होते हैं। आप इसे बनाते समय इसका रीजन चुनते हैं, और बाद में वह रीजन बदला नहीं जा सकता।
- डैशबोर्ड में Realtime > Apps खोलें।
- Create app चुनें।
- Name में एक नाम दर्ज करें।
- एक Region चुनें: United States (us1) या Europe (eu1)।
- Create app चुनें।
Save your app credentials फिर तीन मान दिखाता है, केवल एक बार:
- App ID एक rap_… id है जो Bird API कॉल में ऐप की पहचान करती है।
- Key पब्लिक है। क्लाइंट इससे कनेक्ट करते हैं, और इसे क्लाइंट कोड में शामिल करना सुरक्षित है।
- Secret, key के साथ जुड़कर सर्वर-साइड कॉल को प्रमाणित करती है और चैनल ऑथराइज़ेशन पर हस्ताक्षर करती है। इसे पासवर्ड की तरह सुरक्षित रखें।
I've saved my secret चुनने से पहले तीनों कॉपी कर लें, क्योंकि secret दोबारा नहीं दिखाई जाती। फिर Developers > API keys पेज पर realtime स्कोप के साथ एक Bird API key बनाएँ, और अगले चरणों के लिए ज़रूरी चीज़ें एक्सपोर्ट करें:
कोड उदाहरण
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.0")
]// build.gradle.kts
dependencies {
implementation("com.messagebird:bird-realtime:0.1.3")
}क्लाइंट ऐप को उसकी key से पहचानता है और region से edge चुनता है, इसलिए आपको host कॉन्फ़िगर करने की ज़रूरत नहीं है:
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.bird.realtime.BirdRealtime
import com.bird.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 एक पब्लिक चैनल है, इसलिए ऐप key वाला कोई भी क्लाइंट सब्सक्राइब कर सकता है। private-… या presence-… नाम वाले चैनलों के लिए आपके सर्वर को प्रत्येक सब्सक्रिप्शन को authorize करना होगा। देखें चैनल authorization।
चैनल कहीं बनाए या कॉन्फ़िगर नहीं किए जाते। एक चैनल तब तक मौजूद रहता है जब तक कम से कम एक कनेक्शन उससे सब्सक्राइब है, और अंतिम कनेक्शन छोड़ने पर वह गायब हो जाता है।
3. अपने सर्वर से publish करें
Publishing एक सर्वर-साइड कॉल है। यह आपकी Bird API key से authenticate करती है और ऐप की key तथा secret लेकर जाती है ताकि edge इसे स्वीकार करे। क्लाइंट से कभी publish न करें, क्योंकि इसके लिए secret शिप करना पड़ेगा।
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" }
}'Edge द्वारा इवेंट डिलीवर होने के बाद, सब्सक्राइब किया हुआ क्लाइंट order changed { id: 42, status: 'shipped' } प्रिंट करता है। अगर कुछ नहीं आता, तो जाँचें कि क्लाइंट key और सर्वर credentials एक ही ऐप से हैं और चैनल नाम बिल्कुल मेल खाते हैं। एक publish में अधिकतम 100 चैनल नाम दिए जा सकते हैं। एक ही अनुरोध में 10 अलग-अलग इवेंट भेजने के लिए, बैच publish करें।
Publishing तब resolve होती है जब edge इवेंट स्वीकार कर लेता है। कनेक्टेड क्लाइंट को डिलीवरी असिंक्रोनस है, इसलिए 200 का अर्थ है स्वीकार किया गया, प्राप्त हुआ नहीं।
4. डैशबोर्ड में देखें
Realtime > Metrics प्रति ऐप या पूरे वर्कस्पेस में पीक और औसत समवर्ती कनेक्शन तथा संदेश दिखाता है। चार्ट दैनिक उपयोग बिंदु रिपोर्ट करते हैं, इसलिए इवेंट आने पर उसकी पुष्टि के लिए स्टेप 3 के क्लाइंट आउटपुट का उपयोग करें।
अगले चरण
- चैनल authorization में private और presence चैनल, और आपके backend द्वारा लौटाए जाने वाले signature को शामिल किया गया है।
- इवेंट publish करें में पूरा अनुरोध और प्रतिक्रिया है, जिसमें publish के समय प्रति-चैनल स्थिति भी शामिल है।
- Webhooks & events बताता है कि अपने endpoint पर realtime.* इवेंट कैसे प्राप्त करें, जैसे कि कोई चैनल occupied होना या कोई सदस्य जुड़ना।
संबंधित संसाधन
इस विषय के लिए दस्तावेज़, गाइड और उदाहरणों के साथ आगे बढ़ें।