Oktatóanyag – Üzenetek közzététele és feliratkozása a WebSocket API és az Azure Web PubSub service SDK használatával

Cikk
03/08/2024

Az Azure Web PubSub szolgáltatással egyszerűen készíthet valós idejű webes üzenetküldő alkalmazásokat. Ebben az oktatóanyagban megtudhatja, hogyan iratkozhat fel a szolgáltatásra a WebSocket API használatával, és hogyan tehet közzé üzeneteket a Web PubSub szolgáltatás SDK-val.

Ebben az oktatóanyagban az alábbiakkal fog megismerkedni:

Web PubSub szolgáltatáspéldány létrehozása
A WebSocket-kapcsolat létrehozásához hozza létre a teljes URL-címet
Webes PubSub-előfizetői ügyfél létrehozása üzenetek fogadásához standard WebSocket protokollal
Webes PubSub-közzétevő ügyfél létrehozása üzenetek közzétételéhez a Web PubSub service SDK használatával

Előfeltételek

Azure-előfizetés, hozzon létre egy ingyenes fiókot.
Bash-parancshéj. Használjon helyi rendszerhéjat vagy Bash-környezetet az Azure Cloud Shellben.
Ha a helyi gépen fut, telepítse az Azure CLI-t.

A windowsos cmd.exe parancshéjat bash-rendszerhéj helyett használhatja az oktatóanyag parancsainak futtatásához.

Ha a projektet helyi gépen hozza létre, telepítenie kell a használt nyelv függőségeit:

.NET Core

Azure CLI beállítása helyi fejlesztéshez

Kövesse az alábbi lépéseket az Azure CLI és a projektkörnyezet beállításához.

Nyisson meg egy parancshéjat.
Frissítsen az Azure CLI legújabb verziójára.
```
az upgrade
```
Telepítse az Azure CLI-bővítményt a Web PubSubhoz.
```
az extension add --name webpubsub
```
Jelentkezzen be az Azure CLI-be. Az utasításokat követve adja meg azure-beli hitelesítő adatait.
```
az login
```

Erőforráscsoport létrehozása

Az erőforráscsoport olyan logikai tároló, amelybe a rendszer üzembe helyezi és kezeli az Azure-erőforrásokat. Az az group create paranccsal hozzon létre egy, a eastus helyen elnevezett myResourceGroup erőforráscsoportot.

az group create --name myResourceGroup --location EastUS

1. Azure Web PubSub-példány létrehozása

Web PubSub-példány létrehozása

Az Azure CLI az webpubsub create paranccsal hozzon létre egy Web PubSub-t a létrehozott erőforráscsoportban. Az alábbi parancs létrehoz egy ingyenes Web PubSub-erőforrást a következő EastUSerőforráscsoportbanmyResourceGroup:

Minden Web PubSub-erőforrásnak egyedi névvel kell rendelkeznie. Cserélje le <az egyedi erőforrás nevét> a Web PubSub-példány nevére az alábbi parancsban.

az webpubsub create --resource-group myResourceGroup --name <your-unique-resource-name> --location EastUS --sku Free_F1

A parancs kimenete az újonnan létrehozott erőforrás tulajdonságait jeleníti meg. Jegyezze fel az alábbi két tulajdonságot:

név: A fenti paraméterben --name megadott Web PubSub név.
hostName: A példában a gazdagép neve .<your-unique-resource-name>.webpubsub.azure.com/

Ezen a ponton az Azure-fiók az egyetlen jogosult az új erőforráson végzett műveletek végrehajtására.

A kapcsolati sztring lekérése

Fontos

A kapcsolati sztring tartalmazzák azokat az engedélyezési információkat, amelyekre az alkalmazásnak szüksége van az Azure Web PubSub szolgáltatás eléréséhez. A kapcsolati sztring belüli hozzáférési kulcs hasonló a szolgáltatás gyökérjelszójához. Éles környezetben mindig ügyeljen a hozzáférési kulcsok védelmére. Az Azure Key Vault használatával biztonságosan kezelheti és elforgathatja a kulcsokat. Kerülje a hozzáférési kulcsok más felhasználók számára való terjesztését, a szigorú kódolást, illetve a mások számára hozzáférhető egyszerű szövegek mentését. Ha úgy véli, hogy illetéktelenek lettek, forgassa el a kulcsokat.

A szolgáltatás Csatlakozás ionString parancsának lekéréséhez használja az Azure CLI az webpubsub billentyűkombinációt. Cserélje le a <your-unique-resource-name> helyőrzőt az Azure Web PubSub-példány nevére.

az webpubsub key show --resource-group myResourceGroup --name <your-unique-resource-name> --query primaryConnectionString --output tsv

Másolja a kapcsolati sztring későbbi használatra.

Előfizetői ügyfél létrehozása

Az ügyfelek a standard WebSocket protokollon keresztül csatlakoznak az Azure Web PubSub szolgáltatáshoz JSON Web Token (JWT) hitelesítéssel. A szolgáltatás SDK segítő metódusokat biztosít a jogkivonat létrehozásához. Ebben az oktatóanyagban az előfizető közvetlenül létrehozza a jogkivonatot Csatlakozás ionStringből. Valós alkalmazásokban a kiszolgálóoldali alkalmazások általában a hitelesítési/engedélyezési munkafolyamatot kezelik. A munkafolyamat jobb megismeréséhez tekintse meg a csevegőalkalmazás létrehozása című oktatóanyagot.

Először hozzon létre egy projektkönyvtárat a projekthez, subscriber és telepítse a szükséges függőségeket:
- A Websocket.Client csomag egy külső csomag, amely támogatja a WebSocket-kapcsolatokat. A WebSocketet támogató API-t/kódtárakat használhatja.
- Az SDK-csomag Azure.Messaging.WebPubSub segít létrehozni a JWT-jogkivonatot.
```
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
```

Cserélje le a kódot a Program.cs következő kódra, amely csatlakozik a szolgáltatáshoz:

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

A kód létrehoz egy WebSocket-kapcsolatot, amely egy Web PubSub-központhoz csatlakozik. A központ egy logikai egység a Web PubSubban, ahol üzeneteket tehet közzé ügyfelek egy csoportjában. A fő fogalmak a Web PubSubban használt kifejezések részletes magyarázatát tartalmazzák.

A Web PubSub szolgáltatás JSON Web Token (JWT) hitelesítést használ. A mintakód a Web PubSub SDK-ban egy WebPubSubServiceClient.GetClientAccessUri() OLYAN URL-címet hoz létre a szolgáltatáshoz, amely érvényes hozzáférési jogkivonattal tartalmazza a teljes URL-címet.

A kapcsolat létrejötte után az ügyfél a WebSocket-kapcsolaton keresztül fogad üzeneteket. Az ügyfél figyeli client.MessageReceived.Subscribe(msg => ...)); a bejövő üzeneteket.

Az előfizető elindításához futtassa a következő parancsot a korábban másolt kapcsolati sztring helyett<Web-PubSub-connection-string>:
```
dotnet run <Web-PubSub-connection-string> "myHub1"
```

Először hozzon létre egy projektkönyvtárat nevesített subscriber és telepítse a szükséges függőségeket:
```
mkdir subscriber
cd subscriber
npm init -y
npm install --save ws
npm install --save @azure/web-pubsub
```
A Web PubSub szolgáltatáshoz a WebSocket API használatával csatlakozhat. Hozzon létre egy subscribe.js fájlt a következő kóddal:
```
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();
```
A kód létrehoz egy WebSocket-kapcsolatot, amely egy Web PubSub-központhoz csatlakozik. A központ egy logikai egység a Web PubSubban, ahol üzeneteket tehet közzé ügyfelek egy csoportjában. A fő fogalmak a Web PubSubban használt kifejezések részletes magyarázatát tartalmazzák.

A Web PubSub szolgáltatás JSON Web Token (JWT) hitelesítést használ. A mintakód a Web PubSub SDK-ban egy WebPubSubServiceClient.GetClientAccessUri() OLYAN URL-címet hoz létre a szolgáltatáshoz, amely érvényes hozzáférési jogkivonattal tartalmazza a teljes URL-címet.

A kapcsolat létrejötte után az ügyfél a WebSocket-kapcsolaton keresztül fogad üzeneteket. Az ügyfél figyeli client.MessageReceived.Subscribe(msg => ...)); a bejövő üzeneteket.
Futtassa a következő parancsot a korábban másolt kapcsolati sztring lecserélve<Web-PubSub-connection-string>. Ha Windows parancshéjat használ, használhatja ahelyettexport, hogy set .
```
export WebPubSubConnectionString=<Web-PubSub-connection-string>
node subscribe.js
```

Először hozzon létre egy projektkönyvtárat nevesített subscriber és telepítse a szükséges függőségeket:

mkdir subscriber
cd subscriber
# Create venv
python -m venv env
# Activate venv
source ./env/bin/activate

pip install azure-messaging-webpubsubservice
pip install websockets

A Web PubSub szolgáltatáshoz a WebSocket API használatával csatlakozhat. Hozzon létre egy subscribe.py fájlt a következő kóddal:
```
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
```
A kód létrehoz egy WebSocket-kapcsolatot, amely egy Web PubSub-központhoz csatlakozik. A központ egy logikai egység a Web PubSubban, ahol üzeneteket tehet közzé ügyfelek egy csoportjában. A fő fogalmak a Web PubSubban használt kifejezések részletes magyarázatát tartalmazzák.

A Web PubSub szolgáltatás JSON Web Token (JWT) hitelesítést használ. A mintakód a Web PubSub SDK-ban egy WebPubSubServiceClient.GetClientAccessUri() OLYAN URL-címet hoz létre a szolgáltatáshoz, amely érvényes hozzáférési jogkivonattal tartalmazza a teljes URL-címet.

A kapcsolat létrejötte után az ügyfél a WebSocket-kapcsolaton keresztül fogad üzeneteket. A bejövő üzenetek figyelésére használható await ws.recv() .
Futtassa a következő parancsot a korábban másolt kapcsolati sztring lecserélésével<Web-PubSub-connection-string>:
```
python subscribe.py <Web-PubSub-connection-string> "myHub1"
```

Először hozzon létre egy projektkönyvtárat az oktatóanyaghoz.pubsub
```
mkdir pubsub
cd pubsub
```

A címtárban pubsub a Maven használatával hozzon létre egy új, úgynevezett webpubsub-quickstart-subscriberkonzolalkalmazást, majd nyissa meg a webpubsub-quickstart-subscriber könyvtárat:

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

A WebSocket és az Azure Web PubSub SDK hozzáadása a dependencies következő csomóponthoz pom.xml:
- azure-messaging-webpubsub: Web PubSub service SDK for Java
- Java-WebSocket: WebSocket ügyféloldali SDK For 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>
```
A Web PubSubban csatlakozhat a szolgáltatáshoz, és a WebSocket-kapcsolatokon keresztül előfizethet az üzenetekre. A WebSocket egy teljes kétoldalas kommunikációs csatorna, amely lehetővé teszi, hogy a szolgáltatás valós időben küldjön üzeneteket az ügyfélnek. A WebSocketet támogató API-t vagy kódtárat használhatja. Ebben a példában Java-WebSocket csomagot használunk.
Nyissa meg a /src/main/java/com/webpubsub/quickstart könyvtárat.

Edit cserélje le a App.java fájl tartalmát a következő kódra:

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

Ez a kód létrehoz egy WebSocket-kapcsolatot, amely egy Azure Web PubSub-központhoz csatlakozik. A központ egy logikai egység az Azure Web PubSubban, ahol üzeneteket tehet közzé ügyfelek egy csoportjában. A fő fogalmak az Azure Web PubSubban használt kifejezések részletes magyarázatát tartalmazzák.

A kapcsolat létrejötte után az ügyfél a WebSocket-kapcsolaton keresztül fogad üzeneteket. A bejövő üzenetek figyelésére használható onMessage(String message) .

Az előfizetői alkalmazás elindításához nyissa meg a webpubsub-quickstart-subscriber könyvtárat, és futtassa a következő parancsot. Cserélje le <Web-PubSub-connection-string> a korábban másolt kapcsolati sztring.
```
mvn compile & mvn package & mvn exec:java -Dexec.mainClass="com.webpubsub.quickstart.App" -Dexec.cleanupDaemonThreads=false -Dexec.args="<Web-PubSub-connection-string> 'myHub1'"
```

2. Üzenetek közzététele a Service SDK használatával

Hozzon létre egy közzétevőt az Azure Web PubSub SDK használatával, hogy üzenetet tegyen közzé a csatlakoztatott ügyfélen. Ehhez a projekthez egy másik parancshéjat kell megnyitnia.

Először hozzon létre egy projektkönyvtárat nevesített publisher és telepítse a szükséges függőségeket:
```
mkdir publisher
cd publisher
dotnet new console
dotnet add package Azure.Messaging.WebPubSub
```

Frissítse a fájlt az Program.csWebPubSubServiceClient osztály használatára, és küldjön üzeneteket az ügyfeleknek.

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() hívás egyszerűen üzenetet küld a központ összes csatlakoztatott ügyfélének.

Küldjön üzenetet az alábbi parancs futtatásával. Cserélje le <Web-PubSub-connection-string> a korábban másolt kapcsolati sztring.
```
dotnet run <Web-PubSub-connection-string> "myHub1" "Hello World"
```
Ellenőrizze az előfizető parancshéját, hogy megkapta-e az üzenetet:
```
Message received: Hello World
```

Először hozzon létre egy projektkönyvtárat nevesített publisher és telepítse a szükséges függőségeket:
```
mkdir publisher
cd publisher
npm init -y
npm install --save @azure/web-pubsub
```

Az Azure Web PubSub SDK használatával közzétehet egy üzenetet a szolgáltatásban. Hozzon létre egy publish.js fájlt az alábbi kóddal:

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

A service.sendToAll() hívás egyszerűen üzenetet küld a központ összes csatlakoztatott ügyfélének.

Üzenet küldéséhez futtassa az alábbi parancsot a korábban másolt kapcsolati sztring lecserélve<Web-PubSub-connection-string>. Ha Windows parancshéjat használ, használhatja ahelyettexport, hogy set .
```
export WebPubSubConnectionString=<Web-PubSub-connection-string>
node publish "Hello World"
```
Láthatja, hogy az előfizető megkapta az üzenetet:
```
Message received: Hello World
```

Először hozzon létre egy projektkönyvtárat nevesített publisher és telepítse a szükséges függőségeket:

mkdir publisher
cd publisher
# Create venv
python -m venv env
# Active venv
source ./env/bin/activate

pip install azure-messaging-webpubsubservice

Az Azure Web PubSub SDK használatával közzétehet egy üzenetet a szolgáltatásban. Hozzon létre egy publish.py fájlt az alábbi kóddal:

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)

Az send_to_all() üzenet küldése az összes csatlakoztatott ügyfélnek egy központban.

Üzenet küldéséhez futtassa az alábbi parancsot a korábban másolt kapcsolati sztring lecserélve<Web-PubSub-connection-string>.
```
python publish.py <Web-PubSub-connection-string> "myHub1" "Hello World"
```
Ellenőrizze az előző parancshéjat, hogy az előfizető megkapta-e az üzenetet:
```
Received message: Hello World
```

Nyissa meg a pubsub könyvtárat. A Maven használatával hozzon létre egy közzétevői konzolalkalmazást webpubsub-quickstart-publisher , és lépjen a webpubsub-quickstart-publisher könyvtárra:

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

Adja hozzá az Azure Web PubSub SDK-függőséget a dependencies következő csomóponthoz pom.xml:

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

Az Azure Web PubSub SDK használatával közzétehet egy üzenetet a szolgáltatásban. Nyissa meg a /src/main/java/com/webpubsub/quickstart könyvtárat, nyissa meg a App.java fájlt a szerkesztőben, és cserélje le a tartalmat a következő kódra:


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() hívás üzenetet küld a központ összes csatlakoztatott ügyfélének.

Üzenet küldéséhez lépjen a webpubsub-quickstart-publisher könyvtárba, és futtassa a projektet az alábbi paranccsal. Cserélje le a <Web-PubSub-connection-string> korábban másolt kapcsolati sztring.
```
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'"
```
Láthatja, hogy az előfizető megkapta az üzenetet:
```
Message received: Hello World
```

Felesleges tartalmak törlése

Az ebben a rövid útmutatóban létrehozott erőforrások törléséhez törölje azokat tartalmazó erőforráscsoportot.

az group delete --name myResourceGroup --yes

Ha nem tervezi folytatni az Azure Cloud Shell használatát, elkerülheti a költségek halmozását a társított tárfiókot tartalmazó erőforráscsoport törlésével. Az erőforráscsoport neve cloud-shell-storage-<your-region>. Futtassa a következő parancsot a Cloud Shell-csoport nevére cserélve <CloudShellResourceGroup> .

az group delete --name <CloudShellResourceGroup> --yes

Figyelemfelhívás

Az erőforráscsoportok törlése az összes erőforrást törli, beleértve az oktatóanyag hatókörén kívül létrehozott erőforrásokat is.

Következő lépések

Ez az oktatóanyag bemutatja, hogyan csatlakozhat a Web PubSub szolgáltatáshoz, és hogyan tehet közzé üzeneteket a csatlakoztatott ügyfeleknek.

A szolgáltatás használatának további megismeréséhez tekintse meg a többi oktatóanyagot.

Oktatóanyag: Csevegőszoba létrehozása az Azure Web PubSub használatával

További Azure Web PubSub-minták felfedezése

Oktatóanyag: Üzenetek közzététele és feliratkozása a WebSocket API és az Azure Web PubSub service SDK használatával