Introduzione alle connessioni ibride di inoltroGet started with Relay Hybrid Connections

Questa esercitazione offre un'introduzione alle connessioni ibride di inoltro di Azure,This tutorial provides an introduction to Azure Relay Hybrid Connections. con informazioni su come usare .NET per creare un'applicazione client che invia messaggi a un'applicazione listener corrispondente.Learn how to use Microsoft .NET to create a client application that sends messages to a corresponding listener application.

Contenuto dell'esercitazioneWhat will be accomplished

Le connessioni ibride richiedono sia un componente client che un componente server.Hybrid Connections requires both a client component and a server component. In questa esercitazione verranno completati i passaggi seguenti per creare due applicazioni console:In this tutorial, you complete these steps to create two console applications:

  1. Creare uno spazio dei nomi di inoltro usando il portale di Azure.Create a Relay namespace by using the Azure portal.
  2. Creare una connessione ibrida nello spazio dei nomi usando il portale di Azure.Create a hybrid connection in that namespace by using the Azure portal.
  3. Scrivere un'applicazione console server (listener) per ricevere messaggi.Write a server (listener) console application to receive messages.
  4. Scrivere un'applicazione console client (mittente) per inviare messaggi.Write a client (sender) console application to send messages.

prerequisitiPrerequisites

Per completare questa esercitazione è necessario soddisfare i prerequisiti seguenti:To complete this tutorial, you need the following prerequisites:

Nota

Per completare l'esercitazione, è necessario un account Azure.To complete this tutorial, you need an Azure account. È possibile attivare i benefici della sottoscrizione MSDN o iscriversi per un account gratuito.You can activate your MSDN subscriber benefits or sign up for a free account.

1. Creare uno spazio dei nomi usando il portale di Azure1. Create a namespace by using the Azure portal

Se è già stato creato uno spazio dei nomi di inoltro, passare a Creare una connessione ibrida usando il portale di Azure.If you have already created a Relay namespace, go to Create a hybrid connection by using the Azure portal.

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Nel menu a sinistra selezionare + Crea una risorsa.In the left menu, select + Create a resource. Selezionare quindi Integrazione aziendale > Inoltro.Then, select Enterprise Integration > Relay.
  3. Nel pannello Crea spazio dei nomi immettere un nome per lo spazio dei nomi.Under Create namespace, enter a namespace name. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.The system immediately checks to see if the name is available.
  4. Nella casella Sottoscrizione selezionare una sottoscrizione di Azure in cui creare lo spazio dei nomi.In the Subscription box, select an Azure subscription in which to create the namespace.
  5. Nella casella Gruppo di risorse selezionare un gruppo di risorse esistente nel quale inserire lo spazio dei nomi oppure crearne uno nuovo.In the Resource group box, select an existing resource group in which to place the namespace, or create a new one.
  6. In Località selezionare il paese o l'area in cui deve essere ospitato lo spazio dei nomi.In Location, select the country or region in which your namespace should be hosted.

    Crea spazio dei nomi

  7. Selezionare Create.Select Create. Lo spazio dei nomi verrà creato e abilitato nel sistema.The system creates your namespace and enables it. Dopo alcuni minuti, il sistema effettua il provisioning delle risorse per l'account.After a few minutes, the system provisions resources for your account.

Ottenere le credenziali di gestioneGet management credentials

  1. Selezionare Tutte le risorse e quindi selezionare il nome dello spazio dei nomi appena creato.Select All resources, and then select the newly created namespace name.
  2. Nello spazio dei nomi dell'inoltro selezionare Criteri di accesso condiviso.Under the Relay namespace, select Shared access policies.
  3. In Criteri di accesso condiviso selezionare RootManageSharedAccessKey.Under Shared access policies, select RootManageSharedAccessKey.

    connection-info

  4. In Criteri: RootManageSharedAccessKey selezionare il pulsante Copia accanto a Stringa di connessione - chiave primaria.Under Policy: RootManageSharedAccessKey, select the Copy button next to Connection string–Primary key. La stringa di connessione viene copiata negli Appunti per un uso successivo.This copies the connection string to your clipboard for later use. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.Paste this value into Notepad or some other temporary location.

    connection-string

  5. Ripetere il passaggio precedente per copiare e incollare il valore di Chiave primaria in un percorso temporaneo per usarlo in seguito.Repeat the preceding step to copy and paste the value of Primary key to a temporary location for later use.

2. Creare una connessione ibrida usando il portale di Azure2. Create a hybrid connection by using the Azure portal

Se è già stata creata una connessione ibrida, passare a Creare un'applicazione server.If you have already created a hybrid connection, go to Create a server application.

Verificare che sia già stato creato uno spazio dei nomi dell'inoltro.Ensure that you have already created a Relay namespace.

  1. Accedere al portale di Azure.Sign in to the Azure portal.
  2. Nel menu a sinistra selezionare Tutte le risorse.In the left menu, select All resources.
  3. Selezionare lo spazio dei nomi in cui si vuole creare la connessione ibrida.Select the namespace where you want to create the hybrid connection. In questo caso è mynewns.In this case, it is mynewns.
  4. In Relay namespace (Spazio dei nomi dell'inoltro) selezionare Connessioni ibride.Under Relay namespace, select Hybrid Connections.

    Creare una connessione ibrida

  5. Nella finestra della panoramica dello spazio dei nomi selezionare + Connessione ibridaIn the namespace overview window, select + Hybrid Connection

    Selezionare la connessione ibrida

  6. In Crea connessione ibrida immettere un valore per il nome della connessione ibrida.Under Create Hybrid Connection, enter a value for the hybrid connection name. Lasciare gli altri valori predefiniti.Leave the other default values.

    Selezionare Nuovo

  7. Selezionare Create.Select Create.

3. Creare un'applicazione server (listener)3. Create a server application (listener)

In Visual Studio scrivere un'applicazione console in C# per ascoltare e ricevere messaggi dall'inoltro.In Visual Studio, write a C# console application to listen for and receive messages from the relay.

Creare un'applicazione consoleCreate a console application

In Visual Studio creare un nuovo progetto App console (.NET Framework).In Visual Studio, create a new Console App (.NET Framework) project.

Aggiungere il pacchetto NuGet di inoltroAdd the Relay NuGet package

  1. Fare clic con il pulsante destro del mouse sul progetto appena creato e quindi scegliere Gestisci pacchetti NuGet.Right-click the newly created project, and then select Manage NuGet Packages.
  2. Selezionare Sfoglia e quindi cercare Microsoft.Azure.Relay.Select Browse, and then search for Microsoft.Azure.Relay. Nei risultati della ricerca selezionare Inoltro di Microsoft Azure.In the search results, select Microsoft Azure Relay.
  3. Selezionare Installa per completare l'installazione.Select Install to complete the installation. Chiudere la finestra di dialogo.Close the dialog box.

Scrivere codice per ricevere messaggiWrite code to receive messages

  1. All'inizio del file Program.cs sostituire le istruzioni using esistenti con le istruzioni using seguenti:At the top of the Program.cs file, replace the existing using statements with the following using statements:

    using System;
    using System.IO;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.Relay;
    
  2. Aggiungere costanti alla classe Program per i dettagli della connessione ibrida.Add constants to the Program class for the hybrid connection details. Sostituire i segnaposto tra parentesi con i valori ottenuti durante la creazione della connessione ibrida.Replace the placeholders in brackets with the values that you obtained when you created the hybrid connection. Usare il nome completo dello spazio dei nomi.Be sure to use the fully qualified namespace name.

    private const string RelayNamespace = "{RelayNamespace}.servicebus.windows.net";
    private const string ConnectionName = "{HybridConnectionName}";
    private const string KeyName = "{SASKeyName}";
    private const string Key = "{SASKey}";
    
  3. Aggiungere il metodo ProcessMessagesOnConnection alla classe Program:Add the ProcessMessagesOnConnection method to the Program class:

    // 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. Aggiungere il metodo RunAsync alla classe Program:Add the RunAsync method to the Program class:

    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. Aggiungere la riga di codice seguente al metodo Main nella classe Program:Add the following line of code to the Main method in the Program class:

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

    Il file Program.cs completato avrà l'aspetto seguente:The completed Program.cs file should look like this:

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

4. Creare un'applicazione client (mittente)4. Create a client application (sender)

In Visual Studio scrivere un'applicazione console in C# per inviare messaggi all'inoltro.In Visual Studio, write a C# console application to send messages to the relay.

Creare un'applicazione consoleCreate a console application

In Visual Studio creare un nuovo progetto App console (.NET Framework).In Visual Studio, create a new Console App (.NET Framework) project.

Aggiungere il pacchetto NuGet di inoltroAdd the Relay NuGet package

  1. Fare clic con il pulsante destro del mouse sul progetto appena creato e quindi scegliere Gestisci pacchetti NuGet.Right-click the newly created project, and then select Manage NuGet Packages.
  2. Selezionare Sfoglia e quindi cercare Microsoft.Azure.Relay.Select Browse, and then search for Microsoft.Azure.Relay. Nei risultati della ricerca selezionare Inoltro di Microsoft Azure.In the search results, select Microsoft Azure Relay.
  3. Selezionare Installa per completare l'installazione.Select Install to complete the installation. Chiudere la finestra di dialogo.Close the dialog box.

Scrivere codice per inviare messaggiWrite code to send messages

  1. All'inizio del file Program.cs sostituire le istruzioni using esistenti con le istruzioni using seguenti:At the top of the Program.cs file, replace the existing using statements with the following using statements:

    using System;
    using System.IO;
    using System.Threading;
    using System.Threading.Tasks;
    using Microsoft.Azure.Relay;
    
  2. Aggiungere costanti alla classe Program per i dettagli della connessione ibrida.Add constants to the Program class for the hybrid connection details. Sostituire i segnaposto tra parentesi con i valori ottenuti durante la creazione della connessione ibrida.Replace the placeholders in brackets with the values that you obtained when you created the hybrid connection. Usare il nome completo dello spazio dei nomi.Be sure to use the fully qualified namespace name.

    private const string RelayNamespace = "{RelayNamespace}.servicebus.windows.net";
    private const string ConnectionName = "{HybridConnectionName}";
    private const string KeyName = "{SASKeyName}";
    private const string Key = "{SASKey}";
    
  3. Aggiungere il metodo seguente alla classe Program:Add the following method to the Program class:

    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. Aggiungere la riga di codice seguente al metodo Main nella classe Program.Add the following line of code to the Main method in the Program class.

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

    Program.cs dovrebbe avere l'aspetto seguente:The Program.cs should look like this:

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

5. Eseguire le applicazioni5. Run the applications

  1. Eseguire l'applicazione server.Run the server application.
  2. Eseguire l'applicazione client e immettere il testo.Run the client application and enter some text.
  3. Assicurarsi che la console dell'applicazione server visualizzi il testo immesso nell'applicazione client.Ensure that the server application console displays the text that was entered in the client application.

applicazioni in esecuzione

A questo punto è stata creata un'applicazione per le connessioni ibride end-to-end.Congratulations, you have created an end-to-end Hybrid Connections application!

Passaggi successiviNext steps