Známý model požadavků a odpovědí HTTP byl navržen tak, aby byl snadno použitelný a škálovatelný. V současné době však koncoví uživatelé vyžadují mnohem více z webu, než bylo původně určeno. Protokol HTTP vyžaduje, aby uživatelé zahájili požadavek, aby obdrželi odpověď. Vývojáři ale potřebují způsob, jak odesílat data ze serveru klientům, aniž by o ně žádali; Jinými slovy, musí " nabízet" data klientům, jako je například nabízení nejnovější ceny produktu na aukční lokalitě nebo rychle se pohyblivé ceny akcií v finanční aplikaci.
Tato příručka pro rychlý start ukazuje, jak
přihlášení k odběru zpráv z aplikačního serveru
nabízení dat z aplikačního serveru všempřipojeným klientům
Důležité
Nezpracované připojovací řetězec se v tomto článku zobrazují jenom pro demonstrační účely.
Připojovací řetězec obsahuje informace o autorizaci vyžadované pro vaši aplikaci pro přístup ke službě Azure Web PubSub. Přístupový klíč uvnitř připojovací řetězec je podobný kořenovému heslu pro vaši službu. V produkčních prostředích vždy chraňte přístupové klíče. Pomocí služby Azure Key Vault můžete bezpečně spravovat a obměňovat klíče a zabezpečit připojení WebPubSubServiceClient.
Vyhněte se distribuci přístupových klíčů ostatním uživatelům, jejich pevnému kódování nebo jejich uložení kdekoli ve formátu prostého textu, který je přístupný ostatním uživatelům. Otočte klíče, pokud se domníváte, že mohly být ohroženy.
Pokud se chcete přihlásit k odběru zpráv odsílaných z aplikačního serveru, klienta, jako je prohlížeč, mobilní aplikace nebo zařízení IoT, musí se nejprve připojit k prostředku Web PubSub a naslouchat příslušné události zprávy.
Vytvoření adresáře projektu s názvem subscriber a instalace požadovaných závislostí
mkdir subscriber
cd subscriber
npm init -y
# The client SDK is available as a module on NPM
npm install @azure/web-pubsub-client
Připojte se k prostředku Web PubSub a zaregistrujte pro událost naslouchací server-message proces.
Klient používá adresu URL klientského přístupu k připojení a ověření s vaším prostředkem.
Tato adresa URL se řídí vzorem wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Klient může mít několik způsobů, jak získat adresu URL klientského přístupu. Pro účely tohoto rychlého startu můžete zkopírovat a vložit jeden z webu Azure Portal zobrazený v následujícím diagramu. Osvědčeným postupem je nezakódovat adresu URL klientského přístupu v kódu. V produkčním světě obvykle nastavíme aplikační server tak, aby tuto adresu URL vrátil na vyžádání. Vygenerování adresy URL klientského přístupu podrobně popisuje postup.
Jak je znázorněno v diagramu výše, klient připojí centrum s názvem myHub1.
subscriber Ve složce projektu vytvořte soubor s názvem subscribe.js s následujícím kódem.
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();
Spuštění programu
node subscribe.js
Teď tento klient vytvoří připojení k vašemu prostředku Web PubSub a je připravený přijímat zprávy odesílané z aplikačního serveru.
Vytvoření adresáře projektu s názvem subscriber a instalace požadovaných závislostí
mkdir subscriber
cd subscriber
# Create a .net console app
dotnet new console
# Add the client SDK
dotnet add package Azure.Messaging.WebPubSub.Client --prerelease
Připojte se k prostředku Web PubSub a zaregistrujte pro událost naslouchací ServerMessageReceived proces.
Klient používá adresu URL klientského přístupu k připojení a ověření s vaším prostředkem.
Tato adresa URL se řídí vzorem wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Klient může mít několik způsobů, jak získat adresu URL klientského přístupu. Pro účely tohoto rychlého startu můžete zkopírovat a vložit jeden z webu Azure Portal zobrazený v následujícím diagramu. Osvědčeným postupem je nezakódovat adresu URL klientského přístupu v kódu. V produkčním světě obvykle nastavíme aplikační server tak, aby tuto adresu URL vrátil na vyžádání. Vygenerování adresy URL klientského přístupu podrobně popisuje postup.
Jak je znázorněno v diagramu výše, klient připojí centrum s názvem myHub1.
Nahraďte kód v Program.cs následujícím kódu.
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();
Spusťte následující příkaz
dotnet run
Teď tento klient vytvoří připojení k vašemu prostředku Web PubSub a je připravený přijímat zprávy odesílané z aplikačního serveru.
Vytvořte adresář projektu s názvem subscriber a nainstalujte požadované závislosti:
Pomocí rozhraní WEBSocket API se připojte k prostředku Web PubSub. Vytvořte subscribe.py soubor s následujícím kódem.
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
Kód vytvoří připojení WebSocket, které je připojeno k centru ve službě Web PubSub. Centrum je logická jednotka v podsítě Web PubSub, kde můžete publikovat zprávy do skupiny klientů. Klíčové koncepty obsahují podrobné vysvětlení termínů použitých v podsítě Web PubSub.
Služba Web PubSub používá ověřování pomocí webového tokenu JSON (JWT ). Ukázkový kód používá WebPubSubServiceClient.GetClientAccessUri() v sadě Web PubSub SDK k vygenerování adresy URL služby, která obsahuje úplnou adresu URL s platným přístupovým tokenem.
Po navázání připojení klient obdrží zprávy prostřednictvím připojení WebSocket. Slouží await ws.recv() k naslouchání příchozím zprávům.
Spusťte následující příkaz
python subscribe.py $connection_string "myHub1"
Vytvoření adresáře projektu s názvem pubsub
mkdir pubsub
cd pubsub
Pomocí Mavenu vytvořte novou konzolovou aplikaci s názvem webpubsub-quickstart-subscriber;
Ve službě Web PubSub se můžete připojit ke službě a přihlásit se k odběru zpráv prostřednictvím připojení WebSocket. WebSocket je plně duplexní komunikační kanál, který službě umožňuje odesílat zprávy klientovi v reálném čase. Můžete použít libovolné rozhraní API nebo knihovnu, která podporuje Protokol WebSocket. Pro tuto ukázku používáme balíček Java-WebSocket.
Přejděte do adresáře /src/main/java/com/webpubsub/quickstart .
Obsah souboru App.java nahraďte následujícím kódem:
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();
}
}
Tento kód vytvoří připojení WebSocket, které je připojené k centru ve službě Azure Web PubSub. Centrum je logická jednotka ve službě Azure Web PubSub, kde můžete publikovat zprávy do skupiny klientů. Klíčové koncepty obsahují podrobné vysvětlení termínů používaných ve službě Azure Web PubSub.
Služba Web PubSub používá ověřování pomocí webového tokenu JSON (JWT ). Ukázkový kód používá WebPubSubServiceClient.GetClientAccessUri() v sadě Web PubSub SDK k vygenerování adresy URL služby, která obsahuje úplnou adresu URL s platným přístupovým tokenem.
Po navázání připojení klient obdrží zprávy prostřednictvím připojení WebSocket. Slouží onMessage(String message) k naslouchání příchozím zprávům.
Teď, když máte klienta připojeného k prostředku Web PubSub, můžete odesílat zprávy z aplikačního serveru kdykoli pomocí sady SDK serveru poskytované web pubSub.
Vytvoření nového adresáře projektu s názvem publisher a instalace požadovaných závislostí
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
Vytvořte publish.js soubor s následujícím kódem.
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" });
Volání server.sendToAll() odešle zprávu všem připojeným klientům v centru.
Získání připojovacího řetězce
Důležité
Připojovací řetězec obsahuje informace o autorizaci vyžadované pro přístup ke službě Web PubSub vaší aplikace. Přístupový klíč uvnitř připojovací řetězec je podobný kořenovému heslu pro vaši službu.
Pro tuto příručku pro rychlý start ji získáme z webu Azure Portal, jak je znázorněno níže.
Spuštění serverového programu
V novém příkazovém prostředí spusťte následující příkazy.
Nezpracované připojovací řetězec se v tomto článku zobrazují jenom pro demonstrační účely. V produkčních prostředích vždy chraňte přístupové klíče. Pomocí služby Azure Key Vault můžete bezpečně spravovat a obměňovat klíče a zabezpečit připojení WebPubSubServiceClient.
# Set the environment variable for your connection string.
export WebPubSubConnectionString="<Put your connection string here>"
node publish.js "Hello World"
Sledování přijatých zpráv na straně klienta
Zkuste spustit stejný program "přihlásit k odběru" ve více příkazových prostředích, aby se podnítila více než klienti. Jakmile se spustí program publikovat, měli byste vidět, že se zprávy doručují v reálném čase všem těmto klientům.
Vytvořte adresář projektu s názvem publisher a nainstalujte požadované závislosti:
mkdir publisher
cd publisher
dotnet new console
dotnet add package Azure.Messaging.WebPubSub
Program.cs Nahraďte soubor následujícím kódem.
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);
}
}
}
Volání SendToAllAsync() odešle zprávu všem připojeným klientům v centru.
Spuštěním serveru odešlete zprávy všem připojeným klientům.
$connection_string="<connection-string>"
dotnet run $connection_string "myHub1" "Hello World"
Sledování přijatých zpráv na straně klienta
# 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
Nejprve vytvořte adresář projektu s názvem publisher a nainstalujte požadované závislosti:
mkdir publisher
cd publisher
# Create venv
python -m venv env
# Active venv
source ./env/bin/activate
pip install azure-messaging-webpubsubservice
Pomocí sady AZURE Web PubSub SDK pub Vytvořte publish.py soubor s následujícím kódem:
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)
Zpráva send_to_all() se odešle všem připojeným klientům v centru.
Zkontrolujte předchozí příkazové prostředí, ve které odběratel obdržel zprávu:
Received message: Hello World
Přejděte do pubsub adresáře. Pomocí Mavenu vytvořte konzolovou aplikaci webpubsub-quickstart-publisher vydavatele a přejděte do adresáře webpubsub-quickstart-publisher :
Pomocí sady AZURE Web PubSub SDK pub Přejděte do adresáře /src/main/java/com/webpubsub/quickstart , otevřete soubor App.java v editoru a nahraďte obsah následujícím kódem:
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);
}
}
Volání sendToAll() odešle zprávu všem připojeným klientům v centru.
Přejděte do adresáře webpubsub-quickstart-publisher a spusťte projekt pomocí následujícího příkazu:
Tento rychlý start ukazuje, jak snadné je odesílat zprávy z aplikačního serveru všem připojeným klientům v centru. Web PubSub navíc umožňuje odesílat zprávy do
podmnožina klientů v centru
konkrétní skupina v centru
podmnožina klientů ve skupině
Tato rozhraní API umožňují širokou škálu případů použití, což vývojářům umožňuje zaměřit se na jedinečnou obchodní logiku a zároveň mít jistotu, že Web PubSub nabízí nízkou latenci (<100 ms), vysokou dostupnost a masivní škálování (milion+ souběžná připojení).
Další kroky
V dalším kroku prozkoumáme, jak pracovat se systémem událostí Web PubSub, který je nezbytný k vytvoření kompletních webových aplikací.
