Znany model żądania HTTP/odpowiedzi został zaprojektowany tak, aby był łatwy w pracy i skalowalny. Jednak w dzisiejszych czasach użytkownicy końcowi wymagają o wiele więcej od internetu, niż został pierwotnie zaprojektowany. Protokół HTTP wymaga od użytkowników zainicjowania żądania w celu otrzymania odpowiedzi. Jednak deweloperzy potrzebują sposobu wysyłania danych z serwera do klientów bez ich prośby o to; innymi słowy, muszą one "wypychać" dane do klientów, takie jak wypychanie najnowszej ceny przetargowej produktu na stronie aukcji lub szybkie ceny akcji w aplikacji finansowej.
W tym przewodniku Szybki start pokazano, jak
subskrybowanie komunikatów z serwera aplikacji
wypychanie danych z serwera aplikacji do wszystkich połączonych klientów
Wymagania wstępne
Zasób Web PubSub. Jeśli go nie utworzono, możesz postępować zgodnie ze wskazówkami: Tworzenie zasobu Web PubSub
Edytor kodu, taki jak Visual Studio Code
Instalowanie zależności dla języka, którego planujesz użyć
Aby zasubskrybować komunikaty wypchnięte z serwera aplikacji, klienta, zależnie od przeglądarki, aplikacji mobilnej lub urządzenia IoT, należy najpierw nawiązać połączenie z zasobem Web PubSub i nasłuchiwać odpowiedniego zdarzenia wiadomości.
Tworzenie katalogu projektu o nazwie subscriber i instalowanie wymaganych zależności
mkdir subscriber
cd subscriber
npm init -y
# The client SDK is available as a module on NPM
npm install @azure/web-pubsub-client
Nawiązywanie połączenia z zasobem Web PubSub i rejestrowanie odbiornika server-message dla zdarzenia
Klient używa adresu URL dostępu klienta do nawiązywania połączenia i uwierzytelniania przy użyciu zasobu.
Ten adres URL jest zgodny ze wzorcem wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Klient może mieć kilka sposobów uzyskania adresu URL dostępu klienta. W tym przewodniku Szybki start możesz skopiować i wkleić je z Azure Portal pokazanych na poniższym diagramie. Najlepszym rozwiązaniem jest to, aby nie kodować twardego adresu URL dostępu klienta w kodzie. W świecie produkcyjnym zwykle konfigurujemy serwer aplikacji, aby zwrócić ten adres URL na żądanie.
Wygeneruj adres URL dostępu klienta opisuje szczegółowo praktykę.
Jak pokazano na powyższym diagramie, klient dołącza do centrum o nazwie myHub1.
W folderze subscriber projektu utwórz plik o nazwie subscribe.js z następującym kodem
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();
Uruchamianie programu
node subscribe.js
Teraz ten klient nawiązuje połączenie z zasobem Web PubSub i jest gotowy do odbierania komunikatów wypychanych z serwera aplikacji.
Tworzenie katalogu projektu o nazwie subscriber i instalowanie wymaganych zależności
mkdir subscriber
cd subscriber
# Create a .net console app
dotnet new console
# Add the client SDK
dotnet add package Azure.Messaging.WebPubSub.Client --prerelease
Nawiązywanie połączenia z zasobem Web PubSub i rejestrowanie odbiornika ServerMessageReceived dla zdarzenia
Klient używa adresu URL dostępu klienta do nawiązywania połączenia i uwierzytelniania przy użyciu zasobu.
Ten adres URL jest zgodny ze wzorcem wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Klient może mieć kilka sposobów uzyskania adresu URL dostępu klienta. W tym przewodniku Szybki start możesz skopiować i wkleić je z Azure Portal pokazanych na poniższym diagramie. Najlepszym rozwiązaniem jest to, aby nie kodować twardego adresu URL dostępu klienta w kodzie. W świecie produkcyjnym zwykle konfigurujemy serwer aplikacji, aby zwrócić ten adres URL na żądanie.
Wygeneruj adres URL dostępu klienta opisuje szczegółowo praktykę.
Jak pokazano na powyższym diagramie, klient dołącza do centrum o nazwie myHub1.
Zastąp kod w Program.cs pliku następującym kodem
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();
Uruchom następujące polecenie
dotnet run
Teraz ten klient nawiązuje połączenie z zasobem Web PubSub i jest gotowy do odbierania komunikatów wypychanych z serwera aplikacji.
Utwórz katalog projektu o nazwie subscriber i zainstaluj wymagane zależności:
Użyj interfejsu API protokołu WebSocket, aby nawiązać połączenie z zasobem Web PubSub.
subscribe.py Utwórz plik z następującym kodem
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
Kod tworzy połączenie protokołu WebSocket połączone z koncentratorem w usłudze Web PubSub. Koncentrator to jednostka logiczna w usłudze Web PubSub, w której można publikować komunikaty w grupie klientów.
Kluczowe pojęcia zawierają szczegółowe wyjaśnienie terminów używanych w usłudze Web PubSub.
Usługa Web PubSub używa uwierzytelniania JSON Web Token (JWT). Przykładowy kod używa WebPubSubServiceClient.GetClientAccessUri() zestawu Web PubSub SDK do wygenerowania adresu URL usługi zawierającej pełny adres URL z prawidłowym tokenem dostępu.
Po nawiązaniu połączenia klient otrzyma komunikaty za pośrednictwem połączenia protokołu WebSocket. Służy await ws.recv() do nasłuchiwania komunikatów przychodzących.
Uruchom następujące polecenie
python subscribe.py $connection_string "myHub1"
Tworzenie katalogu projektu o nazwie pubsub
mkdir pubsub
cd pubsub
Użyj narzędzia Maven, aby utworzyć nową aplikację konsolową o nazwie webpubsub-quickstart-subscriber;
W usłudze Web PubSub możesz nawiązać połączenie z usługą i subskrybować komunikaty za pośrednictwem połączeń protokołu WebSocket. WebSocket to kanał komunikacji pełnodupleksowej, który umożliwia usłudze wypychanie komunikatów do klienta w czasie rzeczywistym. Możesz użyć dowolnego interfejsu API lub biblioteki obsługującej protokół WebSocket. W tym przykładzie używamy pakietu Java-WebSocket.
Przejdź do katalogu /src/main/java/com/webpubsub/quickstart .
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();
}
}
Ten kod tworzy połączenie protokołu WebSocket połączone z koncentratorem w usłudze Azure Web PubSub. Koncentrator to jednostka logiczna w usłudze Azure Web PubSub, w której można publikować komunikaty w grupie klientów.
Kluczowe pojęcia zawierają szczegółowe wyjaśnienie terminów używanych w usłudze Azure Web PubSub.
Usługa Web PubSub używa uwierzytelniania JSON Web Token (JWT). Przykładowy kod używa WebPubSubServiceClient.GetClientAccessUri() zestawu Web PubSub SDK do wygenerowania adresu URL usługi zawierającej pełny adres URL z prawidłowym tokenem dostępu.
Po nawiązaniu połączenia klient będzie odbierał komunikaty za pośrednictwem połączenia protokołu WebSocket. Służy onMessage(String message) do nasłuchiwania komunikatów przychodzących.
Uruchom aplikację za pomocą następującego polecenia
Teraz, gdy masz klienta połączonego z zasobem Web PubSub, możesz wypychać komunikaty z serwera aplikacji w dowolnym momencie przy użyciu zestawu SDK serwera dostarczonego przez Web PubSub.
Tworzenie nowego katalogu projektu o nazwie publisher i instalowanie wymaganych zależności
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
publish.js Utwórz plik z następującym kodem
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" });
Wywołanie server.sendToAll() wysyła komunikat do wszystkich połączonych klientów w centrum.
Pobieranie parametrów połączenia
Ważne
Parametry połączenia zawierają informacje o autoryzacji wymagane dla aplikacji w celu uzyskania dostępu do usługi Web PubSub. Klucz dostępu wewnątrz parametrów połączenia jest podobny do hasła głównego usługi.
W tym przewodniku Szybki start uzyskamy go z Azure Portal, jak pokazano poniżej.
Uruchamianie programu serwera
Uruchom następujące polecenia w nowej powłoce poleceń.
# Set the environment variable for your connection string.
export WebPubSubConnectionString="<Put your connection string here>"
node publish.js "Hello World"
Obserwowanie odebranych komunikatów po stronie klienta
Spróbuj uruchomić ten sam program "subskrybuj" w wielu powłokach poleceń, aby pobudzić więcej niż klientów. Po uruchomieniu programu "publikowanie" powinny być wyświetlane komunikaty dostarczane w czasie rzeczywistym do wszystkich tych klientów.
Utwórz katalog projektu o nazwie publisher i zainstaluj wymagane zależności:
mkdir publisher
cd publisher
dotnet new console
dotnet add package Azure.Messaging.WebPubSub
Zastąp Program.cs plik następującym kodem
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);
}
}
}
Wywołanie SendToAllAsync() wysyła komunikat do wszystkich połączonych klientów w centrum.
Uruchamianie programu serwera w celu wypychania komunikatów do wszystkich połączonych klientów
$connection_string="<connection-string>"
dotnet run $connection_string "myHub1" "Hello World"
Obserwowanie odebranych komunikatów po stronie 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 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
Najpierw utwórz katalog projektu o nazwie publisher i zainstaluj wymagane zależności:
mkdir publisher
cd publisher
# Create venv
python -m venv env
# Active venv
source ./env/bin/activate
pip install azure-messaging-webpubsubservice
Użyj zestawu AZURE Web PubSub SDK, aby opublikować komunikat w usłudze.
publish.py Utwórz plik z poniższym kodem:
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)
Wiadomość send_to_all() jest wysyłana do wszystkich połączonych klientów w centrum.
Sprawdź poprzednią powłokę poleceń, aby subskrybent otrzymał komunikat:
Received message: Hello World
Przejdź do pubsub katalogu. Użyj narzędzia Maven, aby utworzyć aplikację webpubsub-quickstart-publisher konsolową wydawcy i przejść do katalogu webpubsub-quickstart-publisher :
Użyj zestawu AZURE Web PubSub SDK, aby opublikować komunikat w usłudze. Przejdź do katalogu /src/main/java/com/webpubsub/quickstart , otwórz plik App.java w edytorze i zastąp zawartość następującym kodem:
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);
}
}
Wywołanie sendToAll() wysyła komunikat do wszystkich połączonych klientów w centrum.
Przejdź do katalogu webpubsub-quickstart-publisher i uruchom projekt przy użyciu następującego polecenia:
Zobaczysz, że poprzedni subskrybent otrzymał komunikat:
Message received: Hello World
Podsumowanie
W tym przewodniku Szybki start pokazano, jak łatwo jest wypychać komunikaty z serwera aplikacji do wszystkich połączonych klientów w centrum. Ponadto usługa Web PubSub umożliwia wypychanie komunikatów do
podzestaw klientów w centrum
określona grupa w centrum
podzestaw klientów w grupie
Te interfejsy API umożliwiają korzystanie z wielu przypadków użycia, dzięki czemu deweloperzy mogą skupić się na unikatowej logice biznesowej, zapewniając jednocześnie, że usługa Web PubSub oferuje małe opóźnienia (<100 ms),wysoką dostępność i ogromną skalę (milion+ równoczesne połączenia).
Następne kroki
W następnym kroku dowiemy się, jak pracować z systemem zdarzeń usługi Web PubSub, niezbędnym do utworzenia kompletnych aplikacji internetowych.
