Il modello familiare di richiesta/risposta HTTP è stato progettato per essere facile da usare e scalabile. Tuttavia, al giorno d'oggi gli utenti finali richiedono molto di più dal Web rispetto a quanto 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 spingere il prezzo di offerta più recente di un prodotto in un sito di aste o prezzi azionari in rapida movimento 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
Importante
Le stringa di connessione non elaborate vengono visualizzate in questo articolo solo a scopo dimostrativo.
Una stringa di connessione include le informazioni sull'autorizzazione necessarie all'applicazione per l'accesso al servizio Azure Web PubSub. La chiave di accesso all'interno della stringa di connessione è simile a una password radice per il servizio. Negli ambienti di produzione proteggere sempre le chiavi di accesso. Usare Azure Key Vault per gestire e ruotare le chiavi in modo sicuro e proteggere la connessione con WebPubSubServiceClient.
Evitare di distribuire le chiavi di accesso ad altri utenti, impostarle come hardcoded o salvarle in un file di testo normale accessibile ad altri. Ruotare le chiavi se si ritiene che siano state compromesse.
Prerequisiti
Risorsa PubSub Web. Se non ne è stato creato uno, è 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, ad esempio un browser, un'app per dispositivi mobili o un dispositivo IoT, deve prima connettersi alla risorsa Web PubSub e rimane in ascolto dell'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 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 accesso client. Per questa guida introduttiva, è possibile copiare e incollare uno da portale di Azure illustrato nel diagramma seguente. È consigliabile non impostare come hardcoded l'URL accesso client nel codice. Nel mondo di produzione viene in genere configurato un server app per restituire questo URL su richiesta. Generare l'URL accesso client descrive in dettaglio la procedura.
Come illustrato nel diagramma precedente, il client unisce 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
Ora 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 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 accesso client. Per questa guida introduttiva, è possibile copiare e incollare uno da portale di Azure illustrato nel diagramma seguente. È consigliabile non impostare come hardcoded l'URL accesso client nel codice. Nel mondo di produzione viene in genere configurato un server app per restituire questo URL su richiesta. Generare l'URL accesso client descrive in dettaglio la procedura.
Come illustrato nel diagramma precedente, il client unisce 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
Ora 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 Web PubSub. 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. Concetti chiave contiene la spiegazione dettagliata dei termini usati in Web PubSub.
Il servizio Web PubSub usa l'autenticazione del token JSON Web (JWT). Il codice di esempio usa WebPubSubServiceClient.GetClientAccessUri() nell'SDK Web PubSub per generare un URL al servizio che contiene l'URL completo con un token di accesso valido.
Una volta stabilita la connessione, il client riceverà i messaggi tramite la connessione WebSocket. Usare await ws.recv() per attendere i messaggi in arrivo.
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 i 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.
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. Concetti chiave contiene la spiegazione dettagliata dei termini usati in Azure Web PubSub.
Il servizio Web PubSub usa l'autenticazione del token JSON Web (JWT). Il codice di esempio usa WebPubSubServiceClient.GetClientAccessUri() nell'SDK Web PubSub per generare un URL al servizio che contiene l'URL completo con un token di accesso valido.
Una volta stabilita la connessione, il client riceverà i messaggi tramite la connessione WebSocket. Usare onMessage(String message) per attendere i messaggi in arrivo.
Eseguire il push dei messaggi dal server applicazioni
Ora che è stato connesso un client alla risorsa Web PubSub, è possibile eseguire il push dei 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 chiamata server.sendToAll() invia un messaggio a tutti i client connessi in un hub.
Ottenere la stringa di connessione
Importante
Un 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, verrà ottenuto da portale di Azure come illustrato di seguito.
Eseguire il programma server
Eseguire i comandi seguenti in una nuova shell dei comandi.
Le stringa di connessione non elaborate vengono visualizzate in questo articolo solo a scopo dimostrativo. Negli ambienti di produzione proteggere sempre le chiavi di accesso. Usare Azure Key Vault per gestire e ruotare le chiavi in modo sicuro e proteggere la connessione con WebPubSubServiceClient.
# 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 "subscribe" in più shell di comandi per stimolare più client. Non appena viene eseguito il programma di "pubblicazione", dovrebbero essere 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 Program.cs file con il 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 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
Creare prima di tutto una directory di progetto denominata publisher progetto 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 l'SDK Azure Web PubSub 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)
La chiamata send_to_all() invia il messaggio a tutti i client connessi in un hub.
Controllare la shell dei comandi precedente per assicurarsi che il sottoscrittore abbia ricevuto il messaggio:
Received message: Hello World
Passare alla directory pubsub. Usare Maven per creare un'app console publisher webpubsub-quickstart-publisher e passare alla directory webpubsub-quickstart-publisher:
Usare l'SDK Azure Web PubSub 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 chiamata sendToAll() 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 quanto sia facile eseguire il push dei 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 particolare gruppo in un hub
un subset di client in un gruppo
Queste API consentono un'ampia gamma di casi d'uso, consentendo agli sviluppatori di concentrarsi su una logica di business univoca, assicurando al tempo stesso che Web PubSub offre bassa latenza (<100 ms), disponibilità elevata e scalabilità elevata (milioni di connessioni simultanee).
Passaggi successivi
Nel passaggio successivo si esaminerà come usare il sistema eventi di Web PubSub, necessario per compilare applicazioni Web complete.
