Partager via

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

  • Article

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.

    Capture d’écran montrant la sélection de Relais -> Bouton 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.

      Capture d’écran montrant la page Créer un espace de noms.

    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.

      Capture d’écran montrant la page d’accueil de l’espace de noms Relais.

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.

    Capture d’écran montrant les informations de connexion pour l’espace de noms Relais.

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.

    Capture d’écran montrant la page Connexions.

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

    Capture d’écran montrant la page Créer une connexion hybride.

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 recevoir 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.

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

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.