Condividi tramite

Introduzione alle richieste WebSocket per connessioni ibride di inoltro in Python

  • Articolo

In questa guida introduttiva si creano applicazioni mittente e ricevitore Python che inviano e ricevono messaggi usando il protocollo WebSocket. Le applicazioni usano la funzionalità Connessioni ibride di Inoltro di Azure. Per informazioni di carattere generale su Inoltro di Azure, vedere Che cos'è il servizio di inoltro di Azure?.

In questa guida introduttiva vengono completati i passaggi seguenti:

  1. Creare uno spazio dei nomi di inoltro usando il portale di Azure.
  2. Creare una connessione ibrida nello spazio dei nomi usando il portale di Azure.
  3. Generare un file di proprietà config.json per archiviare i dettagli della connessione
  4. Sviluppare un relaylib.py per le funzioni helper (token di firma di accesso condiviso, URL)
  5. Scrivere uno script server (listener) per ricevere messaggi.
  6. Scrivere uno script client (mittente) per inviare messaggi.
  7. Eseguire lo script del server (listener) e facoltativamente lo script client (mittente).

Prerequisiti

Creare uno spazio dei nomi tramite il portale di Azure

  1. Accedere al portale di Azure.

  2. Scegliere Tutti i servizi dal menu a sinistra. Selezionare Integrazione, cercare Inoltro, spostare il mouse su Inoltro e quindi selezionare Crea.

    Screenshot che mostra la selezione del pulsante Inoltro -> Crea.

  3. Nella pagina Crea spazio dei nomi seguire questa procedura:

    1. Scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.

    2. Per Gruppo di risorse scegliere un gruppo di risorse esistente in cui inserire lo spazio dei nomi oppure crearne uno nuovo.

    3. Immettere un nome per lo spazio dei nomi Relay.

    4. Selezionare l'area in cui deve essere ospitato lo spazio dei nomi.

    5. Selezionare Rivedi e crea nella parte inferiore della pagina.

      Screenshot che mostra la pagina Crea spazio dei nomi.

    6. Nella pagina Rivedi e crea selezionare Crea.

    7. Dopo alcuni minuti viene visualizzata la pagina Inoltro per lo spazio dei nomi .

      Screenshot che mostra la home page per lo spazio dei nomi relay.

Ottenere le credenziali di gestione

  1. Nella pagina Inoltro selezionare Criteri di accesso condiviso nel menu a sinistra.

  2. Nella pagina Criteri di accesso condiviso selezionare RootManageSharedAccessKey.

  3. In Criteri di firma di accesso condiviso: RootManageSharedAccessKey selezionare il pulsante Copia accanto a Stringa di connessione primaria. La stringa di connessione viene copiata negli Appunti per un uso successivo. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.

  4. Ripetere il passaggio precedente per copiare e incollare il valore di Chiave primaria in un percorso temporaneo per usarlo in seguito.

    Screenshot che mostra le informazioni di connessione per lo spazio dei nomi relay.

Creare una connessione ibrida usando il portale di Azure

Nella pagina Inoltro per lo spazio dei nomi seguire questa procedura per creare una connessione ibrida.

  1. Nel menu a sinistra, in Entità selezionare Connessioni ibride e quindi + Connessione ibrida.

    Screenshot che mostra la pagina Connessioni ibride.

  2. Nella pagina Crea connessione ibrida immettere un nome per la connessione ibrida e selezionare Crea.

    Screenshot che mostra la pagina Crea connessione ibrida.

Creare un'applicazione server (listener)

Per ascoltare e ricevere messaggi dall'inoltro, scrivere uno script del server WebSocket Python.

Creare uno script Python

Se è stata disabilitata l'opzione "Richiede autorizzazione client" durante la creazione dell'inoltro, è possibile inviare richieste all'URL delle connessioni ibride con qualsiasi browser. Per accedere agli endpoint protetti, è necessario creare e passare un token di firma di accesso condiviso, come illustrato di seguito.

Ecco un semplice script Python che illustra l'invio di richieste a un URL di connessioni ibride con token di firma di accesso condiviso che usano WebSocket.

Dipendenze

  1. Installare le librerie Python seguenti usando pip prima di eseguire l'applicazione server

    asyncio, json, loggingwebsockets

    Queste librerie possono essere installate usando il comando seguente:

     pip install <package name>

  2. Generare un config.json file per archiviare i dettagli della connessione

    {
    "namespace": "HYBRID_CONNECTION_NAMESPACE",
    "path": "HYBRID_CONNECTION_ENTITY_NAME",
    "keyrule": "SHARED_ACCESS_KEY_NAME",
    "key": "SHARED_ACCESS_PRIMARY_KEY"
 }

    Sostituire i segnaposto tra parentesi con i valori ottenuti durante la creazione della connessione ibrida.

    • namespace: spazio dei nomi dell'inoltro. Assicurarsi di usare il nome completo dello spazio dei nomi, ad esempio {namespace}.servicebus.windows.net.
    • path: nome della connessione ibrida.
    • keyrule - Nome della chiave criteri di accesso condiviso, che è RootManageSharedAccessKey per impostazione predefinita.
    • key - Chiave primaria dello spazio dei nomi salvato in precedenza.

  3. Generare un file di funzione helper per le funzioni helper

    Il file seguente viene usato come relaylib.py e hanno funzioni helper per la generazione di URL WebSocket e i token di firma di accesso condiviso

    Creare uno script Python

    Questo script fornisce funzioni helper per le applicazioni che usano connessioni ibride di inoltro di Azure. Queste funzioni supportano probabilmente attività come la generazione di token di firma di accesso condiviso e la creazione di connessioni WebSocket per la comunicazione sicura.

    Dipendenze

    Installare le librerie Python seguenti usando pip prima di generare lo script di funzione helper: base64, hmachashlibmath, , timeurllib

    Queste librerie possono essere installate usando il comando seguente:

    pip install <package name>

    Scrivere lo script della funzione helper

    Di seguito è riportato l'aspetto relaylib.py del file:

    import base64
import hashlib
import hmac
import math
import time
import urllib

# Function which generates the HMAC-SHA256 of a given message
def hmac_sha256(key, msg):
   hash_obj = hmac.new(key=key, msg=msg, digestmod=hashlib._hashlib.openssl_sha256)
   return hash_obj.digest()

# Function to create a WebSocket URL for listening for a server application
def createListenUrl(serviceNamespace, entityPath, token = None):
   url = 'wss://' + serviceNamespace + '/$hc/' + entityPath + '?sb-hc-action=listen&sb-hc-id=123456'
   if token is not None:
       url = url + '&sb-hc-token=' + urllib.parse.quote(token)
   return url

# Function which creates the url for the client application
def createSendUrl(serviceNamespace, entityPath, token = None):
   url = 'wss://' + serviceNamespace + '/$hc/' + entityPath + '?sb-hc-action=connect&sb-hc-id=123456'
   if token is not None:
       url = url + '&sb-hc-token=' + urllib.parse.quote(token)
   return url

# Function which creates the Service Bus SAS token. 
def createSasToken(serviceNamespace, entityPath, sasKeyName, sasKey):
   uri = "http://" + serviceNamespace + "/" + entityPath
   encodedResourceUri = urllib.parse.quote(uri, safe = '')

   # Define the token validity period in seconds (48 hours in this case)   
   tokenValidTimeInSeconds = 60 * 60 * 48 
   unixSeconds = math.floor(time.time())
   expiryInSeconds = unixSeconds + tokenValidTimeInSeconds

   # Create the plain signature string by combining the encoded URI and the expiry time
   plainSignature = encodedResourceUri + "\n" + str(expiryInSeconds)

   # Encode the SAS key and the plain signature as bytes
   sasKeyBytes = sasKey.encode("utf-8")
   plainSignatureBytes = plainSignature.encode("utf-8")
   hashBytes = hmac_sha256(sasKeyBytes, plainSignatureBytes)
   base64HashValue = base64.b64encode(hashBytes)

   # Construct the SAS token string
   token = "SharedAccessSignature sr=" + encodedResourceUri + "&sig=" +  urllib.parse.quote(base64HashValue) + "&se=" + str(expiryInSeconds) + "&skn=" + sasKeyName
   return token

Scrivere codice per ricevere messaggi

  1. Verificare che la dipendenza config.json e relaylib.py siano disponibili nel percorso

  2. Di seguito è riportato l'aspetto listener.py del file:

    import asyncio
import json
import logging
import relaylib
import websockets

async def run_application(config):
    serviceNamespace = config["namespace"]
    entityPath = config["path"]
    sasKeyName = config["keyrule"]
    sasKey = config["key"]
    serviceNamespace += ".servicebus.windows.net"
    # Configure logging
    logging.basicConfig(level=logging.INFO)  # Enable DEBUG/INFO logging as appropriate

    try:
        logging.debug("Generating SAS Token for: %s", serviceNamespace)
        token = relaylib.createSasToken(serviceNamespace, entityPath, sasKeyName, sasKey)
        logging.debug("Generating WebSocket URI")
        wssUri = relaylib.createListenUrl(serviceNamespace, entityPath, token)
        async with websockets.connect(wssUri) as websocket:
            logging.info("Listening for messages on Azure Relay WebSocket...")
            while True:
                message = await websocket.recv()
                logging.info("Received message: %s", message)
    except KeyboardInterrupt:
        logging.info("Exiting listener.")

    if __name__ == "__main__":
        # Load configuration from JSON file
        with open("config.json") as config_file:
        config = json.load(config_file)

    asyncio.run(run_application(config))

Creare un'applicazione client (mittente)

Per inviare messaggi all'inoltro, è possibile usare qualsiasi client HTTP o WebSocket, l'esempio incluso è un'implementazione python.

Scrivere codice per inviare messaggi

  1. Verificare che la dipendenza config.json e relaylib.py siano disponibili nel percorso

  2. Di seguito è riportato l'aspetto sender.py del file:

    import asyncio
import json
import logging
import relaylib
import websockets

async def run_application(message, config):
    service_namespace = config["namespace"]
    entity_path = config["path"]
    sas_key_name = config["keyrule"]
    sas_key = config["key"]
    service_namespace += ".servicebus.windows.net"

    # Configure logging
    logging.basicConfig(level=logging.DEBUG)  # Enable debug logging

    token = relaylib.createSasToken(service_namespace, entity_path, sas_key_name, sas_key)
    logging.debug("Token: %s", token)
    wss_uri = relaylib.createSendUrl(service_namespace, entity_path, token)
    logging.debug("WssURI: %s", wss_uri)

    try:
        async with websockets.connect(wss_uri) as websocket:
            logging.info("Sending message to Azure Relay WebSocket...")
            await websocket.send(json.dumps({"message": message}))
            logging.info("Message sent: %s", message)
    except Exception as e:
        logging.error("An error occurred: %s", str(e))

if __name__ == "__main__":
    # Load configuration from JSON file
    with open("config.json") as config_file:
        config = json.load(config_file)

    asyncio.run(run_application("This is a message to Azure Relay Hybrid Connections!", config))

Nota

Il codice di esempio in questo articolo usa un stringa di connessione per eseguire l'autenticazione in uno spazio dei nomi di Inoltro di Azure per semplificare l'esercitazione. È consigliabile usare l'autenticazione con ID Entra di Microsoft negli ambienti di produzione, invece di usare stringa di connessione o firme di accesso condiviso, che possono essere compromesse più facilmente. Per informazioni dettagliate e codice di esempio per l'uso dell'autenticazione di Microsoft Entra ID, vedere Autenticare e autorizzare un'applicazione con Microsoft Entra ID per accedere alle entità di inoltro di Azure e Autenticare un'identità gestita con Microsoft Entra ID per accedere alle risorse di Inoltro di Azure.

Eseguire le applicazioni

  1. Eseguire l'applicazione server: da un prompt dei comandi digitare python3 listener.py.
  2. Eseguire l'applicazione client: da un prompt dei comandi digitare python3 sender.py.

È stata creata un'applicazione di connessioni ibride end-to-end con Python.

Passaggi successivi

In questa guida introduttiva sono state create applicazioni client e server Python che hanno usato WebSocket per inviare e ricevere messaggi. La funzionalità Connessioni ibride di Inoltro di Azure supporta anche l'uso di HTTP per l'invio e la ricezione di messaggi. Per informazioni sull'uso di HTTP con Connessioni ibride di Inoltro di Azure, vedere la guida introduttiva di HTTP.

In questa guida introduttiva è stato usato Python per creare applicazioni client e server. Per informazioni su come scrivere applicazioni client e server con .NET Framework, vedere l'argomento di avvio rapido su HTTP .NET o .NET HTTP.