Freigeben über

Erste Schritte mit WebSocket-Anfragen von Relay Hybrid Connections in Python

  • Artikel

In dieser Schnellstartanleitung erstellen Sie Sender- und Empfängeranwendungen in Python, die mithilfe des WebSocket-Protokoll Nachrichten senden und empfangen. Die Anwendungen verwenden das Hybrid Connections-Feature von Azure Relay. Allgemeine Informationen zu Azure Relay finden Sie unter Was ist Azure Relay?.

Diese Schnellstartanleitung umfasst folgende Schritte:

  1. Erstellen eines Relay-Namespace über das Azure-Portal
  2. Erstellen einer Hybridverbindung in diesem Namespace über das Azure-Portal
  3. Generieren einer config.json-Eigenschaftendatei zum Speichern von Verbindungsdetails
  4. Entwickeln einer relaylib.py für Hilfsfunktionen (SAS-Token, URLs)
  5. Schreiben Sie ein Serverskript (Listener), um Nachrichten zu empfangen.
  6. Schreiben Sie ein Clientskript (Absender), um Nachrichten zu senden.
  7. Führen Sie das Serverskript (Listener) und optional das Clientskript (Absender) aus.

Voraussetzungen

  • Python. Stellen Sie sicher, dass Sie Python 3.10+ oder höher ausführen
  • Ein Azure-Abonnement. Falls Sie kein Abonnement besitzen, können Sie ein kostenloses Konto erstellen, bevor Sie beginnen.

Erstellen eines Namespace mithilfe des Azure-Portals

  1. Melden Sie sich beim Azure-Portal an.

  2. Wählen Sie im Menü links Alle Dienste aus. Wählen Sie Integration aus, suchen Sie nach Relays, zeigen Sie mit der Maus auf Relays, und wählen Sie dann Erstellen.

    Screenshot: Auswahl von Relays > Schaltfläche „Erstellen“

  3. Führen Sie die folgenden Schritte auf der Seite Namespace erstellen aus:

    1. Wählen Sie ein Azure-Abonnement aus, in dem der Namespace erstellt werden soll.

    2. Wählen Sie unter Ressourcengruppe eine vorhandene Ressourcengruppe aus, in der der Namespace platziert werden soll, oder erstellen Sie eine neue Ressourcengruppe.

    3. Geben Sie einen Namen für den Relay-Namespace ein.

    4. Wählen Sie die Region aus, in dem bzw. in der Ihr Namespace gehostet werden soll.

    5. Wählen Sie am unteren Rand der Seite die Option Bewerten + erstellen aus.

      Screenshot: Seite „Namespace erstellen“

    6. Wählen Sie auf der Seite Überprüfen + erstellen die Option Erstellen aus.

    7. Nach ein paar Minuten sehen Sie die Seite Vermittlung für den Namespace.

      Screenshot: Startseite für den Relay-Namespace

Abrufen von Anmeldeinformationen für die Verwaltung

  1. Wählen Sie auf der Seite Vermittlung die Option Freigegebene Zugriffsrichtlinien im linken Menü aus. `

  2. Wählen Sie auf der Seite Freigegebene Zugriffsrichtlinien die Option RootManageSharedAccessKey aus.

  3. Klicken Sie unter SAS-Richtlinie: RootManageSharedAccessKey neben Primäre Verbindungszeichenfolge auf die Schaltfläche Kopieren. Dadurch wird die Verbindungszeichenfolge zur späteren Verwendung in die Zwischenablage kopiert. Fügen Sie diesen Wert in den Editor oder an einem anderen temporären Speicherort ein.

  4. Wiederholen Sie den vorherigen Schritt, um den Wert von Primärschlüssel zu kopieren und zur späteren Verwendung an einem temporären Speicherort einzufügen.

    Screenshot: Verbindungsinformationen für den Relay-Namespace

Erstellen einer Hybridverbindung mit dem Azure-Portal

Führen Sie auf der Seite Relay für Ihren Namespace die folgenden Schritte aus, um eine Hybridverbindung zu erstellen.

  1. Wählen Sie im linken Menü unter Entitäten die Option Hybridverbindungen und dann + Hybridverbindung aus.

    Screenshot: Seite „Hybridverbindungen“

  2. Geben Sie auf der Seite Hybridverbindung erstellen einen Namen für die Hybridverbindung ein, und wählen Sie dann Erstellen aus.

    Screenshot: Seite „Hybridverbindung erstellen“

Entwickeln von Hilfsfunktionen

Erstellen eines Python-Skripts

Dieses Skript stellt Hilfsfunktionen für Anwendungen bereit, die Azure Relay Hybrid Connections verwenden. Diese Funktionen unterstützen wahrscheinlich Aufgaben wie das Generieren von SAS-Token und das Einrichten von WebSocket-Verbindungen für sichere Kommunikation.

Abhängigkeiten

Installieren Sie die folgenden Python-Bibliotheken mithilfe von Pip, bevor Sie das Hilfsfunktionsskript generieren: base64, hashlib, hmac, math, time, urllib

Diese Bibliotheken können mit dem folgenden Befehl installiert werden:

pip install <package name>

Schreiben des Hilfsfunktionsskripts

Die Datei relaylib.py sollte wie folgt aussehen:

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

Erstellen einer Serveranwendung (Listener)

Um Nachrichten vom Relay abzuhören und zu empfangen, schreiben Sie ein Python WebSocket Server-Skript.

Erstellen eines Python-Skripts

Wenn Sie die Option „Clientautorisierung erforderlich“ bei der Relay-Erstellung deaktiviert haben, können Sie mit jedem Browser Anforderungen an die URL der Hybridverbindungen senden. Für den Zugriff auf geschützte Endpunkte müssen Sie ein SAS-Token erstellen und übergeben, das hier gezeigt wird.

Hier ist ein einfaches Python-Skript, welches das Senden von Anforderungen an eine Hybridverbindungs-URL mit SAS-Token mithilfe von WebSockets veranschaulicht.

Abhängigkeiten

  1. Installieren Sie die folgenden Python-Bibliotheken mithilfe von Pip, bevor Sie die Serveranwendung ausführen

    asyncio, json, logging, websockets

    Diese Bibliotheken können mit dem folgenden Befehl installiert werden:

     pip install <package name>

  2. Generieren einer config.json-Datei zum Speichern der Verbindungsdetails

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

    Ersetzen Sie die Platzhalter in Klammern durch die Werte, die beim Erstellen der Hybridverbindung abgerufen wurden.

    • namespace – der Relay-Namespace. Achten Sie darauf, dass Sie den vollqualifizierten Namespacenamen verwenden, wie z.B. {namespace}.servicebus.windows.net.
    • path – der Name der Hybridverbindung
    • keyrule – Name des Schlüssels für SAS-Richtlinien, der standardmäßig RootManageSharedAccessKey ist.
    • key – Der Primärschlüssel des zuvor gespeicherten Namespaces.

  3. Generieren einer Hilfsfunktionsdatei für Hilfsfunktionen

    Die folgende Datei wird als relaylib.py verwendet und verfügt über Hilfsfunktionen für die WebSocket-URL-Generierung und SAS-Token

    Erstellen eines Python-Skripts

    Dieses Skript stellt Hilfsfunktionen für Anwendungen bereit, die Azure Relay Hybrid Connections verwenden. Diese Funktionen unterstützen wahrscheinlich Aufgaben wie das Generieren von SAS-Token und das Einrichten von WebSocket-Verbindungen für sichere Kommunikation.

    Abhängigkeiten

    Installieren Sie die folgenden Python-Bibliotheken mithilfe von Pip, bevor Sie das Hilfsfunktionsskript generieren: base64, hashlib, hmac, math, time, urllib

    Diese Bibliotheken können mit dem folgenden Befehl installiert werden:

    pip install <package name>

    Schreiben des Hilfsfunktionsskripts

    Die Datei relaylib.py sollte wie folgt aussehen:

    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

Schreiben von Code zum Senden von Nachrichten

  1. Stellen Sie sicher, dass Ihre Abhängigkeit config.json und relaylib.py in Ihrem Pfad verfügbar sind

  2. Die Datei listener.py sollte wie folgt aussehen:

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

Erstellen einer Clientanwendung (Absender)

Um Nachrichten an das Relay zu senden, können Sie einen beliebigen HTTP- oder WebSocket-Client verwenden, das Beispiel ist eine Python-Implementierung.

Erstellen eines Python-Skripts

Wenn Sie die Option „Clientautorisierung erforderlich“ bei der Relay-Erstellung deaktiviert haben, können Sie mit jedem Browser Anforderungen an die URL der Hybridverbindungen senden. Für den Zugriff auf geschützte Endpunkte müssen Sie ein SAS-Token erstellen und übergeben, das hier gezeigt wird.

Hier ist ein einfaches Python-Skript, welches das Senden von Anforderungen an eine Hybridverbindungs-URL mit SAS-Token mithilfe von WebSockets veranschaulicht.

Abhängigkeiten

  1. Installieren Sie die folgenden Python-Bibliotheken mithilfe von Pip, bevor Sie die Clientanwendung ausführen

    asyncio, json, logging, websockets

    Diese Bibliotheken können mit dem folgenden Befehl installiert werden:

     pip install <package name>

  2. Generieren einer config.json-Datei zum Speichern der Verbindungsdetails

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

    Ersetzen Sie die Platzhalter in Klammern durch die Werte, die beim Erstellen der Hybridverbindung abgerufen wurden.

    • namespace – der Relay-Namespace. Achten Sie darauf, dass Sie den vollqualifizierten Namespacenamen verwenden, wie z.B. {namespace}.servicebus.windows.net.
    • path – der Name der Hybridverbindung
    • keyrule – Name des Schlüssels für SAS-Richtlinien, der standardmäßig RootManageSharedAccessKey ist.
    • key – Der Primärschlüssel des zuvor gespeicherten Namespaces.

  3. Generieren einer Hilfsfunktionsdatei für Hilfsfunktionen

    Die folgende Datei wird als relaylib.py verwendet und verfügt über Hilfsfunktionen für die WebSocket-URL-Generierung und SAS-Token

    Erstellen eines Python-Skripts

    Dieses Skript stellt Hilfsfunktionen für Anwendungen bereit, die Azure Relay Hybrid Connections verwenden. Diese Funktionen unterstützen wahrscheinlich Aufgaben wie das Generieren von SAS-Token und das Einrichten von WebSocket-Verbindungen für sichere Kommunikation.

    Abhängigkeiten

    Installieren Sie die folgenden Python-Bibliotheken mithilfe von Pip, bevor Sie das Hilfsfunktionsskript generieren: base64, hashlib, hmac, math, time, urllib

    Diese Bibliotheken können mit dem folgenden Befehl installiert werden:

    pip install <package name>

    Schreiben des Hilfsfunktionsskripts

    Die Datei relaylib.py sollte wie folgt aussehen:

    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

Schreiben von Code zum Senden von Nachrichten

  1. Stellen Sie sicher, dass Ihre Abhängigkeit config.json und relaylib.py in Ihrem Pfad verfügbar sind

  2. Die Datei sender.py sollte wie folgt aussehen:

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

Ausführen der Anwendungen

  1. Führen Sie die Serveranwendung aus: über einen Eingabeaufforderungstyp python3 listener.py.
  2. Führen Sie die Clientanwendung aus: über einen Eingabeaufforderungstyp python3 sender.py.

Glückwunsch! Sie haben mithilfe von Python eine Anwendung für End-to-End-Hybridverbindungen erstellt.

Nächste Schritte

In dieser Schnellstartanleitung haben Sie Client- und Serveranwendungen in Python erstellt, die mithilfe von WebSockets Nachrichten senden und empfangen. Das Hybrid Connections-Feature von Azure Relay unterstützt auch die Verwendung von HTTP zum Senden und Empfangen von Nachrichten. Informationen zur Verwendung von HTTP mit Hybrid Connections von Azure Relay finden Sie unter Erste Schritte mit HTTP-Anforderungen von Relay Hybrid Connections in .NET.

In diesem Schnellstart haben Sie Python zum Erstellen von Client- und Serveranwendungen verwendet. Informationen zum Schreiben von Client- und Serveranwendungen mit .NET Framework finden Sie in der .NET HTTP-Schnellstartanleitung oder der .NET HTTP-Schnellstartanleitung.