Share via

libreria client bus di servizio di Azure per Python - versione 7.11.4

  • Articolo

bus di servizio di Azure è un servizio di messaggistica gestito dal cloud ad alte prestazioni per fornire comunicazioni in tempo reale e a tolleranza di errore tra mittenti e ricevitori distribuiti.

Il bus di servizio offre più meccanismi per la comunicazione a elevata affidabilità asincrona, ad esempio la messaggistica first-in-first-out strutturata, le funzionalità di pubblicazione/sottoscrizione e la possibilità di ridimensionare facilmente in base alle esigenze.

Usare la libreria client del bus di servizio per Python per comunicare tra applicazioni e servizi e implementare modelli di messaggistica asincroni.

  • Creare spazi dei nomi, code, argomenti e sottoscrizioni del bus di servizio e modificarne le impostazioni.
  • Inviare e ricevere messaggi all'interno dei canali del bus di servizio.
  • Utilizzare blocchi, sessioni e funzionalità di messaggi non recapitabili per implementare modelli di messaggistica complessi.

Codice | sorgentePacchetto (PyPi) | Pacchetto (Conda) | Documentazione | di riferimento sulle APIDocumentazione | del prodottoCampioni | Changelog

NOTA: se si usa la versione 0.50 o una versione precedente e si vuole eseguire la migrazione alla versione più recente di questo pacchetto, vedere la guida alla migrazione per passare dal bus di servizio V0.50 alla versione 7 del bus di servizio.

Introduzione

Installare il pacchetto

Installare la libreria client bus di servizio di Azure per Python con pip:

pip install azure-servicebus

Prerequisiti:

Per usare questo pacchetto, è necessario disporre di:

Se è necessario uno spazio dei nomi del bus di servizio di Azure, è possibile crearlo tramite il portale di Azure. Se non si vuole usare l'interfaccia utente del portale grafico, è possibile usare l'interfaccia della riga di comando di Azure tramite Cloud Shell o l'interfaccia della riga di comando di Azure viene eseguita in locale per crearne una con questo comando dell'interfaccia della riga di comando di Azure:

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

Autenticare il client

L'interazione con il bus di servizio inizia con un'istanza della ServiceBusClient classe . Per creare un'istanza dell'oggetto client, è necessario un stringa di connessione con chiave di firma di accesso condiviso o uno spazio dei nomi e una delle relative chiavi dell'account. Per una dimostrazione su come eseguire l'autenticazione tramite uno dei due approcci, vedere gli esempi collegati di seguito.

Creare un client da stringa di connessione

  • Per ottenere le credenziali necessarie, è possibile usare il frammento di interfaccia della riga di comando di Azure (formattato per la shell Bash) nella parte superiore dell'esempio collegato per popolare una variabile di ambiente con il stringa di connessione del bus di servizio (è anche possibile trovare questi valori nel portale di Azure seguendo la guida dettagliata per Ottenere un bus di servizio stringa di connessione).

Creare un client usando la libreria azure-identity:

  • Questo costruttore accetta lo spazio dei nomi completo dell'istanza del bus di servizio e una credenziale che implementa il protocollo TokenCredential . Nel pacchetto azure-identity sono disponibili implementazioni del TokenCredential protocollo. Lo spazio dei nomi completo è del formato <yournamespace.servicebus.windows.net>.
  • Per usare i tipi di credenziali forniti da azure-identity, installare il pacchetto: pip install azure-identity
  • Inoltre, per usare l'API asincrona, è prima necessario installare un trasporto asincrono, ad esempio aiohttp: pip install aiohttp
  • Quando si usa Azure Active Directory, all'entità deve essere assegnato un ruolo che consente l'accesso al bus di servizio, ad esempio il ruolo proprietario dei dati bus di servizio di Azure. Per altre informazioni sull'uso dell'autorizzazione di Azure Active Directory con il bus di servizio, vedere la documentazione associata.

Nota: il client può essere inizializzato senza un gestore del contesto, ma deve essere chiuso manualmente tramite client.close() per non perdere risorse.

Concetti chiave

Dopo aver inizializzato un ServiceBusClientoggetto , è possibile interagire con i tipi di risorse primari all'interno di uno spazio dei nomi del bus di servizio, di cui possono esistere più e su cui avviene la trasmissione effettiva dei messaggi, lo spazio dei nomi viene spesso usato come contenitore dell'applicazione:

  • Coda: consente l'invio e la ricezione di messaggi. Spesso usato per la comunicazione da punto a punto.

  • Argomento: a differenza delle code, gli argomenti sono più adatti per gli scenari di pubblicazione/sottoscrizione. Un argomento può essere inviato a , ma richiede una sottoscrizione, di cui possono essere presenti più in parallelo, da utilizzare.

  • Sottoscrizione: meccanismo da utilizzare da un argomento. Ogni sottoscrizione è indipendente e riceve una copia di ogni messaggio inviato all'argomento. Le regole e i filtri possono essere usati per personalizzare i messaggi ricevuti da una sottoscrizione specifica.

Per altre informazioni su queste risorse, vedere Che cos'è bus di servizio di Azure?.

Per interagire con queste risorse, è necessario avere familiarità con i concetti dell'SDK seguenti:

  • ServiceBusClient: si tratta dell'oggetto che un utente deve prima inizializzare per connettersi a uno spazio dei nomi del bus di servizio. Per interagire con una coda, un argomento o una sottoscrizione, è necessario generare un mittente o un destinatario da questo client.

  • ServiceBusSender: per inviare messaggi a una coda o a un argomento, usare il metodo o get_topic_sender corrispondente get_queue_sender all'esterno di un'istanza ServiceBusClient come illustrato di seguito.

  • ServiceBusReceiver: per ricevere messaggi da una coda o una sottoscrizione, usare il metodo o get_subscription_receiver corrispondente get_queue_receiver all'esterno di un'istanzaServiceBusClient, come illustrato di seguito.

  • ServiceBusMessage: durante l'invio, questo è il tipo che verrà costruito per contenere il payload. Quando si riceve, questo è il percorso in cui si accederà al payload.

Thread safety

Microsoft non garantisce che ServiceBusClient, ServiceBusSender e ServiceBusReceiver siano thread-safe. Non è consigliabile riutilizzare queste istanze tra thread. Spetta all'applicazione in esecuzione usare queste classi in modo thread-safe.

Esempio

Le sezioni seguenti forniscono diversi frammenti di codice che illustrano alcune delle attività più comuni del bus di servizio, tra cui:

Per eseguire attività di gestione come la creazione e l'eliminazione di code/argomenti/sottoscrizioni, usare la libreria azure-mgmt-servicebus, disponibile qui.

Per altri esempi, vedere la directory degli esempi che illustra gli scenari comuni del bus di servizio, ad esempio l'invio, la ricezione, la gestione delle sessioni e la gestione dei messaggi.

Inviare messaggi a una coda

NOTA: vedere la documentazione di riferimento qui.

Questo esempio invia un singolo messaggio e una matrice di messaggi a una coda che si presuppone esista già, creata tramite i comandi portale di Azure 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: Un messaggio può essere pianificato per il recapito ritardato usando il ServiceBusSender.schedule_messages() metodo oppure specificando ServiceBusMessage.scheduled_enqueue_time_utc prima di chiamare ServiceBusSender.send_messages()

Per altri dettagli sulla pianificazione e la pianificazione dell'annullamento, vedere un esempio qui.

Ricevere messaggi da una coda

Per ricevere da una coda, è possibile eseguire una ricezione ad hoc tramite receiver.receive_messages() o ricevere in modo permanente tramite il ricevitore stesso.

Ricevere messaggi da una coda tramite iterazione su 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: Qualsiasi messaggio ricevuto con receive_mode=PEEK_LOCK (si tratta dell'impostazione predefinita, con l'alternativa RECEIVE_AND_DELETE la rimozione del messaggio dalla coda immediatamente alla ricezione) ha un blocco che deve essere rinnovato tramite receiver.renew_message_lock prima della scadenza se l'elaborazione richiederebbe più tempo della durata del blocco. Per un helper per eseguire questa operazione in background in background, vedere . La durata del blocco viene impostata in Azure nella coda o nell'argomento stesso.

Ricevere messaggi da una coda tramite ServiceBusReceiver.receive_messages()

NOTA:ServiceBusReceiver.receive_messages() riceve un singolo elenco o vincolato di messaggi tramite una chiamata al metodo ad hoc, anziché ricevere in modo perpetuo dal generatore. Restituisce sempre un elenco.

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

In questo esempio, max_message_count dichiara il numero massimo di messaggi da tentare di ricevere prima di raggiungere un max_wait_time come specificato in secondi.

NOTA: Va inoltre notato che ServiceBusReceiver.peek_messages() è leggermente diverso dalla ricezione, in quanto non blocca i messaggi visualizzati, e quindi non possono essere risolti.

Inviare e ricevere un messaggio da una coda abilitata per la sessione

NOTA: vedere la documentazione di riferimento per l'invio e la ricezione della sessione.

Le sessioni forniscono semantica first-in-first-out e a ricevitore singolo sopra una coda o una sottoscrizione. Mentre la sintassi di ricezione effettiva è la stessa, l'inizializzazione è leggermente diversa.

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: i messaggi ricevuti da una sessione non richiedono che i blocchi vengano rinnovati come un ricevitore non di sessione; Al contrario, la gestione dei blocchi si verifica a livello di sessione con un blocco di sessione che può essere rinnovato con receiver.session.renew_lock()

Utilizzo di argomenti e sottoscrizioni

NOTA: vedere la documentazione di riferimento per argomenti e sottoscrizioni.

Argomenti e sottoscrizioni offrono un'alternativa alle code per l'invio e la ricezione di messaggi. Per altre informazioni dettagliate, vedere i documenti e il modo in cui questi elementi differiscono dalle code.

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

Risolvere un messaggio dopo la ricevuta

Quando si riceve da una coda, sono disponibili più azioni che è possibile eseguire sui messaggi ricevuti.

NOTA: è possibile regolare ServiceBusReceivedMessage solo gli oggetti ricevuti in ServiceBusReceiveMode.PEEK_LOCK modalità (impostazione predefinita). ServiceBusReceiveMode.RECEIVE_AND_DELETE mode rimuove il messaggio dalla coda alla ricezione. ServiceBusReceivedMessage i messaggi restituiti da peek_messages() non possono essere risolti, perché il blocco del messaggio non viene preso come nel metodo di ricezione menzionato in precedenza.

Se il messaggio ha un blocco come indicato in precedenza, il regolamento avrà esito negativo se il blocco del messaggio è scaduto. Se l'elaborazione richiederebbe più tempo della durata del blocco, deve essere mantenuta tramite receiver.renew_message_lock prima della scadenza. La durata del blocco viene impostata in Azure nella coda o nell'argomento stesso. Per un helper per eseguire questa operazione in background in background, vedere .

Operazione completata

Dichiara che l'elaborazione dei messaggi deve essere completata correttamente, rimuovendo il messaggio dalla coda.

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)

Abbandonare

Abbandonare l'elaborazione del messaggio per il momento, restituendo immediatamente il messaggio alla coda per essere prelevato da un altro ricevitore (o lo stesso).

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

Trasferire il messaggio dalla coda primaria in una speciale "coda secondaria di messaggi non recapitabili" in cui è possibile accedervi usando la ServiceBusClient.get_<queue|subscription>_receiver funzione con il parametro sub_queue=ServiceBusSubQueue.DEAD_LETTER e utilizzato da come qualsiasi altro ricevitore. (vedere qui l'esempio)

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)

Rinviare

Il rinvio è leggermente diverso dai metodi di liquidazione precedenti. Impedisce che il messaggio venga ricevuto direttamente dalla coda impostandolo su di esso in modo che debba essere ricevuto dal numero di sequenza in una chiamata a ServiceBusReceiver.receive_deferred_messages (vedere qui l'esempio)

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)

Rinnovare automaticamente i blocchi di messaggio o sessione

NOTA: vedere la documentazione di riferimento per il rinnovo automatico del blocco.

AutoLockRenewer è un metodo semplice per garantire che il messaggio o la sessione rimanga bloccato anche per lunghi periodi di tempo, se la chiamata receiver.renew_message_lock/receiver.session.renew_lock è poco pratica o indesiderata. Internamente, non è molto più breve per creare un watchdog simultaneo per eseguire il rinnovo del blocco se l'oggetto sta per scadere. Deve essere usato come segue:

  • Rinnovo automatico del blocco dei messaggi
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()
  • Rinnovo automatico blocco sessione
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 per qualsiasi motivo il rinnovo automatico è stato interrotto o non è riuscito, è possibile osservare questa situazione tramite la auto_renew_error proprietà sull'oggetto da rinnovare oppure passando un callback al parametro all'inizializzazione del on_lock_renew_failure rinnovo. Si manifesterebbe anche quando si tenta di eseguire un'azione (ad esempio il completamento di un messaggio) sull'oggetto specificato.

Risoluzione dei problemi

Registrazione

  • Abilitare azure.servicebus il logger per raccogliere tracce dalla libreria.
  • Abilitare uamqp il logger per raccogliere tracce dalla libreria uAMQP sottostante.
  • Abilitare la traccia a livello di frame AMQP impostando logging_enable=True durante la creazione del client.
  • In alcuni casi è possibile considerare la uamqp registrazione troppo dettagliata. Per eliminare la registrazione non necessaria, aggiungere il frammento di codice seguente all'inizio del codice:
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)

Timeout

Esistono diversi timeout di cui un utente deve essere a conoscenza all'interno della libreria.

  • Chiusura del collegamento sul lato servizio di 10 minuti: un collegamento, una volta aperto, verrà chiuso dopo 10 minuti di inattività per proteggere il servizio da perdite di risorse. Questo dovrebbe essere in gran parte trasparente per un utente, ma se si nota una riconnessione che si verifica dopo tale durata, questo è il motivo. L'esecuzione di tutte le operazioni, incluse le operazioni di gestione, nel collegamento estenderà questo timeout.
  • max_wait_time: fornito durante la creazione di un ricevitore o quando si chiama receive_messages(), l'ora dopo la quale la ricezione dei messaggi verrà interrotta dopo nessun traffico. Questo vale sia per la funzione imperativa receive_messages() che per la lunghezza per cui verrà eseguita una ricezione in stile generatore prima di uscire se non sono presenti messaggi. Il passaggio di Nessuna (impostazione predefinita) attenderà per sempre, fino alla soglia di 10 minuti se non viene eseguita alcuna altra azione.

NOTA: Se l'elaborazione di un messaggio o di una sessione è sufficientemente lunga da causare timeout, in alternativa alla chiamata receiver.renew_message_lock/receiver.session.renew_lock manuale, è possibile sfruttare la AutoLockRenewer funzionalità dettagliata Rinnovare sopra.

Eccezioni comuni

Le API del bus di servizio generano le eccezioni seguenti in azure.servicebus.exceptions:

  • ServiceBusConnectionError: Si è verificato un errore nella connessione al servizio. Questo problema potrebbe essere stato causato da un problema di rete o di servizio temporaneo. È consigliabile riprovare.
  • ServiceBusAuthorizationError: Errore durante l'autorizzazione della connessione al servizio. Ciò potrebbe essere dovuto al fatto che le credenziali non dispongono dell'autorizzazione corretta per eseguire l'operazione. È consigliabile controllare l'autorizzazione delle credenziali.
  • ServiceBusAuthenticationError: Errore durante l'autenticazione della connessione al servizio. Ciò potrebbe essere stato causato dall'errore delle credenziali. È consigliabile controllare le credenziali.
  • OperationTimeoutError: Ciò indica che il servizio non ha risposto a un'operazione entro il periodo di tempo previsto. Questo problema potrebbe essere stato causato da un problema di rete o di servizio temporaneo. Il servizio può o non aver completato correttamente la richiesta; lo stato non è noto. È consigliabile tentare di verificare lo stato corrente e riprovare, se necessario.
  • MessageSizeExceededError: Ciò indica che il contenuto del messaggio è maggiore delle dimensioni del frame del bus di servizio. Ciò può verificarsi quando un numero eccessivo di messaggi del bus di servizio viene inviato in un batch o il contenuto passato nel corpo di un Message oggetto è troppo grande. È consigliabile ridurre il numero di messaggi inviati in un batch o le dimensioni del contenuto passato in un singolo ServiceBusMessageoggetto .
  • MessageAlreadySettled: Indica che non è possibile risolvere il messaggio. Questo problema può verificarsi quando si tenta di risolvere un messaggio già risolto.
  • MessageLockLostError: Il blocco sul messaggio è scaduto ed è stato rilasciato di nuovo alla coda. Dovrà essere ricevuto di nuovo per stabilirlo. È necessario essere consapevoli della durata del blocco di un messaggio e continuare a rinnovare il blocco prima della scadenza in caso di tempo di elaborazione prolungato. AutoLockRenewer potrebbe contribuire a mantenere il blocco del messaggio rinnovato automaticamente.
  • SessionLockLostError: Il blocco della sessione è scaduto. Non è più possibile risolvere tutti i messaggi non risolti che sono stati ricevuti. Se necessario, è consigliabile riconnettersi alla sessione. È necessario tenere presente la durata del blocco di una sessione e continuare a rinnovare il blocco prima della scadenza in caso di tempo di elaborazione prolungato. AutoLockRenewer potrebbe contribuire a mantenere il blocco della sessione rinnovata automaticamente.
  • MessageNotFoundError: Tentare di ricevere un messaggio con un determinato numero di sequenza. Questo messaggio non viene trovato. Assicurarsi che il messaggio non sia già stato ricevuto. Controllare la coda dei messaggi non recapitabili per verificare che il messaggio non si trovi al suo interno.
  • MessagingEntityNotFoundError: L'entità associata all'operazione non esiste o è stata eliminata. Assicurarsi che l'entità esista.
  • MessagingEntityDisabledError: Richiedere un'operazione di runtime su un'entità disabilitata. Attivare l'entità.
  • ServiceBusQuotaExceededError: L'entità di messaggistica ha raggiunto le dimensioni massime consentite oppure è stato superato il numero massimo di connessioni a uno spazio dei nomi. Creare spazio nell'entità mediante la ricezione di messaggi dall'entità o dalle relative code secondarie.
  • ServiceBusServerBusyError: Il servizio non è in grado di elaborare la richiesta in questo momento. Il client può attendere per un certo periodo di tempo ed è quindi opportuno ripetere l'operazione.
  • ServiceBusCommunicationError: Il client non è in grado di stabilire una connessione al bus di servizio. Assicurarsi che il nome host fornito sia corretto e l'host sia raggiungibile. Se il codice viene eseguito in un ambiente con un firewall/proxy, assicurarsi che il traffico verso il dominio/l'indirizzo IP del bus di servizio e le porte non sia bloccato.
  • SessionCannotBeLockedError: Tentare di connettersi a una sessione con un ID di sessione specifico, ma la sessione è attualmente bloccata da un altro client. Assicurarsi che la sessione venga sbloccata dagli altri client.
  • AutoLockRenewFailed: Tentativo di rinnovo di un blocco su un messaggio o una sessione in background non riuscito. Ciò può verificarsi quando il ricevitore utilizzato da AutoLockRenewer viene chiuso o il blocco delle rinnovabili è scaduto. È consigliabile registrare nuovamente il messaggio o la sessione rinnovabile ricevendo il messaggio o connettendosi di nuovo all'entità con sessione.
  • AutoLockRenewTimeout: Il tempo allocato per rinnovare il messaggio o il blocco di sessione è trascorso. È possibile registrare nuovamente l'oggetto che vuole essere rinnovato automaticamente o estendere il timeout in anticipo.
  • ServiceBusError: Tutti gli altri errori correlati al bus di servizio. Si tratta della classe di errore radice di tutti gli errori descritti in precedenza.

Per una descrizione dettagliata dei tipi di eccezioni comuni, vedere la documentazione di riferimento sulle eccezioni .

Passaggi successivi

Altro codice di esempio

Per altri esempi, vedere la directory degli esempi che illustra gli scenari comuni del bus di servizio, ad esempio l'invio, la ricezione, la gestione delle sessioni e la gestione dei messaggi.

Documentazione aggiuntiva

Per una documentazione più completa sul servizio del bus di servizio, vedere la documentazione del bus di servizio su docs.microsoft.com.

Funzionalità e documentazione di gestione

Per gli utenti che cercano di eseguire operazioni di gestione su ServiceBus (Creazione di una coda,argomento/e così via, modifica delle regole di filtro, enumerazione delle entità) vedere la documentazione di azure-mgmt-servicebus per la documentazione dell'API. Gli esempi di utilizzo di Terse sono disponibili anche qui .

Supporto per il trasporto AMQP python puro e la compatibilità con le versioni precedenti

La libreria client bus di servizio di Azure è ora basata su un'implementazione AMQP python pura. uAMQP è stato rimosso in base alle dipendenze necessarie.

Per usare uAMQP come trasporto sottostante:

  1. Installare uamqp con pip.
$ pip install uamqp
  1. Passare uamqp_transport=True durante la costruzione del client.
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: l'attributo inServiceBusMessageBatchServiceBusMessage//ServiceBusReceivedMessage , che in precedenza ha esposto l'oggetto messageuamqp.Message, è stato deprecato. Gli oggetti "Legacy" restituiti dall'attributo message sono stati introdotti per facilitare la transizione.

Creazione della ruota uAMQP dall'origine

azure-servicebus dipende dall'implementazione del protocollo AMQP uAMQP . Le ruote uAMQP sono disponibili per la maggior parte dei sistemi operativi principali e verranno installati automaticamente durante l'installazione azure-servicebusdi . Se uAMQP è destinato a essere usato come implementazione del protocollo AMQP sottostante per , è possibile trovare ruote uAMQP per azure-servicebusla maggior parte dei sistemi operativi principali.

Se si esegue su una piattaforma per cui non sono disponibili ruote uAMQP, seguire Se si intende usare uAMQP e si sta eseguendo su una piattaforma per cui non sono disponibili ruote uAMQP, seguire le indicazioni per l'installazione uAMQP da origine.

Contributo

In questo progetto sono benvenuti i contributi e i suggerimenti. Per la maggior parte dei contenuti è necessario sottoscrivere un contratto di licenza di collaborazione (CLA, Contributor License Agreement) che stabilisce che l'utente ha il diritto di concedere, e di fatto concede a Microsoft i diritti d'uso del suo contributo. Per informazioni dettagliate, vedere https://cla.microsoft.com.

Quando si invia una richiesta pull, un bot CLA determina automaticamente se è necessario specificare un contratto CLA e completare la richiesta pull in modo appropriato (ad esempio con un'etichetta e un commento). Seguire le istruzioni specificate dal bot. È sufficiente eseguire questa operazione una sola volta per tutti i repository che usano il contratto CLA Microsoft.

Questo progetto ha adottato il Codice di comportamento di Microsoft per l'open source. Per altre informazioni, vedere Code of Conduct FAQ (Domande frequenti sul Codice di comportamento Open Source di Microsoft) oppure contattare opencode@microsoft.com per eventuali altre domande o commenti.