Udostępnij za pośrednictwem

Wprowadzenie do żądań WebSocket połączeń hybrydowych usługi Relay w języku Python

  • Artykuł

W tym przewodniku Szybki start utworzysz aplikacje nadawcy i odbiorcy języka Python, które wysyłają i odbierają komunikaty przy użyciu protokołu WebSocket. Aplikacje korzystają z funkcji połączeń hybrydowych usługi Azure Relay. Aby uzyskać więcej ogólnych informacji o usłudze Azure Relay, zobacz Azure Relay.

W tym przewodniku Szybki start wykonasz następujące kroki:

  1. Utworzenie przestrzeni nazw usługi Relay za pomocą witryny Azure Portal.
  2. Utworzenie połączenia hybrydowego w tej przestrzeni nazw za pomocą witryny Azure Portal.
  3. Generowanie pliku właściwości config.json w celu przechowywania szczegółów połączenia
  4. Opracowywanie relaylib.py dla funkcji pomocnika (tokeny SAS, adresy URL)
  5. Pisanie skryptu serwera (odbiornika) w celu odbierania komunikatów.
  6. Pisanie skryptu klienta (nadawcy) w celu wysyłania komunikatów.
  7. Wykonaj skrypt serwera (odbiornika) i opcjonalnie skrypt klienta (nadawcy).

Wymagania wstępne

  • Python. Upewnij się, że używasz języka Python w wersji 3.10 lub nowszej
  • Subskrypcja Azure. Jeśli nie masz subskrypcji, przed rozpoczęciem utwórz bezpłatne konto.

Tworzenie przestrzeni nazw za pomocą usługi Azure Portal

  1. Zaloguj się w witrynie Azure Portal.

  2. Wybierz pozycję Wszystkie usługi w menu po lewej stronie. Wybierz pozycję Integracja, wyszukaj pozycję Przekaźniki, przenieś wskaźnik myszy nad przekaźnikami, a następnie wybierz pozycję Utwórz.

    Zrzut ekranu przedstawiający wybór przycisku Relays —> Create (Utwórz).

  3. Na stronie Tworzenie przestrzeni nazw wykonaj następujące kroki:

    1. Wybierz subskrypcję platformy Azure, w której chcesz utworzyć przestrzeń nazw.

    2. W obszarze Grupa zasobów wybierz istniejącą grupę zasobów, w której chcesz umieścić przestrzeń nazw, lub utwórz nową.

    3. Wprowadź nazwę przestrzeni nazw usługi Relay.

    4. Wybierz region, w którym powinna być hostowana przestrzeń nazw.

    5. Wybierz pozycję Przejrzyj i utwórz w dolnej części strony.

      Zrzut ekranu przedstawiający stronę Tworzenie przestrzeni nazw.

    6. Na stronie Przeglądanie i tworzenie wybierz pozycję Utwórz.

    7. Po kilku minutach zostanie wyświetlona strona przekaźnika dla przestrzeni nazw.

      Zrzut ekranu przedstawiający stronę główną przestrzeni nazw usługi Relay.

Uzyskiwanie poświadczeń zarządzania

  1. Na stronie Przekaźnik wybierz pozycję Zasady dostępu współdzielonego w menu po lewej stronie. `

  2. Na stronie Zasady dostępu współdzielonego wybierz pozycję RootManageSharedAccessKey.

  3. W obszarze Zasady sygnatury dostępu współdzielonego: RootManageSharedAccessKey wybierz przycisk Kopiuj obok pozycji Podstawowe parametry połączenia. Ta akcja kopiuje parametry połączenia do schowka do późniejszego użycia. Wklej tę wartość do Notatnika lub innej tymczasowej lokalizacji.

  4. Powtórz poprzedni krok w celu skopiowania i wklejenia wartości pozycji Klucz podstawowy w lokalizacji tymczasowej do późniejszego użycia.

    Zrzut ekranu przedstawiający informacje o połączeniu dla przestrzeni nazw usługi Relay.

Tworzenie połączenia hybrydowego za pomocą witryny Azure Portal

Na stronie Przekaźnik dla przestrzeni nazw wykonaj następujące kroki, aby utworzyć połączenie hybrydowe.

  1. W menu po lewej stronie w obszarze Jednostki wybierz pozycję Połączenia hybrydowe, a następnie wybierz pozycję + Połączenie hybrydowe.

    Zrzut ekranu przedstawiający stronę Połączenia hybrydowe.

  2. Na stronie Tworzenie połączenia hybrydowego wprowadź nazwę połączenia hybrydowego, a następnie wybierz pozycję Utwórz.

    Zrzut ekranu przedstawiający stronę Tworzenie połączenia hybrydowego.

Opracowywanie funkcji pomocnika

Tworzenie skryptu języka Python

Ten skrypt udostępnia funkcje pomocnicze dla aplikacji korzystających z połączeń hybrydowych usługi Azure Relay. Te funkcje mogą pomóc w zadaniach, takich jak generowanie tokenów SAS i ustanawianie połączeń protokołu WebSocket na potrzeby bezpiecznej komunikacji.

Zależności

Zainstaluj następujące biblioteki języka Python przy użyciu narzędzia przed wygenerowaniem skryptu funkcji pomocnika: base64, , hashlib, hmacmath, timeurllib

Te biblioteki można zainstalować przy użyciu następującego polecenia:

pip install <package name>

Pisanie skryptu funkcji pomocnika

Oto jak powinien wyglądać plik relaylib.py :

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

Tworzenie aplikacji serwera (odbiornika)

Aby nasłuchiwać i odbierać komunikaty z usługi Relay, napisz skrypt serwera WebSocket języka Python.

Tworzenie skryptu języka Python

Jeśli podczas tworzenia przekaźnika wyłączono opcję "Wymaga autoryzacji klienta", możesz wysyłać żądania do adresu URL połączeń hybrydowych przy użyciu dowolnej przeglądarki. Aby uzyskać dostęp do chronionych punktów końcowych, należy utworzyć i przekazać token SAS, który jest pokazany tutaj.

Oto prosty skrypt języka Python, który demonstruje wysyłanie żądań do adresu URL połączeń hybrydowych przy użyciu tokenów SAS korzystających z obiektów WebSocket.

Zależności

  1. Zainstaluj następujące biblioteki języka Python przy użyciu narzędzia przed uruchomieniem aplikacji serwera

    asyncio, , json, , loggingwebsockets

    Te biblioteki można zainstalować przy użyciu następującego polecenia:

     pip install <package name>

  2. config.json Generowanie pliku do przechowywania szczegółów połączenia

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

    Zastąp symbole zastępcze w nawiasach wartościami uzyskanymi podczas tworzenia połączenia hybrydowego.

    • namespace — obszar nazw usługi Relay. Pamiętaj, aby użyć w pełni kwalifikowanej nazwy obszaru nazw, na przykład {namespace}.servicebus.windows.net.
    • path — nazwa połączenia hybrydowego.
    • keyrule - Nazwa klucza zasad dostępu współdzielonego, który jest RootManageSharedAccessKey domyślnie.
    • key - Klucz podstawowy zapisanej wcześniej przestrzeni nazw.

  3. Generowanie pliku funkcji pomocnika dla funkcji pomocnika

    Poniższy plik jest używany jako relaylib.py funkcja pomocnika dla generowania adresów URL protokołu WebSocket i tokenów SAS i funkcji pomocnika

    Tworzenie skryptu języka Python

    Ten skrypt udostępnia funkcje pomocnicze dla aplikacji korzystających z połączeń hybrydowych usługi Azure Relay. Te funkcje mogą pomóc w zadaniach, takich jak generowanie tokenów SAS i ustanawianie połączeń protokołu WebSocket na potrzeby bezpiecznej komunikacji.

    Zależności

    Zainstaluj następujące biblioteki języka Python przy użyciu narzędzia przed wygenerowaniem skryptu funkcji pomocnika: base64, , hashlib, hmacmath, timeurllib

    Te biblioteki można zainstalować przy użyciu następującego polecenia:

    pip install <package name>

    Pisanie skryptu funkcji pomocnika

    Oto jak powinien wyglądać plik relaylib.py :

    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

Pisanie kodu w celu wysyłania komunikatów

  1. Upewnij się, że zależność config.json i relaylib.py są dostępne w ścieżce

  2. Oto jak powinien wyglądać plik listener.py :

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

Tworzenie aplikacji klienta (nadawcy)

Aby wysyłać komunikaty do usługi Relay, możesz użyć dowolnego klienta HTTP lub WebSocket, dołączony przykład jest implementacją języka Python.

Tworzenie skryptu języka Python

Jeśli podczas tworzenia przekaźnika wyłączono opcję "Wymaga autoryzacji klienta", możesz wysyłać żądania do adresu URL połączeń hybrydowych przy użyciu dowolnej przeglądarki. Aby uzyskać dostęp do chronionych punktów końcowych, należy utworzyć i przekazać token SAS, który jest pokazany tutaj.

Oto prosty skrypt języka Python, który demonstruje wysyłanie żądań do adresu URL połączeń hybrydowych przy użyciu tokenów SAS korzystających z obiektów WebSocket.

Zależności

  1. Zainstaluj następujące biblioteki języka Python przy użyciu narzędzia przed uruchomieniem aplikacji klienckiej

    asyncio, , json, , loggingwebsockets

    Te biblioteki można zainstalować przy użyciu następującego polecenia:

     pip install <package name>

  2. config.json Generowanie pliku do przechowywania szczegółów połączenia

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

    Zastąp symbole zastępcze w nawiasach wartościami uzyskanymi podczas tworzenia połączenia hybrydowego.

    • namespace — obszar nazw usługi Relay. Pamiętaj, aby użyć w pełni kwalifikowanej nazwy obszaru nazw, na przykład {namespace}.servicebus.windows.net.
    • path — nazwa połączenia hybrydowego.
    • keyrule - Nazwa klucza zasad dostępu współdzielonego, który jest RootManageSharedAccessKey domyślnie.
    • key - Klucz podstawowy zapisanej wcześniej przestrzeni nazw.

  3. Generowanie pliku funkcji pomocnika dla funkcji pomocnika

    Poniższy plik jest używany jako relaylib.py funkcja pomocnika dla generowania adresów URL protokołu WebSocket i tokenów SAS i funkcji pomocnika

    Tworzenie skryptu języka Python

    Ten skrypt udostępnia funkcje pomocnicze dla aplikacji korzystających z połączeń hybrydowych usługi Azure Relay. Te funkcje mogą pomóc w zadaniach, takich jak generowanie tokenów SAS i ustanawianie połączeń protokołu WebSocket na potrzeby bezpiecznej komunikacji.

    Zależności

    Zainstaluj następujące biblioteki języka Python przy użyciu narzędzia przed wygenerowaniem skryptu funkcji pomocnika: base64, , hashlib, hmacmath, timeurllib

    Te biblioteki można zainstalować przy użyciu następującego polecenia:

    pip install <package name>

    Pisanie skryptu funkcji pomocnika

    Oto jak powinien wyglądać plik relaylib.py :

    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

Pisanie kodu w celu wysyłania komunikatów

  1. Upewnij się, że zależność config.json i relaylib.py są dostępne w ścieżce

  2. Oto jak powinien wyglądać plik sender.py :

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

Uwaga

Przykładowy kod w tym artykule używa parametry połączenia do uwierzytelniania w przestrzeni nazw usługi Azure Relay, aby zachować prostotę samouczka. Zalecamy użycie uwierzytelniania identyfikatora Entra firmy Microsoft w środowiskach produkcyjnych zamiast używania parametry połączenia lub sygnatur dostępu współdzielonego, co może być łatwiejsze w przypadku naruszenia zabezpieczeń. Aby uzyskać szczegółowe informacje i przykładowy kod do korzystania z uwierzytelniania identyfikatora entra firmy Microsoft, zobacz Uwierzytelnianie i autoryzacja aplikacji przy użyciu identyfikatora Entra firmy Microsoft w celu uzyskania dostępu do jednostek usługi Azure Relay i uwierzytelnianie tożsamości zarządzanej za pomocą identyfikatora Entra firmy Microsoft w celu uzyskania dostępu do zasobów usługi Azure Relay.

Uruchamianie aplikacji

  1. Uruchom aplikację serwera: w wierszu polecenia wpisz python3 listener.py.
  2. Uruchom aplikację kliencką: w wierszu polecenia wpisz python3 sender.py.

Gratulacje, utworzono kompleksową aplikację połączeń hybrydowych przy użyciu języka Python!

Następne kroki

W tym przewodniku Szybki start utworzono aplikacje klienckie i serwerowe języka Python, które używały obiektów WebSocket do wysyłania i odbierania komunikatów. Funkcja połączeń hybrydowych usługi Azure Relay obsługuje również wysyłanie i odbieranie komunikatów przy użyciu protokołu HTTP. Aby dowiedzieć się, jak używać protokołu HTTP z funkcją połączeń hybrydowych usługi Azure Relay, zobacz Przewodnik Szybki start dotyczący protokołu HTTP.

W tym przewodniku Szybki start użyto języka Python do tworzenia aplikacji klienckich i serwerowych. Aby dowiedzieć się, jak pisać aplikacje klienckie i serwerowe przy użyciu programu .NET Framework, zobacz przewodnik Szybki start HTTP platformy .NET lub przewodnik Szybki start http platformy .NET.