Share via

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

  • Artigo

Neste Início Rápido, você cria aplicativos Node.js 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

Criar um namespace usando o portal do Azure

  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 usando o portal do Azure

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)

Para escutar e receber mensagens da retransmissão, grave um aplicativo de console Node.js.

Criar um aplicativo do Node.js

Crie um novo arquivo JavaScript chamado listener.js.

Adicionar o pacote de retransmissão

Execute npm install hyco-https em um prompt de comando do Node na pasta do projeto.

Escrever um código para manipular solicitações

  1. Adicione a seguinte constante ao início do arquivo listener.js.

    const https = require('hyco-https');

  2. Adicione as seguintes constantes ao arquivo listener.js para obter os detalhes de conexão híbrida. Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida.

    • const ns - o namespace de retransmissão. Use o nome totalmente qualificado do namespace, por exemplo, {namespace}.servicebus.windows.net.
    • const path - o nome da conexão híbrida.
    • const keyrule - Nome da chave de Políticas de Acesso Compartilhado, que é RootManageSharedAccessKey por padrão.
    • const key - A chave primária do namespace que você salvou anteriormente.

  3. Adicione o seguinte código ao arquivo listener.js. :

    Você percebe que o código não é muito diferente de qualquer exemplo de servidor HTTP simples que você encontra em tutoriais de iniciantes do Node.js, com a exceção do uso de createRelayedServer, em vez da função createServer típica.

    var uri = https.createRelayListenUri(ns, path);
var server = https.createRelayedServer(
    {
        server : uri,
        token : () => https.createRelayToken(uri, keyrule, key)
    },
    (req, res) => {
        console.log('request accepted: ' + req.method + ' on ' + req.url);
        res.setHeader('Content-Type', 'text/html');
        res.end('<html><head><title>Hey!</title></head><body>Relayed Node.js Server!</body></html>');
    });

server.listen( (err) => {
        if (err) {
          return console.log('something bad happened', err)
        }
        console.log(`server is listening on ${port}`)
      });

server.on('error', (err) => {
    console.log('error: ' + err);
});

    Veja como o arquivo listener.js deve se parecer:

    const https = require('hyco-https');

const ns = "{RelayNamespace}";
const path = "{HybridConnectionName}";
const keyrule = "{SASKeyName}";
const key = "{SASKeyValue}";

var uri = https.createRelayListenUri(ns, path);
var server = https.createRelayedServer(
    {
        server : uri,
        token : () => https.createRelayToken(uri, keyrule, key)
    },
    (req, res) => {
        console.log('request accepted: ' + req.method + ' on ' + req.url);
        res.setHeader('Content-Type', 'text/html');
        res.end('<html><head><title>Hey!</title></head><body>Relayed Node.js Server!</body></html>');
    });

server.listen( (err) => {
        if (err) {
          return console.log('something bad happened', err)
        }
        console.log(`server is listening on ${port}`)
      });

server.on('error', (err) => {
    console.log('error: ' + err);
});

Criar um aplicativo de cliente (remetente)

Para enviar mensagens à Retransmissão, você pode usar qualquer cliente HTTP ou gravar um aplicativo de console Node.js.

Criar um aplicativo do Node.js

Se você tiver desabilitado a opção "Exige Autorização do Cliente" ao criar a Retransmissão, 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.

Para começar, crie um novo arquivo JavaScript chamado sender.js.

Adicionar o pacote do Gerenciador de Pacotes do Nó de Retransmissão

Execute npm install hyco-https em um prompt de comando do Node na pasta do projeto. Este pacote também importa o pacote https normal. Para o lado do cliente, a principal diferença é que o pacote fornece funções para construir URIs de Retransmissão e tokens.

Escrever código para enviar mensagens

  1. Adicione a constants a seguir à parte superior do arquivo sender.js.

    const https = require('hyco-https');

  2. Adicione as seguintes constantes ao arquivo sender.js para obter os detalhes de conexão híbrida. Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida.

    • const ns - o namespace de retransmissão. Use o nome totalmente qualificado do namespace, por exemplo, {namespace}.servicebus.windows.net.
    • const path - o nome da conexão híbrida.
    • const keyrule - Nome da chave de Políticas de Acesso Compartilhado, que é RootManageSharedAccessKey por padrão.
    • const key - A chave primária do namespace que você salvou anteriormente.

  3. Adicione o seguinte código ao arquivo sender.js. Você percebe que o código é muito diferente do uso normal do cliente Node.js HTTPS; ele apenas adiciona o cabeçalho de autorização.

    https.get({
     hostname : ns,
     path : (!path || path.length == 0 || path[0] !== '/'?'/':'') + path,
     port : 443,
     headers : {
         'ServiceBusAuthorization' : 
             https.createRelayToken(https.createRelayHttpsUri(ns, path), keyrule, key)
     }
}, (res) => {
     let error;
     if (res.statusCode !== 200) {
         console.error('Request Failed.\n Status Code: ${statusCode}');
         res.resume();
     } 
     else {
         res.setEncoding('utf8');
         res.on('data', (chunk) => {
             console.log(`BODY: ${chunk}`);
         });
         res.on('end', () => {
             console.log('No more data in response.');
         });
     };
}).on('error', (e) => {
     console.error(`Got error: ${e.message}`);
});

    Veja como o arquivo sender.js deve se parecer:

    const https = require('hyco-https');

const ns = "{RelayNamespace}";
const path = "{HybridConnectionName}";
const keyrule = "{SASKeyName}";
const key = "{SASKeyValue}";

https.get({
    hostname : ns,
    path : (!path || path.length == 0 || path[0] !== '/'?'/':'') + path,
    port : 443,
    headers : {
        'ServiceBusAuthorization' : 
            https.createRelayToken(https.createRelayHttpsUri(ns, path), keyrule, key)
    }
}, (res) => {
    let error;
    if (res.statusCode !== 200) {
        console.error('Request Failed.\n Status Code: ${statusCode}');
        res.resume();
    } 
    else {
        res.setEncoding('utf8');
        res.on('data', (chunk) => {
            console.log(`BODY: ${chunk}`);
        });
        res.on('end', () => {
            console.log('No more data in response.');
        });
    };
}).on('error', (e) => {
    console.error(`Got error: ${e.message}`);
});

Executar os aplicativos

  1. Execute o aplicativo de servidor: de um tipo de prompt de comando node listener.js do Node.js.
  2. Execute o aplicativo cliente: de um prompt de comando do Node.js, digite node sender.js e insira um texto.
  3. Certifique-se de que o console do aplicativo de servidor exiba o texto inserido no aplicativo de cliente.

Parabéns, você criou um aplicativo de Conexões Híbridas de ponta a ponta usando o Node.js!

Próximas etapas

Neste Início Rápido, você criou aplicativos de cliente e de servidor do Node.js 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 Node.js para criar aplicativos cliente e servidor. Para saber como escrever aplicativos cliente e servidor usando o .NET Framework, confira o Início Rápido do WebSockets .NET ou o Início Rápido do HTTP .NET.