Il modello di richiesta/risposta HTTP familiare è stato progettato per essere facile da usare e scalabile. Tuttavia, al giorno d'oggi gli utenti finali richiedono molto più dal Web di quanto sia stato originariamente progettato per. Il protocollo HTTP richiede agli utenti di avviare la richiesta per ricevere una risposta. Ma gli sviluppatori hanno bisogno di un modo per inviare dati dal server ai client senza chiedere loro; in altre parole, devono "spingere" i dati ai clienti, come il push del prezzo più recente dell'offerta di un prodotto in un sito di aste o i prezzi delle azioni in rapida evoluzione in un'applicazione finanziaria.
Questa guida introduttiva illustra come
sottoscrivere messaggi da un server applicazioni
eseguire il push dei dati da un server applicazioni a tutti i client connessi
Prerequisiti
Risorsa PubSub Web. Se non ne è stata creata una, è possibile seguire le indicazioni seguenti: Creare una risorsa PubSub Web
Un editor di codice, ad esempio Visual Studio Code
Installare le dipendenze per la lingua che si prevede di usare
Per sottoscrivere i messaggi inviati dal server applicazioni, un client, sia un browser, un'app per dispositivi mobili o un dispositivo IoT, deve connettersi prima alla risorsa Web PubSub e ascoltare l'evento di messaggio appropriato.
Creare una directory di progetto denominata subscriber e installare le dipendenze necessarie
mkdir subscriber
cd subscriber
npm init -y
# The client SDK is available as a module on NPM
npm install @azure/web-pubsub-client
Connettersi alla risorsa Web PubSub e registrare un listener per l'evento server-message
Un client usa un URL di accesso client per connettersi ed eseguire l'autenticazione con la risorsa.
Questo URL segue un modello di wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Un client può avere alcuni modi per ottenere l'URL di accesso client. Per questa guida introduttiva, è possibile copiare e incollare uno da portale di Azure illustrato nel diagramma seguente. È consigliabile non eseguire il codice rigido dell'URL di accesso client nel codice. Nel mondo di produzione viene in genere configurato un server app per restituire questo URL su richiesta.
Generare l'URL di accesso client descrive in dettaglio la procedura.
Come illustrato nel diagramma precedente, il client aggiunge l'hub denominato myHub1.
Nella cartella del subscriber progetto creare un file denominato subscribe.js con il codice seguente
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();
Eseguire il programma
node subscribe.js
A questo punto questo client stabilisce una connessione con la risorsa Web PubSub ed è pronto per ricevere messaggi inviati dal server applicazioni.
Creare una directory di progetto denominata subscriber e installare le dipendenze necessarie
mkdir subscriber
cd subscriber
# Create a .net console app
dotnet new console
# Add the client SDK
dotnet add package Azure.Messaging.WebPubSub.Client --prerelease
Connettersi alla risorsa Web PubSub e registrare un listener per l'evento ServerMessageReceived
Un client usa un URL di accesso client per connettersi ed eseguire l'autenticazione con la risorsa.
Questo URL segue un modello di wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Un client può avere alcuni modi per ottenere l'URL di accesso client. Per questa guida introduttiva, è possibile copiare e incollare uno da portale di Azure illustrato nel diagramma seguente. È consigliabile non eseguire il codice rigido dell'URL di accesso client nel codice. Nel mondo di produzione viene in genere configurato un server app per restituire questo URL su richiesta.
Generare l'URL di accesso client descrive in dettaglio la procedura.
Come illustrato nel diagramma precedente, il client aggiunge l'hub denominato myHub1.
Sostituire il codice in Program.cs con il codice seguente
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();
Eseguire il comando seguente
dotnet run
A questo punto questo client stabilisce una connessione con la risorsa Web PubSub ed è pronto per ricevere messaggi inviati dal server applicazioni.
Creare una directory di progetto denominata subscriber e installare le dipendenze necessarie:
Usare l'API WebSocket per connettersi alla risorsa PubSub Web. Creare un subscribe.py file con il codice seguente
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
Il codice crea una connessione WebSocket connessa a un hub in Web PubSub. Un hub è un'unità logica in Web PubSub in cui è possibile pubblicare messaggi in un gruppo di client.
I concetti chiave contengono la spiegazione dettagliata sui termini usati in Web PubSub.
Il servizio Web PubSub usa l'autenticazione JWT (JSON Web Token). Il codice di esempio usa WebPubSubServiceClient.GetClientAccessUri() Web PubSub SDK per generare un URL al servizio contenente l'URL completo con un token di accesso valido.
Dopo aver stabilito la connessione, il client riceverà messaggi tramite la connessione WebSocket. Usare await ws.recv() per ascoltare i messaggi in ingresso.
Eseguire il comando seguente
python subscribe.py $connection_string "myHub1"
Creare una directory di progetto denominata pubsub
mkdir pubsub
cd pubsub
Usare Maven per creare una nuova app console denominata webpubsub-quickstart-subscriber;
In Web PubSub è possibile connettersi al servizio e sottoscrivere messaggi tramite connessioni WebSocket. WebSocket è un canale di comunicazione full-duplex che consente al servizio di eseguire il push dei messaggi al client in tempo reale. È possibile usare qualsiasi API o libreria che supporti WebSocket. Per questo esempio viene usato il pacchetto Java-WebSocket.
Passare alla directory /src/main/java/com/webpubsub/quickstart .
Modificare sostituire il contenuto del file App.java con il codice seguente:
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();
}
}
Questo codice crea una connessione WebSocket connessa a un hub in Azure Web PubSub. Un hub è un'unità logica in Azure Web PubSub in cui è possibile pubblicare messaggi in un gruppo di client.
I concetti principali contengono la spiegazione dettagliata sui termini usati in PubSub Web di Azure.
Il servizio Web PubSub usa l'autenticazione JWT (JSON Web Token). Il codice di esempio usa WebPubSubServiceClient.GetClientAccessUri() Web PubSub SDK per generare un URL al servizio contenente l'URL completo con un token di accesso valido.
Dopo aver stabilito la connessione, il client riceverà messaggi tramite la connessione WebSocket. Usare onMessage(String message) per ascoltare i messaggi in ingresso.
Eseguire il push di messaggi dal server applicazioni
Ora che si dispone di un client connesso alla risorsa Web PubSub, è possibile eseguire il push di messaggi da un server applicazioni in qualsiasi momento usando l'SDK server fornito da Web PubSub.
Creare una nuova directory di progetto denominata publisher e installare le dipendenze necessarie
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
Creare un publish.js file con il codice seguente
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" });
La server.sendToAll() chiamata invia un messaggio a tutti i client connessi in un hub.
Ottenere la stringa di connessione
Importante
Una stringa di connessione include le informazioni di autorizzazione necessarie per l'applicazione per accedere al servizio Web PubSub. La chiave di accesso all'interno della stringa di connessione è simile a una password radice per il servizio.
Per questa guida introduttiva, si otterrà da portale di Azure come illustrato di seguito.
Eseguire il programma server
Eseguire i comandi seguenti in una nuova shell dei comandi.
# Set the environment variable for your connection string.
export WebPubSubConnectionString="<Put your connection string here>"
node publish.js "Hello World"
Osservare i messaggi ricevuti sul lato client
Provare a eseguire lo stesso programma "sottoscrizione" in più shell di comandi per stimolare più dei client. Non appena viene eseguito il programma "pubblica", verranno visualizzati messaggi recapitati in tempo reale a tutti questi client.
Creare una directory di progetto denominata publisher e installare le dipendenze necessarie:
mkdir publisher
cd publisher
dotnet new console
dotnet add package Azure.Messaging.WebPubSub
Sostituire il file con il Program.cs codice seguente
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);
}
}
}
La SendToAllAsync() chiamata invia un messaggio a tutti i client connessi nell'hub.
Eseguire il programma server per eseguire il push dei messaggi a tutti i client connessi
$connection_string="<connection-string>"
dotnet run $connection_string "myHub1" "Hello World"
Osservare i messaggi ricevuti sul lato client
# 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
Creare prima di tutto una directory di progetto denominata publisher e installare le dipendenze necessarie:
mkdir publisher
cd publisher
# Create venv
python -m venv env
# Active venv
source ./env/bin/activate
pip install azure-messaging-webpubsubservice
Usare Azure Web PubSub SDK per pubblicare un messaggio nel servizio. Creare un publish.py file con il codice seguente:
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)
Invia send_to_all() il messaggio a tutti i client connessi in un hub.
Controllare la shell dei comandi precedente in cui il sottoscrittore ha ricevuto il messaggio:
Received message: Hello World
Passare alla pubsub directory. Usare Maven per creare un'app webpubsub-quickstart-publisher console di pubblicazione e passare alla directory webpubsub-quickstart-publisher :
Usare Azure Web PubSub SDK per pubblicare un messaggio nel servizio. Passare alla directory /src/main/java/com/webpubsub/quickstart , aprire il file App.java nell'editor e sostituire il contenuto con il codice seguente:
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);
}
}
La sendToAll() chiamata invia un messaggio a tutti i client connessi in un hub.
Passare alla directory webpubsub-quickstart-publisher ed eseguire il progetto usando il comando seguente:
È possibile notare che il sottoscrittore precedente ha ricevuto il messaggio:
Message received: Hello World
Riepilogo
Questa guida introduttiva illustra come è facile eseguire il push di messaggi da un server applicazioni a tutti i client connessi in un hub. Inoltre, Web PubSub consente di eseguire il push dei messaggi in
un subset dei client in un hub
un determinato gruppo in un hub
un subset di client in un gruppo
Queste API consentono una vasta gamma di casi d'uso, consentendo agli sviluppatori di concentrarsi sulla logica di business univoca, assicurandosi che Web PubSub offre bassa latenza (100ms), disponibilità elevata e scalabilità elevata (<milioni di connessioni simultanee).
Passaggi successivi
Nel passaggio successivo verrà illustrato come usare il sistema eventi di Web PubSub, necessario per compilare applicazioni Web complete.
