Get started with Relay Hybrid Connections HTTP requests in Node

In this quickstart, you create Node.js sender and receiver applications that send and receive messages by using the HTTP protocol. The applications use Hybrid Connections feature of Azure Relay. To learn about Azure Relay in general, see Azure Relay.

In this quickstart, you take the following steps:

  1. Create a Relay namespace by using the Azure portal.
  2. Create a hybrid connection in that namespace by using the Azure portal.
  3. Write a server (listener) console application to receive messages.
  4. Write a client (sender) console application to send messages.
  5. Run applications.

Prerequisites

Create a namespace using the Azure portal

  1. Sign in to the Azure portal.

  2. In the left menu, select + Create a resource. Then, select Integration > Relay. If you don't see Relay in the list, select See All in the top-right corner.

  3. Under Create namespace, enter a namespace name. The system immediately checks to see if the name is available.

  4. In the Subscription box, select an Azure subscription in which to create the namespace.

  5. In the Resource group box, select an existing resource group in which to place the namespace, or create a new one.

  6. In Location, select the country or region in which your namespace should be hosted.

    Create namespace

  7. Select Create. The system creates your namespace and enables it. After a few minutes, the system provisions resources for your account.

Get management credentials

  1. Select All resources, and then select the newly created namespace name.

  2. Under the Relay namespace, select Shared access policies.

  3. Under Shared access policies, select RootManageSharedAccessKey.

    connection-info

  4. Under Policy: RootManageSharedAccessKey, select the Copy button next to Connection string–Primary key. This copies the connection string to your clipboard for later use. Paste this value into Notepad or some other temporary location.

    connection-string

  5. Repeat the preceding step to copy and paste the value of Primary key to a temporary location for later use.

Create a hybrid connection using the Azure portal

Ensure that you have already created a Relay namespace.

  1. Sign in to the Azure portal.

  2. In the left menu, select All resources.

  3. Select the namespace where you want to create the hybrid connection. In this case, it is mynewns.

  4. Under Relay namespace, select Hybrid Connections.

    Create a hybrid connection

  5. In the namespace overview window, select + Hybrid Connection

    Select the hybrid connection

  6. Under Create Hybrid Connection, enter a value for the hybrid connection name. Leave the other default values.

    Select New

  7. Select Create.

Create a server application (listener)

To listen and receive messages from the Relay, write a Node.js console application.

Create a Node.js application

Create a new JavaScript file called listener.js.

Add the Relay NPM package

Run npm install hyco-https from a Node command prompt in your project folder.

Write some code to handle requests

  1. Add the following constant to the top of the listener.js file.

    const https = require('hyco-https');
    
  2. Add the following constants to the listener.js file for the hybrid connection details. Replace the placeholders in brackets with the values you obtained when you created the hybrid connection.

    1. const ns - The Relay namespace. Be sure to use the fully qualified namespace name; for example, {namespace}.servicebus.windows.net.
    2. const path - The name of the hybrid connection.
    3. const keyrule - The name of the SAS key.
    4. const key - The SAS key value.
  3. Add the following code to the listener.js file. :

    You will notice that the code is not much different from any simple HTTP server example you can find in Node.js beginner tutorials, which the exception of using the createRelayedServer instead of the typical createServer function.

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

    Here is what your listener.js file should look like:

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

Create a client application (sender)

To send messages to the Relay, you can use any HTTP client, or write a Node.js console application.

Create a Node.js application

If you have disabled the "Requires Client Authorization" option when creating the Relay, you can send requests to the Hybrid Connections URL with any browser. For accessing protected endpoints, you need to create and pass a token in the ServiceBusAuthorization header, which is shown here.

To start, create a new JavaScript file called sender.js.

Add the Relay NPM package

Run npm install hyco-https from a Node command prompt in your project folder. This package also imports the regular https package. For the client-side, the key difference is that the package provides functions to construct Relay URIs and tokens.

Write some code to send messages

  1. Add the following constants to the top of the sender.js file.

    const https = require('hyco-https');
    
  2. Add the following constants to the sender.js file for the hybrid connection details. Replace the placeholders in brackets with the values you obtained when you created the hybrid connection.

    1. const ns - The Relay namespace. Be sure to use the fully qualified namespace name; for example, {namespace}.servicebus.windows.net.
    2. const path - The name of the hybrid connection.
    3. const keyrule - The name of the SAS key.
    4. const key - The SAS key value.
  3. Add the following code to the sender.js file. You will notice that the code does not differ significantly from the regular use of the Node.js HTTPS client; it just adds the authorization header.

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

    Here is what your sender.js file should look like:

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

Run the applications

  1. Run the server application: from a Node.js command prompt type node listener.js.
  2. Run the client application: from a Node.js command prompt type node sender.js, and enter some text.
  3. Ensure that the server application console outputs the text that was entered in the client application.

Congratulations, you have created an end-to-end Hybrid Connections application using Node.js!

Next steps

In this quickstart, you created Node.js client and server applications that used HTTP to send and receive messages. The Hybrid Connections feature of Azure Relay also supports using WebSockets to send and receive messages. To learn how to use WebSockets with Azure Relay Hybrid Connections, see the WebSockets quickstart.

In this quickstart, you used Node.js to create client and server applications. To learn how to write client and server applications using .NET Framework, see the .NET WebSockets quickstart or the .NET HTTP quickstart.