Wypychanie komunikatów z serwera

Znany model żądania HTTP/odpowiedzi został zaprojektowany tak, aby był łatwy w pracy i skalowalny. Jednak w dzisiejszych czasach użytkownicy końcowi domagają się o wiele więcej od internetu, niż pierwotnie został zaprojektowany. Protokół HTTP wymaga od użytkowników zainicjowania żądania w celu odebrania odpowiedzi. Deweloperzy potrzebują jednak sposobu wysyłania danych z serwera do klientów bez ich prośby o to; innymi słowy, muszą "wypychać " dane do klientów, takie jak wypychanie najnowszej ceny licytacji produktu na stronie aukcji lub szybkie ceny akcji w aplikacji finansowej.

W tym przewodniku Szybki start pokazano, jak

• subskrybowanie komunikatów z serwera aplikacji
• wypychanie danych z serwera aplikacji do wszystkich połączonych klientów

Ważne

Nieprzetworzone parametry połączenia są wyświetlane tylko w tym artykule w celach demonstracyjnych.

Parametry połączenia zawiera informacje o autoryzacji wymagane przez aplikację w celu uzyskania dostępu do usługi Azure Web PubSub. Klucz dostępu wewnątrz parametry połączenia jest podobny do hasła głównego usługi. W środowiskach produkcyjnych zawsze chroń klucze dostępu. Użyj usługi Azure Key Vault, aby bezpiecznie zarządzać kluczami i obracać je oraz zabezpieczać połączenie za pomocą usługi WebPubSubServiceClient.

Unikaj dystrybuowania kluczy dostępu do innych użytkowników, kodowania ich lub zapisywania ich w dowolnym miejscu w postaci zwykłego tekstu, który jest dostępny dla innych użytkowników. Obracanie kluczy, jeśli uważasz, że mogły one zostać naruszone.

Wymagania wstępne

• Zasób Web PubSub. Jeśli go nie utworzono, możesz postępować zgodnie ze wskazówkami: Tworzenie zasobu Web PubSub
• Edytor kodu, taki jak Visual Studio Code
• Instalowanie zależności dla języka, którego planujesz użyć

JavaScript

Node.js

C#

.NET Core

Python

Python

Java

• Zestaw Java Development Kit (JDK).
• Apache Maven

Tworzenie klienta subskrybenta

Aby zasubskrybować komunikaty wypychane z serwera aplikacji, klienta, przeglądarki, aplikacji mobilnej lub urządzenia IoT, należy najpierw nawiązać połączenie z zasobem Web PubSub i nasłuchuje odpowiedniego zdarzenia wiadomości.

JavaScript

Tworzenie katalogu projektu o nazwie subscriber i instalowanie wymaganych zależności

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

Nawiązywanie połączenia z zasobem Web PubSub i rejestrowanie odbiornika server-message dla zdarzenia

Klient używa adresu URL dostępu klienta do nawiązywania połączenia i uwierzytelniania za pomocą zasobu. Ten adres URL jest zgodny ze wzorcem .wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token> Klient może mieć kilka sposobów uzyskania adresu URL dostępu klienta. Na potrzeby tego przewodnika Szybki start możesz skopiować i wkleić go z witryny Azure Portal pokazanej na poniższym diagramie. Najlepszym rozwiązaniem jest, aby nie kodować twardego adresu URL dostępu klienta w kodzie. W świecie produkcyjnym zwykle konfigurujemy serwer aplikacji, aby zwracał ten adres URL na żądanie. Wygeneruj adres URL dostępu klienta opisuje szczegółowo praktykę.

Jak pokazano na powyższym diagramie, klient dołącza do centrum o nazwie myHub1.

W folderze subscriber projektu utwórz plik o nazwie z subscribe.js następującym kodem

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

Uruchamianie programu

node subscribe.js

Teraz ten klient nawiązuje połączenie z zasobem Web PubSub i jest gotowy do odbierania komunikatów wypychanych z serwera aplikacji.

C#

Tworzenie katalogu projektu o nazwie subscriber i instalowanie wymaganych zależności

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

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

Nawiązywanie połączenia z zasobem Web PubSub i rejestrowanie odbiornika ServerMessageReceived dla zdarzenia

Klient używa adresu URL dostępu klienta do nawiązywania połączenia i uwierzytelniania za pomocą zasobu. Ten adres URL jest zgodny ze wzorcem .wss://<service_name>.webpubsub.azure.com/client/hubs/<hub_name>?access_token=<token> Klient może mieć kilka sposobów uzyskania adresu URL dostępu klienta. Na potrzeby tego przewodnika Szybki start możesz skopiować i wkleić go z witryny Azure Portal pokazanej na poniższym diagramie. Najlepszym rozwiązaniem jest, aby nie kodować twardego adresu URL dostępu klienta w kodzie. W świecie produkcyjnym zwykle konfigurujemy serwer aplikacji, aby zwracał ten adres URL na żądanie. Wygeneruj adres URL dostępu klienta opisuje szczegółowo praktykę.

Jak pokazano na powyższym diagramie, klient dołącza do centrum o nazwie myHub1.

Zastąp kod w Program.cs pliku poniższym kodem

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

Uruchom następujące polecenie

dotnet run

Teraz ten klient nawiązuje połączenie z zasobem Web PubSub i jest gotowy do odbierania komunikatów wypychanych z serwera aplikacji.

Python

Utwórz katalog projektu o nazwie subscriber i zainstaluj wymagane zależności:

mkdir subscriber
cd subscriber

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

pip install azure-messaging-webpubsubservice
pip install websock

Użyj interfejsu API protokołu WebSocket, aby nawiązać połączenie z zasobem Web PubSub. subscribe.py Utwórz plik przy użyciu następującego kodu

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
    

Kod tworzy połączenie protokołu WebSocket, które jest połączone z koncentratorem w usłudze Web PubSub. Koncentrator to jednostka logiczna w usłudze Web PubSub, w której można publikować komunikaty w grupie klientów. Kluczowe pojęcia zawierają szczegółowe wyjaśnienie terminów używanych w usłudze Web PubSub.

Usługa Web PubSub używa uwierzytelniania JSON Web Token (JWT). Przykładowy kod używa WebPubSubServiceClient.GetClientAccessUri() zestawu WEB PubSub SDK do wygenerowania adresu URL usługi zawierającej pełny adres URL z prawidłowym tokenem dostępu.

Po nawiązaniu połączenia klient będzie odbierał komunikaty za pośrednictwem połączenia protokołu WebSocket. Użyj await ws.recv() polecenia , aby nasłuchiwać przychodzących wiadomości.

Uruchom następujące polecenie

python subscribe.py $connection_string "myHub1"

Java

Tworzenie katalogu projektu o nazwie pubsub

mkdir pubsub
cd pubsub

Użyj narzędzia Maven, aby utworzyć nową aplikację konsolową o nazwie 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

Dodaj zestaw WebSocket i zestaw AZURE Web PubSub SDK do węzła w pliku dependencies pom.xml:

• azure-messaging-webpubsub: internetowy zestaw SDK usługi PubSub dla języka Java
• Java-WebSocket: Zestaw SDK klienta protokołu WebSocket dla języka 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>

W usłudze Web PubSub możesz nawiązać połączenie z usługą i subskrybować komunikaty za pośrednictwem połączeń protokołu WebSocket. WebSocket to kanał komunikacji pełnodupleksowej umożliwiający usłudze wypychanie komunikatów do klienta w czasie rzeczywistym. Możesz użyć dowolnego interfejsu API lub biblioteki obsługującej protokół WebSocket. W tym przykładzie używamy pakietu Java-WebSocket.

1. Przejdź do katalogu /src/main/java/com/webpubsub/quickstart .

2. Zmodyfikuj zawartość pliku App.java następującym kodem:

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

   Ten kod tworzy połączenie protokołu WebSocket połączone z centrum w usłudze Azure Web PubSub. Koncentrator to jednostka logiczna w usłudze Azure Web PubSub, w której można publikować komunikaty w grupie klientów. Kluczowe pojęcia zawierają szczegółowe wyjaśnienie terminów używanych w usłudze Azure Web PubSub.

   Usługa Web PubSub używa uwierzytelniania JSON Web Token (JWT). Przykładowy kod używa WebPubSubServiceClient.GetClientAccessUri() zestawu WEB PubSub SDK do wygenerowania adresu URL usługi zawierającej pełny adres URL z prawidłowym tokenem dostępu.

   Po nawiązaniu połączenia klient będzie odbierał komunikaty za pośrednictwem połączenia protokołu WebSocket. Użyj onMessage(String message) polecenia , aby nasłuchiwać przychodzących wiadomości.

Uruchom aplikację za pomocą następującego polecenia

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

Wypychanie komunikatów z serwera aplikacji

Teraz, gdy masz klienta połączonego z zasobem Web PubSub, możesz wypychać komunikaty z serwera aplikacji w dowolnym momencie przy użyciu zestawu SDK serwera dostarczonego przez usługę Web PubSub.

JavaScript

Tworzenie nowego katalogu projektu o nazwie publisher i instalowanie wymaganych zależności

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

publish.js Utwórz plik przy użyciu następującego kodu

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

Wywołanie server.sendToAll() wysyła komunikat do wszystkich połączonych klientów w centrum.

Pobieranie parametrów połączenia

Ważne

Parametry połączenia zawiera informacje o autoryzacji wymagane przez aplikację w celu uzyskania dostępu do usługi Web PubSub. Klucz dostępu wewnątrz parametry połączenia jest podobny do hasła głównego usługi.

W tym przewodniku Szybki start uzyskamy go z witryny Azure Portal, jak pokazano poniżej.

Uruchamianie programu serwera

Uruchom następujące polecenia w nowej powłoce poleceń.

Nieprzetworzone parametry połączenia są wyświetlane tylko w tym artykule w celach demonstracyjnych. W środowiskach produkcyjnych zawsze chroń klucze dostępu. Użyj usługi Azure Key Vault, aby bezpiecznie zarządzać kluczami i obracać je oraz zabezpieczać połączenie za pomocą usługi WebPubSubServiceClient.

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

node publish.js "Hello World"

Obserwowanie odebranych komunikatów po stronie klienta

Spróbuj uruchomić ten sam program "subskrybuj" w wielu powłokach poleceń, aby pobudzić więcej niż klientów. Po uruchomieniu programu "publikowanie" powinny być wyświetlane komunikaty dostarczane w czasie rzeczywistym do wszystkich tych klientów.

C#

Utwórz katalog projektu o nazwie publisher i zainstaluj wymagane zależności:

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

Zastąp Program.cs plik następującym kodem

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

Wywołanie SendToAllAsync() wysyła komunikat do wszystkich połączonych klientów w centrum.

Uruchom program serwera, aby wypychać komunikaty do wszystkich połączonych klientów

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

Obserwowanie odebranych komunikatów po stronie klienta

# 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

Python

1. Najpierw utwórz katalog projektu o nazwie publisher i zainstaluj wymagane zależności:

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

2. Użyj zestawu Azure Web PubSub SDK, aby opublikować komunikat w usłudze. publish.py Utwórz plik z poniższym kodem:

   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)
   

   Komunikat send_to_all() wyślij do wszystkich połączonych klientów w koncentratonie.

3. Uruchom następujące polecenie:

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

4. Sprawdź poprzednią powłokę poleceń, aby subskrybent otrzymał komunikat:

   Received message: Hello World
   

Java

1. Przejdź do pubsub katalogu. Użyj narzędzia Maven, aby utworzyć aplikację webpubsub-quickstart-publisher konsolową wydawcy i przejść do katalogu 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. Dodaj zależność zestawu AZURE Web PubSub SDK do dependencies węzła :pom.xml

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

3. Użyj zestawu Azure Web PubSub SDK, aby opublikować komunikat w usłudze. Przejdź do katalogu /src/main/java/com/webpubsub/quickstart , otwórz plik App.java w edytorze i zastąp zawartość następującym kodem:

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

   Wywołanie sendToAll() wysyła komunikat do wszystkich połączonych klientów w centrum.

4. Przejdź do katalogu webpubsub-quickstart-publisher i uruchom projekt przy użyciu następującego polecenia:

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

5. Zobaczysz, że poprzedni subskrybent otrzymał komunikat:

   Message received: Hello World
   

Podsumowanie

W tym przewodniku Szybki start pokazano, jak łatwo wypychać komunikaty z serwera aplikacji do wszystkich połączonych klientów w centrum. Ponadto usługa Web PubSub umożliwia wypychanie komunikatów do

• podzbiór klientów w centrum
• określona grupa w centrum
• podzbiór klientów w grupie

Te interfejsy API umożliwiają korzystanie z wielu przypadków użycia, dzięki czemu deweloperzy mogą skupić się na unikatowej logice biznesowej, a jednocześnie mieć pewność, że usługa Web PubSub oferuje małe opóźnienia (<100 ms), wysoką dostępność i ogromną skalę (milion+ jednoczesne połączenia).

Następne kroki

W następnym kroku dowiemy się, jak pracować z systemem zdarzeń usługi Web PubSub, który jest niezbędny do kompilowania kompletnych aplikacji internetowych.

Powiadomienia o zdarzeniach od klientów