Dela via

Kom igång med WebSocket-begäranden för Relay Hybrid-anslutningar i Python

  • Artikel

I den här snabbstarten skapar du Python-avsändare och mottagarprogram som skickar och tar emot meddelanden med hjälp av WebSocket-protokollet. Programmen använder funktionen Hybridanslutningar i Azure Relay. Läs mer om Azure Relay i allmänhet i Azure Relay.

I den här snabbstarten gör du följande:

  1. Skapa ett Relay-namnområde med Azure Portal.
  2. Skapa en hybridanslutning i det namnområdet med Azure Portal.
  3. Generera en config.json egenskapsfil för att lagra anslutningsinformation
  4. Utveckla en relaylib.py för hjälpfunktioner (SAS-token, URL:er)
  5. Skriv ett serverskript (lyssnarskript) för att ta emot meddelanden.
  6. Skriv ett klientskript (avsändare) för att skicka meddelanden.
  7. Kör serverskriptet (lyssnaren) och eventuellt klientskriptet (avsändaren).

Förutsättningar

Skapa ett namnområde med Azure Portal

  1. Logga in på Azure-portalen.

  2. Välj Alla tjänster på den vänstra menyn. Välj Integrering, sök efter Reläer, flytta musen över Reläer och välj sedan Skapa.

    Skärmbild som visar valet av knappen Reläer –> Skapa.

  3. Följ dessa steg på sidan Skapa namnområde :

    1. Välj en Azure-prenumeration där du vill skapa namnområdet.

    2. För Resursgrupp väljer du en befintlig resursgrupp där du vill placera namnområdet eller skapar en ny.

    3. Ange ett namn för Relay-namnområdet.

    4. Välj den region där ditt namnområde ska finnas.

    5. Välj Granska + skapa längst ned på sidan.

      Skärmbild som visar sidan Skapa namnområde.

    6. På sidan Granska + skapa väljer du Skapa.

    7. Efter några minuter visas sidan Relay för namnområdet.

      Skärmbild som visar startsidan för Relay-namnområdet.

Få autentiseringsuppgifter för hantering

  1. På sidan Relay väljer du Principer för delad åtkomst på den vänstra menyn. `

  2. På sidan Principer för delad åtkomst väljer du RootManageSharedAccessKey.

  3. Under SAS-princip: RootManageSharedAccessKey väljer du knappen Kopiera bredvid Primär anslutningssträng. Den här åtgärden kopierar niska veze till Urklipp för senare användning. Klistra in det här värdet i Anteckningar eller på en tillfällig plats.

  4. Upprepa föregående steg för att kopiera och klistra in värdet för primärnyckeln till en tillfällig plats för senare användning.

    Skärmbild som visar anslutningsinformationen för Relay-namnområdet.

Skapa en hybridanslutning med Azure Portal

På sidan Relay för ditt namnområde följer du de här stegen för att skapa en hybridanslutning.

  1. På den vänstra menyn under Entiteter väljer du Hybridanslutningar och sedan + Hybridanslutning.

    Skärmbild som visar sidan Hybridanslutningar.

  2. På sidan Skapa hybridanslutning anger du ett namn för hybridanslutningen och väljer Skapa.

    Skärmbild som visar sidan Skapa hybridanslutning.

Utveckla hjälpfunktioner

Skapa ett Python-skript

Det här skriptet innehåller hjälpfunktioner för program som använder Azure Relay Hybrid-anslutningar. Dessa funktioner hjälper troligen till med uppgifter som att generera SAS-token och upprätta WebSocket-anslutningar för säker kommunikation.

Beroenden

Installera följande Python-bibliotek med pip innan du genererar hjälpfunktionsskriptet: base64, hashlib, hmac, math, , timeurllib

Dessa bibliotek kan installeras med hjälp av följande kommando:

pip install <package name>

Skriva hjälpfunktionsskriptet

Så här bör filen relaylib.py se ut:

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

Skapa ett serverprogram (lyssnare)

Om du vill lyssna och ta emot meddelanden från Relay skriver du ett Python WebSocket Server-skript.

Skapa ett Python-skript

Om du inaktiverade alternativet "Kräver klientauktorisering" när du skapar Relay kan du skicka begäranden till URL:en för hybridanslutningar med valfri webbläsare. För åtkomst till skyddade slutpunkter måste du skapa och skicka en SAS-token, som visas här.

Här är ett enkelt Python-skript som visar hur begäranden skickas till en URL för hybridanslutningar med SAS-token som använder WebSockets.

Beroenden

  1. Installera följande Python-bibliotek med pip innan du kör serverprogrammet

    asyncio, json, , loggingwebsockets

    Dessa bibliotek kan installeras med hjälp av följande kommando:

     pip install <package name>

  2. Generera en config.json fil för att lagra anslutningsinformationen

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

    Ersätt platshållarna inom hakparentes med de värden du erhöll när du skapade hybridanslutningen.

    • namespace – Relay-namnområde. Se till att du använder det fullständiga namnområdesnamnet, till exempel {namespace}.servicebus.windows.net.
    • path – Namnet på hybridanslutningen.
    • keyrule – Namnet på nyckeln för principer för delad åtkomst, vilket är RootManageSharedAccessKey som standard.
    • key – Primärnyckeln för namnområdet som du sparade tidigare.

  3. Generera en hjälpfunktionsfil för hjälpfunktioner

    Följande fil används som relaylib.py och har hjälpfunktioner för WebSocket URL-generering och SAS-token

    Skapa ett Python-skript

    Det här skriptet innehåller hjälpfunktioner för program som använder Azure Relay Hybrid-anslutningar. Dessa funktioner hjälper troligen till med uppgifter som att generera SAS-token och upprätta WebSocket-anslutningar för säker kommunikation.

    Beroenden

    Installera följande Python-bibliotek med pip innan du genererar hjälpfunktionsskriptet: base64, hashlib, hmac, math, , timeurllib

    Dessa bibliotek kan installeras med hjälp av följande kommando:

    pip install <package name>

    Skriva hjälpfunktionsskriptet

    Så här bör filen relaylib.py se ut:

    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

Skriva kod för att skicka meddelanden

  1. Se till att ditt beroende config.json och relaylib.py är tillgängligt i din sökväg

  2. Så här bör filen listener.py se ut:

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

Skapa ett klientprogram (avsändare)

Om du vill skicka meddelanden till Relay kan du använda valfri HTTP- eller WebSocket-klient. Exemplet som ingår är en python-implementering.

Skapa ett Python-skript

Om du inaktiverade alternativet "Kräver klientauktorisering" när du skapar Relay kan du skicka begäranden till URL:en för hybridanslutningar med valfri webbläsare. För åtkomst till skyddade slutpunkter måste du skapa och skicka en SAS-token, som visas här.

Här är ett enkelt Python-skript som visar hur begäranden skickas till en URL för hybridanslutningar med SAS-token som använder WebSockets.

Beroenden

  1. Installera följande Python-bibliotek med pip innan du kör klientprogrammet

    asyncio, json, , loggingwebsockets

    Dessa bibliotek kan installeras med hjälp av följande kommando:

     pip install <package name>

  2. Generera en config.json fil för att lagra anslutningsinformationen

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

    Ersätt platshållarna inom hakparentes med de värden du erhöll när du skapade hybridanslutningen.

    • namespace – Relay-namnområde. Se till att du använder det fullständiga namnområdesnamnet, till exempel {namespace}.servicebus.windows.net.
    • path – Namnet på hybridanslutningen.
    • keyrule – Namnet på nyckeln för principer för delad åtkomst, vilket är RootManageSharedAccessKey som standard.
    • key – Primärnyckeln för namnområdet som du sparade tidigare.

  3. Generera en hjälpfunktionsfil för hjälpfunktioner

    Följande fil används som relaylib.py och har hjälpfunktioner för WebSocket URL-generering och SAS-token

    Skapa ett Python-skript

    Det här skriptet innehåller hjälpfunktioner för program som använder Azure Relay Hybrid-anslutningar. Dessa funktioner hjälper troligen till med uppgifter som att generera SAS-token och upprätta WebSocket-anslutningar för säker kommunikation.

    Beroenden

    Installera följande Python-bibliotek med pip innan du genererar hjälpfunktionsskriptet: base64, hashlib, hmac, math, , timeurllib

    Dessa bibliotek kan installeras med hjälp av följande kommando:

    pip install <package name>

    Skriva hjälpfunktionsskriptet

    Så här bör filen relaylib.py se ut:

    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

Skriva kod för att skicka meddelanden

  1. Se till att ditt beroende config.json och relaylib.py är tillgängligt i din sökväg

  2. Så här bör filen sender.py se ut:

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

Kommentar

Exempelkoden i den här artikeln använder en niska veze för att autentisera till ett Azure Relay-namnområde för att hålla självstudien enkel. Vi rekommenderar att du använder Microsoft Entra-ID-autentisering i produktionsmiljöer i stället för att använda niska veze eller signaturer för delad åtkomst, vilket är enklare att kompromettera. Detaljerad information och exempelkod för användning av Microsoft Entra-ID-autentisering finns i Autentisera och auktorisera ett program med Microsoft Entra-ID för åtkomst till Azure Relay-entiteter och Autentisera en hanterad identitet med Microsoft Entra-ID för åtkomst till Azure Relay-resurser.

Kör programmen

  1. Kör serverprogrammet: från en kommandotolktyp python3 listener.py.
  2. Kör klientprogrammet: från en kommandotolktyp python3 sender.py.

Grattis, du har skapat ett hybridanslutningsprogram från slutpunkt till slutpunkt med Python!

Nästa steg

I den här snabbstarten skapade du Python-klient- och serverprogram som använde WebSockets för att skicka och ta emot meddelanden. Funktionen Hybridanslutningar i Azure Relay stöder också användningen av HTTP för att skicka och ta emot meddelanden. Läs om hur du använder HTTP med Azure Relay-hybridanslutningar i HTTP-snabbstarten.

I den här snabbstarten använde du Python för att skapa klient- och serverprogram. Information om hur du skriver klient- och serverprogram med hjälp av .NET Framework finns i .NET HTTP-snabbstarten eller .NET HTTP-snabbstarten.