Den välbekanta HTTP-modellen för begäran/svar har utformats för att vara enkel att arbeta med och skalbar. Men numera slutanvändare kräver mycket mer från webben än den ursprungligen utformades för. HTTP-protokollet kräver att användarna initierar begäran för att få ett svar. Men utvecklare behöver ett sätt att skicka data från servern till klienter utan att de ber om det. Med andra ord måste de "skicka" data till kunder, som att driva det senaste budpriset för en produkt på en auktionswebbplats eller snabba aktiekurser i en finansiell tillämpning.
Den här snabbstartsguiden visar hur du
prenumerera på meddelanden från en programserver
skicka data från en programserver till alla anslutna klienter
Viktigt!
Råa anslutningssträng visas endast i den här artikeln i demonstrationssyfte.
En anslutningssträng innehåller den auktoriseringsinformation som krävs för att ditt program ska få åtkomst till Azure Web PubSub-tjänsten. Åtkomstnyckeln i anslutningssträng liknar ett rotlösenord för din tjänst. Skydda alltid dina åtkomstnycklar i produktionsmiljöer. Använd Azure Key Vault för att hantera och rotera dina nycklar på ett säkert sätt och skydda anslutningen med WebPubSubServiceClient.
Undvik att distribuera åtkomstnycklar till andra användare, hårdkoda dem eller spara dem var som helst i oformaterad text som är tillgänglig för andra. Rotera dina nycklar om du tror att de har komprometterats.
Förutsättningar
En Web PubSub-resurs. Om du inte har skapat någon kan du följa anvisningarna: Skapa en Web PubSub-resurs
En kodredigerare, till exempel Visual Studio Code
Installera beroendena för det språk som du planerar att använda
Om du vill prenumerera på meddelanden som skickas från programservern måste en klient, oavsett om det är en webbläsare, en mobilapp eller en IoT-enhet, ansluta till din Web PubSub-resurs först och lyssna efter lämplig meddelandehändelse.
Skapa en projektkatalog med namnet subscriber och installera nödvändiga beroenden
mkdir subscriber
cd subscriber
npm init -y
# The client SDK is available as a module on NPM
npm install @azure/web-pubsub-client
Anslut till din Web PubSub-resurs och registrera en lyssnare för server-message händelsen
En klient använder en URL för klientåtkomst för att ansluta och autentisera med din resurs.
Den här URL:en följer ett mönster med wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. En klient kan ha några sätt att hämta URL:en för klientåtkomst. För den här snabbstarten kan du kopiera och klistra in en från Azure Portal som visas i följande diagram. Det är bästa praxis att inte hårdkoda URL:en för klientåtkomst i koden. I produktionsvärlden konfigurerar vi vanligtvis en appserver för att returnera den här URL:en på begäran. Generera URL för klientåtkomst beskriver metoden i detalj.
Som du ser i diagrammet ovan ansluter klienten hubben med namnet myHub1.
I projektmappen subscriber skapar du en fil med namnet subscribe.js med följande kod
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();
Köra programmet
node subscribe.js
Nu upprättar den här klienten en anslutning till din Web PubSub-resurs och är redo att ta emot meddelanden som skickas från programservern.
Skapa en projektkatalog med namnet subscriber och installera nödvändiga beroenden
mkdir subscriber
cd subscriber
# Create a .net console app
dotnet new console
# Add the client SDK
dotnet add package Azure.Messaging.WebPubSub.Client --prerelease
Anslut till din Web PubSub-resurs och registrera en lyssnare för ServerMessageReceived händelsen
En klient använder en URL för klientåtkomst för att ansluta och autentisera med din resurs.
Den här URL:en följer ett mönster med wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. En klient kan ha några sätt att hämta URL:en för klientåtkomst. För den här snabbstarten kan du kopiera och klistra in en från Azure Portal som visas i följande diagram. Det är bästa praxis att inte hårdkoda URL:en för klientåtkomst i koden. I produktionsvärlden konfigurerar vi vanligtvis en appserver för att returnera den här URL:en på begäran. Generera URL för klientåtkomst beskriver metoden i detalj.
Som du ser i diagrammet ovan ansluter klienten hubben med namnet myHub1.
Ersätt koden i Program.cs med följande kod
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();
Kör följande kommando
dotnet run
Nu upprättar den här klienten en anslutning till din Web PubSub-resurs och är redo att ta emot meddelanden som skickas från programservern.
Skapa en projektkatalog med namnet subscriber och installera nödvändiga beroenden:
Använd WebSocket-API:et för att ansluta till din Web PubSub-resurs. Skapa en subscribe.py fil med följande kod
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
Koden skapar en WebSocket-anslutning som är ansluten till en hubb i Web PubSub. En hubb är en logisk enhet i Web PubSub där du kan publicera meddelanden till en grupp klienter. Viktiga begrepp innehåller en detaljerad förklaring av de termer som används i Web PubSub.
Tjänsten Web PubSub använder JSON-autentisering (JWT). Exempelkoden använder WebPubSubServiceClient.GetClientAccessUri() i Web PubSub SDK för att generera en URL till tjänsten som innehåller den fullständiga URL:en med en giltig åtkomsttoken.
När anslutningen har upprättats får klienten meddelanden via WebSocket-anslutningen. Använd await ws.recv() för att lyssna efter inkommande meddelanden.
Kör följande kommando
python subscribe.py $connection_string "myHub1"
Skapa en projektkatalog med namnet pubsub
mkdir pubsub
cd pubsub
Använd Maven för att skapa en ny konsolapp med namnet webpubsub-quickstart-subscriber;
I Web PubSub kan du ansluta till tjänsten och prenumerera på meddelanden via WebSocket-anslutningar. WebSocket är en kommunikationskanal med full duplex som gör att tjänsten kan skicka meddelanden till klienten i realtid. Du kan använda valfritt API eller bibliotek som stöder WebSocket. I det här exemplet använder vi paketet Java-WebSocket.
Gå till katalogen /src/main/java/com/webpubsub/quickstart .
Redigera ersätter innehållet i App.java-filen med följande kod:
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();
}
}
Den här koden skapar en WebSocket-anslutning som är ansluten till en hubb i Azure Web PubSub. En hubb är en logisk enhet i Azure Web PubSub där du kan publicera meddelanden till en grupp klienter. Viktiga begrepp innehåller en detaljerad förklaring av de termer som används i Azure Web PubSub.
Tjänsten Web PubSub använder JSON-autentisering (JWT). Exempelkoden använder WebPubSubServiceClient.GetClientAccessUri() i Web PubSub SDK för att generera en URL till tjänsten som innehåller den fullständiga URL:en med en giltig åtkomsttoken.
När anslutningen har upprättats tar klienten emot meddelanden via WebSocket-anslutningen. Använd onMessage(String message) för att lyssna efter inkommande meddelanden.
Nu när du har en klient ansluten till din Web PubSub-resurs kan du skicka meddelanden från en programserver när som helst med hjälp av server-SDK:et som tillhandahålls av Web PubSub.
Skapa en ny projektkatalog med namnet publisher och installera nödvändiga beroenden
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
Skapa en publish.js fil med följande kod
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" });
Samtalet server.sendToAll() skickar ett meddelande till alla anslutna klienter i en hubb.
Hämta anslutningssträngen
Viktigt!
En anslutningssträng innehåller auktoriseringsinformation som krävs för att ditt program ska få åtkomst till Web PubSub-tjänsten. Åtkomstnyckeln i anslutningssträng liknar ett rotlösenord för din tjänst.
I den här snabbstartsguiden får vi den från Azure Portal enligt nedan.
Kör serverprogrammet
Kör följande kommandon i ett nytt kommandogränssnitt.
Råa anslutningssträng visas endast i den här artikeln i demonstrationssyfte. Skydda alltid dina åtkomstnycklar i produktionsmiljöer. Använd Azure Key Vault för att hantera och rotera dina nycklar på ett säkert sätt och skydda anslutningen med WebPubSubServiceClient.
# Set the environment variable for your connection string.
export WebPubSubConnectionString="<Put your connection string here>"
node publish.js "Hello World"
Observera de mottagna meddelandena på klientsidan
Prova att köra samma "prenumerera"-program i flera kommandogränssnitt för att stimulera fler än klienter. Så snart "publicera"-programmet körs bör du se meddelanden som levereras i realtid till alla dessa klienter.
Skapa en projektkatalog med namnet publisher och installera nödvändiga beroenden:
mkdir publisher
cd publisher
dotnet new console
dotnet add package Azure.Messaging.WebPubSub
Program.cs Ersätt filen med följande kod
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);
}
}
}
Samtalet SendToAllAsync() skickar ett meddelande till alla anslutna klienter i hubben.
Kör serverprogrammet för att skicka meddelanden till alla anslutna klienter
$connection_string="<connection-string>"
dotnet run $connection_string "myHub1" "Hello World"
Observera de mottagna meddelandena på klientsidan
# 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 simulates 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
Skapa först en projektkatalog med namnet publisher och installera nödvändiga beroenden:
mkdir publisher
cd publisher
# Create venv
python -m venv env
# Active venv
source ./env/bin/activate
pip install azure-messaging-webpubsubservice
Använd Azure Web PubSub SDK för att publicera ett meddelande till tjänsten. Skapa en publish.py fil med koden nedan:
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)
Skicka send_to_all() meddelandet till alla anslutna klienter i en hubb.
Kontrollera det tidigare kommandogränssnittet till att prenumeranten tog emot meddelandet:
Received message: Hello World
Gå till pubsub katalogen. Använd Maven för att skapa en utgivarkonsolapp webpubsub-quickstart-publisher och gå till katalogen webpubsub-quickstart-publisher :
Använd Azure Web PubSub SDK för att publicera ett meddelande till tjänsten. Gå till katalogen /src/main/java/com/webpubsub/quickstart , öppna filen App.java i redigeringsprogrammet och ersätt innehållet med följande kod:
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);
}
}
Samtalet sendToAll() skickar ett meddelande till alla anslutna klienter i en hubb.
Gå till katalogen webpubsub-quickstart-publisher och kör projektet med följande kommando:
Du kan se att den tidigare prenumeranten fick meddelandet:
Message received: Hello World
Sammanfattning
Den här snabbstarten visar hur enkelt det är att skicka meddelanden från en programserver till alla anslutna klienter i en hubb. Dessutom kan du med Web PubSub skicka meddelanden till
en delmängd av klienterna i en hubb
en viss grupp i en hubb
en delmängd av klienter i en grupp
Dessa API:er möjliggör en mängd användningsfall, vilket gör att utvecklare kan fokusera på unik affärslogik samtidigt som de är säkra på att Web PubSub erbjuder låg svarstid (<100 ms), hög tillgänglighet och massiv skala (miljoner+ samtidiga anslutningar).
Nästa steg
I nästa steg ska vi utforska hur du arbetar med händelsesystemet för Web PubSub, som är nödvändigt för att skapa fullständiga webbprogram.
