Szybki start: publikowanie komunikatów przy użyciu zestawu SDK usługi Azure Web PubSub

Usługa Azure Web PubSub ułatwia zarządzanie klientami protokołu WebSocket. W tym przewodniku Szybki start pokazano, jak publikować komunikaty na klientach protokołu WebSocket przy użyciu zestawu SDK usługi Azure Web PubSub.

Wymagania wstępne

Subskrypcja platformy Azure, jeśli jej nie masz, utwórz bezpłatne konto.
powłoka poleceń powłoki Bash i PowerShell. Przykłady języków Python, JavaScript i Java wymagają powłoki poleceń powłoki Bash.
Edytor plików, taki jak VS Code.
Interfejs wiersza polecenia platformy Azure: instalowanie interfejsu wiersza polecenia platformy Azure

Jeśli tworzysz projekt na komputerze lokalnym, musisz zainstalować zależności dla używanego języka:

Zainstaluj zarówno zestaw .NET Core SDK, jak i środowisko uruchomieniowe aspnetcore i dotnet.

.NET Core

1. Konfiguracja

Aby zalogować się do platformy Azure z poziomu interfejsu wiersza polecenia, uruchom następujące polecenie i postępuj zgodnie z monitami, aby ukończyć proces uwierzytelniania. Jeśli korzystasz z Cloud Shell, nie musisz się logować.

az login

Upewnij się, że używasz najnowszej wersji interfejsu wiersza polecenia za pomocą polecenia uaktualnienia.

az upgrade

Następnie zainstaluj lub zaktualizuj rozszerzenie Azure Web PubSub dla interfejsu wiersza polecenia, jeśli nie zostało zainstalowane za pomocą az upgrade.

az extension add --name webpubsub --upgrade

1. Tworzenie grupy zasobów

Ustaw następujące zmienne środowiskowe. Zastąp <symbol zastępczy> unikatową nazwą 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>'

Utwórz grupę zasobów dla projektu Web PubSub.

Bash
Azure PowerShell

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

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

2. Wdrażanie instancji usługi Web PubSub

Użyj polecenia, az webpubsub create aby utworzyć i wdrożyć wystąpienie usługi 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

Zapisz parametry połączenia usługi. Parametry połączenia są używane przez zestaw SDK usługi do publikowania komunikatów.

Ważne

W środowisku produkcyjnym parametry połączenia należy bezpiecznie przechowywać przy użyciu usługi 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. Łączenie klienta z wystąpieniem usługi

Utwórz klienta Web PubSub. Klient utrzymuje połączenie z usługą do momentu jej zakończenia.

Użyj polecenia, az webpubsub client aby uruchomić połączenie klienta protokołu WebSocket z usługą. Klienci zawsze łączą się z koncentratorem, dlatego podaj nazwę koncentratora, z którym klient ma się połączyć.

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'

Połączenie z usługą Web PubSub jest nawiązywane, gdy zostanie wyświetlony komunikat JSON wskazujący, że klient został pomyślnie połączony i ma przypisany unikatowy connectionId:

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

4. Publikowanie wiadomości przy użyciu zestawu SDK usługi

Użyjesz zestawu Azure Web PubSub SDK, aby opublikować komunikat do wszystkich klientów połączonych z centrum. Możesz wybierać między C#, JavaScript, Python i Java. Zależności dla każdego języka są instalowane w krokach dla tego języka. Języki Python, JavaScript i Java wymagają powłoki bash do uruchamiania poleceń w tym przewodniku Szybki start.

Konfigurowanie projektu do publikowania wiadomości

Otwórz nową powłokę poleceń dla tego projektu.
Zapisz parametry połączenia z powłoki klienta. Zastąp <your_connection_string> symbol zastępczy parametrami połączenia wyświetlonymi we wcześniejszym kroku.
- Bash
- Azure PowerShell
```
connection_string="<your_connection_string>"
```
```
$connection_string = "<your_connection_string>"
```
Teraz wybierz język dla swojego projektu.

Dodaj nowy projekt o nazwie publisher i pakiet Azure.Messaging.WebPubSubSDK.

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

Zaktualizuj plik, Program.cs aby używał WebPubSubServiceClient klasy do wysyłania komunikatów do klientów. Zastąp kod w Program.cs pliku 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];

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

Połączenie service.SendToAllAsync() po prostu wysyła wiadomość do wszystkich podłączonych klientów w hubie.

Uruchom następujące polecenie, aby opublikować komunikat w usłudze.
```
dotnet run $connection_string "myHub1" "Hello World"
```
Poprzednia powłoka poleceń zawierająca klienta Web PubSub pokazuje odebrany komunikat.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Utwórz nowy folder o nazwie publisher dla tego projektu i zainstaluj wymagane zależności:
```
mkdir publisher
cd publisher
npm init -y
npm install --save @azure/web-pubsub
```

Użyj zestawu Azure Web PubSub SDK, aby opublikować komunikat w usłudze. publish.js Utwórz plik zawierający kod:

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

Wywołanie sendToAll() po prostu wysyła wiadomość do wszystkich podłączonych klientów w hubie.

Uruchom następujące polecenie, aby opublikować komunikat w usłudze:

export WebPubSubConnectionString=$connection_string
node publish "Hello World"

Poprzednia powłoka poleceń zawierająca klienta Web PubSub pokazuje odebrany komunikat.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Utwórz nowy folder o nazwie publisher dla tego projektu 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

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)

Metoda service.send_to_all() wysyła komunikat do wszystkich połączonych klientów w hubie.

Uruchom następujące polecenie, aby opublikować komunikat w usłudze:
```
python publish.py $connection_string "myHub1" "Hello World"
```
Poprzednia powłoka poleceń zawierająca klienta Web PubSub pokazuje odebrany komunikat.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

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

Dodaj zestaw Azure Web PubSub SDK do węzła dependenciespom.xml:

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

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

Zastąp zawartość pliku App.java 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);
    }
}

Ten kod używa zestawu Azure Web PubSub SDK do publikowania komunikatu w usłudze. Wywołanie service.sendToAll() wysyła komunikat do wszystkich połączonych klientów w hubie.

Zwróć katalog webpubsub-quickstart-publisher zawierający plik pom.xml i skompiluj projekt przy użyciu następującego mvn polecenia.
```
mvn compile
```
Skompiluj pakiet.
```
mvn package
```

Uruchom następujące mvn polecenie, aby uruchomić aplikację w celu opublikowania komunikatu w usłudze:

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

Poprzednia powłoka poleceń zawierająca klienta Web PubSub pokazuje odebrany komunikat.
```
{"type":"message","from":"server","dataType":"text","data":"Hello World"}
```

Sprzątanie

Zasoby utworzone w tym przewodniku Szybki start można usunąć, usuwając grupę zasobów, która je zawiera.

Bash
Azure PowerShell

az group delete --name $RESOURCE_GROUP --yes

az group delete --name $ResourceGroup --yes

Dalsze kroki

Ten przewodnik Szybki start zawiera podstawowe informacje na temat nawiązywania połączenia z usługą Web PubSub i publikowania komunikatów na połączonych klientach.

W rzeczywistych aplikacjach można używać zestawów SDK w różnych językach tworzących własną aplikację. Udostępniamy również rozszerzenia funkcji do łatwego kompilowania aplikacji bezserwerowych.

Użyj tych zasobów, aby rozpocząć tworzenie własnej aplikacji:

Samouczek: publikowanie i subskrybowanie komunikatów w usłudze Azure Web PubSub

Samouczek: tworzenie prostego czatroomu za pomocą usługi Azure Web PubSub

Poradnik: użycie subprotokołu obsługiwanego przez usługę do przesyłania strumieniowego klienta

Samouczek: tworzenie czatu bezserwerowego za pomocą usług Azure Functions i Web PubSub

Samouczek: konfigurowanie nasłuchiwacza zdarzeń

Baw się pokazami na żywo

Zapoznaj się z więcej przykładów usługi Azure Web PubSub

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-06-22