Introdução as solicitações de WebSocket de Conexões Híbridas de Retransmissão no Python.

• NET
• Node.js

Neste início rápido, você criará aplicativos Python de remetente e receptor que enviam e recebem mensagens usando o protocolo WebSocket. Os aplicativos usam o recurso Conexões Híbridas da Retransmissão do Azure. Para saber mais sobre a Retransmissão do Azure em geral, confira Retransmissão do Azure.

Neste início rápido, você segue os seguintes passos:

1. Criar um namespace de Retransmissão usando o Portal do Azure.
2. Crie uma conexão híbrida nesse namespace usando o Portal do Azure.
3. Gerar um arquivo de propriedades config.json para armazenar os detalhes da conexão
4. Desenvolver um relaylib.py para funções auxiliares (tokens SAS, URLs)
5. Escreva um script de servidor (ouvinte) para receber mensagens.
6. Escreva um script de cliente (remetente) para enviar mensagens.
7. Execute o script do servidor (ouvinte) e, opcionalmente, o script do cliente (remetente).

Pré-requisitos

• Python. Certifique-se de que esteja executando o Python 3.10+
• Uma assinatura do Azure. Se você não tiver uma conta gratuita, crie uma antes de começar.

Criar um namespace usando o portal do Azure

1. Entre no portal do Azure.

2. Selecione Todos os serviços no menu esquerdo. Selecione Integração, procure por Retransmissões, passe o mouse sobre Retransmissões e clique em Criar.

   

3. Na página Criar namespace, siga estas etapas:

   1. Escolha uma assinatura do Azure na qual criar o namespace.

   2. Em Grupo de recursos, escolha um grupo de recursos existente no qual colocar o namespace ou crie um.

   3. Insira um nome para o namespace de Retransmissão.

   4. Selecione o país ou região no qual o namespace deve ser hospedado.

   5. Selecione Revisar + criar na parte inferior da página.

      

   6. Na página Examinar + criar escolha Criar.

   7. Depois de alguns minutos, você verá a página de Retransmissão do namespace.

      

Obter credenciais de gerenciamento

1. Na página Retransmissão, selecione Políticas de acesso compartilhado no menu à esquerda.

2. Na página Políticas de acesso compartilhado, selecione RootManageSharedAccessKey.

3. Em Política de SAS: RootManageSharedAccessKey, clique no botão Copiar ao lado da opção Cadeia de Conexão Primária. Isso copiará a cadeia de conexão para a área de transferência para uso posterior. Cole esse valor no Bloco de notas ou em outro local temporário.

4. Repita a etapa anterior para copiar e colar o valor de Chave primária para um local temporário para uso posterior.

   

Criar uma conexão híbrida usando o portal do Azure

Na página Retransmissão para seu namespace, siga estas etapas para criar uma conexão híbrida.

1. No menu à esquerda, em Entidades, selecione Conexões Híbridas e selecione + Conexão Híbrida.

   

2. Na página Criar Conexão Híbrida, insira um nome para a conexão híbrida e selecione Criar.

   

Desenvolva funções auxiliares

Criar um script Python

Esse script fornece funções auxiliares para aplicativos que utilizam Conexões Híbridas de Retransmissão do Azure. Essas funções provavelmente auxiliam em tarefas como a geração de tokens SAS e o estabelecimento de conexões WebSocket para comunicação segura.

Dependências

Instale as seguintes bibliotecas Python utilizando pip antes de gerar o script de função auxiliar: base64, hashlib, hmac, math, time, urllib

Essas bibliotecas podem ser instaladas usando o seguinte comando:

pip install <package name>

Gravar o script da função auxiliar

Veja abaixo como o seu arquivo relaylib.py deverá ficar:

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

Criar um aplicativo de servidor (escuta)

Para ouvir e receber mensagens de Retransmissão, escreva um script de Servidor WebSocket em Python.

Criar um script Python

Se tiver desativado a opção "Requer Autorização do Cliente" ao criar a Retransmissão, você poderá enviar solicitações para a URL de Conexões Híbridas com qualquer navegador. Para acessar pontos de extremidade protegidos, é necessário criar e passar um Token SAS, que é mostrado aqui.

Aqui está um script Python simples que demonstra o envio de solicitações para uma URL de conexões Híbridas com tokens SAS utilizando WebSockets.

Dependências

1. Instale as seguintes bibliotecas Python usando pip antes de executar o aplicativo do servidor

   asyncio, json, logging, websockets

   Essas bibliotecas podem ser instaladas usando o seguinte comando:

    pip install <package name>
   

2. Gerar um arquivo config.json para armazenar os detalhes da conexão

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

   Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida.

   • namespace - o namespace de retransmissão. Use o nome totalmente qualificado do namespace, por exemplo, {namespace}.servicebus.windows.net.
   • path - o nome da conexão híbrida.
   • keyrule — Nome da sua chave de Políticas de Acesso Compartilhado, que é RootManageSharedAccessKey por padrão.
   • key — A chave primária do namespace que você salvou anteriormente.

3. Gerar um arquivo de função auxiliar para funções auxiliares

   O arquivo a seguir é usado como relaylib.py e tem funções auxiliares para geração de URL WebSocket e tokens SAS

   Criar um script Python

   Esse script fornece funções auxiliares para aplicativos que utilizam Conexões Híbridas de Retransmissão do Azure. Essas funções provavelmente auxiliam em tarefas como a geração de tokens SAS e o estabelecimento de conexões WebSocket para comunicação segura.

   Dependências

   Instale as seguintes bibliotecas Python utilizando pip antes de gerar o script de função auxiliar: base64, hashlib, hmac, math, time, urllib

   Essas bibliotecas podem ser instaladas usando o seguinte comando:

   pip install <package name>
   

   Gravar o script da função auxiliar

   Veja abaixo como o seu arquivo relaylib.py deverá ficar:

   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
   

Escrever código para enviar mensagens

1. Certifique-se de que as dependências config.json e relaylib.py estejam disponíveis em seu caminho

2. Veja abaixo como o seu arquivo listener.py deverá ficar:

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

Criar um aplicativo de cliente (remetente)

Para enviar mensagens para a Retransmissão, você pode usar qualquer cliente HTTP ou WebSocket; o exemplo incluído é uma implementação em python.

Criar um script Python

Se tiver desativado a opção "Requer Autorização do Cliente" ao criar a Retransmissão, você poderá enviar solicitações para a URL de Conexões Híbridas com qualquer navegador. Para acessar pontos de extremidade protegidos, é necessário criar e passar um Token SAS, que é mostrado aqui.

Aqui está um script Python simples que demonstra o envio de solicitações para uma URL de conexões Híbridas com tokens SAS utilizando WebSockets.

Dependências

1. Instale as seguintes bibliotecas Python usando pip antes de executar o aplicativo cliente

   asyncio, json, logging, websockets

   Essas bibliotecas podem ser instaladas usando o seguinte comando:

    pip install <package name>
   

2. Gerar um arquivo config.json para armazenar os detalhes da conexão

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

   Substitua os espaços reservados entre colchetes pelos valores obtidos quando você criou a conexão híbrida.

   • namespace - o namespace de retransmissão. Use o nome totalmente qualificado do namespace, por exemplo, {namespace}.servicebus.windows.net.
   • path - o nome da conexão híbrida.
   • keyrule — Nome da sua chave de Políticas de Acesso Compartilhado, que é RootManageSharedAccessKey por padrão.
   • key — A chave primária do namespace que você salvou anteriormente.

3. Gerar um arquivo de função auxiliar para funções auxiliares

   O arquivo a seguir é usado como relaylib.py e tem funções auxiliares para geração de URL WebSocket e tokens SAS

   Criar um script Python

   Esse script fornece funções auxiliares para aplicativos que utilizam Conexões Híbridas de Retransmissão do Azure. Essas funções provavelmente auxiliam em tarefas como a geração de tokens SAS e o estabelecimento de conexões WebSocket para comunicação segura.

   Dependências

   Instale as seguintes bibliotecas Python utilizando pip antes de gerar o script de função auxiliar: base64, hashlib, hmac, math, time, urllib

   Essas bibliotecas podem ser instaladas usando o seguinte comando:

   pip install <package name>
   

   Gravar o script da função auxiliar

   Veja abaixo como o seu arquivo relaylib.py deverá ficar:

   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
   

Escrever código para enviar mensagens

1. Certifique-se de que as dependências config.json e relaylib.py estejam disponíveis em seu caminho

2. Veja abaixo como o seu arquivo sender.py deverá ficar:

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

Observação

O código de exemplo neste artigo utiliza uma cadeia de conexão para autenticar em um namespace da Retransmissão do Azure a fim de manter o tutorial simples. Recomendamos que você use a autenticação do Microsoft Entra ID em ambientes de produção, em vez de usar cadeias de conexão ou assinaturas de acesso compartilhado, que podem ser comprometidas mais facilmente. Para obter informações detalhadas e o código de exemplo para usar a autenticação do Microsoft Entra ID, veja Autenticar e autorizar um aplicativo com o Microsoft Entra ID para acessar entidades da Retransmissão do Azure e Autenticar uma identidade gerenciada com o Microsoft Entra ID para acessar os recursos da Retransmissão do Azure.

Executar os aplicativos

1. Execute o aplicativo do servidor: em um prompt de comando, digite python3 listener.py.
2. Execute o aplicativo cliente: em um prompt de comando, digite python3 sender.py.

Parabéns, você criou um aplicativo de Conexões Híbridas de ponta a ponta usando Python!

Próximas etapas

Neste início rápido, você criou aplicativos cliente e servidor Python que usaram WebSockets para enviar e receber mensagens. O recurso Conexões Híbridas de Retransmissão do Azure também dá suporte ao uso de HTTP para enviar e receber mensagens. Para saber como usar HTTP com as Conexões Híbridas de Retransmissão do Azure, consulte o Início Rápido do HTTP.

Neste início rápido, você usou o Python para criar aplicativos cliente e servidor. Para saber como escrever aplicativos cliente e servidor usando o .NET Framework, consulte o início rápido do HTTP .NET ou o início rápido do HTTP .NET.