Share via

Azure Service Bus biblioteca de cliente para Python – versão 7.11.4

  • Artigo

Azure Service Bus é um serviço de mensagens gerido pela cloud de elevado desempenho para fornecer comunicação tolerante a falhas e em tempo real entre remetentes distribuídos e recetores.

O Service Bus fornece vários mecanismos para uma comunicação assíncrona e altamente fiável, como mensagens estruturadas, funcionalidades de publicação/subscrição e a capacidade de dimensionar facilmente à medida que as suas necessidades aumentam.

Utilize a biblioteca de cliente do Service Bus para Python para comunicar entre aplicações e serviços e implementar padrões de mensagens assíncronas.

  • Crie espaços de nomes, filas, tópicos e subscrições do Service Bus e modifique as respetivas definições.
  • Envie e receba mensagens nos seus canais do Service Bus.
  • Utilize bloqueios de mensagens, sessões e funcionalidades de mensagens não entregues para implementar padrões de mensagens complexos.

Código fonte | Pacote (PyPi) | Pacote (Conda) | Documentação | de referência da APIDocumentação do | produtoExemplos | Caixa de alterações

NOTA: se estiver a utilizar a versão 0.50 ou inferior e quiser migrar para a versão mais recente deste pacote, veja o nosso guia de migração para passar do Service Bus V0.50 para o Service Bus V7.

Introdução

Instalar o pacote

Instale a biblioteca de cliente Azure Service Bus para Python com pip:

pip install azure-servicebus

Pré-requisitos:

Para utilizar este pacote, tem de ter:

Se precisar de um espaço de nomes do service bus do Azure, pode criá-lo através do Portal do Azure. Se não quiser utilizar a IU do portal gráfico, pode utilizar a CLI do Azure através de Cloud Shell ou a CLI do Azure é executada localmente para criar uma com este comando da CLI do Azure:

az servicebus namespace create --resource-group <resource-group-name> --name <servicebus-namespace-name> --location <servicebus-namespace-location>

Autenticar o cliente

A interação com o Service Bus começa com uma instância da ServiceBusClient classe . Precisa de um cadeia de ligação com a chave SAS ou um espaço de nomes e uma das respetivas chaves de conta para instanciar o objeto de cliente. Veja os exemplos associados abaixo para obter uma demonstração sobre como autenticar através de qualquer uma das abordagens.

Criar cliente a partir de cadeia de ligação

  • Para obter as credenciais necessárias, pode utilizar o fragmento da CLI do Azure (Formatted for Bash Shell) na parte superior do exemplo ligado para preencher uma variável de ambiente com o service bus cadeia de ligação (também pode encontrar estes valores no portal do Azure ao seguir o guia passo a passo para Obter um service bus cadeia de ligação).

Crie um cliente com a biblioteca azure-identity:

  • Este construtor utiliza o espaço de nomes completamente qualificado da instância do Service Bus e uma credencial que implementa o protocolo TokenCredential . Existem implementações do TokenCredential protocolo disponíveis no pacote azure-identity. O espaço de nomes completamente qualificado tem o formato <yournamespace.servicebus.windows.net>.
  • Para utilizar os tipos de credenciais fornecidos pelo azure-identity, instale o pacote: pip install azure-identity
  • Além disso, para utilizar a API assíncrona, primeiro tem de instalar um transporte assíncrono, como aiohttp: pip install aiohttp
  • Ao utilizar o Azure Active Directory, tem de ser atribuída uma função ao principal que permita o acesso ao Service Bus, como a função proprietário de dados Azure Service Bus. Para obter mais informações sobre como utilizar a autorização do Azure Active Directory com o Service Bus, veja a documentação associada.

Nota: o cliente pode ser inicializado sem um gestor de contexto, mas tem de ser fechado manualmente através de client.close() para não fuga de recursos.

Conceitos-chave

Depois de inicializar um ServiceBusClient, pode interagir com os principais tipos de recursos num Espaço de Nomes do Service Bus, dos quais podem existir múltiplos e em que a transmissão real de mensagens ocorre, o espaço de nomes funciona frequentemente como um contentor de aplicações:

  • Fila: permite o envio e a receção de mensagens. Frequentemente utilizado para comunicação ponto a ponto.

  • Tópico: Ao contrário das Filas, os Tópicos são mais adequados para publicar/subscrever cenários. Um tópico pode ser enviado para, mas requer uma subscrição, da qual pode haver vários em paralelo, para consumir.

  • Subscrição: o mecanismo a consumir a partir de um Tópico. Cada subscrição é independente e recebe uma cópia de cada mensagem enviada para o tópico. As regras e filtros podem ser utilizados para personalizar as mensagens recebidas por uma subscrição específica.

Para obter mais informações sobre estes recursos, consulte O que é Azure Service Bus?.

Para interagir com estes recursos, deve estar familiarizado com os seguintes conceitos do SDK:

  • ServiceBusClient: este é o objeto que um utilizador deve inicializar primeiro para ligar a um Espaço de Nomes do Service Bus. Para interagir com uma fila, tópico ou subscrição, seria gerado um remetente ou recetor fora deste cliente.

  • ServiceBusSender: para enviar mensagens para uma Fila ou Tópico, utilizaria o método ou get_topic_sender correspondente get_queue_sender de uma ServiceBusClient instância, conforme visto aqui.

  • ServiceBusReceiver: para receber mensagens de uma Fila ou Subscrição, utilizaria o método ou get_subscription_receiver correspondente get_queue_receiver de uma ServiceBusClient instância, conforme visto aqui.

  • ServiceBusMessage: ao enviar, este é o tipo que irá construir para conter o payload. Ao receber, é aqui que irá aceder ao payload.

Segurança de threads

Não garantimos que ServiceBusClient, ServiceBusSender e ServiceBusReceiver sejam seguros para threads. Não recomendamos reutilizar estas instâncias entre threads. Cabe à aplicação em execução utilizar estas classes de forma segura para threads.

Exemplos

As secções seguintes fornecem vários fragmentos de código que abrangem algumas das tarefas mais comuns do Service Bus, incluindo:

Para realizar tarefas de gestão, como criar e eliminar filas/tópicos/subscrições, utilize a biblioteca azure-mgmt-servicebus, disponível aqui.

Encontre mais exemplos no diretório de exemplos que demonstram cenários comuns do Service Bus, como o envio, a receção, a gestão de sessões e o processamento de mensagens.

Enviar mensagens para uma fila

NOTA: veja a documentação de referência aqui.

Este exemplo envia uma única mensagem e matriz de mensagens para uma fila que se presume já existir, criada através dos comandos portal do Azure ou az.

from azure.servicebus import ServiceBusClient, ServiceBusMessage

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_sender(queue_name) as sender:
        # Sending a single message
        single_message = ServiceBusMessage("Single message")
        sender.send_messages(single_message)

        # Sending a list of messages
        messages = [ServiceBusMessage("First message"), ServiceBusMessage("Second message")]
        sender.send_messages(messages)

NOTA: Uma mensagem pode ser agendada para entrega atrasada com o ServiceBusSender.schedule_messages() método ou especificando antes de efetuar ServiceBusMessage.scheduled_enqueue_time_utc chamadas ServiceBusSender.send_messages()

Para obter mais detalhes sobre como agendar e agendar o cancelamento, veja um exemplo aqui.

Receber mensagens de uma fila

Para receber de uma fila, pode efetuar uma receção ad hoc via receiver.receive_messages() ou receber persistentemente através do próprio recetor.

Receber mensagens de uma fila através da iteração através do ServiceBusReceiver

from azure.servicebus import ServiceBusClient

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    # max_wait_time specifies how long the receiver should wait with no incoming messages before stopping receipt.
    # Default is None; to receive forever.
    with client.get_queue_receiver(queue_name, max_wait_time=30) as receiver:
        for msg in receiver:  # ServiceBusReceiver instance is a generator.
            print(str(msg))
            # If it is desired to halt receiving early, one can break out of the loop here safely.

NOTA: Qualquer mensagem recebida com receive_mode=PEEK_LOCK (esta é a predefinição, com a alternativa RECEIVE_AND_DELETE remover a mensagem da fila imediatamente no recibo) tem um bloqueio que tem de ser renovado receiver.renew_message_lock antes de expirar se o processamento demorar mais tempo do que a duração do bloqueio. Consulte AutoLockRenewer para obter um programa auxiliar para efetuar esta ação automaticamente em segundo plano. A duração do bloqueio é definida no Azure na própria fila ou tópico.

Receber mensagens de uma fila através de ServiceBusReceiver.receive_messages()

NOTA:ServiceBusReceiver.receive_messages() recebe uma lista única ou restrita de mensagens através de uma chamada de método ad hoc, em vez de receber perpétuamente do gerador. Devolve sempre uma lista.

from azure.servicebus import ServiceBusClient

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_receiver(queue_name) as receiver:
        received_message_array = receiver.receive_messages(max_wait_time=10)  # try to receive a single message within 10 seconds
        if received_message_array:
            print(str(received_message_array[0]))

    with client.get_queue_receiver(queue_name) as receiver:
        received_message_array = receiver.receive_messages(max_message_count=5, max_wait_time=10)  # try to receive maximum 5 messages in a batch within 10 seconds
        for message in received_message_array:
            print(str(message))

Neste exemplo, max_message_count declara o número máximo de mensagens a tentar receber antes de atingir um max_wait_time conforme especificado em segundos.

NOTA: Também deve ser notado que ServiceBusReceiver.peek_messages() é subtilmente diferente de receber, uma vez que não bloqueia as mensagens que estão a ser espreitadas e, portanto, não podem ser resolvidas.

Enviar e receber uma mensagem de uma fila com sessão ativada

NOTA: veja a documentação de referência para enviar e receber sessões.

As sessões fornecem semântica de primeira entrada e recetor único sobre uma fila ou subscrição. Embora a sintaxe de receção real seja a mesma, a inicialização difere ligeiramente.

from azure.servicebus import ServiceBusClient, ServiceBusMessage

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_SESSION_QUEUE_NAME']
session_id = os.environ['SERVICE_BUS_SESSION_ID']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_sender(queue_name) as sender:
        sender.send_messages(ServiceBusMessage("Session Enabled Message", session_id=session_id))

    # If session_id is null here, will receive from the first available session.
    with client.get_queue_receiver(queue_name, session_id=session_id) as receiver:
        for msg in receiver:
            print(str(msg))

NOTA: as mensagens recebidas de uma sessão não precisam dos respetivos bloqueios renovados, como um recetor que não seja de sessão; em vez disso, a gestão de bloqueios ocorre ao nível da sessão com um bloqueio de sessão que pode ser renovado com receiver.session.renew_lock()

Trabalhar com tópicos e subscrições

NOTA: veja a documentação de referência para tópicos e subscrições.

Os tópicos e subscrições fornecem uma alternativa às filas para enviar e receber mensagens. Veja os documentos aqui para obter mais detalhes abrangentes e como diferem das filas.

from azure.servicebus import ServiceBusClient, ServiceBusMessage

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
topic_name = os.environ['SERVICE_BUS_TOPIC_NAME']
subscription_name = os.environ['SERVICE_BUS_SUBSCRIPTION_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_topic_sender(topic_name) as sender:
        sender.send_messages(ServiceBusMessage("Data"))

    # If session_id is null here, will receive from the first available session.
    with client.get_subscription_receiver(topic_name, subscription_name) as receiver:
        for msg in receiver:
            print(str(msg))

Liquidar uma mensagem após o recibo

Ao receber de uma fila, tem várias ações que pode efetuar nas mensagens que recebe.

NOTA: só pode resolver ServiceBusReceivedMessage objetos que são recebidos no ServiceBusReceiveMode.PEEK_LOCK modo (esta é a predefinição). ServiceBusReceiveMode.RECEIVE_AND_DELETE o modo remove a mensagem da fila no recibo. ServiceBusReceivedMessage as mensagens devolvidas de peek_messages() não podem ser resolvidas, uma vez que o bloqueio de mensagens não é tomado como está nos métodos de receção mencionados anteriormente.

Se a mensagem tiver um bloqueio conforme mencionado acima, a liquidação falhará se o bloqueio da mensagem tiver expirado. Se o processamento demorar mais tempo do que a duração do bloqueio, tem de ser mantido receiver.renew_message_lock antes de expirar. A duração do bloqueio é definida no Azure na própria fila ou tópico. Consulte AutoLockRenewer para obter um auxiliar para efetuar esta ação automaticamente em segundo plano.

Concluído

Declara que o processamento de mensagens foi concluído com êxito, removendo a mensagem da fila.

from azure.servicebus import ServiceBusClient

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_receiver(queue_name) as receiver:
        for msg in receiver:
            print(str(msg))
            receiver.complete_message(msg)

Abandonar

Abandone o processamento da mensagem por enquanto, devolvendo imediatamente a mensagem à fila para ser recolhida por outro (ou o mesmo) recetor.

from azure.servicebus import ServiceBusClient

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_receiver(queue_name) as receiver:
        for msg in receiver:
            print(str(msg))
            receiver.abandon_message(msg)

DeadLetter

Transfira a mensagem da fila primária para uma "sub-fila de letras não entregues" especial, onde pode ser acedida com a função com o ServiceBusClient.get_<queue|subscription>_receiver parâmetro sub_queue=ServiceBusSubQueue.DEAD_LETTER e consumida como qualquer outro recetor. (veja exemplo aqui)

from azure.servicebus import ServiceBusClient

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_receiver(queue_name) as receiver:
        for msg in receiver:
            print(str(msg))
            receiver.dead_letter_message(msg)

Diferir

Diferir é subtilmente diferente dos métodos de liquidação anteriores. Impede que a mensagem seja recebida diretamente da fila ao colocá-la de lado para que tenha de ser recebida por número de sequência numa chamada para ServiceBusReceiver.receive_deferred_messages (veja exemplo aqui)

from azure.servicebus import ServiceBusClient

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_receiver(queue_name) as receiver:
        for msg in receiver:
            print(str(msg))
            receiver.defer_message(msg)

Renovar automaticamente bloqueios de Mensagens ou Sessões

NOTA: veja a documentação de referência para a renovação do bloqueio automático.

AutoLockRenewer é um método simples para garantir que a sua mensagem ou sessão permanece bloqueada mesmo durante longos períodos de tempo, se a chamada receiver.renew_message_lock/receiver.session.renew_lock for impraticável ou indesejada. Internamente, não é muito mais do que abreviatura para criar um cão de guarda simultâneo para bloquear a renovação se o objeto estiver prestes a expirar. Deve ser utilizado da seguinte forma:

  • Renovação automática do bloqueio de mensagens
from azure.servicebus import ServiceBusClient, AutoLockRenewer

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
queue_name = os.environ['SERVICE_BUS_QUEUE_NAME']

# Can also be called via "with AutoLockRenewer() as renewer" to automate closing.
renewer = AutoLockRenewer()
with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_receiver(queue_name) as receiver:
        for msg in receiver.receive_messages():
            renewer.register(receiver, msg, max_lock_renewal_duration=60)
            # Do your application logic here
            receiver.complete_message(msg)
renewer.close()
  • Renovação automática do bloqueio de sessão
from azure.servicebus import ServiceBusClient, AutoLockRenewer

import os
connstr = os.environ['SERVICE_BUS_CONNECTION_STR']
session_queue_name = os.environ['SERVICE_BUS_SESSION_QUEUE_NAME']
session_id = os.environ['SERVICE_BUS_SESSION_ID']

# Can also be called via "with AutoLockRenewer() as renewer" to automate closing.
renewer = AutoLockRenewer()
with ServiceBusClient.from_connection_string(connstr) as client:
    with client.get_queue_receiver(session_queue_name, session_id=session_id) as receiver:
        renewer.register(receiver, receiver.session, max_lock_renewal_duration=300) # Duration for how long to maintain the lock for, in seconds.

        for msg in receiver.receive_messages():
            # Do your application logic here
            receiver.complete_message(msg)
renewer.close()

Se, por alguma razão, a renovação automática tiver sido interrompida ou tiver falhado, tal pode ser observado através da auto_renew_error propriedade no objeto que está a ser renovado ou por ter passado uma chamada de retorno para o on_lock_renew_failure parâmetro sobre a inicialização do renovador. Também se manifestaria ao tentar tomar medidas (como concluir uma mensagem) no objeto especificado.

Resolução de problemas

Registo

  • Ative azure.servicebus o logger para recolher rastreios da biblioteca.
  • Ative uamqp o logger para recolher rastreios da biblioteca uAMQP subjacente.
  • Ative o rastreio ao nível da moldura AMQP ao definir logging_enable=True ao criar o cliente.
  • Pode haver casos em que considera o uamqp registo demasiado verboso. Para suprimir o registo desnecessário, adicione o seguinte fragmento à parte superior do código:
import logging

# The logging levels below may need to be changed based on the logging that you want to suppress.
uamqp_logger = logging.getLogger('uamqp')
uamqp_logger.setLevel(logging.ERROR)

# or even further fine-grained control, suppressing the warnings in uamqp.connection module
uamqp_connection_logger = logging.getLogger('uamqp.connection')
uamqp_connection_logger.setLevel(logging.ERROR)

Tempos limite

Existem vários tempos limite que um utilizador deve ter em conta na biblioteca.

  • Fecho da ligação do lado do serviço de 10 minutos: uma ligação, uma vez aberta, será fechada após 10 minutos inativa para proteger o serviço contra fugas de recursos. Isto deve ser em grande parte transparente para um utilizador, mas se notar que ocorre uma nova ligação após tal duração, é por isso que. A execução de quaisquer operações, incluindo operações de gestão, na ligação irá prolongar este tempo limite.
  • max_wait_time: fornecido sobre a criação de um recetor ou ao chamar receive_messages(), a hora após a qual as mensagens recebidas serão interrompidas após nenhum tráfego. Isto aplica-se tanto à função imperativa receive_messages() como ao comprimento para o qual uma receção de estilo gerador será executada antes de sair se não existirem mensagens. A passagem de Nenhum (predefinição) aguardará para sempre, até ao limiar de 10 minutos, se não for efetuada qualquer outra ação.

NOTA: Se o processamento de uma mensagem ou sessão for suficientemente longo para causar tempos limite, como alternativa às chamadas receiver.renew_message_lock/receiver.session.renew_lock manualmente, pode-se tirar partido da AutoLockRenewer funcionalidade detalhada acima.

Exceções Comuns

As APIs do Service Bus geram as seguintes exceções em azure.servicebus.exceptions:

  • ServiceBusConnectionError: Ocorreu um erro na ligação ao serviço. Isto pode ter sido causado por um problema transitório de rede ou de serviço. Recomenda-se que repita.
  • ServiceBusAuthorizationError: Ocorreu um erro ao autorizar a ligação ao serviço. Isto pode ter sido causado por as credenciais não terem a permissão certa para efetuar a operação. Recomenda-se verificar a permissão das credenciais.
  • ServiceBusAuthenticationError: Ocorreu um erro ao autenticar a ligação ao serviço. Isto pode ter sido causado por as credenciais estarem incorretas. Recomenda-se que verifique as credenciais.
  • OperationTimeoutError: Isto indica que o serviço não respondeu a uma operação dentro do período de tempo esperado. Isto pode ter sido causado por um problema transitório de rede ou de serviço. O serviço pode ou não ter concluído o pedido com êxito; o estado não é conhecido. Recomenda-se que tente verificar o estado atual e tente novamente, se necessário.
  • MessageSizeExceededError: Isto indica que o conteúdo da mensagem é maior do que o tamanho da moldura do service bus. Isto pode acontecer quando são enviadas demasiadas mensagens do service bus num lote ou o conteúdo transmitido para o corpo de um Message é demasiado grande. Recomenda-se reduzir a contagem de mensagens enviadas num lote ou o tamanho do conteúdo a ser transmitido para um único ServiceBusMessage.
  • MessageAlreadySettled: Isto indica uma falha ao resolver a mensagem. Isto pode acontecer ao tentar resolver uma mensagem já resolvida.
  • MessageLockLostError: O bloqueio na mensagem expirou e foi libertado novamente para a fila. Terá de ser recebido novamente para o resolver. Deve estar ciente da duração do bloqueio de uma mensagem e continuar a renovar o bloqueio antes da expiração em caso de tempo de processamento longo. AutoLockRenewer pode ajudar a manter o bloqueio da mensagem automaticamente renovado.
  • SessionLockLostError: O bloqueio na sessão expirou. Todas as mensagens não resolvidas que foram recebidas já não podem ser resolvidas. Recomenda-se que volte a ligar-se à sessão se receber mensagens novamente, se necessário. Deve estar ciente da duração do bloqueio de uma sessão e continuar a renovar o bloqueio antes da expiração em caso de tempo de processamento longo. AutoLockRenewer pode ajudar a manter o bloqueio da sessão automaticamente renovado.
  • MessageNotFoundError: Tente receber uma mensagem com um número de sequência específico. Esta mensagem não foi encontrada. Certifique-se de que a mensagem ainda não foi recebida. Verifique a fila deadletter para ver se a mensagem foi eliminada.
  • MessagingEntityNotFoundError: A entidade associada à operação não existe ou foi eliminada. Certifique-se de que a entidade existe.
  • MessagingEntityDisabledError: Pedido para uma operação de runtime numa entidade desativada. Ative a entidade.
  • ServiceBusQuotaExceededError: A entidade de mensagens atingiu o tamanho máximo permitido ou o número máximo de ligações a um espaço de nomes foi excedido. Crie espaço na entidade ao receber mensagens da entidade ou das respetivas subconsultas.
  • ServiceBusServerBusyError: O serviço não consegue processar o pedido neste momento. O cliente pode aguardar um período de tempo e, em seguida, repetir a operação.
  • ServiceBusCommunicationError: O cliente não consegue estabelecer uma ligação ao Service Bus. Certifique-se de que o nome do anfitrião fornecido está correto e que o anfitrião está acessível. Se o código for executado num ambiente com uma firewall/proxy, certifique-se de que o tráfego para o domínio/endereço IP do Service Bus não está bloqueado.
  • SessionCannotBeLockedError: Tente ligar a uma sessão com um ID de sessão específico, mas a sessão está atualmente bloqueada por outro cliente. Certifique-se de que a sessão está desbloqueada por outros clientes.
  • AutoLockRenewFailed: Uma tentativa de renovar um bloqueio numa mensagem ou sessão em segundo plano falhou. Isto pode acontecer quando o recetor utilizado pelo AutoLockRenewer está fechado ou o bloqueio da renovável expirou. Recomenda-se que volte a registar a mensagem ou sessão renovável ao receber a mensagem ou ligar novamente à entidade com sessão.
  • AutoLockRenewTimeout: Decorrido o tempo alocado para renovar a mensagem ou o bloqueio de sessão. Pode voltar a registar o objeto que quer que o bloqueio automático seja renovado ou prolongar o tempo limite com antecedência.
  • ServiceBusError: Todos os outros erros relacionados com o Service Bus. É a classe de erro raiz de todos os erros descritos acima.

Veja os documentos de referência de exceções para obter descrições detalhadas dos nossos tipos de Exceção comuns.

Passos seguintes

Mais código de exemplo

Encontre mais exemplos no diretório de exemplos que demonstram cenários comuns do Service Bus, como o envio, receção, gestão de sessões e processamento de mensagens.

Documentação adicional

Para obter documentação mais extensa sobre o serviço Service Bus, consulte a documentação do Service Bus sobre docs.microsoft.com.

Documentação e capacidades de gestão

Para os utilizadores que procuram efetuar operações de gestão no ServiceBus (Criar uma fila/tópico/etc., alterar regras de filtro, enumerar entidades), consulte a documentação azure-mgmt-servicebus para obter a documentação da API. Os exemplos de utilização terse também podem ser encontrados aqui .

Suporte de Transporte e Retrocompatibilidade do Python Puro

A biblioteca de cliente Azure Service Bus baseia-se agora numa implementação amQP de Python pura. uAMQP foi removido como dependência necessária.

Para utilizar uAMQP como transporte subjacente:

  1. Instale uamqp com pip.
$ pip install uamqp
  1. Passe uamqp_transport=True durante a construção do cliente.
from azure.servicebus import ServiceBusClient
connection_str = '<< CONNECTION STRING FOR THE SERVICE BUS NAMESPACE >>'
queue_name = '<< NAME OF THE QUEUE >>'
client = ServiceBusClient.from_connection_string(
    connection_str, uamqp_transport=True
)

Nota: o message atributo em ServiceBusMessage//ServiceBusMessageBatchServiceBusReceivedMessage, que expôs anteriormente o uamqp.Message, foi preterido. Os objetos "Legados" devolvidos pelo message atributo foram introduzidos para ajudar a facilitar a transição.

Criar roda uAMQP a partir da origem

azure-servicebus depende do uAMQP para a implementação do protocolo AMQP. As rodas uAMQP são fornecidas para a maioria dos principais sistemas operativos e serão instaladas automaticamente ao instalar azure-servicebuso . Se o uAMQP se destinar a ser utilizado como a implementação do protocolo AMQP subjacente para azure-servicebus, as rodas uAMQP podem ser encontradas para a maioria dos principais sistemas operativos.

Se estiver a executar numa plataforma para a qual as rodas uAMQP não são fornecidas, siga Se pretender utilizar uAMQP e estiver a executar numa plataforma para a qual as rodas uAMQP não são fornecidas, siga a documentação de orientação da Instalação uAMQP para instalar a partir da origem.

Contribuir

Agradecemos todas as contribuições e sugestões para este projeto. A maioria das contribuições requerem que celebre um Contrato de Licença de Contribuição (CLA) no qual se declare que tem o direito de conceder e que, na verdade, concede-nos os direitos para utilizar a sua contribuição. Para mais detalhes, visite https://cla.microsoft.com.

Quando submete um pedido Pull, um bot do CLA determina automaticamente se tem de fornecer um CLA e decorar o PR de forma adequada (por exemplo, etiqueta, comentário). Só tem de seguir as instruções fornecidas pelo bot. Apenas terá de fazer isto uma vez em todos os repositórios com o nosso CLA.

Este projeto adotou o Microsoft Open Source Code of Conduct (Código de Conduta do Microsoft Open Source). Para obter mais informações, consulte as FAQ do Código de Conduta ou o contacto opencode@microsoft.com com quaisquer perguntas ou comentários adicionais.