Guia de início rápido: publicar mensagens usando o SDK do serviço Azure Web PubSub

O Azure Web PubSub ajuda você a gerenciar clientes WebSocket. Este guia de início rápido mostra como publicar mensagens em clientes WebSocket usando o SDK do serviço Azure Web PubSub.

Pré-requisitos

Uma assinatura do Azure, se você não tiver uma, crie uma conta gratuita.
um shell de comando Bash e PowerShell. Os exemplos de Python, JavaScript e Java requerem um shell de comando Bash.
Um editor de arquivos, como o VS Code.
CLI do Azure: instalar a CLI do Azure

Se estiver criando o projeto em uma máquina local, você precisará instalar as dependências para o idioma que está usando:

Instale o SDK do .NET Core e o aspnetcore tempo de execução e dotnet.

Núcleo do .NET

1. Configuração

Para entrar no Azure a partir da CLI, execute o seguinte comando e siga os prompts para concluir o processo de autenticação. Se você estiver usando o Cloud Shell, não é necessário fazer login.

az login

Verifique se você está executando a versão mais recente da CLI por meio do comando upgrade.

az upgrade

Em seguida, instale ou atualize a extensão Azure Web PubSub para a CLI, caso ela não tenha sido instalada com az upgradeo .

az extension add --name webpubsub --upgrade

1. Criar um grupo de recursos

Defina as seguintes variáveis de ambiente. Substitua o espaço reservado <> por um nome exclusivo do Web PubSub.

Bash
Azure PowerShell

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

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

Crie um grupo de recursos para o projeto Web PubSub.

Bash
Azure PowerShell

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

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

2. Implantar uma instância de serviço Web PubSub

Use o az webpubsub create comando para criar e implantar uma instância de serviço 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

Salve a cadeia de conexão do serviço. A cadeia de conexão é usada pelo SDK do serviço para publicar mensagens.

Importante

Em um ambiente de produção, você deve armazenar cadeias de conexão com segurança usando o Cofre de Chaves do Azure.

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. Conectar um cliente à instância de serviço

Crie um cliente Web PubSub. O cliente mantém uma conexão com o serviço até que ele seja encerrado.

Use o az webpubsub client comando para iniciar uma conexão de cliente WebSocket com o serviço. Os clientes sempre se conectam a um hub, portanto, forneça um nome de hub para o cliente se conectar.

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'

A conexão com o serviço Web PubSub é estabelecida quando você vê uma mensagem JSON indicando que o cliente agora está conectado com êxito e é atribuído um exclusivo connectionId:

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

4. Publicar mensagens usando o SDK do serviço

Você usará o SDK do Azure Web PubSub para publicar uma mensagem para todos os clientes conectados ao hub. Você pode escolher entre C#, JavaScript, Python e Java. As dependências para cada idioma são instaladas nas etapas para esse idioma. Python, JavaScript e Java requerem um shell bash para executar os comandos neste início rápido.

Configurar o projeto para publicar mensagens

Abra um novo shell de comando para este projeto.
Salve a cadeia de conexão do shell do cliente. Substitua o espaço reservado <your_connection_string> pela cadeia de conexão exibida em uma etapa anterior.
- Bash
- Azure PowerShell
```
connection_string="<your_connection_string>"
```
```
$connection_string = "<your_connection_string>"
```
Agora, selecione o idioma para o seu projeto.

Adicione um novo projeto chamado publisher e o pacote Azure.Messaging.WebPubSubSDK .

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

Atualize o Program.cs arquivo para usar a WebPubSubServiceClient classe para enviar mensagens aos clientes. Substitua o código no Program.cs arquivo com o código a seguir.

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

A service.SendToAllAsync() chamada simplesmente envia uma mensagem para todos os clientes conectados no hub.

Execute o seguinte comando para publicar uma mensagem no serviço.
```
dotnet run $connection_string "myHub1" "Hello World"
```
O shell de comando anterior que contém o cliente Web PubSub mostra a mensagem recebida.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Crie uma nova pasta com o nome publisher deste projeto e instale as dependências necessárias:
```
mkdir publisher
cd publisher
npm init -y
npm install --save @azure/web-pubsub
```

Use o SDK do Azure Web PubSub para publicar uma mensagem no serviço. Crie um publish.js arquivo contendo o código:

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

A sendToAll() chamada simplesmente envia uma mensagem para todos os clientes conectados em um hub.

Execute o seguinte comando para publicar uma mensagem no serviço:

export WebPubSubConnectionString=$connection_string
node publish "Hello World"

O shell de comando anterior que contém o cliente Web PubSub mostra a mensagem recebida.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Crie uma nova pasta com o nome publisher deste projeto e instale as dependências necessárias:

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

Use o SDK do Azure Web PubSub para publicar uma mensagem no serviço. Crie um publish.py arquivo com o código abaixo:

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)

O service.send_to_all() método envia a mensagem para todos os clientes conectados em um hub.

Execute o seguinte comando para publicar uma mensagem no serviço:
```
python publish.py $connection_string "myHub1" "Hello World"
```
O shell de comando anterior que contém o cliente Web PubSub mostra a mensagem recebida.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Use o Maven para criar um novo aplicativo de console chamado webpubsub-quickstart-publisher e vá para o diretório 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

Adicione o SDK do Azure Web PubSub ao dependencies nó de pom.xml:

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

Vá para o diretório src/main/java/com/webpubsub/quickstart .

Substitua o conteúdo no arquivo App.java com o seguinte código:

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

Esse código usa o SDK do Azure Web PubSub para publicar uma mensagem no serviço. A service.sendToAll() chamada envia uma mensagem para todos os clientes conectados em um hub.

Retorne t o diretório webpubsub-quickstart-publisher que contém o arquivo pom.xml e compile o projeto usando o seguinte mvn comando.
```
mvn compile
```
Crie o pacote.
```
mvn package
```

Execute o seguinte mvn comando para executar o aplicativo para publicar uma mensagem no serviço:

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

O shell de comando anterior que contém o cliente Web PubSub mostra a mensagem recebida.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Limpeza

Você pode excluir os recursos criados neste início rápido excluindo o grupo de recursos que os contém.

Bash
Azure PowerShell

az group delete --name $RESOURCE_GROUP --yes

az group delete --name $ResourceGroup --yes

Próximos passos

Este guia de início rápido fornece uma ideia básica de como se conectar ao serviço Web PubSub e como publicar mensagens para os clientes conectados.

Em aplicativos do mundo real, você pode usar SDKs em várias linguagens para criar seu próprio aplicativo. Nós também fornecemos extensões de função para você construir aplicativos sem servidor facilmente.

Use estes recursos para começar a criar seu próprio aplicativo:

Tutorial: Publicar e subscrever mensagens no Azure Web PubSub

Tutorial: Criar uma sala de chat simples com o Azure Web PubSub

Tutorial: Usar um subprotocolo suportado por serviço para streaming de cliente

Tutorial: Criar chat sem servidor com o Azure Functions e o Web PubSub

Tutorial: Configurar um ouvinte de eventos

Jogue com demonstrações ao vivo

Explore mais exemplos do Azure Web PubSub