SSE — यह क्या है, Server-Sent Events और एकतरफा स्ट्रीमिंग

SSE क्या है?

SSE (Server-Sent Events) एक प्रौद्योगिकी है जो एक वेब सर्वर को कनेक्शन स्थापित होने के बाद किसी भी समय क्लायंट को डेटा भेजने की अनुमति देती है। इसे WHATWG द्वारा HTML Living Standard के भाग के रूप में मानकीकृत किया गया है और यह MIME प्रकार text/event-stream का उपयोग करती है। SSE संदेश पहचानकर्ता, इवेंट प्रकार और पुनः कनेक्शन विलंब निर्दिष्ट करने की क्षमता के साथ टेक्स्ट डेटा के संचरण का समर्थन करती है।

द्वितरफीय प्रोटोकॉल और अपग्रेड अनुरोध की आवश्यकता वाले WebSocket के विपरीत, SSE सामान्य HTTP पर काम करता है। सर्वर Content-Type: text/event-stream हीडर सेट करता है, आंशिक रूप से डेटा भेजता है और कनेक्शन खुला रखता है। क्लायंट ब्राउजर के EventSource API के माध्यम से डेटा प्राप्त करता है, जो स्वचालित रूप से स्ट्रीम का विग्रहण करता है और इवेंट उत्पन्न करता है।

CanIUse (2025) के अनुसार, EventSource API वैश्विक स्तर पर 97.5% ब्राउजर्स में समर्थित है। यह Internet Explorer और कुछ मोबाइल ब्राउजर्स (संस्करण 7.0 से पहले Samsung Internet) में समर्थित नहीं है। इन मामलों के लिए, पॉलीफिल हैं जो XHR स्ट्रीमिंग के माध्यम से EventSource का अनुकरण करते हैं। SSE HTTP/1.1 पाइपलाइनिंग के साथ काम नहीं करता, लेकिन HTTP/2 सर्वर पुश के साथ पूर्ण रूप से संगत है।

इतिहास और मानकीकरण

SSE को 2009 में Server-Sent DOM Events नाम से HTML5 विनिर्देश के भाग के रूप में प्रस्तावित किया गया था। पहला कार्यान्वयन Opera 9.0 में, फिर Firefox 6.0 (2011), Chrome 9.0 (2011) और Safari 5.0 (2010) में दिखा। 2015 में, विनिर्देश को HTML Living Standard के एक अलग अनुभाग में ले जाया गया। एक दशक के इतिहास के बावजूद, SSE अपनी एकतरफा प्रकृति के कारण WebSocket से कम लोकप्रिय बना हुआ है।

SSE कैसे काम करता है

SSE का कार्य तंत्र इस प्रकार है: क्लायंट सर्वर एंडपॉइंट के URL के साथ EventSource का एक उदाहरण बनाता है। ब्राउजर Accept: text/event-stream हीडर के साथ GET अनुरोध भेजता है। सर्वर स्थिति 200 OK और Content-Type: text/event-stream हीडर के साथ जवाब देता है, फिर event-stream प्रारूप में डेटा भेजना शुरू करता है। कनेक्शन तब तक खुला रहता है जब तक सर्वर एक समाप्ति संकेत नहीं भेजता या क्लायंट close() कॉल नहीं करता।

सर्वर पक्ष पर, डेटा आंशिक रूप से (chunked transfer encoding) भेजा जाता है। प्रत्येक डेटा आंश एक टेक्स्ट संदेश है जिसमें क्षेत्र पंक्तियाँ (event, data, id, retry) होती हैं। सर्वर किसी भी समय संदेश भेज सकता है, जो SSE को अधिसूचनाओं और स्थिति अद्यतनीकरण के लिए आदर्श बनाता है। कनेक्शन को WebSocket की तरह निरंतर हार्टबीट पैकेट आदान-प्रदान की आवश्यकता नहीं है, हालांकि retry क्षेत्र पुनः कनेक्शन आवृत्ति को नियंत्रित करता है।

प्रदर्शन परीक्षण (2024) के अनुसार, SSE प्रति कनेक्शन 256 बाइट के संदेश आकार के साथ 10,000 संदेश प्रति सेकंड तक का थ्रूपुट प्रदान करता है। सर्वर पक्ष पर, प्रत्येक SSE कनेक्शन लगभग 5–10 KB मेमरी की खपत करता है, जो 1 GB RAM के साथ एक सर्वर को 50,000+ एकसाथ कनेक्शन समर्थन करने की अनुमति देता है। बाइनरी प्रोटोकॉल की अनुपस्थिति के कारण यह WebSocket की तुलना में काफी कम है।

Event-stream प्रारूप

text/event-stream प्रारूप एक सरल टेक्स्ट प्रोटोकॉल है जहाँ प्रत्येक संदेश में नए पंक्ति वर्णों द्वारा अलग किए गए नामित क्षेत्र होते हैं। प्रत्येक क्षेत्र का प्रारूप “क्षेत्र नाम: मान” होता है। संदेश दो नए पंक्ति वर्णों (\n\n) द्वारा अलग किए जाते हैं।

समर्थित क्षेत्र: event (इवेंट प्रकार, डिफ़ॉल्ट message), data (डेटा स्ट्रिंग, बहुपंक्तीय हो सकती है), id (अंतिम इवेंट पहचानकर्ता, Last-Event-ID में संग्रहीत), retry (मिलीसेकंड में पुनः कनेक्शन समय). टिप्पणियाँ कॉलन (:) से शुरू होती हैं और पार्सर द्वारा अनदेखी की जाती हैं, लेकिन हार्टबीट के लिए उपयोग की जा सकती हैं।

Event-stream उदाहरण

: heartbeat comment
event: update
data: {"user": "Alice", "action": "typing"}
id: 1001

event: notification
data: {"type": "info", "text": "New version available"}
data: {"type": "action", "url": "/upgrade"}
retry: 3000

event: close
data: Session ended

क्लायंट पर EventSource API

EventSource API SSE प्राप्त करने के लिए एक निर्मित ब्राउजर इंटरफेस है। कनेक्शन बनाने के लिए, एंडपॉइंट URL के साथ कंस्ट्रक्टर को कॉल करना पर्याप्त है। EventSource स्वचालित रूप से कनेक्शन स्थापित करता है, पुनः कनेक्शन को संभालता है और आने वाले संदेशों को JavaScript इवेंट्स में पार्स करता है।

EventSource इवेंट: open (कनेक्शन स्थापित), message (बिना इवेंट निर्देश के संदेश प्राप्त), error (कनेक्शन त्रुटि). कस्टम इवेंट (event: custom) के लिए, आप इवेंट नाम के साथ addEventListener का उपयोग कर सकते हैं। EventSource पुनः कनेक्शन पर स्वचालित रूप से Last-Event-ID हीडर भेजता है, जो सर्वर को स्ट्रीम को वहीं से फिर से शुरू करने की अनुमति देता है जहाँ से यह बाधित हुआ था।

MDN दस्तावेज़ (2025) के अनुसार, EventSource CORS और क्रेडेंशियल ट्रांसमिशन (withCredentials) का समर्थन करता है। EventSource कस्टम हीडर या अनुरोध बॉडी भेजने के लिए उपयुक्त नहीं है — इसके लिए fetch + ReadableStream के माध्यम से मैनुअल कार्यान्वयन की आवश्यकता है। EventSource बाइनरी डेटा का समर्थन नहीं करता — केवल टेक्स्ट और JSON।

क्लायंट-साइड JavaScript कोड

const eventSource = new EventSource('/api/events/stream');

eventSource.addEventListener('open', () => {
    console.log('SSE कनेक्शन खुला');
});

eventSource.addEventListener('message', (event) => {
    const data = JSON.parse(event.data);
    console.log('प्राप्त:', data);
    renderUpdate(data);
});

eventSource.addEventListener('notification', (event) => {
    const notification = JSON.parse(event.data);
    showNotification(notification.text);
});

eventSource.addEventListener('error', (error) => {
    console.error('SSE त्रुटि:', error);
    // ब्राउजर स्वचालित रूप से पुनः जुड़ता है
});

// कनेक्शन बंद करें
eventSource.close();

SSE बनाम WebSocket: तुलना

SSE और WebSocket रियल-टाइम संचार के लिए अलग-अलग प्रौद्योगिकियाँ हैं, प्रत्येक की अपनी ताकत है। WebSocket द्वितरफीय डेटा आदान-प्रदान (चैट, गेम्स, सहयोगिता संपादन) के लिए उपयुक्त है, जबकि SSE सर्वर से क्लायंट को एकतरफी प्रवाह (अधिसूचनाएँ, समाचार फीड, टाइकर्स) के लिए है।

मुख्य अंतर यह है कि WebSocket को HTTP/1.1 से WebSocket प्रोटोकॉल (ws://) में अपग्रेड अनुरोध की आवश्यकता होती है, जो कॉर्पोरेट प्रॉक्सी द्वारा अवरुद्ध हो सकता है। SSE सामान्य HTTP पर काम करता है, किसी भी प्रॉक्सी से गुजरता है और सर्वर को विशेष कॉन्फ़िगरेशन की आवश्यकता नहीं है। SSE को लागू करना भी आसान है — सर्वर को अतिरिक्त लाइब्रेरी की आवश्यकता नहीं, बस HTTP प्रतिक्रिया को सही ढंग से बनाना होगा।

तुलनात्मक परीक्षण (2024) के अनुसार, एक सर्वर प्रक्रिया पर SSE सरल प्रोटोकॉल के कारण WebSocket की तुलना में 30–50% अधिक कनेक्शन का समर्थन करता है। हालांकि, SSE में अधिक विलंब है (50–200 मिलीसेकंड बनाम 10–50 मिलीसेकंड WebSocket) क्योंकि SSE पूर्ण द्वितरफीय बाइनरी फ्रेम के बजाय चंक्ड HTTP का उपयोग करता है।

सर्वर पर SSE कैसे लागू करें

सर्वर पर SSE का कार्यान्वयन लाइब्रेरियों की आवश्यकता नहीं है — बस सही HTTP हीडर सेट करें और text/event-stream प्रारूप में डेटा भेजें। आइए निर्मित http मॉड्यूल का उपयोग करके Node.js में एक उदाहरण देखें। सर्वर Content-Type और Cache-Control हीडर सेट करता है, फिर हर N सेकंड में संदेश भेजता है।

MDN Web Docs (2025) के अनुसार, SSE के लिए आवश्यक हीडर हैं: Content-Type: text/event-stream, Cache-Control: no-cache और Connection: keep-alive। Cache-Control के बिना, ब्राउजर SSE स्ट्रीम को कैश कर सकता है, जो डेलीवरी को रोक देगा। Connection: keep-alive ब्राउजर को कनेक्शन खुला रखने के लिए स्पष्ट रूप से बताता है।

Node.js में सर्वर कोड

const http = require('http');

http.createServer((req, res) => {
    res.writeHead(200, {
        'Content-Type': 'text/event-stream',
        'Cache-Control': 'no-cache',
        'Connection': 'keep-alive'
    });

    let eventId = 0;
    const interval = setInterval(() => {
        eventId++;
        res.write(`id: ${eventId}\n`);
        res.write(`event: update\n`);
        res.write(`data: {"time": "${new Date().toISOString()}", "id":${eventId}}\n\n`);
    }, 2000);

    req.on('close', () => {
        clearInterval(interval);
    });
}).listen(3000);

Python (Flask) में SSE

from flask import Response, Flask
import time
import json

app = Flask(__name__)

@app.route('/stream')
def stream():
    def generate():
        event_id = 0
        while True:
            event_id += 1
            data = json.dumps(
                {'ticker': 'AAPL', 'price': 150.25})
            yield f'id: {event_id}\nevent: price\ndata: {data}\n\n'
            time.sleep(1)
    return Response(generate(),
        mimetype='text/event-stream')

मोबाइल एप्लिकेशन्स में SSE

मोबाइल एप्लिकेशन्स में SSE का उपयोग iOS और Android के लिए निर्मित EventSource कार्यान्वयन की कमी के कारण सीमित है। मोबाइल प्लेटफॉर्म्स पर, SSE तीसरे पक्ष की लाइब्रेरियों के माध्यम से लागू किया जाता है: iOS पर — URLSession के साथ NSURLProtocol के माध्यम से, Android पर — OkHttp के साथ SSE समर्थन (okhttp-sse) के माध्यम से। React Native और Flutter के लिए, ऐसे पैकेज उपलब्ध हैं जो EventSource का अनुकरण करते हैं।

iOS पर, SSE का निर्मित कार्यान्वयन URLSessionDataDelegate के माध्यम से संभव है। urlSession(_:dataTask:didReceive:) मेथड में डेटा प्राप्त करने पर, एप्लिकेशन एक बफर जमा करता है और event-stream प्रारूप को मैनुअली पार्स करता है। iOS डेवेलपमेंट ब्लॉग (2024) के अनुसार, हार्टबीट पैकेटों की अनुपस्थिति के कारण iOS पर SSE के साथ बैटरी खपत लगातार WebSocket कनेक्शन की तुलना में 40% कम है।

Android पर, OkHttp SSE स्ट्रीम्स की सदस्यता लेने के लिए EventSource.Factory क्लास प्रदान करता है। Android एप्लिकेशन्स FCM अनुपलब्ध होने पर अधिसूचनाओं के लिए, या पृष्ठभूमि में डेटा सिंक के लिए SSE का उपयोग कर सकते हैं। Android पर SSE लंबे समय तक चलने वाले बैकग्रॉंड कार्यों के लिए WorkManager के साथ अच्छी तरह से काम करता है। OkHttp दस्तावेज़ (2025) के अनुसार, okhttp-sse कस्टम लिसनर के साथ स्वचालित पुनः कनेक्शन का समर्थन करता है।