Udostępnij za pośrednictwem

Wprowadzenie do obiektów WebSocket połączeń hybrydowych usługi Relay na platformie .NET

  • Artykuł

W tym przewodniku Szybki start utworzysz aplikacje nadawcy i odbiorcy w środowisku .NET umożliwiające wysyłanie i odbieranie komunikatów przy użyciu obiektów WebSocket połączeń hybrydowych w usłudze Azure Relay. Aby uzyskać więcej ogólnych informacji o usłudze Azure Relay, zobacz Azure Relay.

W tym przewodniku Szybki start wykonasz następujące kroki:

  1. Utworzenie przestrzeni nazw usługi Relay za pomocą witryny Azure Portal.
  2. Utworzenie połączenia hybrydowego w tej przestrzeni nazw za pomocą witryny Azure Portal.
  3. Napisanie aplikacji konsolowej serwera (odbiornika) służącej do odbierania komunikatów.
  4. Napisanie aplikacji konsolowej klienta (nadawcy) służącej do wysyłania komunikatów.
  5. Uruchamianie aplikacji.

Wymagania wstępne

Do wykonania kroków tego samouczka niezbędne jest spełnienie następujących wymagań wstępnych:

Tworzenie przestrzeni nazw

  1. Zaloguj się w witrynie Azure Portal.

  2. Wybierz pozycję Wszystkie usługi w menu po lewej stronie. Wybierz pozycję Integracja, wyszukaj pozycję Przekaźniki, przenieś wskaźnik myszy nad przekaźnikami, a następnie wybierz pozycję Utwórz.

    Zrzut ekranu przedstawiający wybór przycisku Relays —> Create (Utwórz).

  3. Na stronie Tworzenie przestrzeni nazw wykonaj następujące kroki:

    1. Wybierz subskrypcję platformy Azure, w której chcesz utworzyć przestrzeń nazw.

    2. W obszarze Grupa zasobów wybierz istniejącą grupę zasobów, w której chcesz umieścić przestrzeń nazw, lub utwórz nową.

    3. Wprowadź nazwę przestrzeni nazw usługi Relay.

    4. Wybierz region, w którym powinna być hostowana przestrzeń nazw.

    5. Wybierz pozycję Przejrzyj i utwórz w dolnej części strony.

      Zrzut ekranu przedstawiający stronę Tworzenie przestrzeni nazw.

    6. Na stronie Przeglądanie i tworzenie wybierz pozycję Utwórz.

    7. Po kilku minutach zostanie wyświetlona strona przekaźnika dla przestrzeni nazw.

      Zrzut ekranu przedstawiający stronę główną przestrzeni nazw usługi Relay.

Uzyskiwanie poświadczeń zarządzania

  1. Na stronie Przekaźnik wybierz pozycję Zasady dostępu współdzielonego w menu po lewej stronie. `

  2. Na stronie Zasady dostępu współdzielonego wybierz pozycję RootManageSharedAccessKey.

  3. W obszarze Zasady sygnatury dostępu współdzielonego: RootManageSharedAccessKey wybierz przycisk Kopiuj obok pozycji Podstawowe parametry połączenia. Ta akcja kopiuje parametry połączenia do schowka do późniejszego użycia. Wklej tę wartość do Notatnika lub innej tymczasowej lokalizacji.

  4. Powtórz poprzedni krok w celu skopiowania i wklejenia wartości pozycji Klucz podstawowy w lokalizacji tymczasowej do późniejszego użycia.

    Zrzut ekranu przedstawiający informacje o połączeniu dla przestrzeni nazw usługi Relay.

Tworzenie połączenia hybrydowego

Na stronie Przekaźnik dla przestrzeni nazw wykonaj następujące kroki, aby utworzyć połączenie hybrydowe.

  1. W menu po lewej stronie w obszarze Jednostki wybierz pozycję Połączenia hybrydowe, a następnie wybierz pozycję + Połączenie hybrydowe.

    Zrzut ekranu przedstawiający stronę Połączenia hybrydowe.

  2. Na stronie Tworzenie połączenia hybrydowego wprowadź nazwę połączenia hybrydowego, a następnie wybierz pozycję Utwórz.

    Zrzut ekranu przedstawiający stronę Tworzenie połączenia hybrydowego.

Tworzenie aplikacji serwera (odbiornika)

W programie Visual Studio napisz aplikację konsoli w języku C#, aby nasłuchiwać i odbierać komunikaty z usługi Relay.

Tworzenie aplikacji konsolowej

W programie Visual Studio utwórz nowy projekt Aplikacja konsoli (.NET Framework).

Dodawanie pakietu NuGet usługi Relay

  1. Kliknij prawym przyciskiem myszy nowo utworzony projekt, a następnie wybierz pozycję Zarządzaj pakietami NuGet.
  2. Wybierz pozycję Przeglądaj, a następnie wyszukaj pozycję Microsoft.Azure.Relay. W wynikach wyszukiwania wybierz pozycję Microsoft Azure Relay.
  3. Wybierz pozycję Zainstaluj, aby ukończyć instalację. Zamknij okno dialogowe.

Pisanie kodu w celu odbierania komunikatów

  1. Na początku pliku Program.cs zastąp istniejące instrukcje using następującymi instrukcjami using:

    using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Net;
using Microsoft.Azure.Relay;

  2. Dodaj stałe do klasy Program na potrzeby szczegółów połączenia hybrydowego. Zastąp symbole zastępcze wartościami uzyskanymi podczas tworzenia połączenia hybrydowego. Pamiętaj, aby użyć w pełni kwalifikowanej nazwy przestrzeni nazw.

    // replace {RelayNamespace} with the name of your namespace
private const string RelayNamespace = "YOUR-RELAY-NAMESPACE-NAME.servicebus.windows.net";

// replace {HybridConnectionName} with the name of your hybrid connection
private const string ConnectionName = "HYBRID-CONNECTION-NAME";

// replace {SAKKeyName} with the name of your Shared Access Policies key, which is RootManageSharedAccessKey by default
private const string KeyName = "SAS-KEY-NAME";

// replace {SASKey} with the primary key of the namespace you saved earlier
private const string Key = "SAS-KEY-VALUE";

  3. Dodaj metodę ProcessMessagesOnConnection do klasy Program:

    // The method initiates the connection.
private static async void ProcessMessagesOnConnection(HybridConnectionStream relayConnection, CancellationTokenSource cts)
{
    Console.WriteLine("New session");

    // The connection is a fully bidrectional stream. 
    // Put a stream reader and a stream writer over it.  
    // This allows you to read UTF-8 text that comes from 
    // the sender, and to write text replies back.
    var reader = new StreamReader(relayConnection);
    var writer = new StreamWriter(relayConnection) { AutoFlush = true };
    while (!cts.IsCancellationRequested)
    {
        try
        {
            // Read a line of input until a newline is encountered.
            var line = await reader.ReadLineAsync();

            if (string.IsNullOrEmpty(line))
            {
                // If there's no input data, signal that 
                // you will no longer send data on this connection,
                // and then break out of the processing loop.
                await relayConnection.ShutdownAsync(cts.Token);
                break;
            }

            // Write the line on the console.
            Console.WriteLine(line);

            // Write the line back to the client, prepended with "Echo:"
            await writer.WriteLineAsync($"Echo: {line}");
        }
        catch (IOException)
        {
            // Catch an I/O exception. This likely occurred when
            // the client disconnected.
            Console.WriteLine("Client closed connection");
            break;
        }
    }

    Console.WriteLine("End session");

    // Close the connection.
    await relayConnection.CloseAsync(cts.Token);
}

  4. Dodaj metodę RunAsync do klasy Program:

    private static async Task RunAsync()
{
    var cts = new CancellationTokenSource();

    var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
    var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);

    // Subscribe to the status events.
    listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
    listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
    listener.Online += (o, e) => { Console.WriteLine("Online"); };

    // Opening the listener establishes the control channel to
    // the Azure Relay service. The control channel is continuously 
    // maintained, and is reestablished when connectivity is disrupted.
    await listener.OpenAsync(cts.Token);
    Console.WriteLine("Server listening");

    // Provide callback for the cancellation token that will close the listener.
    cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));

    // Start a new thread that will continuously read the console.
    new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start();

    // Accept the next available, pending connection request. 
    // Shutting down the listener allows a clean exit. 
    // This method returns null.
    while (true)
    {
        var relayConnection = await listener.AcceptConnectionAsync();
        if (relayConnection == null)
        {
            break;
        }

        ProcessMessagesOnConnection(relayConnection, cts);
    }

    // Close the listener after you exit the processing loop.
    await listener.CloseAsync(cts.Token);
}

  5. Dodaj następujący wiersz kodu do metody Main w klasie Program:

    RunAsync().GetAwaiter().GetResult();

    Oto jak powinien wyglądać kompletny plik Program.cs:

    namespace Server
{
    using System;
    using System.IO;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.Relay;

    public class Program
    {
        private const string RelayNamespace = "{RelayNamespace}.servicebus.windows.net";
        private const string ConnectionName = "{HybridConnectionName}";
        private const string KeyName = "{SASKeyName}";
        private const string Key = "{SASKey}";

        public static void Main(string[] args)
        {
            RunAsync().GetAwaiter().GetResult();
        }

        private static async Task RunAsync()
        {
            var cts = new CancellationTokenSource();

            var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
            var listener = new HybridConnectionListener(new Uri(string.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);

            // Subscribe to the status events.
            listener.Connecting += (o, e) => { Console.WriteLine("Connecting"); };
            listener.Offline += (o, e) => { Console.WriteLine("Offline"); };
            listener.Online += (o, e) => { Console.WriteLine("Online"); };

            // Opening the listener establishes the control channel to
            // the Azure Relay service. The control channel is continuously 
            // maintained, and is reestablished when connectivity is disrupted.
            await listener.OpenAsync(cts.Token);
            Console.WriteLine("Server listening");

            // Provide callback for a cancellation token that will close the listener.
            cts.Token.Register(() => listener.CloseAsync(CancellationToken.None));

            // Start a new thread that will continuously read the console.
            new Task(() => Console.In.ReadLineAsync().ContinueWith((s) => { cts.Cancel(); })).Start();

            // Accept the next available, pending connection request. 
            // Shutting down the listener allows a clean exit. 
            // This method returns null.
            while (true)
            {
                var relayConnection = await listener.AcceptConnectionAsync();
                if (relayConnection == null)
                {
                    break;
                }

                ProcessMessagesOnConnection(relayConnection, cts);
            }

            // Close the listener after you exit the processing loop.
            await listener.CloseAsync(cts.Token);
        }

        private static async void ProcessMessagesOnConnection(HybridConnectionStream relayConnection, CancellationTokenSource cts)
        {
            Console.WriteLine("New session");

            // The connection is a fully bidrectional stream. 
            // Put a stream reader and a stream writer over it.  
            // This allows you to read UTF-8 text that comes from 
            // the sender, and to write text replies back.
            var reader = new StreamReader(relayConnection);
            var writer = new StreamWriter(relayConnection) { AutoFlush = true };
            while (!cts.IsCancellationRequested)
            {
                try
                {
                    // Read a line of input until a newline is encountered.
                    var line = await reader.ReadLineAsync();

                    if (string.IsNullOrEmpty(line))
                    {
                        // If there's no input data, signal that 
                        // you will no longer send data on this connection.
                        // Then, break out of the processing loop.
                        await relayConnection.ShutdownAsync(cts.Token);
                        break;
                    }

                    // Write the line on the console.
                    Console.WriteLine(line);

                    // Write the line back to the client, prepended with "Echo:"
                    await writer.WriteLineAsync($"Echo: {line}");
                }
                catch (IOException)
                {
                    // Catch an I/O exception. This likely occurred when
                    // the client disconnected.
                    Console.WriteLine("Client closed connection");
                    break;
                }
            }

            Console.WriteLine("End session");

            // Close the connection.
            await relayConnection.CloseAsync(cts.Token);
        }
    }
}

Tworzenie aplikacji klienta (nadawcy)

W programie Visual Studio napisz aplikację konsoli w języku C#, aby wysyłać komunikaty do usługi Relay.

Tworzenie aplikacji konsolowej

W programie Visual Studio utwórz nowy projekt Aplikacja konsoli (.NET Framework).

Dodawanie pakietu NuGet usługi Relay

  1. Kliknij prawym przyciskiem myszy nowo utworzony projekt, a następnie wybierz pozycję Zarządzaj pakietami NuGet.
  2. Wybierz pozycję Przeglądaj, a następnie wyszukaj pozycję Microsoft.Azure.Relay. W wynikach wyszukiwania wybierz pozycję Microsoft Azure Relay.
  3. Wybierz pozycję Zainstaluj, aby ukończyć instalację. Zamknij okno dialogowe.

Pisanie kodu w celu wysyłania komunikatów

  1. Na początku pliku Program.cs zastąp istniejące instrukcje using następującymi instrukcjami using:

    using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.Relay;

  2. Dodaj stałe do klasy Program na potrzeby szczegółów połączenia hybrydowego. Zastąp symbole zastępcze wartościami uzyskanymi podczas tworzenia połączenia hybrydowego. Pamiętaj, aby użyć w pełni kwalifikowanej nazwy przestrzeni nazw.

    // replace {RelayNamespace} with the name of your namespace
private const string RelayNamespace = "YOUR-RELAY-NAMESPACE-NAME.servicebus.windows.net";

// replace {HybridConnectionName} with the name of your hybrid connection
private const string ConnectionName = "HYBRID-CONNECTION-NAME";

// replace {SAKKeyName} with the name of your Shared Access Policies key, which is RootManageSharedAccessKey by default
private const string KeyName = "SAS-KEY-NAME";

// replace {SASKey} with the primary key of the namespace you saved earlier
private const string Key = "SAS-KEY-VALUE";

  3. Dodaj następującą metodę do klasy Program:

    private static async Task RunAsync()
{
    Console.WriteLine("Enter lines of text to send to the server with ENTER");

    // Create a new hybrid connection client.
    var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
    var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);

    // Initiate the connection.
    var relayConnection = await client.CreateConnectionAsync();

    // Run two concurrent loops on the connection. One 
    // reads input from the console and writes it to the connection 
    // with a stream writer. The other reads lines of input from the 
    // connection with a stream reader and writes them to the console. 
    // Entering a blank line shuts down the write task after 
    // sending it to the server. The server then cleanly shuts down
    // the connection, which terminates the read task.

    var reads = Task.Run(async () => {
        // Initialize the stream reader over the connection.
        var reader = new StreamReader(relayConnection);
        var writer = Console.Out;
        do
        {
            // Read a full line of UTF-8 text up to newline.
            string line = await reader.ReadLineAsync();
            // If the string is empty or null, you are done.
            if (String.IsNullOrEmpty(line))
                break;
            // Write to the console.
            await writer.WriteLineAsync(line);
        }
        while (true);
    });

    // Read from the console and write to the hybrid connection.
    var writes = Task.Run(async () => {
        var reader = Console.In;
        var writer = new StreamWriter(relayConnection) { AutoFlush = true };
        do
        {
            // Read a line from the console.
            string line = await reader.ReadLineAsync();
            // Write the line out, also when it's empty.
            await writer.WriteLineAsync(line);
            // Quit when the line is empty,
            if (String.IsNullOrEmpty(line))
                break;
        }
        while (true);
    });

    // Wait for both tasks to finish.
    await Task.WhenAll(reads, writes);
    await relayConnection.CloseAsync(CancellationToken.None);
}

  4. Dodaj następujący wiersz kodu do metody Main w klasie Program.

    RunAsync().GetAwaiter().GetResult();

    Plik Program.cs powinien wyglądać następująco:

    using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Azure.Relay;

namespace Client
{
    class Program
    {
        private const string RelayNamespace = "{RelayNamespace}.servicebus.windows.net";
        private const string ConnectionName = "{HybridConnectionName}";
        private const string KeyName = "{SASKeyName}";
        private const string Key = "{SASKey}";

        static void Main(string[] args)
        {
            RunAsync().GetAwaiter().GetResult();
        }

        private static async Task RunAsync()
        {
            Console.WriteLine("Enter lines of text to send to the server with ENTER");

            // Create a new hybrid connection client.
            var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, Key);
            var client = new HybridConnectionClient(new Uri(String.Format("sb://{0}/{1}", RelayNamespace, ConnectionName)), tokenProvider);

            // Initiate the connection.
            var relayConnection = await client.CreateConnectionAsync();

            // Run two concurrent loops on the connection. One 
            // reads input from the console and then writes it to the connection 
            // with a stream writer. The other reads lines of input from the 
            // connection with a stream reader and then writes them to the console. 
            // Entering a blank line shuts down the write task after 
            // sending it to the server. The server then cleanly shuts down
            // the connection, which terminates the read task.

            var reads = Task.Run(async () => {
                // Initialize the stream reader over the connection.
                var reader = new StreamReader(relayConnection);
                var writer = Console.Out;
                do
                {
                    // Read a full line of UTF-8 text up to newline.
                    string line = await reader.ReadLineAsync();
                    // If the string is empty or null, you are done.
                    if (String.IsNullOrEmpty(line))
                        break;
                    // Write to the console.
                    await writer.WriteLineAsync(line);
                }
                while (true);
            });

            // Read from the console and write to the hybrid connection.
            var writes = Task.Run(async () => {
                var reader = Console.In;
                var writer = new StreamWriter(relayConnection) { AutoFlush = true };
                do
                {
                    // Read a line from the console.
                    string line = await reader.ReadLineAsync();
                    // Write the line out, also when it's empty.
                    await writer.WriteLineAsync(line);
                    // Quit when the line is empty.
                    if (String.IsNullOrEmpty(line))
                        break;
                }
                while (true);
            });

            // Wait for both tasks to finish.
            await Task.WhenAll(reads, writes);
            await relayConnection.CloseAsync(CancellationToken.None);
        }
    }
}

Uwaga

Przykładowy kod w tym artykule używa parametry połączenia do uwierzytelniania w przestrzeni nazw usługi Azure Relay, aby zachować prostotę samouczka. Zalecamy użycie uwierzytelniania identyfikatora Entra firmy Microsoft w środowiskach produkcyjnych zamiast używania parametry połączenia lub sygnatur dostępu współdzielonego, co może być łatwiejsze w przypadku naruszenia zabezpieczeń. Aby uzyskać szczegółowe informacje i przykładowy kod do korzystania z uwierzytelniania identyfikatora entra firmy Microsoft, zobacz Uwierzytelnianie i autoryzacja aplikacji przy użyciu identyfikatora Entra firmy Microsoft w celu uzyskania dostępu do jednostek usługi Azure Relay i uwierzytelnianie tożsamości zarządzanej za pomocą identyfikatora Entra firmy Microsoft w celu uzyskania dostępu do zasobów usługi Azure Relay.

Uruchamianie aplikacji

  1. Uruchom aplikację serwera.

  2. Uruchom aplikację klienta i wprowadź jakiś tekst.

  3. Upewnij się, że w konsoli aplikacji serwera jest wyświetlany tekst wprowadzony w aplikacji klienta.

    Okna konsoli testujące zarówno serwer, jak i aplikacje klienckie.

Gratulacje, utworzono kompletną aplikację połączeń hybrydowych!

Następne kroki

W tym przewodniku Szybki start utworzono aplikacje klienta i serwera w środowisku .NET służące do wysyłania i odbierania komunikatów za pomocą obiektów WebSocket. Funkcja połączeń hybrydowych usługi Azure Relay obsługuje również wysyłanie i odbieranie komunikatów przy użyciu protokołu HTTP. Aby dowiedzieć się, jak używać protokołu HTTP z funkcją połączeń hybrydowych usługi Azure Relay, zobacz Przewodnik Szybki start dotyczący protokołu HTTP.

W tym przewodniku Szybki start za pomocą programu .NET Framework utworzono aplikacje klienta i serwera. Aby dowiedzieć się, jak pisać aplikacje klienta i serwera w środowisku Node.js, zapoznaj się z przewodnikiem Szybki start dotyczącym obiektów WebSocket w środowisku Node.js lub przewodnikiem Szybki start dotyczącym protokołu HTTP w środowisku Node.js.