Sdílet prostřednictvím

Začínáme s požadavky WebSocket WebSocket služby Relay Hybrid Connections v Pythonu

  • Článek

V tomto rychlém startu vytvoříte aplikace odesílatele a příjemce Pythonu, které odesílají a přijímají zprávy pomocí protokolu WebSocket. Aplikace používají funkci Hybridní připojení služby Azure Relay. Obecné informace o Azure Relay najdete v tématu Azure Relay.

V tomto rychlém startu provedete následující kroky:

  1. Pomocí webu Azure Portal vytvoříte obor názvů služby Relay.
  2. Pomocí webu Azure Portal vytvoříte v tomto oboru názvů hybridní připojení.
  3. Vygenerování souboru vlastností config.json pro uložení podrobností o připojení
  4. Vývoj relaylib.py pro pomocné funkce (tokeny SAS, adresy URL)
  5. Napište skript serveru (naslouchacího procesu) pro příjem zpráv.
  6. Napište skript klienta (odesílatele) pro odesílání zpráv.
  7. Spusťte skript serveru (naslouchací proces) a volitelně i skript klienta (odesílatele).

Požadavky

  • Python. Ujistěte se, že používáte Python 3.10+
  • Předplatné Azure. Pokud ho nemáte, vytvořte si bezplatný účet před tím, než začnete.

Vytvoření oboru názvů služby Service Bus pomocí webu Azure Portal

  1. Přihlaste se k portálu Azure.

  2. V nabídce vlevo vyberte Všechny služby . Vyberte Možnost Integrace, vyhledejte Relays, přesuňte myš na Relays a pak vyberte Vytvořit.

    Snímek obrazovky s výběrem tlačítka Relays –> Vytvořit

  3. Na stránce Vytvořit obor názvů postupujte takto:

    1. Zvolte předplatné Azure, ve kterém chcete vytvořit obor názvů.

    2. Pro skupinu prostředků zvolte existující skupinu prostředků, do které chcete obor názvů umístit, nebo vytvořte novou.

    3. Zadejte název oboru názvů služby Relay.

    4. Vyberte oblast, ve které má být váš obor názvů hostovaný.

    5. Vyberte Zkontrolovat a vytvořit v dolní části stránky.

      Snímek obrazovky se stránkou Vytvořit obor názvů

    6. Na stránce Zkontrolovat a vytvořit vyberte Vytvořit.

    7. Po několika minutách se zobrazí stránka Relay pro obor názvů.

      Snímek obrazovky s domovskou stránkou oboru názvů služby Relay

Získání přihlašovacích údajů pro správu

  1. Na stránce Relay vyberte v nabídce vlevo zásady sdíleného přístupu.

  2. Na stránce Zásady sdíleného přístupu vyberte RootManageSharedAccessKey.

  3. V části Zásady SAS: RootManageSharedAccessKey vyberte tlačítko Kopírovat vedle primárního připojovacího řetězce. Tato akce zkopíruje připojovací řetězec do schránky pro pozdější použití. Vložte tuto hodnotu do Poznámkového bloku nebo jiného dočasného umístění.

  4. Zopakujte předchozí krok, zkopírujte si hodnotu primárního klíče a vložte ji do dočasného umístění pro pozdější použití.

    Snímek obrazovky zobrazující informace o připojení pro obor názvů služby Relay

Vytvoření hybridního připojení pomocí webu Azure Portal

Na stránce Relay pro váš obor názvů vytvořte hybridní připojení pomocí následujícího postupu.

  1. V nabídce vlevo v části Entity vyberte Hybridní připojení a pak vyberte + Hybridní připojení.

    Snímek obrazovky se stránkou Hybridní připojení

  2. Na stránce Vytvořit hybridní připojení zadejte název hybridního připojení a vyberte Vytvořit.

    Snímek obrazovky se stránkou Vytvořit hybridní připojení

Vývoj pomocných funkcí

Vytvoření skriptu Pythonu

Tento skript poskytuje pomocné funkce pro aplikace využívající azure Relay Hybrid Connections. Tyto funkce pravděpodobně pomáhají s úlohami, jako je generování tokenů SAS a vytváření připojení WebSocket pro zabezpečenou komunikaci.

Závislosti

Před vygenerováním pomocného skriptu funkce nainstalujte následující knihovny Pythonu pomocí nástroje pip: base64, hashlib, hmac, math, timeurllib

Tyto knihovny je možné nainstalovat pomocí následujícího příkazu:

pip install <package name>

Napsání pomocného skriptu funkce

relaylib.py Soubor by měl vypadat takto:

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

Vytvoření serverové aplikace (naslouchací proces)

Pokud chcete naslouchat a přijímat zprávy ze služby Relay, napište skript serveru WebSocket v Pythonu.

Vytvoření skriptu Pythonu

Pokud jste při vytváření služby Relay zakázali možnost Vyžadovat autorizaci klienta, můžete odesílat požadavky na adresu URL hybridních připojení pomocí libovolného prohlížeče. Pro přístup k chráněným koncovým bodům je potřeba vytvořit a předat token SAS, který je zde uvedený.

Tady je jednoduchý skript Pythonu, který demonstruje odesílání požadavků na adresu URL hybridních připojení pomocí tokenů SAS využívajících webSockets.

Závislosti

  1. Před spuštěním serverové aplikace nainstalujte následující knihovny Pythonu pomocí nástroje pip.

    asyncio, json, , loggingwebsockets

    Tyto knihovny je možné nainstalovat pomocí následujícího příkazu:

     pip install <package name>

  2. config.json Vygenerování souboru pro uložení podrobností o připojení

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

    Zástupné symboly v závorkách nahraďte hodnotami, které jste získali při vytváření hybridního připojení.

    • namespace – Obor názvů služby Relay. Nezapomeňte použít plně kvalifikovaný obor názvů, například {namespace}.servicebus.windows.net.
    • path – Název hybridního připojení.
    • keyrule – Název klíče zásad sdíleného přístupu, který je RootManageSharedAccessKey ve výchozím nastavení.
    • key – Primární klíč oboru názvů, který jste si uložili dříve.

  3. Vygenerování souboru pomocné funkce pro pomocné funkce

    Následující soubor se používá jako relaylib.py pomocné funkce pro generování adres URL protokolu WebSocket a tokeny SAS.

    Vytvoření skriptu Pythonu

    Tento skript poskytuje pomocné funkce pro aplikace využívající azure Relay Hybrid Connections. Tyto funkce pravděpodobně pomáhají s úlohami, jako je generování tokenů SAS a vytváření připojení WebSocket pro zabezpečenou komunikaci.

    Závislosti

    Před vygenerováním pomocného skriptu funkce nainstalujte následující knihovny Pythonu pomocí nástroje pip: base64, hashlib, hmac, math, timeurllib

    Tyto knihovny je možné nainstalovat pomocí následujícího příkazu:

    pip install <package name>

    Napsání pomocného skriptu funkce

    relaylib.py Soubor by měl vypadat takto:

    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

Napsání kódu pro odesílání zpráv

  1. Ujistěte se, že je vaše závislost config.json relaylib.py dostupná v cestě.

  2. listener.py Soubor by měl vypadat takto:

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

Vytvoření klientské aplikace (odesílatel)

Pokud chcete odesílat zprávy do služby Relay, můžete použít libovolného klienta HTTP nebo WebSocket, součástí ukázky je implementace Pythonu.

Vytvoření skriptu Pythonu

Pokud jste při vytváření služby Relay zakázali možnost Vyžadovat autorizaci klienta, můžete odesílat požadavky na adresu URL hybridních připojení pomocí libovolného prohlížeče. Pro přístup k chráněným koncovým bodům je potřeba vytvořit a předat token SAS, který je zde uvedený.

Tady je jednoduchý skript Pythonu, který demonstruje odesílání požadavků na adresu URL hybridních připojení pomocí tokenů SAS využívajících webSockets.

Závislosti

  1. Před spuštěním klientské aplikace nainstalujte následující knihovny Pythonu pomocí nástroje pip.

    asyncio, json, , loggingwebsockets

    Tyto knihovny je možné nainstalovat pomocí následujícího příkazu:

     pip install <package name>

  2. config.json Vygenerování souboru pro uložení podrobností o připojení

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

    Zástupné symboly v závorkách nahraďte hodnotami, které jste získali při vytváření hybridního připojení.

    • namespace – Obor názvů služby Relay. Nezapomeňte použít plně kvalifikovaný obor názvů, například {namespace}.servicebus.windows.net.
    • path – Název hybridního připojení.
    • keyrule – Název klíče zásad sdíleného přístupu, který je RootManageSharedAccessKey ve výchozím nastavení.
    • key – Primární klíč oboru názvů, který jste si uložili dříve.

  3. Vygenerování souboru pomocné funkce pro pomocné funkce

    Následující soubor se používá jako relaylib.py pomocné funkce pro generování adres URL protokolu WebSocket a tokeny SAS.

    Vytvoření skriptu Pythonu

    Tento skript poskytuje pomocné funkce pro aplikace využívající azure Relay Hybrid Connections. Tyto funkce pravděpodobně pomáhají s úlohami, jako je generování tokenů SAS a vytváření připojení WebSocket pro zabezpečenou komunikaci.

    Závislosti

    Před vygenerováním pomocného skriptu funkce nainstalujte následující knihovny Pythonu pomocí nástroje pip: base64, hashlib, hmac, math, timeurllib

    Tyto knihovny je možné nainstalovat pomocí následujícího příkazu:

    pip install <package name>

    Napsání pomocného skriptu funkce

    relaylib.py Soubor by měl vypadat takto:

    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

Napsání kódu pro odesílání zpráv

  1. Ujistěte se, že je vaše závislost config.json relaylib.py dostupná v cestě.

  2. sender.py Soubor by měl vypadat takto:

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

Poznámka:

Ukázkový kód v tomto článku používá připojovací řetězec k ověření v oboru názvů Služby Azure Relay, aby byl kurz jednoduchý. Doporučujeme používat ověřování Microsoft Entra ID v produkčních prostředích místo použití připojovací řetězec nebo sdílených přístupových podpisů, které se dají snadněji ohrozit. Podrobné informace a vzorový kód pro použití ověřování POMOCÍ ID Microsoft Entra najdete v tématu Ověřování a autorizace aplikace pomocí Microsoft Entra ID pro přístup k entitě Azure Relay a ověření spravované identity pomocí Microsoft Entra ID pro přístup k prostředkům Azure Relay.

Spuštění aplikací

  1. Spusťte serverovou aplikaci: z příkazového řádku zadejte python3 listener.py.
  2. Spusťte klientskou aplikaci: z příkazového řádku zadejte python3 sender.py.

Blahopřejeme, vytvořili jste kompletní aplikaci Hybridní připojení pomocí Pythonu!

Další kroky

V tomto rychlém startu jste vytvořili klientské a serverové aplikace Pythonu, které k odesílání a příjmu zpráv používaly webSockety. Funkce Hybridní připojení služby Azure Relay také podporuje odesílání a přijímání zpráv pomocí protokolu HTTP. Informace o použití PROTOKOLU HTTP s hybridními připojeními Azure Relay najdete v rychlém startu HTTP.

V tomto rychlém startu jste k vytváření klientských a serverových aplikací použili Python. Informace o tom, jak psát klientské a serverové aplikace pomocí rozhraní .NET Framework, najdete v rychlém startu pro .NET HTTP nebo v rychlém startu pro .NET HTTP.