Tutoriel : publier et s’abonner à des messages à l’aide de l’API WebSocket et du kit de développement logiciel (SDK) du service Azure Web PubSub

.NET Core

Node.JS

Python

• Kit de développement Java (JDK).
• Apache Maven

Configurer Azure CLI pour le développement local

Effectuez les étapes suivantes pour configurer Azure CLI et l’environnement de votre projet.

1. Ouvrez un interpréteur de commandes.

2. Effectuez une mise à niveau vers la dernière version d’Azure CLI.

   az upgrade
   

3. Installez l’extension Azure CLI pour Web PubSub.

   az extension add --name webpubsub
   

4. Connectez-vous à Azure CLI. Après les invites, entrez vos informations d’identification Azure.

   az login
   

1. Tout d’abord, créez un répertoire de projet appelé subscriber pour ce projet et installez les dépendances requises :

   • Le package Websocket.Client est un package tiers qui prend en charge les connexions WebSocket. Vous pouvez utiliser n’importe quelle API ou bibliothèque qui prend en charge WebSocket.
   • Le package Azure.Messaging.WebPubSub sdk permet de générer le JWT.

   mkdir subscriber
   cd subscriber
   dotnet new console
   dotnet add package Websocket.Client --version 4.3.30
   dotnet add package Azure.Messaging.WebPubSub --version 1.0.0
   

2. Remplacez le code dans le fichier Program.cs par le code suivant, qui se connecte au service :

   using System;
   using System.Threading.Tasks;
   
   using Azure.Messaging.WebPubSub;
   
   using Websocket.Client;
   
   namespace subscriber
   {
       class Program
       {
           static async Task Main(string[] args)
           {
               if (args.Length != 2)
               {
                   Console.WriteLine("Usage: subscriber <connectionString> <hub>");
                   return;
               }
               var connectionString = args[0];
               var hub = args[1];
   
               // Either generate the URL or fetch it from server or fetch a temp one from the portal
               var serviceClient = new WebPubSubServiceClient(connectionString, hub);
               var url = serviceClient.GetClientAccessUri();
   
               using (var client = new WebsocketClient(url))
               {
                   // Disable the auto disconnect and reconnect because the sample would like the client to stay online even no data comes in
                   client.ReconnectTimeout = null;
                   client.MessageReceived.Subscribe(msg => Console.WriteLine($"Message received: {msg}"));
                   await client.Start();
                   Console.WriteLine("Connected.");
                   Console.Read();
               }
           }
       }
   }
   
   

   Le code crée une connexion WebSocket qui est connectée à un hub dans Web PubSub. Le hub est une unité logique dans Web PubSub où vous pouvez publier des messages sur un groupe de clients. Les concepts clés contiennent une explication détaillée sur les termes utilisés dans Web PubSub.

   Le service Web PubSub utilise l’authentification JWT (JSON Web Token). L’exemple de code utilise WebPubSubServiceClient.GetClientAccessUri() dans le Kit de développement logiciel (SDK) Web PubSub pour générer une URL pour le service qui contient l’URL complète avec un jeton d’accès valide.

   Une fois la connexion établie, votre client reçoit des messages via la connexion WebSocket. Le client utilise client.MessageReceived.Subscribe(msg => ...)); pour écouter les messages entrants.

3. Pour démarrer l’abonné, exécutez la commande pour remplacer <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment :

   dotnet run <Web-PubSub-connection-string> "myHub1"
   

1. Tout d’abord, créez un répertoire de projet appelé subscriber et installez les dépendances requises :

   mkdir subscriber
   cd subscriber
   npm init -y
   npm install --save ws
   npm install --save @azure/web-pubsub
   
   

2. Utilisez l’API WebSocket pour vous connecter au service Web PubSub. Créez un fichier subscribe.js avec le code suivant :

   const WebSocket = require('ws');
   const { WebPubSubServiceClient } = require('@azure/web-pubsub');
   
   async function main() {
     const hub = "pubsub";
     let service = new WebPubSubServiceClient(process.env.WebPubSubConnectionString, hub);
     let token = await service.getClientAccessToken();
     let ws = new WebSocket(token.url);
     ws.on('open', () => console.log('connected'));
     ws.on('message', data => console.log('Message received: %s', data));
   }
   
   main();
   

   Le code crée une connexion WebSocket qui est connectée à un hub dans Web PubSub. Le hub est une unité logique dans Web PubSub où vous pouvez publier des messages sur un groupe de clients. Les concepts clés contiennent une explication détaillée sur les termes utilisés dans Web PubSub.

   Le service Web PubSub utilise l’authentification JWT (JSON Web Token). L’exemple de code utilise WebPubSubServiceClient.GetClientAccessUri() dans le Kit de développement logiciel (SDK) Web PubSub pour générer une URL pour le service qui contient l’URL complète avec un jeton d’accès valide.

   Une fois la connexion établie, votre client reçoit des messages via la connexion WebSocket. Le client utilise client.MessageReceived.Subscribe(msg => ...)); pour écouter les messages entrants.

3. Exécutez la commande pour remplacer <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment. Si vous utilisez l’interpréteur de commandes Windows, vous pouvez utiliser set au lieu de export.

   export WebPubSubConnectionString=<Web-PubSub-connection-string>
   node subscribe.js
   

1. Tout d’abord, créez un répertoire de projet appelé subscriber et installez les dépendances requises :

   mkdir subscriber
   cd subscriber
   # Create venv
   python -m venv env
   # Activate venv
   source ./env/bin/activate
   
   pip install azure-messaging-webpubsubservice
   pip install websockets
   
   

2. Utilisez l’API WebSocket pour vous connecter au service Web PubSub. Créez un fichier subscribe.py avec le code suivant :

   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
   
   

   Le code crée une connexion WebSocket qui est connectée à un hub dans Web PubSub. Le hub est une unité logique dans Web PubSub où vous pouvez publier des messages sur un groupe de clients. Les concepts clés contiennent une explication détaillée sur les termes utilisés dans Web PubSub.

   Le service Web PubSub utilise l’authentification JWT (JSON Web Token). L’exemple de code utilise WebPubSubServiceClient.GetClientAccessUri() dans le Kit de développement logiciel (SDK) Web PubSub pour générer une URL pour le service qui contient l’URL complète avec un jeton d’accès valide.

   Une fois la connexion établie, votre client recevra des messages via la connexion WebSocket. Utilisez await ws.recv() pour écouter les messages entrants.

3. Exécutez la commande suivante pour remplacer <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment :

   python subscribe.py <Web-PubSub-connection-string> "myHub1"
   

1. Tout d’abord, créez un répertoire de projet nommé pubsub pour ce didacticiel.

   mkdir pubsub
   cd pubsub
   

2. Dans le répertoire pubsub, utilisez Maven pour créer une application console appelée webpubsub-quickstart-subscriber, puis accédez au répertoire 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
   

3. Ajoutez WebSocket et le Kit de développement logiciel (SDK) Azure Web PubSub au nœud dependencies dans pom.xml :

   • azure-messaging-webpubsub : kit de développement logiciel (SDK) du service Web PubSub pour Java
   • Java-WebSocket : kit de développement logiciel (SDK) client WebSocket pour 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>
   
   

   Dans Web PubSub, vous pouvez vous connecter au service et vous abonner à des messages via des connexions WebSocket. WebSocket est un canal de communication en duplex intégral afin que le service puisse envoyer des messages à votre client en temps réel. Vous pouvez utiliser n’importe quelle API ou bibliothèque qui prend en charge WebSocket. Pour cet échantillon, nous utilisons le package Java-WebSocket.

4. Accédez au répertoire /src/main/java/com/webpubsub/quickstart.

5. Éditez le remplacement du contenu du fichier App.java par le code suivant :

   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();
       }
   }
   
   

   Ce code crée une connexion WebSocket qui est connectée à un hub dans Azure Web PubSub. Un hub est une unité logique dans Azure Web PubSub où vous pouvez publier des messages sur un groupe de clients. Les concepts clés contiennent une explication détaillée sur les termes utilisés dans Azure Web PubSub.

   Le service Web PubSub utilise l’authentification JWT (JSON Web Token). L’exemple de code utilise WebPubSubServiceClient.GetClientAccessUri() dans le Kit de développement logiciel (SDK) Web PubSub pour générer une URL pour le service qui contient l’URL complète avec un jeton d’accès valide.

   Une fois la connexion établie, votre client reçoit des messages via la connexion WebSocket. Utilisez onMessage(String message) pour écouter les messages entrants.

6. Pour démarrer l’application abonné, accédez au répertoire webpubsub-quickstart-subscriber et exécutez la commande suivante. Remplacez <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment.

   mvn compile & mvn package & mvn exec:java -Dexec.mainClass="com.webpubsub.quickstart.App" -Dexec.cleanupDaemonThreads=false -Dexec.args="<Web-PubSub-connection-string> 'myHub1'"
   

1. Tout d’abord, créez un répertoire de projet appelé publisher et installez les dépendances requises :

   mkdir publisher
   cd publisher
   dotnet new console
   dotnet add package Azure.Messaging.WebPubSub
   

2. Mettez à jour le fichier Program.cs de façon à utiliser la classe WebPubSubServiceClient et à envoyer des messages aux clients.

   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);
           }
       }
   }
   
   

   L’appel SendToAllAsync() envoie simplement un message à tous les clients connectés dans le hub.

3. Envoyez un message en exécutant la commande suivante. Remplacez <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment.

   dotnet run <Web-PubSub-connection-string> "myHub1" "Hello World"
   

4. Vérifiez que l’interpréteur de commandes de l’abonné reçoit le message :

   Message received: Hello World
   

1. Tout d’abord, créez un répertoire de projet appelé publisher et installez les dépendances requises :

   mkdir publisher
   cd publisher
   npm init -y
   npm install --save @azure/web-pubsub
   
   

2. Utilisez le Kit de développement logiciel (SDK) Azure Web PubSub pour publier un message sur le service. Créez un fichier publish.js avec le code suivant :

   const { WebPubSubServiceClient } = require('@azure/web-pubsub');
   
   const hub = "pubsub";
   let service = new WebPubSubServiceClient(process.env.WebPubSubConnectionString, hub);
   
   // by default it uses `application/json`, specify contentType as `text/plain` if you want plain-text
   service.sendToAll(process.argv[2], { contentType: "text/plain" });
   

   L’appel service.sendToAll() envoie simplement un message à tous les clients connectés dans un hub.

3. Pour envoyer un message, exécutez la commande suivante pour remplacer <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment. Si vous utilisez l’interpréteur de commandes Windows, vous pouvez utiliser set au lieu de export.

   export WebPubSubConnectionString=<Web-PubSub-connection-string>
   node publish "Hello World"
   

4. Vous pouvez voir que l’abonné précédent a reçu le message :

   Message received: Hello World
   

1. Tout d’abord, créez un répertoire de projet appelé publisher et installez les dépendances requises :

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

2. Utilisez le Kit de développement logiciel (SDK) Azure Web PubSub pour publier un message sur le service. Créez un fichier publish.py avec le code suivant :

   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() envoie le message à tous les clients connectés dans un hub.

3. Pour envoyer un message, exécutez la commande suivante pour remplacer <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment.

   python publish.py <Web-PubSub-connection-string> "myHub1" "Hello World"
   

4. Vérifiez que l’interpréteur de commandes précédent indique que l’abonné a reçu le message :

   Received message: Hello World
   

1. Accédez au répertoire pubsub. Utilisez Maven pour créer une application console d’éditeur nommée webpubsub-quickstart-publisher et accédez au répertoire 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. Ajoutez la dépendance du Kit de développement logiciel (SDK) Azure Web PubSub dans le nœud dependencies de pom.xml :

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

3. Utilisez le Kit de développement logiciel (SDK) Azure Web PubSub pour publier un message sur le service. Accédez au répertoire /src/main/java/com/webpubsub/quickstart, ouvrez le fichier App.java dans votre éditeur et remplacez le contenu par le code qui suit :

   
   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);
       }
   }
   
   

   L’appel sendToAll() envoie un message à tous les clients connectés dans un hub.

4. Pour envoyer un message, accédez au répertoire webpubsub-quickstart-publisher et exécutez le projet à l’aide de la commande suivante. Remplacez <Web-PubSub-connection-string> par la chaîne de connexion que vous avez copiée précédemment.

   mvn compile & mvn package & mvn exec:java -Dexec.mainClass="com.webpubsub.quickstart.App" -Dexec.cleanupDaemonThreads=false -Dexec.args="<Web-PubSub-connection-string> 'myHub1' 'Hello World'"
   

5. Vous pouvez voir que l’abonné précédent a reçu le message :

   Message received: Hello World