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

• NET
• Node.js

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.

   

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.

      

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

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

      

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.

   

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.

   

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

   

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

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.

Parabéns, você criou um aplicativo de Conexões Híbridas completo!

Próximas etapas

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.