Enviar mensagens para um tópico do Barramento de Serviço do Azure e receber mensagens de assinaturas para o tópico (Python)

Atribuir funções ao usuário do Microsoft Entra

Ao desenvolver localmente, a conta de usuário que se conecta ao Barramento de Serviço do Azure deve ter as permissões corretas. Você precisará da função Proprietário de Dados do Barramento de Serviço do Azure para enviar e receber mensagens. Para atribuir essa função a si mesmo, você precisará da função Administrador de acesso do usuário ou de outra função que inclua a ação Microsoft.Authorization/roleAssignments/write. É possível atribuir funções RBAC do Azure a um usuário usando o portal do Azure, a CLI do Azure ou o Azure PowerShell. Saiba mais sobre os escopos disponíveis para atribuições de função na página de visão geral do escopo.

O exemplo a seguir atribui a função Azure Service Bus Data Owner à sua conta de usuário, que fornece acesso completo aos recursos do Barramento de Serviço do Azure. Em um cenário real, siga o Princípio do Privilégio Mínimo para dar aos usuários apenas as permissões mínimas necessárias para um ambiente de produção mais seguro.

Funções internas do Azure para o Barramento de Serviço do Azure

Para o Barramento de Serviço do Azure, o gerenciamento de namespaces e de todos os recursos relacionados por meio do portal do Azure e da API de gerenciamento de recursos do Azure já está protegido pelo modelo RBAC do Azure. O Azure fornece as funções internas do Azure abaixo para autorizar o acesso a um namespace do Barramento de Serviço:

• Proprietário de Dados do Barramento de Serviço do Azure: habilita o acesso a dados ao namespace do Barramento de Serviço e as entidades dele (filas, tópicos, assinaturas e filtros). Um membro dessa função pode enviar e receber mensagens de filas ou tópicos/assinaturas.
• Remetente de Dados do Barramento de Serviço do Azure: use essa função para fornecer acesso de envio ao namespace do Barramento de Serviço e às entidades dele.
• Receptor de Dados do Barramento de Serviço do Azure: use essa função para conceder acesso de recebimento ao namespace do barramento de serviço e suas entidades.

Se você quiser criar uma função personalizada, consulte Direitos exigidos para operações do Barramento de Serviço.

Adicionar usuário do Microsoft Entra à função Proprietário do Barramento de Serviço do Azure

Adicione seu nome de usuário do Microsoft Entra à função de Proprietário de Dados do Barramento de Serviço do Azure no nível do namespace do Barramento de Serviço. Ele permitirá que um aplicativo em execução no contexto de sua conta de usuário envie mensagens para uma fila ou um tópico e receba mensagens de uma fila ou assinatura de um tópico.

1. Se você a página Namespace do Barramento de Serviço não estiver aberta no portal do Azure, localize o namespace do Barramento de Serviço usando a barra de pesquisa principal ou a navegação à esquerda.

2. Na página de visão geral, selecione Controle de acesso (IAM) no menu à esquerda.

3. Na página Controle de acesso (IAM), selecione a guia Atribuições de função.

4. Selecione + Adicionar no menu superior e, em seguida, Adicionar atribuição de função no menu suspenso resultante.

   

5. Use a caixa de pesquisa para filtrar os resultados para a função desejada. Neste exemplo, pesquise Azure Service Bus Data Owner e selecione o resultado correspondente. Em seguida, escolha Avançar.

6. Em Atribuir acesso a, selecione Usuário, grupo ou entidade de serviço e, em seguida, selecione + Selecionar membros.

7. No diálogo, pesquise seu nome de usuário do Microsoft Entra (geralmente seu endereço de email user@domain) e escolha Selecionar na parte inferior do diálogo.

8. Selecione Revisar + atribuir para ir para a página final e, em seguida, Revisar + atribuir novamente para concluir o processo.

Obtenha a cadeia de conexão

Criar um namespace gera automaticamente uma política inicial de SAS (Assinatura de Acesso Compartilhado) com chaves primárias e secundárias e cadeias de conexão primárias e secundárias que concedem controle total sobre todos os aspectos do namespace. Consulte Autenticação e autorização do Barramento de Serviço para obter informações sobre como criar regras com direitos mais restritos para remetentes e destinatários regulares.

Um cliente pode usar a cadeia de conexão para se conectar ao namespace do Barramento de Serviço. Para copiar a cadeia de conexão primária para seu namespace, siga estas etapas:

1. Na página Namespace do Barramento de Serviço, selecione Políticas de acesso compartilhado no menu à esquerda.

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

3. Na janela Política: RootManageSharedAccessKey, selecione o botão Copiar próximo à Cadeia de Conexão Primária para copiar a cadeia de conexão na área de transferência para uso posterior. Cole esse valor no Bloco de notas ou em outro local temporário.

   

   Você pode usar essa página para copiar a chave primária, a chave secundária, a cadeia de conexão primária e a cadeia de conexão secundária.

Para seguir este guia de início rápido usando a autenticação sem senha e sua conta do Azure:

• Instale a CLI do Azure.
• Entrar com sua conta do Azure no terminal ou no prompt de comando com az login.
• Use a mesma conta ao adicionar a função apropriada ao recurso posteriormente no tutorial.
• Execute o código do tutorial no mesmo terminal ou prompt de comando.

Para usar o código sem senha, você precisará especificar um:

• namespace do barramento de serviço totalmente qualificado, por exemplo: <service-bus-namespace>.servicebus.windows.net
• nome do tópico
• subscription name

Para seguir este guia de início rápido usando uma cadeia de conexão para de autenticar, você não usa sua conta do Azure. Em vez disso, use a cadeia de conexão do namespace do barramento de serviço.

Para usar o código de conexão, você precisará especificar um:

• cadeia de conexão
• nome do tópico
• subscription name

1. Para instalar os pacotes do Python necessários para este tutorial do Barramento de Serviço, abra um prompt de comando que tenha o Python no caminho. Altere o diretório para a pasta em que deseja ter os exemplos.

2. Instalar pacotes:

   pip install azure-servicebus
   pip install azure-identity
   pip install aiohttp
   

1. Para instalar os pacotes do Python necessários para este tutorial do Barramento de Serviço, abra um prompt de comando que tenha o Python no caminho. Altere o diretório para a pasta em que deseja ter os exemplos.

2. Instale o pacote:

   pip install azure-servicebus
   

1. Adicione as seguintes declarações de import.

   import asyncio
   from azure.servicebus.aio import ServiceBusClient
   from azure.servicebus import ServiceBusMessage
   from azure.identity.aio import DefaultAzureCredential
   

2. Adicione as constantes e defina uma credencial.

   FULLY_QUALIFIED_NAMESPACE = "FULLY_QUALIFIED_NAMESPACE"
   TOPIC_NAME = "TOPIC_NAME"
   
   credential = DefaultAzureCredential()
   

   Importante

   • Substitua FULLY_QUALIFIED_NAMESPACE pelo namespace totalmente qualificado do Barramento de Serviço.
   • Substitua TOPIC_NAME pelo nome do tópico.

   No código anterior, você usou a classe DefaultAzureCredential da biblioteca de clientes da Identidade do Azure. Quando o aplicativo for executado localmente durante o desenvolvimento, DefaultAzureCredential descobrirá e autenticará automaticamente no Azure usando a conta com a qual você fez logon na CLI do Azure. Quando o aplicativo é implantado no Azure, DefaultAzureCredential pode autenticar seu aplicativo no Microsoft Entra por meio de uma identidade gerenciada sem alterações de código.

3. Adicione um método para enviar uma mensagem individual.

   async def send_single_message(sender):
       # Create a Service Bus message
       message = ServiceBusMessage("Single Message")
       # send the message to the topic
       await sender.send_messages(message)
       print("Sent a single message")
   

   O remetente é um objeto que funciona como um cliente para o tópico criado. Você o criará posteriormente e o enviará como um argumento para essa função.

4. Adicione um método para enviar uma lista de mensagens.

   async def send_a_list_of_messages(sender):
       # Create a list of messages
       messages = [ServiceBusMessage("Message in list") for _ in range(5)]
       # send the list of messages to the topic
       await sender.send_messages(messages)
       print("Sent a list of 5 messages")
   

5. Adicione um método para enviar um lote de mensagens.

   async def send_batch_message(sender):
       # Create a batch of messages
       async with sender:
           batch_message = await sender.create_message_batch()
           for _ in range(10):
               try:
                   # Add a message to the batch
                   batch_message.add_message(ServiceBusMessage("Message inside a ServiceBusMessageBatch"))
               except ValueError:
                   # ServiceBusMessageBatch object reaches max_size.
                   # New ServiceBusMessageBatch object can be created here to send more data.
                   break
           # Send the batch of messages to the topic
           await sender.send_messages(batch_message)
       print("Sent a batch of 10 messages")
   

6. Crie um cliente do Barramento de Serviço e, depois, um objeto de remetente do tópico para enviar mensagens.

   async def run():
       # create a Service Bus client using the credential.
       async with ServiceBusClient(
           fully_qualified_namespace=FULLY_QUALIFIED_NAMESPACE,
           credential=credential,
           logging_enable=True) as servicebus_client:
           # Get a Topic Sender object to send messages to the topic
           sender = servicebus_client.get_topic_sender(topic_name=TOPIC_NAME)
           async with sender:
               # Send one message
               await send_single_message(sender)
               # Send a list of messages
               await send_a_list_of_messages(sender)
               # Send a batch of messages
               await send_batch_message(sender)
           # Close credential when no longer needed.
           await credential.close()
   
   asyncio.run(run())
   print("Done sending messages")
   print("-----------------------")
   

1. Adicione as seguintes declarações de import.

   import asyncio
   from azure.servicebus.aio import ServiceBusClient
   from azure.servicebus import ServiceBusMessage
   

2. Adicione as constantes a seguir.

   NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STRING"
   TOPIC_NAME = "TOPIC_NAME"
   

   Importante

   • Substitua NAMESPACE_CONNECTION_STRING pela cadeia de conexão do namespace.
   • Substitua TOPIC_NAME pelo nome do tópico.

3. Adicione um método para enviar uma mensagem individual.

   async def send_single_message(sender):
       # Create a Service Bus message
       message = ServiceBusMessage("Single Message")
       # send the message to the topic
       await sender.send_messages(message)
       print("Sent a single message")
   

   O remetente é um objeto que funciona como um cliente para o tópico criado. Você o criará posteriormente e o enviará como um argumento para essa função.

4. Adicione um método para enviar uma lista de mensagens.

   async def send_a_list_of_messages(sender):
       # Create a list of messages
       messages = [ServiceBusMessage("Message in list") for _ in range(5)]
       # send the list of messages to the topic
       await sender.send_messages(messages)
       print("Sent a list of 5 messages")
   

5. Adicione um método para enviar um lote de mensagens.

   async def send_batch_message(sender):
       # Create a batch of messages
       async with sender:
           batch_message = await sender.create_message_batch()
           for _ in range(10):
               try:
                   # Add a message to the batch
                   batch_message.add_message(ServiceBusMessage("Message inside a ServiceBusMessageBatch"))
               except ValueError:
                   # ServiceBusMessageBatch object reaches max_size.
                   # New ServiceBusMessageBatch object can be created here to send more data.
                   break
           # Send the batch of messages to the topic
           await sender.send_messages(batch_message)
       print("Sent a batch of 10 messages")
   

6. Crie um cliente do Barramento de Serviço e, depois, um objeto de remetente do tópico para enviar mensagens.

   async def run():
       # create a Service Bus client using the connection string
       async with ServiceBusClient.from_connection_string(
           conn_str=NAMESPACE_CONNECTION_STR,
           logging_enable=True) as servicebus_client:
           # Get a Topic Sender object to send messages to the topic
           sender = servicebus_client.get_topic_sender(topic_name=TOPIC_NAME)
           async with sender:
               # Send one message
               await send_single_message(sender)
               # Send a list of messages
               await send_a_list_of_messages(sender)
               # Send a batch of messages
               await send_batch_message(sender)
   
   asyncio.run(run())
   print("Done sending messages")
   print("-----------------------")
   

1. Como no exemplo de envio, adicione instruções import, defina constantes que você deve substituir pelos seus valores e defina uma credencial.

   import asyncio
   from azure.servicebus.aio import ServiceBusClient
   from azure.identity.aio import DefaultAzureCredential
   
   FULLY_QUALIFIED_NAMESPACE = "FULLY_QUALIFIED_NAMESPACE"
   SUBSCRIPTION_NAME = "SUBSCRIPTION_NAME"
   TOPIC_NAME = "TOPIC_NAME"
   
   credential = DefaultAzureCredential()
   

2. Crie um cliente do Barramento de Serviço e, depois, um objeto de destinatário da assinatura para receber mensagens.

   async def run():
       # create a Service Bus client using the credential
       async with ServiceBusClient(
           fully_qualified_namespace=FULLY_QUALIFIED_NAMESPACE,
           credential=credential,
           logging_enable=True) as servicebus_client:
   
           async with servicebus_client:
               # get the Subscription Receiver object for the subscription
               receiver = servicebus_client.get_subscription_receiver(topic_name=TOPIC_NAME, 
               subscription_name=SUBSCRIPTION_NAME, max_wait_time=5)
               async with receiver:
                   received_msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
                   for msg in received_msgs:
                       print("Received: " + str(msg))
                       # complete the message so that the message is removed from the subscription
                       await receiver.complete_message(msg)
           # Close credential when no longer needed.
           await credential.close()
   

3. Chame o método run .

   asyncio.run(run())
   

1. Como no exemplo de envio, adicione instruções import e defina constantes que você deve substituir pelos seus valores.

   import asyncio
   from azure.servicebus.aio import ServiceBusClient
   
   NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STRING"
   SUBSCRIPTION_NAME = "SUBSCRIPTION_NAME"
   TOPIC_NAME = "TOPIC_NAME"
   

2. Crie um cliente do Barramento de Serviço e, depois, um objeto de destinatário da assinatura para receber mensagens.

   async def run():
       # create a Service Bus client using the connection string
       async with ServiceBusClient.from_connection_string(
           conn_str=NAMESPACE_CONNECTION_STR,
           logging_enable=True) as servicebus_client:
   
           async with servicebus_client:
               # get the Subscription Receiver object for the subscription
               receiver = servicebus_client.get_subscription_receiver(topic_name=TOPIC_NAME, 
               subscription_name=SUBSCRIPTION_NAME, max_wait_time=5)
               async with receiver:
                   received_msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
                   for msg in received_msgs:
                       print("Received: " + str(msg))
                       # complete the message so that the message is removed from the subscription
                       await receiver.complete_message(msg)
   

3. Chame o método run .

   asyncio.run(run())