Démarrage rapide : Publier des messages en utilisant le Kit de développement logiciel (SDK) du service Azure Web PubSub

Article
04/03/2023

Azure Web PubSub vous aide à gérer les clients WebSocket. Ce guide de démarrage rapide vous montre comment publier des messages à des clients WebSocket à l’aide du Kit de développement logiciel (SDK) du service Azure Web PubSub.

Prérequis

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit.
un interpréteur de commandes Bash et PowerShell. Les exemples Python, JavaScript et Java nécessitent un interpréteur de commandes Bash.
Un éditeur de fichiers tel que VSCode.
Azure CLI : installer Azure CLI

Si vous créez le projet sur un ordinateur local, vous devez installer les dépendances pour le langage que vous utilisez :

Installez à la fois le kit SDK .NET Core et aspnetcore et le runtime .Net.

.NET Core

1. Configurer

Pour vous connecter à Azure à partir de l’interface CLI, exécutez la commande suivante et suivez les invites pour procéder à l’authentification. Si vous utilisez Cloud Shell, il n’est pas nécessaire de se connecter.

az login

Vérifiez que vous exécutez la dernière version de l’interface CLI à l’aide de la commande de mise à niveau.

az upgrade

Ensuite, installez ou mettez à jour l’extension Azure Web PubSub pour l’interface CLI, si elle n’a pas été installée avec az upgrade.

az extension add --name webpubsub --upgrade

1. Créer un groupe de ressources

Définissez les variables d’environnement suivantes. Remplacez l’<espace réservé> par un nom Web PubSub unique.

Bash
Azure PowerShell

RESOURCE_GROUP="webpubsub-resource-group"
LOCATION="EastUS"
WEB_PUBSUB_NAME="<your-unique-name>"

$ResourceGroupName = 'webpubsub-resource-group'
$Location = 'EastUS'
$WebPubSubName = '<YourUniqueName>'

Créez un groupe de ressources pour le projet Web PubSub.

Bash
Azure PowerShell

az group create \
  --name $RESOURCE_GROUP \
  --location $LOCATION

az group create --location $Location --name $ResourceGroupName

2. Déployer une instance de service Web PubSub

Utilisez la commande az webpubsub create pour créer et déployer une instance de service Web PubSub.

Bash
Azure PowerShell

az webpubsub create \
  --name $WEB_PUBSUB_NAME \
  --resource-group $RESOURCE_GROUP \
  --location $LOCATION \
  --sku Free_F1

az webpubsub create `
  --name $WebPubSubName `
  --location $Location `
  --resource-group $ResourceGroupName `
  --sku Free_F1

Enregistrez la chaîne de connexion du service. La chaîne de connexion est utilisée par le Kit de développement logiciel (SDK) de service pour publier des messages.

Important

Dans un environnement de production, vous devez stocker en toute sécurité les chaînes de connexion à l’aide d’Azure Key Vault.

Bash
Azure PowerShell

az webpubsub key show --name $WEB_PUBSUB_NAME --resource-group $RESOURCE_GROUP --query primaryConnectionString

az webpubsub key show --name $WebPubSubName --resource-group $ResourceGroupName --query primaryConnectionString

3. Connecter un client à l’instance de service

Créez un client Web PubSub. Le client maintient une connexion au service jusqu’à son arrêt.

Utilisez la commande az webpubsub client pour démarrer une connexion cliente WebSocket au service. Les clients se connectent toujours à un hub. Indiquez donc un nom de hub auquel le client doit se connecter.

Bash
Azure PowerShell

az webpubsub client start \
  --name $WEB_PUBSUB_NAME \
  --resource-group $RESOURCE_GROUP \
  --hub-name "myHub1" \
  --user-id "user1"

az webpubsub client start `
  --name $WebPubSubName `
  --resource-group $ResourceGroupName `
  --hub-name 'myHub1' `
  --user-id 'user1'

La connexion au service Web PubSub est établie lorsque vous recevez un message JSON indiquant que le client est désormais connecté avec succès et qu’il est attribué avec un connectionId unique :

{"type":"system","event":"connected","userId":"user1","connectionId":"<your_unique_connection_id>"}

4. Publier des messages à l’aide du Kit de développement logiciel (SDK) de service

Vous allez utiliser le Kit de développement logiciel (SDK) Azure Web PubSub pour publier un message à tous les clients connectés au hub. Vous pouvez choisir entre C#, JavaScript, Python et Java. Les dépendances de chaque langage sont installées dans les étapes de ce langage. Python, JavaScript et Java nécessitent un interpréteur de commandes Bash pour exécuter les commandes de ce démarrage rapide.

Configurer le projet pour publier des messages

Ouvrez un nouvel interpréteur de commandes pour ce projet.
Enregistrez la chaîne de connexion à partir de l’interpréteur de commandes client. Remplacez l’espace réservé <your_connection_string> par la chaîne de connexion que vous avez affichée à une étape précédente.
- Bash
- Azure PowerShell
```
connection_string="<your_connection_string>"
```
```
$connection_string = "<your_connection_string>"
```
À présent, sélectionnez le langage de votre projet.

Ajoutez un nouveau projet appelé publisher et le package du Kit de développement logiciel (SDK) Azure.Messaging.WebPubSub.
```
mkdir publisher
cd publisher
dotnet new console
dotnet add package Azure.Messaging.WebPubSub
```

Mettez à jour le fichier Program.cs de façon à utiliser la classe WebPubSubServiceClient pour envoyer des messages aux clients. Remplacez le code du fichier Program.cs par le code suivant.

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];

            var service = new WebPubSubServiceClient(connectionString, hub);

            // Send messages to all the connected clients
            // You can also try SendToConnectionAsync to send messages to the specific connection
            await service.SendToAllAsync(message);
        }
    }
}

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

Exécutez la commande suivante pour publier un message sur le service.
```
dotnet run $connection_string "myHub1" "Hello World"
```
L’interpréteur de commandes précédent contenant le client Web PubSub affiche le message reçu.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Créez un nouveau dossier appelé publisher pour ce projet et installez les dépendances requises :
```
mkdir publisher
cd publisher
npm init -y
npm install --save @azure/web-pubsub
```

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

const { WebPubSubServiceClient } = require('@azure/web-pubsub');

if (process.argv.length !== 3) {
  console.log('Usage: node publish <message>');
  return 1;
}
const hub = "myHub1";
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 sendToAll() envoie simplement un message à tous les clients connectés dans un hub.

Exécutez la commande suivante pour publier un message sur le service :

export WebPubSubConnectionString=$connection_string
node publish "Hello World"

L’interpréteur de commandes précédent contenant le client Web PubSub affiche le message reçu.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Créez un nouveau dossier appelé publisher pour ce projet 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

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 ci-dessous :

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

Exécutez la commande suivante pour publier un message sur le service :
```
python publish.py $connection_string "myHub1" "Hello World"
```
L’interpréteur de commandes précédent contenant le client Web PubSub affiche le message reçu.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Utilisez Maven pour créer une application console 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

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

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

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

Remplacez le contenu du fichier App.java par le code suivant :

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

Ce code utilise le Kit de développement logiciel (SDK) Azure Web PubSub pour publier un message sur le service. L’appel service.sendToAll() envoie un message à tous les clients connectés dans un hub.

Retournez au répertoire webpubsub-quickstart-publisher contenant le fichier pom.xml, puis compilez le projet à l’aide de la commande mvn suivante.
```
mvn compile
```
Générer le package.
```
mvn package
```

Exécutez la commande mvn suivante pour exécuter l’application afin de publier un message sur le service :

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

L’interpréteur de commandes précédent contenant le client Web PubSub affiche le message reçu.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Nettoyage

Vous pouvez supprimer les ressources que vous avez créées dans ce guide de démarrage rapide en supprimant le groupe de ressources qui les contient.

Bash
Azure PowerShell

az group delete --name $RESOURCE_GROUP --yes

az group delete --name $ResourceGroup --yes

Étapes suivantes

Ce tutoriel donne une idée de base de la procédure à suivre pour se connecter au service Web PubSub et publier des messages sur les clients connectés.

Dans les applications réelles, vous pouvez utiliser des kits de développement logiciel (SDK) dans différents langages pour créer votre propre application. Nous fournissons également des extensions de fonction qui vous permettent de créer facilement des applications serverless.

Utilisez ces ressources pour commencer à créer votre propre application :

Tutoriel : Publier et s’abonner à des messages dans Azure Web PubSub

Tutoriel : Créer un salon de conversation simple avec Azure Web PubSub

Tutoriel : Utiliser un sous-protocole pris en charge par le service pour le streaming client

Tutoriel : Créer une conversation serverless avec Azure Functions et Web PubSub

Tutoriel : Configurer un détecteur d’événements

Expérimenter des démonstrations en direct

Explorer d’autres exemples Azure Web PubSub