Compartir a través de

Introducción a las solicitudes WebSocket de conexiones híbridas de Relay en Python

  • Artículo

En esta guía de inicio rápido, creará aplicaciones de remitente y receptor de Python que envían y reciben mensajes mediante el protocolo WebSocket. Las aplicaciones usan la característica Conexiones híbridas de Azure Relay. Para información acerca de Azure Relay en general, consulte Azure Relay.

En esta guía de inicio rápido, realizará los siguientes pasos:

  1. Creación de un espacio de nombres de Relay mediante Azure Portal.
  2. Creación de una conexión híbrida en dicho espacio de nombres mediante Azure Portal.
  3. Generación de un archivo de propiedades de config.json para almacenar los detalles de la conexión
  4. Desarrollo de un relaylib.py para funciones auxiliares (tokens de SAS, direcciones URL)
  5. Escriba un script de servidor (cliente de escucha) para recibir mensajes.
  6. Escriba un script de cliente (emisor) para enviar mensajes.
  7. Ejecute el script del servidor (cliente de escucha) y, opcionalmente, el script de cliente (emisor).

Requisitos previos

Creación de un espacio de nombres mediante Azure Portal

  1. Inicie sesión en Azure Portal.

  2. Seleccione Todos los servicios en el menú de la izquierda. Seleccione Integración, busque Retransmisiones, mueva el mouse sobre Retransmisiones y, a continuación, seleccione Crear.

    Captura de pantalla en la que se muestra la selección del botón Retransmisiones -> Crear.

  3. En la página Crear espacio de nombres, siga estos pasos:

    1. Elija la suscripción de Azure en la que se va a crear el espacio de nombres.

    2. En Grupo de recursos, elija un grupo de recursos existente en el que se colocará el espacio de nombres o cree uno.

    3. Escriba un nombre para el espacio de nombres de Retransmisión.

    4. Seleccione la región donde se debe hospedar el espacio de nombres.

    5. En la parte inferior de la página, seleccione Revisar y crear.

      Captura de pantalla en la que se muestra la página Crear un espacio de nombres.

    6. En la página Revisar y crear, seleccione Crear.

    7. Al cabo de unos minutos, verá la página Retransmisión del espacio de nombres.

      Captura de pantalla en la que se muestra la página principal del espacio de nombres de Retransmisión.

Obtención de las credenciales de administración

  1. En la página Retransmisión, seleccione Directivas de acceso compartido en el menú de la izquierda.

  2. En la página Directivas de acceso compartido, seleccione RootManageSharedAccessKey.

  3. En Directiva SAS: RootManageSharedAccessKey, haga clic en el botón Copiar situado junto a Cadena de conexión principal. Esta acción copia la cadena de conexión en el Portapapeles para su uso posterior. Pegue este valor en el Bloc de notas o cualquier otra ubicación temporal.

  4. Repita el paso anterior para copiar y pegar el valor de Clave principal en una ubicación temporal para su uso posterior.

    Captura de pantalla en la que se muestra la información de conexión para el espacio de nombres de Retransmisión.

Creación de una conexión híbrida mediante Azure Portal

En la página Relay del espacio de nombres, siga estos pasos para crear una conexión híbrida.

  1. En el menú de la izquierda, en Entidades, seleccione Conexiones híbridas y, después, + Conexión híbrida.

    Captura de pantalla en la que se muestra la página Conexiones híbridas.

  2. En la página Crear conexión híbrida, escriba un nombre para la conexión híbrida y seleccione Crear.

    Captura de pantalla en la que se muestra la página Crear conexión híbrida.

Desarrollo de funciones auxiliares

Crear un script de Python

Este script proporciona funciones auxiliares para aplicaciones que usan conexiones híbridas de Azure Relay. Es probable que estas funciones ayuden con tareas como generar tokens de SAS y establecer conexiones WebSocket para una comunicación segura.

Dependencias

Instale las siguientes bibliotecas de Python mediante pip antes de generar el script de función auxiliar: base64, hashlib, hmac, math, time, urllib

Estas bibliotecas se pueden instalar mediante el siguiente comando:

pip install <package name>

Escritura del script de función auxiliar

Este es el aspecto que debe tener el archivo relaylib.py:

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

Creación de una aplicación de servidor (agente de escucha)

Para escuchar y recibir mensajes de Relay, escriba un script de servidor WebSocket de Python.

Crear un script de Python

Si deshabilitó la opción que indica que se requiere la autorización del cliente al crear la retransmisión, puede enviar solicitudes a la dirección URL de conexiones híbridas con un explorador. Para acceder a los puntos de conexión protegidos, debe crear y pasar un token de SAS, que se muestra aquí.

Este es un script de Python sencillo que muestra el envío de solicitudes a una dirección URL de conexiones híbridas con tokens de SAS mediante WebSockets.

Dependencias

  1. Instale las siguientes bibliotecas de Python mediante pip antes de ejecutar la aplicación de servidor.

    asyncio, json, logging, websockets

    Estas bibliotecas se pueden instalar mediante el siguiente comando:

     pip install <package name>

  2. Generación de un archivo config.json para almacenar los detalles de la conexión

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

    Reemplace los marcadores de posición entre corchetes por los valores que obtuvo al crear la conexión híbrida.

    • namespace: el espacio de nombres de Relay. Asegúrese de utilizar el nombre de espacio de nombres completo; por ejemplo, {namespace}.servicebus.windows.net.
    • path: el nombre de la conexión híbrida.
    • keyrule: nombre de la clave de directivas de acceso compartido, que es RootManageSharedAccessKey de forma predeterminada.
    • key: la clave principal del espacio de nombres que guardó anteriormente.

  3. Generación de un archivo de función auxiliar para funciones auxiliares

    El siguiente archivo se usa como relaylib.py y tiene funciones auxiliares para la generación de direcciones URL de WebSocket y tokens de SAS.

    Crear un script de Python

    Este script proporciona funciones auxiliares para aplicaciones que usan conexiones híbridas de Azure Relay. Es probable que estas funciones ayuden con tareas como generar tokens de SAS y establecer conexiones WebSocket para una comunicación segura.

    Dependencias

    Instale las siguientes bibliotecas de Python mediante pip antes de generar el script de función auxiliar: base64, hashlib, hmac, math, time, urllib

    Estas bibliotecas se pueden instalar mediante el siguiente comando:

    pip install <package name>

    Escritura del script de función auxiliar

    Este es el aspecto que debe tener el archivo relaylib.py:

    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

Escritura de código para enviar mensajes

  1. Asegúrese de que las dependencias config.json y relaylib.py estén disponibles en la ruta de acceso

  2. Este es el aspecto que debe tener el archivo listener.py:

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

Creación de una aplicación de cliente (remitente)

Para enviar mensajes a Relay, puede usar cualquier cliente HTTP o WebSocket. El ejemplo incluido es una implementación de Python.

Crear un script de Python

Si deshabilitó la opción que indica que se requiere la autorización del cliente al crear la retransmisión, puede enviar solicitudes a la dirección URL de conexiones híbridas con un explorador. Para acceder a los puntos de conexión protegidos, debe crear y pasar un token de SAS, que se muestra aquí.

Este es un script de Python sencillo que muestra el envío de solicitudes a una dirección URL de conexiones híbridas con tokens de SAS mediante WebSockets.

Dependencias

  1. Instale las siguientes bibliotecas de Python mediante pip antes de ejecutar la aplicación cliente.

    asyncio, json, logging, websockets

    Estas bibliotecas se pueden instalar mediante el siguiente comando:

     pip install <package name>

  2. Generación de un archivo config.json para almacenar los detalles de la conexión

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

    Reemplace los marcadores de posición entre corchetes por los valores que obtuvo al crear la conexión híbrida.

    • namespace: el espacio de nombres de Relay. Asegúrese de utilizar el nombre de espacio de nombres completo; por ejemplo, {namespace}.servicebus.windows.net.
    • path: el nombre de la conexión híbrida.
    • keyrule: nombre de la clave de directivas de acceso compartido, que es RootManageSharedAccessKey de forma predeterminada.
    • key: la clave principal del espacio de nombres que guardó anteriormente.

  3. Generación de un archivo de función auxiliar para funciones auxiliares

    El siguiente archivo se usa como relaylib.py y tiene funciones auxiliares para la generación de direcciones URL de WebSocket y tokens de SAS.

    Crear un script de Python

    Este script proporciona funciones auxiliares para aplicaciones que usan conexiones híbridas de Azure Relay. Es probable que estas funciones ayuden con tareas como generar tokens de SAS y establecer conexiones WebSocket para una comunicación segura.

    Dependencias

    Instale las siguientes bibliotecas de Python mediante pip antes de generar el script de función auxiliar: base64, hashlib, hmac, math, time, urllib

    Estas bibliotecas se pueden instalar mediante el siguiente comando:

    pip install <package name>

    Escritura del script de función auxiliar

    Este es el aspecto que debe tener el archivo relaylib.py:

    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

Escritura de código para enviar mensajes

  1. Asegúrese de que las dependencias config.json y relaylib.py estén disponibles en la ruta de acceso

  2. Este es el aspecto que debe tener el archivo sender.py:

     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.createListenUrl(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:

El código de ejemplo de este artículo usa una cadena de conexión para autenticarse en un espacio de nombres de Azure Relay para simplificar el tutorial. Se recomienda usar la autenticación de Microsoft Entra ID en entornos de producción, en lugar de usar cadenas de conexión o firmas de acceso compartido, lo que puede verse más fácilmente comprometido. Para obtener información detallada y código de ejemplo para usar la autenticación de Microsoft Entra ID, consulte Autenticación y autorización de una aplicación con Microsoft Entra ID para acceder a las entidades de Azure Relay y Autenticación de una identidad administrada con Microsoft Entra ID para acceder a los recursos de Azure Relay.

Ejecución de las aplicaciones

  1. Ejecute la aplicación de servidor: en un símbolo del sistema escriba python3 listener.py.
  2. Ejecute la aplicación cliente: desde un símbolo del sistema, escriba python3 sender.py.

Enhorabuena, ha creado una aplicación de conexiones híbridas de extremo a extremo mediante Python.

Pasos siguientes

En esta guía de inicio rápido, ha creado aplicaciones de cliente y servidor de Python que han usado WebSockets para enviar y recibir mensajes. La característica Conexiones híbridas de Azure Relay también admite el uso de HTTP para enviar y recibir mensajes. Para aprender a usar HTTP con Conexiones híbridas de Azure Relay, consulte la guía de inicio rápido de HTTP.

En esta guía de inicio rápido, ha usado Python para crear aplicaciones cliente y servidor. Para aprender a escribir aplicaciones cliente y servidor con .NET Framework, consulte la Guía de inicio rápido de HTTP para .NET o la Guía de inicio rápido de HTTP para .NET.