Compartir a través de

biblioteca cliente de Azure Service Bus para Python: versión 7.11.4

  • Artículo

Azure Service Bus es un servicio de mensajería administrado por la nube de alto rendimiento para proporcionar comunicación en tiempo real y tolerante a errores entre remitentes distribuidos y receptores.

Service Bus proporciona varios mecanismos para la comunicación asincrónica de alta confianza, como la mensajería estructurada primero en salir, las funcionalidades de publicación y suscripción, y la capacidad de escalar fácilmente a medida que crezcan sus necesidades.

Use la biblioteca cliente de Service Bus para Python para comunicarse entre aplicaciones y servicios e implementar patrones de mensajería asincrónica.

  • Cree espacios de nombres, colas, temas y suscripciones de Service Bus y modifique su configuración.
  • Envíe y reciba mensajes dentro de los canales de Service Bus.
  • Use bloqueos de mensajes, sesiones y funcionalidad de mensajes fallidos para implementar patrones de mensajería complejos.

Código | fuentePaquete (PyPi) | Paquete (Conda) | Documentación | de referencia de API | Documentación del productoMuestras | Changelog

NOTA: Si usa la versión 0.50 o inferior y quiere migrar a la versión más reciente de este paquete, consulte nuestra guía de migración para pasar de Service Bus V0.50 a Service Bus V7.

Introducción

Instalar el paquete

Instale la biblioteca cliente de Azure Service Bus para Python con pip:

pip install azure-servicebus

Requisitos previos:

Para usar este paquete, debe tener:

Si necesita un espacio de nombres de Azure Service Bus, puede crearlo a través de Azure Portal. Si no desea usar la interfaz de usuario gráfica del portal, puede usar la CLI de Azure a través de Cloud Shell o la CLI de Azure se ejecuta localmente para crear una con este comando de la CLI de Azure:

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

Autenticar el cliente

La interacción con Service Bus comienza con una instancia de la ServiceBusClient clase . Necesita una cadena de conexión con clave SAS o un espacio de nombres y una de sus claves de cuenta para crear una instancia del objeto de cliente. Busque los ejemplos vinculados a continuación para la demostración sobre cómo autenticarse a través de cualquiera de los enfoques.

Creación de un cliente a partir de cadena de conexión

  • Para obtener las credenciales necesarias, se puede usar el fragmento de código de la CLI de Azure (formateado para el shell de Bash) en la parte superior del ejemplo vinculado para rellenar una variable de entorno con el cadena de conexión de Service Bus (también puede encontrar estos valores en Azure Portal siguiendo la guía paso a paso para obtener un bus de servicio cadena de conexión).

Cree un cliente mediante la biblioteca azure-identity:

  • Este constructor toma el espacio de nombres completo de la instancia de Service Bus y una credencial que implementa el protocolo TokenCredential . Hay implementaciones del TokenCredential protocolo disponibles en el paquete azure-identity. El espacio de nombres completo tiene el formato <yournamespace.servicebus.windows.net>.
  • Para usar los tipos de credenciales proporcionados por azure-identity, instale el paquete: pip install azure-identity
  • Además, para usar la API asincrónica, primero debe instalar un transporte asincrónico, como aiohttp: pip install aiohttp
  • Al usar Azure Active Directory, se debe asignar a la entidad de seguridad un rol que permita el acceso a Service Bus, como el rol propietario de datos Azure Service Bus. Para más información sobre el uso de la autorización de Azure Active Directory con Service Bus, consulte la documentación asociada.

Nota: el cliente se puede inicializar sin un administrador de contexto, pero debe cerrarse manualmente a través de client.close() para no filtrar recursos.

Conceptos clave

Una vez que haya inicializado un ServiceBusClient, puede interactuar con los tipos de recursos principales dentro de un espacio de nombres de Service Bus, del que pueden existir varios y en qué transmisión de mensajes real tiene lugar, el espacio de nombres a menudo actúa como contenedor de aplicaciones:

  • Cola: permite enviar y recibir mensajes. A menudo se usa para la comunicación de punto a punto.

  • Tema: en lugar de las colas, los temas son más adecuados para escenarios de publicación y suscripción. Se puede enviar un tema a , pero requiere una suscripción, de la que puede haber varios en paralelo, para consumir.

  • Suscripción: mecanismo para consumir desde un tema. Cada suscripción es independiente y recibe una copia de cada mensaje enviado al tema. Las reglas y filtros se pueden usar para adaptar los mensajes que recibe una suscripción específica.

Para obtener más información sobre estos recursos, consulte ¿Qué es Azure Service Bus?.

Para interactuar con estos recursos, debe estar familiarizado con los siguientes conceptos del SDK:

  • ServiceBusClient: este es el objeto que un usuario debe inicializar primero para conectarse a un espacio de nombres de Service Bus. Para interactuar con una cola, un tema o una suscripción, uno generaría un remitente o receptor fuera de este cliente.

  • ServiceBusSender: para enviar mensajes a una cola o tema, se usaría el método o get_topic_sender correspondiente get_queue_sender de una ServiceBusClient instancia como se muestra aquí.

  • ServiceBusReceiver: para recibir mensajes de una cola o suscripción, se usaría el método o get_subscription_receiver correspondiente get_queue_receiver de una ServiceBusClient instancia, como se muestra aquí.

  • ServiceBusMessage: al enviar, este es el tipo que construirá para contener la carga. Al recibir, aquí es donde accederá a la carga útil.

Seguridad para subprocesos

No garantizamos que ServiceBusClient, ServiceBusSender y ServiceBusReceiver sean seguros para subprocesos. No se recomienda reutilizar estas instancias entre subprocesos. La aplicación en ejecución puede usar estas clases de forma segura para subprocesos.

Ejemplos

En las secciones siguientes se proporcionan varios fragmentos de código que abarcan algunas de las tareas más comunes de Service Bus, entre las que se incluyen:

Para realizar tareas de administración como la creación y eliminación de colas, temas o suscripciones, use la biblioteca azure-mgmt-servicebus, disponible aquí.

Busque más ejemplos en el directorio de ejemplos que muestran escenarios comunes de Service Bus, como el envío, la recepción, la administración de sesiones y el control de mensajes.

mensajes a una cola

NOTA: consulte la documentación de referencia aquí.

En este ejemplo se envía un único mensaje y una matriz de mensajes a una cola que se supone que ya existe, creada a través de los comandos Azure Portal o 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: Se puede programar un mensaje para la entrega retrasada mediante el ServiceBusSender.schedule_messages() método o especificando ServiceBusMessage.scheduled_enqueue_time_utc antes de llamar a . ServiceBusSender.send_messages()

Para obtener más información sobre la programación y la cancelación de la programación, consulte un ejemplo aquí.

mensajes de una cola

Para recibir de una cola, puede realizar una recepción ad hoc a través receiver.receive_messages() de o recibir de forma persistente a través del propio receptor.

Recepción de mensajes de una cola a través de la iteración a través de 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: Cualquier mensaje recibido con receive_mode=PEEK_LOCK (es el valor predeterminado, con la alternativa RECEIVE_AND_DELETE quitar el mensaje de la cola inmediatamente al recibir) tiene un bloqueo que se debe renovar antes receiver.renew_message_lock de que expire si el procesamiento tardaría más tiempo que la duración del bloqueo. Consulte AutoLockRenewer para obtener ayuda para realizar esto en segundo plano automáticamente. La duración del bloqueo se establece en Azure en la cola o el tema en sí.

Recepción de mensajes de una cola a través de ServiceBusReceiver.receive_messages()

NOTA:ServiceBusReceiver.receive_messages() recibe una lista única o restringida de mensajes a través de una llamada de método ad hoc, en lugar de recibir perpetuamente del generador. Siempre devuelve una 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))

En este ejemplo, max_message_count declara el número máximo de mensajes que se van a intentar recibir antes de alcanzar un max_wait_time como se especifica en segundos.

NOTA: También debe tenerse en cuenta que ServiceBusReceiver.peek_messages() es sutilmente diferente de la recepción, ya que no bloquea los mensajes que se ven y, por tanto, no se pueden resolver.

Envío y recepción de un mensaje de una cola habilitada para sesión

NOTA: consulte la documentación de referencia para el envío y recepción de sesiones.

Las sesiones proporcionan la semántica del primer en salir y el receptor único sobre una cola o suscripción. Aunque la sintaxis de recepción real es la misma, la inicialización difiere ligeramente.

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: Los mensajes recibidos de una sesión no necesitan que sus bloqueos se renueven como un receptor que no es de sesión; en su lugar, la administración de bloqueos se produce en el nivel de sesión con un bloqueo de sesión que se puede renovar con receiver.session.renew_lock()

Trabajar con temas y suscripciones

NOTA: consulte la documentación de referencia para temas y suscripciones.

Los temas y las suscripciones ofrecen una alternativa a las colas para enviar y recibir mensajes. Consulte los documentos aquí para obtener más detalles generales y sobre cómo difieren de las colas.

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 un mensaje después de la recepción

Al recibir desde una cola, tiene varias acciones que puede realizar en los mensajes que recibe.

NOTA: Solo puede liquidar ServiceBusReceivedMessage los objetos que se reciben en ServiceBusReceiveMode.PEEK_LOCK modo (este es el valor predeterminado). ServiceBusReceiveMode.RECEIVE_AND_DELETE el modo quita el mensaje de la cola al recibirlo. ServiceBusReceivedMessage Los mensajes devueltos de peek_messages() no se pueden liquidar, ya que el bloqueo del mensaje no se toma como si estuviera en los métodos de recepción mencionados anteriormente.

Si el mensaje tiene un bloqueo como se mencionó anteriormente, se producirá un error en la liquidación si el bloqueo del mensaje ha expirado. Si el procesamiento tardaría más tiempo que la duración del bloqueo, debe mantenerse a través receiver.renew_message_lock de antes de que expire. La duración del bloqueo se establece en Azure en la cola o el tema en sí. Consulte AutoLockRenewer para obtener ayuda para realizar esto en segundo plano automáticamente.

Completo

Declara que el procesamiento de mensajes se completará correctamente, quitando el mensaje de la cola.

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)

Abandon

Abandone el procesamiento del mensaje por el momento, devolviendo el mensaje inmediatamente de vuelta a la cola para ser recogido por otro receptor (o el mismo).

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

Transfiera el mensaje de la cola principal a una "sub-cola de mensajes fallidos" especial en la que se puede acceder a él mediante la función con el ServiceBusClient.get_<queue|subscription>_receiver parámetro sub_queue=ServiceBusSubQueue.DEAD_LETTER y consumido como cualquier otro receptor. (consulte el ejemplo aquí)

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)

Defer

El aplazamiento es ligeramente diferente de los métodos de liquidación anteriores. Impide que el mensaje se reciba directamente de la cola al establecerlo a un lado para que se reciba por número de secuencia en una llamada a ServiceBusReceiver.receive_deferred_messages (consulte el ejemplo aquí).

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)

Renovación automática de bloqueos de mensaje o sesión

NOTA: consulte la documentación de referencia para la renovación automática del bloqueo.

AutoLockRenewer es un método sencillo para asegurarse de que el mensaje o la sesión permanece bloqueado incluso durante largos períodos de tiempo, si la llamada receiver.renew_message_lock/receiver.session.renew_lock no es práctica o no deseada. Internamente, no es mucho más que abreviada para crear un guardián simultáneo para realizar la renovación del bloqueo si el objeto está a punto de expirar. Se debe usar de la siguiente manera:

  • Renovación automática del bloqueo de mensajes
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()
  • Renovación automática del bloqueo de sesión
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()

Si por algún motivo se ha interrumpido o se ha producido un error en la renovación automática, esto se puede observar a través de la propiedad del objeto que se está renovando o pasando una devolución de llamada al parámetro durante la auto_renew_error inicialización del on_lock_renew_failure renovador. También se manifestaría al intentar realizar una acción (por ejemplo, completar un mensaje) en el objeto especificado.

Solución de problemas

Registro

  • Habilite azure.servicebus el registrador para recopilar seguimientos de la biblioteca.
  • Habilite uamqp el registrador para recopilar seguimientos de la biblioteca uAMQP subyacente.
  • Habilite el seguimiento de nivel de fotograma de AMQP estableciendo logging_enable=True al crear el cliente.
  • Puede haber casos en los que considere que el uamqp registro es demasiado detallado. Para suprimir el registro innecesario, agregue el siguiente fragmento de código a la parte superior del 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)

Tiempos de expiración

Hay varios tiempos de espera que un usuario tenga en cuenta dentro de la biblioteca.

  • Cierre del vínculo lateral de servicio de 10 minutos: un vínculo, una vez abierto, se cerrará después de 10 minutos inactivos para proteger el servicio contra la pérdida de recursos. Esto debe ser en gran medida transparente para un usuario, pero si observa que se produce una reconexión después de esa duración, este es el motivo. La realización de cualquier operación, incluidas las operaciones de administración, en el vínculo extenderá este tiempo de espera.
  • max_wait_time: se proporciona al crear un receptor o al llamar a receive_messages(), la hora después de la cual los mensajes receptores se detendrán después de que no haya tráfico. Esto se aplica tanto a la función imperativa receive_messages() como a la longitud de que se ejecutará una recepción de estilo generador antes de salir si no hay ningún mensaje. Pasar Ninguno (valor predeterminado) esperará para siempre, hasta el umbral de 10 minutos si no se realiza ninguna otra acción.

NOTA: Si el procesamiento de un mensaje o sesión es lo suficientemente largo como para provocar tiempos de espera, como alternativa a llamar receiver.renew_message_lock/receiver.session.renew_lock manualmente, puede aprovechar la AutoLockRenewer funcionalidad detallada anteriores.

Excepciones comunes

Las API de Service Bus generan las siguientes excepciones en azure.servicebus.exceptions:

  • ServiceBusConnectionError: Error en la conexión al servicio. Esto puede deberse a un problema transitorio de red o servicio. Se recomienda volver a intentarlo.
  • ServiceBusAuthorizationError: Error al autorizar la conexión al servicio. Esto puede deberse a que las credenciales no tienen el permiso adecuado para realizar la operación. Se recomienda comprobar el permiso de las credenciales.
  • ServiceBusAuthenticationError: Error al autenticar la conexión al servicio. Esto puede deberse a que las credenciales son incorrectas. Se recomienda comprobar las credenciales.
  • OperationTimeoutError: Esto indica que el servicio no respondió a una operación dentro del período de tiempo esperado. Esto puede deberse a un problema transitorio de red o servicio. El servicio puede o no haber completado correctamente la solicitud; el estado no se conoce. Se recomienda intentar comprobar el estado actual y volver a intentarlo si es necesario.
  • MessageSizeExceededError: Esto indica que el contenido del mensaje es mayor que el tamaño del marco del bus de servicio. Esto puede ocurrir cuando se envían demasiados mensajes de Service Bus en un lote o el contenido pasado al cuerpo de es Message demasiado grande. Se recomienda reducir el número de mensajes que se envían en un lote o el tamaño del contenido que se pasa a un solo ServiceBusMessage.
  • MessageAlreadySettled: Esto indica que no se ha resuelto el mensaje. Esto podría ocurrir al intentar resolver un mensaje ya establecido.
  • MessageLockLostError: El bloqueo del mensaje ha expirado y se ha vuelto a liberar a la cola. Tendrá que volver a recibirse para resolverlo. Debe tener en cuenta la duración del bloqueo de un mensaje y mantener la renovación del bloqueo antes de la expiración en caso de un tiempo de procesamiento largo. AutoLockRenewer podría ayudar a mantener el bloqueo del mensaje renovado automáticamente.
  • SessionLockLostError: El bloqueo de la sesión ha expirado. Todos los mensajes sin resolver que se han recibido ya no se pueden resolver. Se recomienda volver a conectarse a la sesión si se vuelven a recibir mensajes si es necesario. Debe tener en cuenta la duración del bloqueo de una sesión y mantener la renovación del bloqueo antes de la expiración en caso de un tiempo de procesamiento largo. AutoLockRenewer podría ayudar a mantener el bloqueo de la sesión renovado automáticamente.
  • MessageNotFoundError: Intente recibir un mensaje con un número de secuencia determinado. Este mensaje no se encuentra. Asegúrese de que aún no se recibió el mensaje. Compruebe la cola de correo devuelto para ver si el mensaje se procesó como correo devuelto.
  • MessagingEntityNotFoundError: La entidad asociada a la operación no existe o se ha eliminado. Asegúrese de que la entidad existe.
  • MessagingEntityDisabledError: Solicitud de una operación en tiempo de ejecución en una entidad deshabilitada. Active la entidad.
  • ServiceBusQuotaExceededError: La entidad de mensajería ha alcanzado su tamaño máximo permitido o se ha superado el número máximo de conexiones a un espacio de nombres. Cree espacio en la entidad recibiendo mensajes de esta o de sus subcolas.
  • ServiceBusServerBusyError: El servicio no puede procesar la solicitud en este momento. El cliente puede esperar durante un período de tiempo y volver a intentar realizar la operación.
  • ServiceBusCommunicationError: El cliente no puede establecer una conexión a Service Bus. Asegúrese de que el nombre de host proporcionado sea correcto y que este sea accesible. Si el código se ejecuta en un entorno con un firewall o proxy, asegúrese de que el tráfico a la dirección IP o el dominio de Service Bus no esté bloqueado.
  • SessionCannotBeLockedError: Intente conectarse a una sesión con un identificador de sesión específico, pero la sesión está bloqueada actualmente por otro cliente. Asegúrese de que otros clientes desbloqueen la sesión.
  • AutoLockRenewFailed: Error al intentar renovar un bloqueo en un mensaje o sesión en segundo plano. Esto puede ocurrir cuando el receptor utilizado por AutoLockRenewer está cerrado o el bloqueo de las energías renovables ha expirado. Se recomienda volver a registrar el mensaje o sesión renovable al recibir el mensaje o conectarse de nuevo a la entidad con sesión.
  • AutoLockRenewTimeout: Ha transcurrido el tiempo asignado para renovar el mensaje o el bloqueo de sesión. Puede volver a registrar el objeto que quiere que se renueve el bloqueo automático o ampliar el tiempo de espera de antemano.
  • ServiceBusError: Todos los demás errores relacionados con Service Bus. Es la clase de error raíz de todos los errores descritos anteriormente.

Consulte los documentos de referencia de excepciones para obtener descripciones detalladas de nuestros tipos de excepciones comunes.

Pasos siguientes

Más código de ejemplo

Busque más ejemplos en el directorio de ejemplos que muestran escenarios comunes de Service Bus, como el envío, la recepción, la administración de sesiones y el control de mensajes.

Documentación adicional

Para obtener más documentación sobre el servicio Service Bus, consulte la documentación de Service Bus sobre docs.microsoft.com.

Funcionalidades y documentación de administración

Para los usuarios que buscan realizar operaciones de administración en ServiceBus (Creación de una cola o tema,etc., modificación de reglas de filtro, enumeración de entidades), consulte la documentación de azure-mgmt-servicebus para la documentación de la API. Aquí también se pueden encontrar ejemplos de uso terse.

Compatibilidad con transporte y compatibilidad con versiones anteriores de AMQP de Pure Python

La biblioteca cliente de Azure Service Bus ahora se basa en una implementación de AMQP de Python pura. uAMQP se ha quitado como dependencia necesaria.

Para usar uAMQP como transporte subyacente:

  1. Instale uamqp con pip.
$ pip install uamqp
  1. Pase uamqp_transport=True durante la construcción del 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: El message atributo en ServiceBusMessage//ServiceBusMessageBatchServiceBusReceivedMessage, que anteriormente expone , uamqp.Messageha quedado en desuso. Se han introducido los objetos "Heredados" devueltos por message el atributo para ayudar a facilitar la transición.

Creación de la rueda uAMQP desde el origen

azure-servicebus depende del uAMQP para la implementación del protocolo AMQP. Las ruedas uAMQP se proporcionan para la mayoría de los sistemas operativos principales y se instalarán automáticamente al instalar azure-servicebus. Si uAMQP está pensado para usarse como implementación del protocolo AMQP subyacente para azure-servicebus, se pueden encontrar ruedas uAMQP para la mayoría de los sistemas operativos principales.

Si se ejecuta en una plataforma para la que no se proporcionan ruedas uAMQP, siga Si piensa usar uAMQP y se ejecuta en una plataforma para la que no se proporcionan ruedas uAMQP, siga las instrucciones de instalación de uAMQP para instalar desde el origen.

Contribuciones

Este proyecto agradece las contribuciones y sugerencias. La mayoría de las contribuciones requieren que acepte un Contrato de licencia para el colaborador (CLA) que declara que tiene el derecho a concedernos y nos concede los derechos para usar su contribución. Para más detalles, visite https://cla.microsoft.com.

Cuando se envía una solicitud de incorporación de cambios, un bot de CLA determinará de forma automática si tiene que aportar un CLA y completar la PR adecuadamente (por ejemplo, la etiqueta, el comentario). Solo siga las instrucciones que le dará el bot. Solo será necesario que lo haga una vez en todos los repositorios con nuestro CLA.

Este proyecto ha adoptado el Código de conducta de Microsoft Open Source. Para más información, consulte las preguntas más frecuentes del código de conducta o póngase en contacto con opencode@microsoft.com si tiene cualquier otra pregunta o comentario.