Delen via

Aan de slag met Relay Hybrid Connections WebSocket-aanvragen in Python

  • Artikel

In deze quickstart maakt u Python-toepassingen voor afzender en ontvanger die berichten verzenden en ontvangen met behulp van het WebSocket-protocol. De toepassingen maken gebruik van de functie Hybride verbindingen van Azure Relay. Zie Azure Relay voor meer informatie over Azure Relay in het algemeen.

In deze snelstart voert u de volgende stappen uit:

  1. Een Relay-naamruimte maken met behulp van Azure Portal.
  2. Een hybride verbinding in die naamruimte maken met behulp van Azure Portal.
  3. Een config.json eigenschappenbestand genereren om verbindingsgegevens op te slaan
  4. Een relaylib.py ontwikkelen voor helperfuncties (SAS-tokens, URL's)
  5. Schrijf een serverscript (listener) om berichten te ontvangen.
  6. Schrijf een clientscript (afzender) om berichten te verzenden.
  7. Voer het serverscript (listener) en eventueel het clientscript (afzender) uit.

Vereisten

Een naamruimte maken met Azure Portal

  1. Meld u aan bij het Azure-portaal.

  2. Selecteer Alle services in het linkermenu. Selecteer Integratie, zoek naar Relays, beweeg de muis over Relays en selecteer Vervolgens Maken.

    Schermopname van de selectie van Relays -> Knop Maken.

  3. Voer op de pagina Naamruimte maken de volgende stappen uit:

    1. Kies een Azure-abonnement waarin u de naamruimte wilt maken.

    2. Kies bij Resourcegroep een bestaande resourcegroep waarin de naamruimte moet worden geplaatst of maak een nieuwe resourcegroep.

    3. Voer een naam in voor de Relay-naamruimte.

    4. Selecteer de regio waarin uw naamruimte moet worden gehost.

    5. Selecteer Controleren en maken onderaan de pagina.

      Schermopname van de pagina Naamruimte maken.

    6. Selecteer Maken op de pagina Beoordelen en maken.

    7. Na enkele minuten ziet u de Relay-pagina voor de naamruimte.

      Schermopname van de startpagina voor Relay-naamruimte.

Beheerreferenties ophalen

  1. Selecteer op de pagina Relay beleid voor gedeelde toegang in het menu links.

  2. Selecteer RootManageSharedAccessKey op de pagina Beleid voor gedeelde toegang.

  3. Selecteer onder SAS-beleid: RootManageSharedAccessKey de knop Kopiëren naast primaire verbindingsreeks. Met deze actie kopieert u de verbindingsreeks naar het Klembord voor later gebruik. Plak deze waarde in Kladblok of een andere tijdelijke locatie.

  4. Herhaal de vorige stap om de waarde voor de Primaire sleutel te kopiëren en plakken naar een tijdelijke locatie zodat u deze later kunt gebruiken.

    Schermopname van de verbindingsgegevens voor Relay-naamruimte.

Een hybride verbinding maken met behulp van Azure Portal

Volg deze stappen op de relaypagina voor uw naamruimte om een hybride verbinding te maken.

  1. Selecteer hybride verbindingen in het linkermenu onder Entiteiten en selecteer vervolgens + Hybride verbinding.

    Schermopname van de pagina Hybride verbindingen.

  2. Voer op de pagina Hybride verbinding maken een naam in voor de hybride verbinding en selecteer Maken.

    Schermopname van de pagina Hybride verbinding maken.

Een servertoepassing (listener) maken

Als u berichten van Relay wilt beluisteren en ontvangen, schrijft u een Python WebSocket Server-script.

Een Python-script maken

Als u de optie 'Clientautorisatie vereist' hebt uitgeschakeld bij het maken van relay, kunt u aanvragen verzenden naar de URL voor hybride verbindingen met elke browser. Voor toegang tot beveiligde eindpunten moet u een SAS-token maken en doorgeven. Dit wordt hier weergegeven.

Hier volgt een eenvoudig Python-script dat laat zien hoe aanvragen worden verzonden naar een URL voor hybride verbindingen met SAS-tokens die gebruikmaken van WebSockets.

Afhankelijkheden

  1. Installeer de volgende Python-bibliotheken met pip voordat u de servertoepassing uitvoert

    asyncio, , , jsonloggingwebsockets

    Deze bibliotheken kunnen worden geïnstalleerd met behulp van de volgende opdracht:

     pip install <package name>

  2. config.json Een bestand genereren om uw verbindingsgegevens op te slaan

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

    Vervang de tijdelijke aanduidingen tussen punthaken door de waarden die u hebt verkregen bij het maken van de hybride verbinding.

    • namespace: de Relay-naamruimte. Zorg ervoor dat u de volledig gekwalificeerde naamruimte gebruikt, bijvoorbeeld {namespace}.servicebus.windows.net.
    • path: de naam van de hybride verbinding.
    • keyrule - De naam van uw sleutel voor gedeeld toegangsbeleid, wat standaard is RootManageSharedAccessKey .
    • key - De primaire sleutel van de naamruimte die u eerder hebt opgeslagen.

  3. Een Helper-functiebestand genereren voor helperfuncties

    Het volgende bestand wordt gebruikt als relaylib.py helperfuncties voor het genereren van WEBSocket-URL's en SAS-tokens

    Een Python-script maken

    Dit script biedt helperfuncties voor toepassingen die gebruikmaken van hybride Verbindingen van Azure Relay. Deze functies helpen waarschijnlijk bij taken zoals het genereren van SAS-tokens en het tot stand brengen van WebSocket-verbindingen voor beveiligde communicatie.

    Afhankelijkheden

    Installeer de volgende Python-bibliotheken met behulp van pip voordat u het helper-functiescript genereert: base64, hashlib, hmac, math, , timeurllib

    Deze bibliotheken kunnen worden geïnstalleerd met behulp van de volgende opdracht:

    pip install <package name>

    Het helper-functiescript schrijven

    Dit is hoe uw relaylib.py bestand eruit moet zien:

    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

Code schrijven om berichten te ontvangen

  1. Zorg ervoor dat uw afhankelijkheid config.json en relaylib.py beschikbaar zijn in uw pad

  2. Dit is hoe uw listener.py bestand eruit moet zien:

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

Een clienttoepassing maken (afzender)

Als u berichten naar relay wilt verzenden, kunt u elke HTTP- of WebSocket-client gebruiken. Het voorbeeld dat is opgenomen, is een Python-implementatie.

Code schrijven om berichten te verzenden

  1. Zorg ervoor dat uw afhankelijkheid config.json en relaylib.py beschikbaar zijn in uw pad

  2. Dit is hoe uw sender.py bestand eruit moet zien:

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

Notitie

De voorbeeldcode in dit artikel maakt gebruik van een verbindingsreeks voor verificatie bij een Azure Relay-naamruimte om de zelfstudie eenvoudig te houden. U wordt aangeraden Microsoft Entra ID-verificatie te gebruiken in productieomgevingen, in plaats van gebruik te maken van verbindingsreeks s of handtekeningen voor gedeelde toegang, die gemakkelijker kunnen worden aangetast. Zie Een toepassing verifiëren en autoriseren met Microsoft Entra ID voor toegang tot Azure Relay-entiteiten en een beheerde identiteit verifiëren met Microsoft Entra ID voor toegang tot Azure Relay-entiteiten en een beheerde identiteit verifiëren met Microsoft Entra-id voor toegang tot Azure Relay-resources voor gedetailleerde informatie en voorbeeldcode voor het gebruik van de Microsoft Entra-id.

De toepassingen uitvoeren

  1. Voer de servertoepassing uit: vanaf een opdrachtprompttype python3 listener.py.
  2. Voer de clienttoepassing uit: vanaf een opdrachtprompttype python3 sender.py.

Gefeliciteerd, u hebt een end-to-end hybride verbindingstoepassing gemaakt met behulp van Python.

Volgende stappen

In deze quickstart hebt u Python-client- en servertoepassingen gemaakt waarmee WebSockets berichten kunnen verzenden en ontvangen. De hybride verbindingsfunctie van Azure Relay ondersteunt tevens HTTP voor het verzenden en ontvangen van berichten. Zie de snelstart over HTTP voor informatie over het gebruik van HTTP met hybride verbindingen van Azure Relay.

In deze quickstart hebt u Python gebruikt om client- en servertoepassingen te maken. Als u wilt weten hoe u client- en servertoepassingen schrijft met .NET Framework, raadpleegt u de quickstart voor .NET HTTP of de .NET HTTP-quickstart.