Introduzione alle connessioni ibride di inoltro

Questa esercitazione offre un'introduzione alle connessioni ibride di inoltro di Azure e illustra come usare Node.js per creare un'applicazione client che invia messaggi a un'applicazione listener corrispondente.

Contenuto dell'esercitazione

Dato che le connessioni ibride richiedono sia un componente client che un componente server, in questa esercitazione verranno create due applicazioni console. Di seguito sono riportati i passaggi necessari:

  1. Creare uno spazio dei nomi di inoltro usando il portale di Azure.
  2. Creare una connessione ibrida usando il portale di Azure.
  3. Scrivere un'applicazione console server per ricevere messaggi.
  4. Scrivere un'applicazione console client per inviare messaggi.

Prerequisiti

  1. Node.js.
  2. Una sottoscrizione di Azure.

Nota

Per completare l'esercitazione, è necessario un account Azure. È possibile attivare i benefici della sottoscrizione MSDN o iscriversi per un account gratuito.

1. Creare uno spazio dei nomi tramite il portale di Azure

Se è già stato creato uno spazio dei nomi dell'inoltro, passare alla sezione Creare una connessione ibrida usando il portale di Azure.

  1. Accedere al portale di Azure.
  2. Nel riquadro di spostamento sinistro del portale fare clic su Nuovo, quindi su Enterprise Integration e infine su Inoltro.
  3. Nella finestra di dialogo Crea spazio dei nomi immettere un nome per lo spazio dei nomi. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.
  4. Nel campo Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.
  5. Nel campo Gruppo di risorse scegliere un gruppo di risorse esistente nel quale risiederà lo spazio dei nomi oppure crearne uno nuovo.
  6. In Localitàscegliere il paese o l'area in cui deve essere ospitato lo spazio dei nomi.

    Crea spazio dei nomi

  7. Fare clic su Crea. A questo punto, lo spazio dei nomi verrà creato e abilitato nel sistema. Dopo alcuni minuti, il sistema effettua il provisioning delle risorse per l'account.

Ottenere le credenziali di gestione

  1. Nell'elenco degli spazi dei nomi fare clic sul nome dello spazio dei nomi appena creato.
  2. Nel pannello dello spazio dei nomi fare clic su Criteri di accesso condivisi.
  3. Nel pannello Criteri di accesso condivisi fare clic su RootManageSharedAccessKey.

    connection-info

  4. Nel pannello Criteri: RootManageSharedAccessKey fare clic sul pulsante Copia accanto a Stringa di connessione - chiave primaria per copiare la stringa di connessione negli Appunti e usarla in un secondo momento. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.

    connection-string

  5. Ripetere il passaggio precedente e copiare e incollare il valore della chiave primaria in un percorso temporaneo per usarlo in seguito.

2. Creare una connessione ibrida usando il portale di Azure

Se è già stata creata una connessione ibrida, passare alla sezione Creare un'applicazione server.

Verificare che sia già stato creato uno spazio dei nomi di inoltro, come illustrato qui.

  1. Accedere al portale di Azure.
  2. Nel pannello di navigazione sinistro del portale fare clic su Inoltro.
  3. Selezionare lo spazio dei nomi in cui si vuole creare la connessione ibrida. In questo caso è mynewns.

    Creare una connessione ibrida

  4. Nel pannello Relay namespace (Spazio dei nomi di inoltro) selezionare Connessioni ibride, quindi fare clic su + Connessione ibrida.

    Selezionare la connessione ibrida

  5. Immettere il Nome connessione ibrida e lasciare invariati gli altri valori.

    Selezionare Nuovo

  6. Fare clic su Creanella parte inferiore del pannello.

3. Creare un'applicazione server (listener)

Per ascoltare e ricevere messaggi da servizio di inoltro, verrà scritta un'applicazione console Node.js.

Creare un'applicazione Node.js

Creare un nuovo file JavaScript denominato listener.js.

Aggiungere il pacchetto NPM di inoltro

Eseguire npm install hyco-ws dal prompt dei comandi di Node nella cartella del progetto.

Scrivere codice per ricevere messaggi

  1. Aggiungere la costante seguente all'inizio del file listener.js.

    const WebSocket = require('hyco-ws');
    
  2. Aggiungere le costanti seguenti al file listener.js per i dettagli della connessione ibrida. Sostituire i segnaposto tra parentesi con i valori ottenuti durante la creazione della connessione ibrida.

    1. const ns: spazio dei nomi dell'inoltro. Assicurarsi di usare il nome completo dello spazio dei nomi, ad esempio {namespace}.servicebus.windows.net.
    2. const path: nome della connessione ibrida.
    3. const keyrule: nome della chiave di firma di accesso condiviso.
    4. const key: valore della chiave di firma di accesso condiviso.
  3. Aggiungere il codice seguente al file listener.js:

    var wss = WebSocket.createRelayedServer(
    {
        server : WebSocket.createRelayListenUri(ns, path),
        token: WebSocket.createRelayToken('http://' + ns, keyrule, key)
    }, 
    function (ws) {
        console.log('connection accepted');
        ws.onmessage = function (event) {
            console.log(event.data);
        };
        ws.on('close', function () {
            console.log('connection closed');
        });       
    });
    
    console.log('listening');
    
    wss.on('error', function(err) {
        console.log('error' + err);
    });
    

    Il file listener.js sarà simile al seguente:

    const WebSocket = require('hyco-ws');
    
    const ns = "{RelayNamespace}";
    const path = "{HybridConnectionName}";
    const keyrule = "{SASKeyName}";
    const key = "{SASKeyValue}";
    
    var wss = WebSocket.createRelayedServer(
        {
            server : WebSocket.createRelayListenUri(ns, path),
            token: WebSocket.createRelayToken('http://' + ns, keyrule, key)
        }, 
        function (ws) {
            console.log('connection accepted');
            ws.onmessage = function (event) {
                console.log(event.data);
            };
            ws.on('close', function () {
                console.log('connection closed');
            });       
    });
    
    console.log('listening');
    
    wss.on('error', function(err) {
        console.log('error' + err);
    });
    

4. Creare un'applicazione client (mittente)

Per inviare messaggi al servizio di inoltro, verrà scritta un'applicazione console Node.js.

Creare un'applicazione Node.js

Creare un nuovo file JavaScript denominato sender.js.

Aggiungere il pacchetto NPM di inoltro

Eseguire npm install hyco-ws dal prompt dei comandi di Node nella cartella del progetto.

Scrivere codice per inviare messaggi

  1. Aggiungere il valore constants seguente alla parte iniziale del file sender.js.

    const WebSocket = require('hyco-ws');
    const readline = require('readline')
        .createInterface({
            input: process.stdin,
            output: process.stdout
        });;
    
  2. Aggiungere le costanti seguenti al file sender.js per i dettagli della connessione ibrida. Sostituire i segnaposto tra parentesi con i valori ottenuti durante la creazione della connessione ibrida.

    1. const ns: spazio dei nomi dell'inoltro. Assicurarsi di usare il nome completo dello spazio dei nomi, ad esempio {namespace}.servicebus.windows.net.
    2. const path: nome della connessione ibrida.
    3. const keyrule: nome della chiave di firma di accesso condiviso.
    4. const key: valore della chiave di firma di accesso condiviso.
  3. Aggiungere il codice seguente al file sender.js:

    WebSocket.relayedConnect(
        WebSocket.createRelaySendUri(ns, path),
        WebSocket.createRelayToken('http://'+ns, keyrule, key),
        function (wss) {
            readline.on('line', (input) => {
                wss.send(input, null);
            });
    
            console.log('Started client interval.');
            wss.on('close', function () {
                console.log('stopping client interval');
                process.exit();
            });
        }
    );
    

    Il file sender.js sarà simile al seguente:

    const WebSocket = require('hyco-ws');
    const readline = require('readline')
        .createInterface({
            input: process.stdin,
            output: process.stdout
        });;
    
    const ns = "{RelayNamespace}";
    const path = "{HybridConnectionName}";
    const keyrule = "{SASKeyName}";
    const key = "{SASKeyValue}";
    
    WebSocket.relayedConnect(
        WebSocket.createRelaySendUri(ns, path),
        WebSocket.createRelayToken('http://'+ns, keyrule, key),
        function (wss) {
            readline.on('line', (input) => {
                wss.send(input, null);
            });
    
            console.log('Started client interval.');
            wss.on('close', function () {
                console.log('stopping client interval');
                process.exit();
            });
        }
    );
    

5. Eseguire le applicazioni

  1. Eseguire l'applicazione server digitando node listener.js al prompt dei comandi Node.js.
  2. Eseguire l'applicazione client digitando node sender.js al prompt dei comandi Node.js e immettendo testo.
  3. Assicurarsi che la console dell'applicazione server restituisca il testo immesso nell'applicazione client.

applicazioni in esecuzione

A questo punto è stata creata un'applicazione per le connessioni ibride end-to-end con Node.js.

Passaggi successivi: