Enviar mensagens do servidor

Node.js

.NET Core

Python

• Java Development Kit (JDK).
• Apache Maven

Criar um diretório de projeto com o nome subscriber e instalar as dependências necessárias

mkdir subscriber
cd subscriber
npm init -y
    
# The client SDK is available as a module on NPM
npm install @azure/web-pubsub-client

Ligar ao recurso Web PubSub e registar um serviço de escuta para o server-message evento

Um cliente utiliza um URL de Acesso de Cliente para se ligar e autenticar com o recurso. Este URL segue um padrão de wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Um cliente pode ter algumas formas de obter o URL de Acesso do Cliente. Para este guia de introdução, pode copiar e colar um dos portal do Azure apresentados no diagrama seguinte. É melhor prática não codificar o URL de Acesso do Cliente no seu código. No mundo da produção, normalmente, configuramos um servidor de aplicações para devolver este URL a pedido. Gerar URL de Acesso de Cliente descreve a prática em detalhe.

Conforme mostrado no diagrama acima, o cliente associa-se ao hub com o nome myHub1.

Na pasta do subscriber projeto, crie um ficheiro com o nome subscribe.js com o seguinte código

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

Execute o programa

node subscribe.js

Agora, este cliente estabelece uma ligação com o recurso Web PubSub e está pronto para receber mensagens enviadas a partir do servidor da aplicação.

Criar um diretório de projeto com o nome subscriber e instalar as dependências necessárias

mkdir subscriber
cd subscriber
# Create a .net console app
dotnet new console

# Add the client SDK
dotnet add package Azure.Messaging.WebPubSub.Client --prerelease

Ligar ao recurso Web PubSub e registar um serviço de escuta para o ServerMessageReceived evento

Um cliente utiliza um URL de Acesso de Cliente para se ligar e autenticar com o recurso. Este URL segue um padrão de wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token>. Um cliente pode ter algumas formas de obter o URL de Acesso do Cliente. Para este guia de introdução, pode copiar e colar um dos portal do Azure apresentados no diagrama seguinte. É melhor prática não codificar o URL de Acesso do Cliente no seu código. No mundo da produção, normalmente, configuramos um servidor de aplicações para devolver este URL a pedido. Gerar URL de Acesso de Cliente descreve a prática em detalhe.

Conforme mostrado no diagrama acima, o cliente associa-se ao hub com o nome myHub1.

Substitua o código no Program.cs pelo seguinte código

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

Execute o seguinte comando

dotnet run

Agora, este cliente estabelece uma ligação com o recurso Web PubSub e está pronto para receber mensagens enviadas a partir do servidor da aplicação.

Crie um diretório de projeto com o nome subscriber e instale as dependências necessárias:

mkdir subscriber
cd subscriber

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

pip install azure-messaging-webpubsubservice
pip install websock

Utilize a API WebSocket para ligar ao recurso Web PubSub. Criar um subscribe.py ficheiro com o seguinte código

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
    

O código cria uma ligação WebSocket que está ligada a um hub no Web PubSub. Um hub é uma unidade lógica no Web PubSub onde pode publicar mensagens num grupo de clientes. Os principais conceitos contêm a explicação detalhada sobre os termos utilizados no Web PubSub.

O serviço Web PubSub utiliza a autenticação JSON Web Token (JWT ). O código de exemplo utiliza WebPubSubServiceClient.GetClientAccessUri() no SDK Web PubSub para gerar um URL para o serviço que contém o URL completo com um token de acesso válido.

Após a ligação ser estabelecida, o cliente receberá mensagens através da ligação WebSocket. Utilize await ws.recv() para ouvir mensagens recebidas.

Execute o seguinte comando

python subscribe.py $connection_string "myHub1"

Criar um diretório de projeto com o nome pubsub

mkdir pubsub
cd pubsub

Utilize o Maven para criar uma nova aplicação de consola chamada 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

Adicione o WebSocket e o SDK Azure Web PubSub ao dependencies nó em pom.xml:

• azure-messaging-webpubsub: SDK do serviço Web PubSub para Java
• Java-WebSocket: SDK de cliente WebSocket para 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>

No Web PubSub, pode ligar ao serviço e subscrever mensagens através de ligações WebSocket. O WebSocket é um canal de comunicação completo e duplex que permite que o serviço envie mensagens para o seu cliente em tempo real. Pode utilizar qualquer API ou biblioteca que suporte WebSocket. Para este exemplo, utilizamos o pacote Java-WebSocket.

1. Aceda ao diretório /src/main/java/com/webpubsub/quickstart .

2. Editar substitua o conteúdo do ficheiro App.java pelo seguinte código:

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

   Este código cria uma ligação WebSocket que está ligada a um hub no Azure Web PubSub. Um hub é uma unidade lógica no Azure Web PubSub onde pode publicar mensagens num grupo de clientes. Os principais conceitos contêm a explicação detalhada sobre os termos utilizados no Azure Web PubSub.

   O serviço Web PubSub utiliza a autenticação JSON Web Token (JWT ). O código de exemplo utiliza WebPubSubServiceClient.GetClientAccessUri() no SDK Web PubSub para gerar um URL para o serviço que contém o URL completo com um token de acesso válido.

   Após a ligação ser estabelecida, o cliente receberá mensagens através da ligação WebSocket. Utilize onMessage(String message) para ouvir mensagens recebidas.

Execute a aplicação com o seguinte comando

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

Criar um novo diretório de projeto com o nome publisher e instalar as dependências necessárias

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

Criar um publish.js ficheiro com o seguinte código

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

A server.sendToAll() chamada envia uma mensagem a todos os clientes ligados num hub.

Obter a cadeia de ligação

Para este guia de início rápido, vamos obtê-lo a partir de portal do Azure conforme mostrado abaixo.

Executar o programa de servidor

Execute os seguintes comandos numa nova shell de comandos.

# Set the environment variable for your connection string.
export WebPubSubConnectionString="<Put your connection string here>" 

node publish.js "Hello World"

Observar as mensagens recebidas no lado do cliente

Experimente executar o mesmo programa "subscrever" em várias shells de comandos para estimular mais do que os clientes. Assim que o programa de "publicação" for executado, deverá ver mensagens a serem entregues em tempo real a todos estes clientes.

Crie um diretório de projeto com o nome publisher e instale as dependências necessárias:

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

Substitua o Program.cs ficheiro pelo seguinte código

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

A SendToAllAsync() chamada envia uma mensagem a todos os clientes ligados no hub.

Executar o programa de servidor para enviar mensagens push para todos os clientes ligados

$connection_string="<connection-string>"
dotnet run $connection_string "myHub1" "Hello World"

Observar as mensagens recebidas no lado do cliente

# 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 simluates 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. Primeiro, crie um diretório de projeto com o nome publisher 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
   
   

2. Utilize o SDK do Azure Web PubSub para publicar uma mensagem no serviço. Crie um publish.py ficheiro 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)
   

   Envie send_to_all() a mensagem a todos os clientes ligados num hub.

3. Execute o seguinte comando:

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

4. Verifique a shell de comandos anterior para a qual o subscritor recebeu a mensagem:

   Received message: Hello World
   

1. Aceda ao pubsub diretório. Utilize o Maven para criar uma aplicação webpubsub-quickstart-publisher de consola do publicador e aceda ao 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
   

2. Adicione a dependência do 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>
   

3. Utilize o SDK do Azure Web PubSub para publicar uma mensagem no serviço. Aceda ao diretório /src/main/java/com/webpubsub/quickstart , abra o ficheiro App.java no seu editor e substitua os conteúdos pelo 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);
       }
   }
   
   

   A sendToAll() chamada envia uma mensagem a todos os clientes ligados num hub.

4. Aceda ao diretório webpubsub-quickstart-publisher e execute o projeto com o seguinte comando:

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

5. Pode ver que o subscritor anterior recebeu a mensagem:

   Message received: Hello World