Das vertraute HTTP-Anforderungs-/Antwortmodell wurde so konzipiert, dass es einfach zu bedienen und skalierbar ist. Heutzutage stellen Endbenutzer jedoch viel höhere Anforderungen an das Web, als ursprünglich vorgesehen war. Das HTTP-Protokoll erfordert, dass Benutzer die Anforderung initiieren, um eine Antwort zu erhalten. Entwickler benötigen jedoch eine Möglichkeit, Daten ohne Anforderung vom Server an Clients zu senden. Mit anderen Worten, sie müssen Daten an Kunden „pushen“, z. B. den aktuellsten Gebotspreis eines Produkts auf einer Auktionswebsite oder sich schnell ändernde Aktienkurse in einer Finanzanwendung.
In dieser Schnellstartanleitung wird veranschaulicht, wie Sie
Nachrichten von einem Anwendungsserver abonnieren
Daten von einem Anwendungsserver auf alle verbundenen Clients pushen
Voraussetzungen
Eine Web PubSub-Ressource. Wenn Sie noch keine Ressource erstellt haben, können Sie dieser Anleitung folgen: Erstellen einer Web PubSub-Ressource
Ein Code-Editor wie Visual Studio Code
Installieren der Abhängigkeiten für die Sprache, die Sie verwenden möchten
Um Nachrichten zu abonnieren, die von Ihrem Anwendungsserver gepusht werden, muss ein Client, sei es ein Browser, eine mobile App oder ein IoT-Gerät, zuerst eine Verbindung mit Ihrer Web PubSub-Ressource herstellen und auf ein entsprechendes Nachrichtenereignis warten.
Erstellen Sie zuerst ein Projektverzeichnis namens subscriber und installieren Sie die erforderlichen Abhängigkeiten
mkdir subscriber
cd subscriber
npm init -y
# The client SDK is available as a module on NPM
npm install @azure/web-pubsub-client
Stellen Sie eine Verbindung mit Ihrer Web PubSub-Ressource her und registrieren Sie einen Listener für das Ereignis server-message
Ein Client verwendet eine Clientzugriffs-URL, um eine Verbindung herzustellen und sich mit dem Dienst zu authentifizieren.
Diese URL folgt dem Muster wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Ein Client kann die Clientzugriffs-URL mit verschiedenen Methoden abrufen. Für diese Schnellstartanleitung können Sie die im folgenden Diagramm gezeigte Datei aus dem Azure-Portal kopieren und einfügen. Es empfiehlt sich, die Clientzugriffs-URL in Ihrem Code nicht hart zu codieren. In der Produktionswelt richten wir normalerweise einen App-Server ein, um diese URL bei Bedarf zurückzugeben. Unter Generieren der URL für den Clientzugriff wird die Vorgehensweise ausführlich beschrieben.
Wie im obigen Diagramm gezeigt, verbindet sich der Client mit dem Hub namens myHub1.
Erstellen Sie im Projektordner subscriber eine Datei mit dem Namen subscribe.js und dem folgenden Code
const { WebPubSubClient } = require("@azure/web-pubsub-client");
// Instantiates the client object
// <client-access-url> is copied from Azure portal mentioned above
const client = new WebPubSubClient("<client-access-url>")
// Registers a handler for the "server-message" event
client.on("server-message", (e) => {
console.log(`Received message ${e.message.data}`)
});
// Before a client can receive a message,
// you must invoke start() on the client object.
client.start();
Ausführen des Programms
node subscribe.js
Nun stellt dieser Client eine Verbindung mit Ihrer Web PubSub-Ressource her und kann Nachrichten empfangen, die von Ihrem Anwendungsserver gepusht wurden.
Erstellen Sie zuerst ein Projektverzeichnis namens subscriber und installieren Sie die erforderlichen Abhängigkeiten
mkdir subscriber
cd subscriber
# Create a .net console app
dotnet new console
# Add the client SDK
dotnet add package Azure.Messaging.WebPubSub.Client --prerelease
Stellen Sie eine Verbindung mit Ihrer Web PubSub-Ressource her und registrieren Sie einen Listener für das Ereignis ServerMessageReceived
Ein Client verwendet eine Clientzugriffs-URL, um eine Verbindung herzustellen und sich mit dem Dienst zu authentifizieren.
Diese URL folgt dem Muster wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Ein Client kann die Clientzugriffs-URL mit verschiedenen Methoden abrufen. Für diese Schnellstartanleitung können Sie die im folgenden Diagramm gezeigte Datei aus dem Azure-Portal kopieren und einfügen. Es empfiehlt sich, die Clientzugriffs-URL in Ihrem Code nicht hart zu codieren. In der Produktionswelt richten wir normalerweise einen App-Server ein, um diese URL bei Bedarf zurückzugeben. Unter Generieren der URL für den Clientzugriff wird die Vorgehensweise ausführlich beschrieben.
Wie im obigen Diagramm gezeigt, verbindet sich der Client mit dem Hub namens myHub1.
Ersetzen Sie den Code in Program.cs durch den folgenden Code
using Azure.Messaging.WebPubSub.Clients;
// Instantiates the client object
// <client-access-uri> is copied from Azure portal mentioned above
var client = new WebPubSubClient(new Uri("<client-access-uri>"));
client.ServerMessageReceived += eventArgs =>
{
Console.WriteLine($"Receive message: {eventArgs.Message.Data}");
return Task.CompletedTask;
};
client.Connected += eventArgs =>
{
Console.WriteLine("Connected");
return Task.CompletedTask;
};
await client.StartAsync();
// This keeps the subscriber active until the user closes the stream by pressing Ctrl+C
var streaming = Console.ReadLine();
while (streaming != null)
{
if (!string.IsNullOrEmpty(streaming))
{
await client.SendToGroupAsync("stream", BinaryData.FromString(streaming + Environment.NewLine), WebPubSubDataType.Text);
}
streaming = Console.ReadLine();
}
await client.StopAsync();
Führen Sie den folgenden Befehl aus.
dotnet run
Nun stellt dieser Client eine Verbindung mit Ihrer Web PubSub-Ressource her und kann Nachrichten empfangen, die von Ihrem Anwendungsserver gepusht wurden.
Erstellen Sie zuerst ein Projektverzeichnis namens subscriber und installieren Sie die erforderlichen Abhängigkeiten:
Verwenden Sie die WebSocket-API, um eine Verbindung mit Ihrer Web PubSub-Ressource herzustellen. Erstellen Sie eine Datei subscribe.py mit dem folgenden Code
import asyncio
import sys
import websockets
from azure.messaging.webpubsubservice import WebPubSubServiceClient
async def connect(url):
async with websockets.connect(url) as ws:
print('connected')
while True:
print('Received message: ' + await ws.recv())
if __name__ == '__main__':
if len(sys.argv) != 3:
print('Usage: python subscribe.py <connection-string> <hub-name>')
exit(1)
connection_string = sys.argv[1]
hub_name = sys.argv[2]
service = WebPubSubServiceClient.from_connection_string(connection_string, hub=hub_name)
token = service.get_client_access_token()
try:
asyncio.get_event_loop().run_until_complete(connect(token['url']))
except KeyboardInterrupt:
pass
Der Code erstellt eine WebSocket-Verbindung mit einem Hub in Web PubSub. Ein Hub ist eine logische Einheit in Web PubSub, in der Sie Nachrichten für eine Gruppe von Clients veröffentlichen können. Unter Wichtige Konzepte finden Sie ausführliche Erläuterungen der in Web PubSub verwendeten Begriffe.
Der Web PubSub-Dienst verwendet die Authentifizierung über ein JSON Web Token (JWT). Der Beispielcode verwendet WebPubSubServiceClient.GetClientAccessUri() im Web PubSub SDK, um eine URL zum Dienst zu generieren, die die vollständige URL mit einem gültigen Zugriffstoken umfasst.
Nachdem die Verbindung hergestellt wurde, erhält Ihr Client Nachrichten über die WebSocket-Verbindung. Verwenden Sie await ws.recv(), um auf eingehende Nachrichten zu lauschen.
Führen Sie den folgenden Befehl aus.
python subscribe.py $connection_string "myHub1"
Erstellen eines Projektverzeichnisses mit dem Namen pubsub
mkdir pubsub
cd pubsub
Verwenden Sie Maven, um eine neue Konsolen-App namens webpubsub-quickstart-subscriber zu erstellen;
In Web PubSub können Sie eine Verbindung mit dem Dienst herstellen und Nachrichten über WebSocket-Verbindungen abonnieren. WebSocket ist ein Vollduplex-Kommunikationskanal, über den der Dienst Nachrichten in Echtzeit an Ihren Client pushen kann. Sie können jede beliebige API oder Bibliothek verwenden, die WebSocket unterstützt. Für dieses Beispiel verwenden wir das Paket Java-WebSocket.
Wechseln Sie zum Verzeichnis /src/main/java/com/webpubsub/quickstart.
Bearbeiten Sie die Datei App.java, und ersetzen Sie den Inhalt durch den folgenden Code:
package com.webpubsub.quickstart;
import com.azure.messaging.webpubsub.*;
import com.azure.messaging.webpubsub.models.*;
import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
/**
* Connect to Azure Web PubSub service using WebSocket protocol
*/
public class App
{
public static void main( String[] args ) throws IOException, URISyntaxException
{
if (args.length != 2) {
System.out.println("Expecting 2 arguments: <connection-string> <hub-name>");
return;
}
WebPubSubServiceClient service = new WebPubSubServiceClientBuilder()
.connectionString(args[0])
.hub(args[1])
.buildClient();
WebPubSubClientAccessToken token = service.getClientAccessToken(new GetClientAccessTokenOptions());
WebSocketClient webSocketClient = new WebSocketClient(new URI(token.getUrl())) {
@Override
public void onMessage(String message) {
System.out.println(String.format("Message received: %s", message));
}
@Override
public void onClose(int arg0, String arg1, boolean arg2) {
// TODO Auto-generated method stub
}
@Override
public void onError(Exception arg0) {
// TODO Auto-generated method stub
}
@Override
public void onOpen(ServerHandshake arg0) {
// TODO Auto-generated method stub
}
};
webSocketClient.connect();
System.in.read();
}
}
Dieser Code erstellt eine WebSocket-Verbindung mit einem Hub in Azure Web PubSub. Ein Hub ist eine logische Einheit in Azure Web PubSub, in der Sie Nachrichten für eine Gruppe von Clients veröffentlichen können. Unter Wichtige Konzepte finden Sie ausführliche Erläuterungen der in Azure Web PubSub verwendeten Begriffe.
Der Web PubSub-Dienst verwendet die Authentifizierung über ein JSON Web Token (JWT). Der Beispielcode verwendet WebPubSubServiceClient.GetClientAccessUri() im Web PubSub SDK, um eine URL zum Dienst zu generieren, die die vollständige URL mit einem gültigen Zugriffstoken umfasst.
Nachdem die Verbindung hergestellt wurde, erhält Ihr Client Nachrichten über die WebSocket-Verbindung. Verwenden Sie onMessage(String message), um auf eingehende Nachrichten zu lauschen.
Nachdem Sie Ihren Client mit Ihrer Web PubSub-Ressource verbunden haben, können Sie jederzeit Nachrichten über das von Web PubSub bereitgestellte Server-SDK von einem Anwendungsserver pushen.
Erstellen eines neuen Projektverzeichnisses mit dem Namen publisher und Installieren der erforderlichen Abhängigkeiten
mkdir publisher
cd publisher
npm init
# This command installs the server SDK from NPM,
# which is different from the client SDK you used in subscribe.js
npm install --save @azure/web-pubsub
Erstellen Sie eine Datei publish.js mit dem folgenden Code
const { WebPubSubServiceClient } = require('@azure/web-pubsub');
// This is the hub name we used on Azure portal when generating the Client Access URL.
// It ensures this server can push messages to clients in the hub named "myHub1".
const hub = "myHub1";
let server = new WebPubSubServiceClient(process.env.WebPubSubConnectionString, hub);
// By default, the content type is `application/json`.
// Specify contentType as `text/plain` for this demo.
server.sendToAll(process.argv[2], { contentType: "text/plain" });
Der Aufruf server.sendToAll() sendet eine Nachricht an alle verbundenen Clients in einem Hub.
Abrufen der Verbindungszeichenfolge
Wichtig
Eine Verbindungszeichenfolge enthält die Autorisierungsinformationen, die Ihre Anwendung für den Zugriff auf den Azure Web PubSub-Dienst benötigt. Der Zugriffsschlüssel in der Verbindungszeichenfolge ähnelt einem Stammkennwort für Ihren Dienst.
In dieser Schnellstartanleitung erhalten wir ihn wie unten gezeigt vom Azure-Portal.
Ausführen des Serverprogramms
Führen Sie die folgenden Befehle in einer neuen Befehlsshell aus.
# Set the environment variable for your connection string.
export WebPubSubConnectionString="<Put your connection string here>"
node publish.js "Hello World"
Beobachten der empfangenen Nachrichten auf der Clientseite
Versuchen Sie, dasselbe „Subscribe“-Programm in mehreren Befehlsshells auszuführen, um mehr als Clients zu stimulieren. Sobald das Programm „Veröffentlichen“ ausgeführt wird, sollten Nachrichten in Echtzeit an alle diese Clients übermittelt werden.
Erstellen Sie zuerst ein Projektverzeichnis namens publisher und installieren Sie die erforderlichen Abhängigkeiten:
mkdir publisher
cd publisher
dotnet new console
dotnet add package Azure.Messaging.WebPubSub
Ersetzen Sie die Datei Program.cs durch den folgenden Code
using System;
using System.Threading.Tasks;
using Azure.Messaging.WebPubSub;
namespace publisher
{
class Program
{
static async Task Main(string[] args)
{
if (args.Length != 3) {
Console.WriteLine("Usage: publisher <connectionString> <hub> <message>");
return;
}
var connectionString = args[0];
var hub = args[1];
var message = args[2];
// Either generate the token or fetch it from server or fetch a temp one from the portal
var serviceClient = new WebPubSubServiceClient(connectionString, hub);
await serviceClient.SendToAllAsync(message);
}
}
}
Der Aufruf SendToAllAsync() sendet eine Nachricht an alle verbundenen Clients in dem Hub.
Ausführen des Serverprogramms zum Pushen von Nachrichten an alle verbundenen Clients
$connection_string="<connection-string>"
dotnet run $connection_string "myHub1" "Hello World"
Beobachten der empfangenen Nachrichten auf der Clientseite
# On the command shell used for running the "subscribe" program, you should see the received the messaged logged there.
# Try running the same "subscribe" program in multiple command shells, which simluates more than clients.
# Try running the "publish" program several times and you see messages being delivered in real-time to all these clients.
Message received: Hello World
Erstellen Sie zuerst ein Projektverzeichnis namens publisher, und installieren Sie die erforderlichen Abhängigkeiten:
mkdir publisher
cd publisher
# Create venv
python -m venv env
# Active venv
source ./env/bin/activate
pip install azure-messaging-webpubsubservice
Verwenden Sie das Azure Web PubSub SDK, um eine Nachricht für den Dienst zu veröffentlichen. Erstellen Sie eine Datei vom Typ publish.py mit dem folgenden Code:
import sys
from azure.messaging.webpubsubservice import WebPubSubServiceClient
if __name__ == '__main__':
if len(sys.argv) != 4:
print('Usage: python publish.py <connection-string> <hub-name> <message>')
exit(1)
connection_string = sys.argv[1]
hub_name = sys.argv[2]
message = sys.argv[3]
service = WebPubSubServiceClient.from_connection_string(connection_string, hub=hub_name)
res = service.send_to_all(message, content_type='text/plain')
print(res)
Mit send_to_all() wird die Nachricht an alle verbundenen Clients in einem Hub gesendet.
Überprüfen Sie in der vorherigen Befehlsshell, ob der Abonnent die Nachricht empfangen hat:
Received message: Hello World
Wechseln Sie zum Verzeichnis pubsub. Verwenden Sie Maven, um eine Herausgeberkonsolen-App namens webpubsub-quickstart-publisher zu erstellen, und wechseln Sie zum Verzeichnis webpubsub-quickstart-publisher:
Verwenden Sie das Azure Web PubSub SDK, um eine Nachricht für den Dienst zu veröffentlichen. Wechseln Sie zum Verzeichnis /src/main/java/com/webpubsub/quickstart, öffnen Sie die Datei App.java in Ihrem Editor, und ersetzen Sie den Inhalt durch folgenden Code:
package com.webpubsub.quickstart;
import com.azure.messaging.webpubsub.*;
import com.azure.messaging.webpubsub.models.*;
/**
* Publish messages using Azure Web PubSub service SDK
*
*/
public class App
{
public static void main( String[] args )
{
if (args.length != 3) {
System.out.println("Expecting 3 arguments: <connection-string> <hub-name> <message>");
return;
}
WebPubSubServiceClient service = new WebPubSubServiceClientBuilder()
.connectionString(args[0])
.hub(args[1])
.buildClient();
service.sendToAll(args[2], WebPubSubContentType.TEXT_PLAIN);
}
}
Der Aufruf sendToAll() sendet eine Nachricht an alle verbundenen Clients in einem Hub.
Wechseln Sie zum Verzeichnis webpubsub-quickstart-publisher, und führen Sie das Projekt mit dem folgenden Befehl aus:
Sie sehen, dass der vorherige Abonnent die Nachricht erhalten hat:
Message received: Hello World
Zusammenfassung
In dieser Schnellstartanleitung wird veranschaulicht, wie einfach Nachrichten von einem Anwendungsserver an alle verbundenen Clients in einem Hub gepusht können. Darüber hinaus ermöglicht Web PubSub das Pushen von Nachrichten an
eine Teilmenge von Clients in einem Hub
eine bestimmte Gruppe in einem Hub
eine Teilmenge von Clients in einer Gruppe
Diese APIs ermöglichen eine Vielzahl von Anwendungsfällen, sodass Entwickler sich auf eine einzigartige Geschäftslogik konzentrieren können, während Sie sicher sein können, dass Web PubSub eine geringe Latenz (<100 ms),Hochverfügbarkeit und eine massive Skalierung (mehrere Millionen gleichzeitige Verbindungen) bietet.
Nächste Schritte
Im nächsten Schritt erfahren Sie, wie Sie mit dem Ereignissystem von Web PubSub arbeiten, das zum Erstellen vollständiger Webanwendungen erforderlich ist.
