Eseguire il push dei messaggi dal server

Node.js

.NET Core

Python

• Java Development Kit (JDK).
• Apache Maven

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 alla risorsa e autenticarsi. Questo URL segue un modello di wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Un cliente può ottenere l'URL di accesso del client in diversi modi. Per questa guida introduttiva, è possibile copiare e incollare uno da portale di Azure illustrato nel diagramma seguente. Una buona prassi consiste nel non codificare direttamente nel codice l'URL di accesso client. Nel mondo di produzione viene in genere configurato un server app per restituire questo URL su richiesta. Genera URL di 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 di accesso client per connettersi alla risorsa e autenticarsi. Questo URL segue un modello di wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Un cliente può ottenere l'URL di accesso del client in diversi modi. Per questa guida introduttiva, è possibile copiare e incollare uno da portale di Azure illustrato nel diagramma seguente. Una buona prassi consiste nel non codificare direttamente nel codice l'URL di accesso client. Nel mondo di produzione viene in genere configurato un server app per restituire questo URL su richiesta. Genera URL di 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:

mkdir subscriber
cd subscriber

# Create venv
python -m venv env
# Activate venv
source ./env/bin/activ

pip install azure-messaging-webpubsubservice
pip install websockets

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;

mvn archetype:generate --define interactiveMode=n --define groupId=com.webpubsub.quickstart --define artifactId=webpubsub-quickstart-subscriber --define archetypeArtifactId=maven-archetype-quickstart --define archetypeVersion=1.4

cd webpubsub-quickstart-subscriber

Aggiungere WebSocket e l'SDK Azure Web PubSub al nodo dependencies in pom.xml:

• azure-messaging-webpubsub: SDK del servizio Web PubSub per Java
• Java-WebSocket: SDK del client WebSocket per Java

<dependency>
    <groupId>com.azure</groupId>
    <artifactId>azure-messaging-webpubsub</artifactId>
    <version>1.0.0</version>
</dependency>
<dependency>
    <groupId>org.java-websocket</groupId>
    <artifactId>Java-WebSocket</artifactId>
    <version>1.5.1</version>
</dependency>

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.

1. Passare alla directory /src/main/java/com/webpubsub/quickstart.

2. 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 l'app con il comando seguente

mvn compile & mvn package & mvn exec:java -Dexec.mainClass="com.webpubsub.quickstart.App" -Dexec.cleanupDaemonThreads=false -Dexec.args="$connection_string 'myHub1'"

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

In questa guida introduttiva, lo otterremo dal portale di Azure come illustrato di seguito.

Eseguire il programma server

Eseguite i comandi seguenti in una nuova shell di comando.

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

1. Per prima cosa, crea una directory del progetto denominata publisher e installa le dipendenze richieste:

   mkdir publisher
   cd publisher
   # Create venv
   python -m venv env
   # Active venv
   source ./env/bin/activate
   
   pip install azure-messaging-webpubsubservice
   
   

2. 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)
   

   send_to_all() invia il messaggio a tutti i client connessi a un hub.

3. Esegui questo comando:

   python publish.py $connection_string "myHub1" "Hello World"
   

4. Controllare la shell dei comandi precedente per assicurarsi che il sottoscrittore abbia ricevuto il messaggio:

   Received message: Hello World
   

1. Passare alla directory pubsub. Usare Maven per creare un'app console publisher webpubsub-quickstart-publisher e passare alla directory webpubsub-quickstart-publisher:

   mvn archetype:generate --define interactiveMode=n --define groupId=com.webpubsub.quickstart --define artifactId=webpubsub-quickstart-publisher --define archetypeArtifactId=maven-archetype-quickstart --define archetypeVersion=1.4
   cd webpubsub-quickstart-publisher
   

2. Aggiungere la dipendenza dell'SDK Azure Web PubSub nel nodo dependencies di pom.xml:

   <dependency>
       <groupId>com.azure</groupId>
       <artifactId>azure-messaging-webpubsub</artifactId>
       <version>1.0.0</version>
   </dependency>
   

3. 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.

4. Passare alla directory webpubsub-quickstart-publisher ed eseguire il progetto usando il comando seguente:

   mvn compile & mvn package & mvn exec:java -Dexec.mainClass="com.webpubsub.quickstart.App" -Dexec.cleanupDaemonThreads=false -Dexec.args="$connection_string 'myHub1' 'Hello World'"
   

5. È possibile notare che il sottoscrittore precedente ha ricevuto il messaggio:

   Message received: Hello World