Začínáme s hybridním Připojení ions požadavků Protokolu WebSocket v Pythonu

• NET
• Node.js

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ích Připojení ionů 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.

   

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.

      

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

      

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 řetězce Připojení ionu. 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í.

   

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í ions a pak vyberte + Hybridní Připojení ion.

   

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

   

Vývoj pomocných funkcí

Vytvoření skriptu Pythonu

Tento skript poskytuje pomocné funkce pro aplikace využívající hybridní Připojení Azure Relay. 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í ionů 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ý ukazuje odesílání požadavků na adresu URL hybridních Připojení ionů pomocí tokenů SAS využívajících webSockety.

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í hybridní Připojení Azure Relay. 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.jsonrelaylib.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í ionů 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ý ukazuje odesílání požadavků na adresu URL hybridních Připojení ionů pomocí tokenů SAS využívajících webSockety.

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í hybridní Připojení Azure Relay. 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.jsonrelaylib.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))
   

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 ucelenou hybridní Připojení ionovou aplikaci 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ích Připojení ionů služby Azure Relay také podporuje odesílání a přijímání zpráv pomocí protokolu HTTP. Informace o používání protokolu HTTP s hybridními Připojení 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 startupro .NET HTTP.