Compartilhar via

Tutorial: Introdução às Conexões Híbridas de Retransmissão de solicitações HTTP no .NET

  • Artigo

Neste Início Rápido, você cria aplicativos .NET remetente e destinatário que enviam e recebem mensagens usando o protocolo HTTP. Os aplicativos usam o recurso Conexões Híbridas da Retransmissão do Azure. Para saber mais sobre a Retransmissão do Azure em geral, confira Retransmissão do Azure.

Neste início rápido, você segue os seguintes passos:

  1. Criar um namespace de Retransmissão usando o Portal do Azure.
  2. Crie uma conexão híbrida nesse namespace usando o Portal do Azure.
  3. Escreva um aplicativo de console do servidor (ouvinte) para receber mensagens.
  4. Escreva um aplicativo de console de cliente (remetente) para enviar mensagens.
  5. Execute aplicativos.

Pré-requisitos

Para concluir este tutorial, você precisará dos seguintes pré-requisitos:

  • Visual Studio 2019 ou posterior. Os exemplos deste tutorial usam o Visual Studio 2022.
  • Uma assinatura do Azure. Se você não tiver uma conta gratuita, crie uma antes de começar.

Criar um namespace

  1. Entre no portal do Azure.

  2. Selecione Todos os serviços no menu esquerdo. Selecione Integração, procure por Retransmissões, passe o mouse sobre Retransmissões e clique em Criar.

    Captura de tela mostrando a seleção de Retransmissões –> botão Criar.

  3. Na página Criar namespace, siga estas etapas:

    1. Escolha uma assinatura do Azure na qual criar o namespace.

    2. Em Grupo de recursos, escolha um grupo de recursos existente no qual colocar o namespace ou crie um.

    3. Insira um nome para o namespace de Retransmissão.

    4. Selecione o país ou região no qual o namespace deve ser hospedado.

    5. Selecione Revisar + criar na parte inferior da página.

      Captura de tela mostrando a página Criar namespace.

    6. Na página Examinar + criar escolha Criar.

    7. Depois de alguns minutos, você verá a página de Retransmissão do namespace.

      Captura de tela mostrando a home page do namespace de Retransmissão.

Obter credenciais de gerenciamento

  1. Na página Retransmissão, selecione Políticas de acesso compartilhado no menu à esquerda.

  2. Na página Políticas de acesso compartilhado, selecione RootManageSharedAccessKey.

  3. Em Política de SAS: RootManageSharedAccessKey, clique no botão Copiar ao lado da opção Cadeia de Conexão Primária. Isso copiará a cadeia de conexão para a área de transferência para uso posterior. Cole esse valor no Bloco de notas ou em outro local temporário.

  4. Repita a etapa anterior para copiar e colar o valor de Chave primária para um local temporário para uso posterior.

    Captura de tela mostrando as informações de conexão do namespace de Retransmissão.

Criar uma Conexão Híbrida

Na página Retransmissão para seu namespace, siga estas etapas para criar uma conexão híbrida.

  1. No menu à esquerda, em Entidades, selecione Conexões Híbridas e selecione + Conexão Híbrida.

    Captura de tela mostrando a página Conexões Híbridas.

  2. Na página Criar Conexão Híbrida, insira um nome para a conexão híbrida e selecione Criar.

    Captura de tela mostrando a página Criar Conexão Híbrida.

Criar um aplicativo de servidor (escuta)

No Visual Studio, grave um aplicativo de console em C# para escutar e receber mensagens da retransmissão.

Criar um aplicativo de console

N o Visual Studio, crie um novo projeto de Aplicativo de Console (.NET Framework).

Adicione o pacote NuGet de retransmissão

  1. Clique com o botão direito do mouse no projeto recém-criado e selecione Gerenciar Pacotes NuGet.
  2. Selecione Procurar e, em seguida, procure Microsoft.Azure.Relay. Nos resultados da pesquisa, selecione Retransmissão do Microsoft Azure.
  3. Selecione Instalar para concluir a instalação. Fechar a caixa de diálogo.

Gravar código para receber mensagens

  1. Na parte superior do arquivo Program.cs, substitua as instruções using existentes pelas instruções using a seguir:

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

  2. Adicione constantes à classe Program para os detalhes da conexão híbrida. Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida. Use o nome totalmente qualificado do namespace.

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

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

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

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

  3. Adicione o método RunAsync à classe 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"); };

    // Provide an HTTP request handler
    listener.RequestHandler = (context) =>
    {
        // Do something with context.Request.Url, HttpMethod, Headers, InputStream...
        context.Response.StatusCode = HttpStatusCode.OK;
        context.Response.StatusDescription = "OK, This is pretty neat";
        using (var sw = new StreamWriter(context.Response.OutputStream))
        {
            sw.WriteLine("hello!");
        }

        // The context MUST be closed here
        context.Response.Close();
    };

    // 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();
    Console.WriteLine("Server listening");

    // Start a new thread that will continuously read the console.
    await Console.In.ReadLineAsync();

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

  4. Adicione a linha de código a seguir ao método Main na classe Program:

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

    O arquivo Program.cs concluído deve ter esta aparência:

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

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

            // Provide an HTTP request handler
            listener.RequestHandler = (context) =>
            {
                // Do something with context.Request.Url, HttpMethod, Headers, InputStream...
                context.Response.StatusCode = HttpStatusCode.OK;
                context.Response.StatusDescription = "OK";
                using (var sw = new StreamWriter(context.Response.OutputStream))
                {
                    sw.WriteLine("hello!");
                }

                // The context MUST be closed here
                context.Response.Close();
            };

            // 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();
            Console.WriteLine("Server listening");

            // Start a new thread that will continuously read the console.
            await Console.In.ReadLineAsync();

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

Criar um aplicativo de cliente (remetente)

No Visual Studio, grave um aplicativo de console em C# para enviar mensagens à retransmissão.

Criar um aplicativo de console

Se você desativou a opção "Requer autorização do cliente" ao criar o Relay, poderá enviar solicitações para a URL de conexões híbridas com qualquer navegador. Para acessar os pontos de extremidade protegidos, você precisa criar e passar um token no cabeçalho ServiceBusAuthorization, que é mostrado aqui.

N o Visual Studio, crie um novo projeto de Aplicativo de Console (.NET Framework).

Adicione o pacote NuGet de retransmissão

  1. Clique com o botão direito do mouse no projeto recém-criado e selecione Gerenciar Pacotes NuGet.
  2. Selecione a opção Incluir pré-lançamento.
  3. Selecione Procurar e, em seguida, procure Microsoft.Azure.Relay. Nos resultados da pesquisa, selecione Retransmissão do Microsoft Azure.
  4. Selecione Instalar para concluir a instalação. Fechar a caixa de diálogo.

Gravar código para enviar solicitações

  1. Na parte superior do arquivo Program.cs, substitua as instruções using existentes pelas instruções using a seguir:

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

  2. Adicione constantes à classe Program para os detalhes da conexão híbrida. Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida. Use o nome totalmente qualificado do namespace.

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

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

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

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

  3. Adicione o seguinte método à classe Program:

    private static async Task RunAsync()
{
    var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
            KeyName, Key);
    var uri = new Uri(string.Format("https://{0}/{1}", RelayNamespace, ConnectionName));
    var token = (await tokenProvider.GetTokenAsync(uri.AbsoluteUri, TimeSpan.FromHours(1))).TokenString;
    var client = new HttpClient();
    var request = new HttpRequestMessage()
    {
        RequestUri = uri,
        Method = HttpMethod.Get,
    };
    request.Headers.Add("ServiceBusAuthorization", token);
    var response = await client.SendAsync(request);
    Console.WriteLine(await response.Content.ReadAsStringAsync());        Console.ReadLine();
}

  4. Adicione a linha de código a seguir ao método Main na classe Program.

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

    O Program.cs deve ter esta aparência:

    using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;
using System.Net.Http;
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()
        {
           var tokenProvider = TokenProvider.CreateSharedAccessSignatureTokenProvider(
            KeyName, Key);
            var uri = new Uri(string.Format("https://{0}/{1}", RelayNamespace, ConnectionName));
            var token = (await tokenProvider.GetTokenAsync(uri.AbsoluteUri, TimeSpan.FromHours(1))).TokenString;
            var client = new HttpClient();
            var request = new HttpRequestMessage()
            {
                RequestUri = uri,
                Method = HttpMethod.Get,
            };
            request.Headers.Add("ServiceBusAuthorization", token);
            var response = await client.SendAsync(request);
            Console.WriteLine(await response.Content.ReadAsStringAsync());
        }
    }
}

Observação

O código de exemplo neste artigo utiliza uma cadeia de conexão para autenticar em um namespace da Retransmissão do Azure a fim de manter o tutorial simples. Recomendamos que você use a autenticação do Microsoft Entra ID em ambientes de produção, em vez de usar cadeias de conexão ou assinaturas de acesso compartilhado, que podem ser comprometidas mais facilmente. Para obter informações detalhadas e o código de exemplo para usar a autenticação do Microsoft Entra ID, veja Autenticar e autorizar um aplicativo com o Microsoft Entra ID para acessar entidades da Retransmissão do Azure e Autenticar uma identidade gerenciada com o Microsoft Entra ID para acessar os recursos da Retransmissão do Azure.

Executar os aplicativos

  1. Execute o aplicativo de servidor. Você vê o texto a seguir na janela do console:

    Online
Server listening

  2. Execute o aplicativo cliente. Você verá hello! na janela do cliente. O cliente enviou uma solicitação HTTP para o servidor e o servidor respondeu com um hello!.

  3. Agora, para fechar as janelas do console, pressione ENTER nas duas janelas do console.

Conteúdo relacionado

Neste Início Rápido, você criou aplicativos de cliente e servidor do .NET que usavam HTTP para enviar e receber mensagens. O recurso Conexões Híbridas da Retransmissão do Azure também dá suporte ao uso de WebSockets para enviar e receber mensagens. Para saber como usar o WebSockets com as Conexões Híbridas da Retransmissão do Azure, confira o Início Rápido do WebSockets.

Neste Início Rápido, você usou o .NET Framework para criar aplicativos cliente e servidor. Para saber como escrever aplicativos cliente e servidor usando o Node.js, confira o Início Rápido de WebSockets do Node.js ou o Início Rápido do HTTP Node.js.