Bien démarrer avec les requêtes WebSockets de connexions hybrides Relay en Python

• NET
• Node.JS

Dans ce guide de démarrage rapide, vous créez des applications Python, à savoir un expéditeur et un récepteur, qui envoient et reçoivent des messages à l’aide du protocole WebSocket. Les applications utilisent la fonctionnalité Connexions hybrides d’Azure Relay. Pour en savoir plus sur Azure Relay en général, consultez Azure Relay.

Ce démarrage rapide comporte les étapes suivantes :

1. Créer un espace de noms Relay à l’aide du portail Azure.
2. Créer une connexion hybride dans cet espace de noms à l’aide du portail Azure.
3. Générer un fichier de propriétés config.json pour stocker les détails de connexion
4. Développer un relaylib.py pour les fonctions d’assistance (jetons SAP, URL)
5. Écrivez un script serveur (écouteur) pour recevoir des messages.
6. Écrivez un script client (expéditeur) pour envoyer des messages.
7. Exécutez le script serveur (écouteur) et éventuellement le script client (expéditeur).

Prérequis

• Python Assurez-vous que vous utilisez Python 3.10+
• Un abonnement Azure. Si vous n’en avez pas, créez un compte gratuit avant de commencer.

Créer un espace de noms à l’aide du Portail Azure

1. Connectez-vous au portail Azure.

2. Sélectionnez Tous les services dans le menu de gauche. Sélectionnez Intégration, recherchez Relais, déplacez la souris sur Relais, puis sélectionnez Créer.

   

3. Dans la page Créer un espace de noms, suivez ces étapes :

   1. Choisissez un abonnement Azure dans lequel créer l’espace de noms.

   2. Pour l’option Groupe de ressources, choisissez un groupe de ressources existant dans lequel placer l’espace de noms, ou créez-en un nouveau.

   3. Donnez un nom à l’espace de noms Relais.

   4. Sélectionnez la région où votre espace de noms doit être hébergé.

   5. Au bas de la page, sélectionnez Examiner et créer.

      

   6. Dans la page Vérifier + créer, sélectionnez Créer.

   7. Après quelques minutes, la page Relais de l’espace de noms s’affiche.

      

Obtenir des informations d'identification d'administration

1. Dans la page Relais, sélectionnez Stratégies d’accès partagé sur le menu de gauche. `

2. Dans la page Stratégies d’accès partagé, sélectionnez RootManageSharedAccessKey.

3. Sous Stratégie SAS : RootManageSharedAccessKey, sélectionnez le bouton Copier à côté de Chaîne de connexion principale. L’action copie la chaîne de connexion dans le Presse-papiers pour l’utiliser plus tard. Copiez cette valeur dans le Bloc-notes ou un autre emplacement temporaire.

4. Répétez l’étape précédente pour copier et coller la valeur de Clé primaire dans un emplacement temporaire pour une utilisation ultérieure.

   

Créer une connexion hybride à l’aide du portail Azure

Dans la page Relay de votre espace de noms, suivez ces étapes pour créer une connexion hybride.

1. Dans le menu de gauche, sous Entités, sélectionnez Connexions hybrides, puis + Connexion hybride.

   

2. Dans la page Créer une connexion hybride, entrez un nom pour la connexion hybride, puis sélectionnez Créer.

   

Développer des fonctions d’assistance

Créer un script Python

Ce script fournit des fonctions d’assistance pour les applications utilisant les connexions hybrides Azure Relay. Ces fonctions aident probablement à effectuer des tâches telles que la génération de jetons SAP et l’établissement de connexions WebSocket pour une communication sécurisée.

Dépendances

Installez les bibliothèques Python suivantes à l’aide de pip avant de générer le script de fonction d’assistance : base64, hashlib, hmac, math, time, urllib

Ces bibliothèques peuvent être installées avec la commande suivante :

pip install <package name>

Écrire le script de fonction d’assistance

Voici à quoi devrait ressembler votre fichier 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

Créer une application de serveur (récepteur)

Pour écouter et recevoir des messages du Relais, écrivez un script Python WebSocket Server.

Créer un script Python

Si vous avez désactivé l’option « Nécessite l’autorisation client » lors de la création du Relay, vous pouvez envoyer des requêtes à l’URL de Connexions hybrides avec n’importe quel navigateur. Pour accéder à des points de terminaison protégés, vous devez créer et transmettre un jeton SAS, qui est illustré ici.

Voici un script Python simple qui illustre l’envoi de requêtes à une URL de connexions hybrides avec des jetons SAP en utilisant des WebSockets.

Dépendances

1. Installer les bibliothèques Python suivantes à l’aide de pip avant d’exécuter l’application serveur

   asyncio, json, logging, websockets

   Ces bibliothèques peuvent être installées avec la commande suivante :

    pip install <package name>
   

2. Générer un fichier config.json pour stocker les détails de votre connexion

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

   Remplacez les espaces réservés entre crochets par les valeurs obtenues lors de la création de la connexion hybride.

   • namespace - L’espace de noms du relais. Veillez à utiliser le nom de l’espace de noms complet, par exemple {namespace}.servicebus.windows.net.
   • path - Le nom de la connexion hybride.
   • keyrule : nom de votre clé de stratégies d’accès partagé, qui est RootManageSharedAccessKey par défaut.
   • key : clé primaire de l’espace de noms que vous avez enregistrée précédemment.

3. Générer un fichier de fonction d’assistance pour les fonctions d’assistance

   Le fichier suivant est utilisé comme relaylib.py et contient des fonctions d’assistance pour la génération d’URL webSocket et les jetons SAS

   Créer un script Python

   Ce script fournit des fonctions d’assistance pour les applications utilisant les connexions hybrides Azure Relay. Ces fonctions aident probablement à effectuer des tâches telles que la génération de jetons SAP et l’établissement de connexions WebSocket pour une communication sécurisée.

   Dépendances

   Installez les bibliothèques Python suivantes à l’aide de pip avant de générer le script de fonction d’assistance : base64, hashlib, hmac, math, time, urllib

   Ces bibliothèques peuvent être installées avec la commande suivante :

   pip install <package name>
   

   Écrire le script de fonction d’assistance

   Voici à quoi devrait ressembler votre fichier 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
   

Écriture de code pour envoyer des messages

1. Vérifiez que votre dépendance config.json et relaylib.py sont disponibles dans votre chemin d’accès

2. Voici à quoi devrait ressembler votre fichier 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))
   

Créer une application cliente (expéditeur)

Pour envoyer des messages au relais, vous pouvez utiliser n’importe quel client HTTP ou WebSocket, l’exemple inclus est une implémentation python.

Créer un script Python

Si vous avez désactivé l’option « Nécessite l’autorisation client » lors de la création du Relay, vous pouvez envoyer des requêtes à l’URL de Connexions hybrides avec n’importe quel navigateur. Pour accéder à des points de terminaison protégés, vous devez créer et transmettre un jeton SAS, qui est illustré ici.

Voici un script Python simple qui illustre l’envoi de requêtes à une URL de connexions hybrides avec des jetons SAP en utilisant des WebSockets.

Dépendances

1. Installer les bibliothèques Python suivantes à l’aide de pip avant d’exécuter l’application cliente

   asyncio, json, logging, websockets

   Ces bibliothèques peuvent être installées avec la commande suivante :

    pip install <package name>
   

2. Générer un fichier config.json pour stocker les détails de votre connexion

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

   Remplacez les espaces réservés entre crochets par les valeurs obtenues lors de la création de la connexion hybride.

   • namespace - L’espace de noms du relais. Veillez à utiliser le nom de l’espace de noms complet, par exemple {namespace}.servicebus.windows.net.
   • path - Le nom de la connexion hybride.
   • keyrule : nom de votre clé de stratégies d’accès partagé, qui est RootManageSharedAccessKey par défaut.
   • key : clé primaire de l’espace de noms que vous avez enregistrée précédemment.

3. Générer un fichier de fonction d’assistance pour les fonctions d’assistance

   Le fichier suivant est utilisé comme relaylib.py et contient des fonctions d’assistance pour la génération d’URL webSocket et les jetons SAS

   Créer un script Python

   Ce script fournit des fonctions d’assistance pour les applications utilisant les connexions hybrides Azure Relay. Ces fonctions aident probablement à effectuer des tâches telles que la génération de jetons SAP et l’établissement de connexions WebSocket pour une communication sécurisée.

   Dépendances

   Installez les bibliothèques Python suivantes à l’aide de pip avant de générer le script de fonction d’assistance : base64, hashlib, hmac, math, time, urllib

   Ces bibliothèques peuvent être installées avec la commande suivante :

   pip install <package name>
   

   Écrire le script de fonction d’assistance

   Voici à quoi devrait ressembler votre fichier 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
   

Écriture de code pour envoyer des messages

1. Vérifiez que votre dépendance config.json et relaylib.py sont disponibles dans votre chemin d’accès

2. Voici à quoi devrait ressembler votre fichier 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))
   

Remarque

L’exemple de code de cet article utilise une chaîne de connexion pour s’authentifier auprès d’un espace de noms Azure Relay afin de simplifier le tutoriel. Nous vous recommandons d’utiliser l’authentification Microsoft Entra ID dans les environnements de production, plutôt que d’utiliser des chaînes de connexion ou des signatures d’accès partagé, qui peuvent être plus facilement compromises. Pour obtenir des informations détaillées et des exemples de code sur l’utilisation de l’authentification Microsoft Entra ID, consultez Authentifier et autoriser une application avec Microsoft Entra ID pour accéder aux entités Azure Relay et Authentifier une identité managée avec Microsoft Entra ID pour accéder aux ressources Azure Relay.

Exécution des applications

1. Exécutez l’application serveur : à partir d’un type d’invite de commandes python3 listener.py.
2. Exécutez l’application cliente : à partir d’un type d’invite de commandes python3 sender.py.

Félicitations, vous avez créé une application de connexions hybrides complète avec Python !

Étapes suivantes

Dans ce guide de démarrage rapide, vous avez créé des applications cliente et serveur Python qui utilisent des WebSockets pour envoyer et recevoir des messages. La fonctionnalité Connexions hybrides d’Azure Relay permet également d’envoyer et de recevoir des messages avec HTTP. Pour apprendre à utiliser HTTP avec des connexions hybrides Azure Relay, consultez le guide de démarrage rapide de HTTP.

Dans ce guide de démarrage rapide, vous avez utilisé Python pour créer des applications cliente et serveur. Pour apprendre à écrire des applications cliente et serveur à l’aide du .NET Framework, consultez le guide de démarrage rapide de HTTP dans .NET ou le guide de démarrage rapide de HTTP dans .NET.