Come usare gli argomenti e le sottoscrizioni del bus di servizio con RubyHow to use Service Bus topics and subscriptions with Ruby

Questo articolo descrive come usare gli argomenti e le sottoscrizioni del bus di servizio da applicazioni Ruby.This article describes how to use Service Bus topics and subscriptions from Ruby applications. Gli scenari illustrati includono creazione di argomenti e sottoscrizioni, creazione di filtri per le sottoscrizioni, invio di messaggi a un argomento, ricezione di messaggi da una sottoscrizione ed eliminazione di argomenti e sottoscrizioni.The scenarios covered include creating topics and subscriptions, creating subscription filters, sending messages to a topic, receiving messages from a subscription, and deleting topics and subscriptions. Per altre informazioni sugli argomenti e sulle sottoscrizioni, vedere la sezione Passaggi successivi.For more information on topics and subscriptions, see the Next Steps section.

Cosa sono gli argomenti e le sottoscrizioni del bus di servizio?What are Service Bus topics and subscriptions?

Gli argomenti e le sottoscrizioni del bus di servizio supportano un modello di comunicazione con messaggistica di pubblicazione-sottoscrizione .Service Bus topics and subscriptions support a publish/subscribe messaging communication model. Quando si usano gli argomenti e le sottoscrizioni, i componenti di un'applicazione distribuita non comunicano direttamente l'uno con l'altro, ma scambiano messaggi tramite un argomento, che agisce da intermediario.When using topics and subscriptions, components of a distributed application do not communicate directly with each other; instead they exchange messages via a topic, which acts as an intermediary.

Concetti relativi agli argomenti

Diversamente dalle code del bus di servizio, in cui ogni messaggio viene elaborato da un unico consumer, gli argomenti e le sottoscrizioni offrono una forma di comunicazione "uno a molti" tramite un modello di pubblicazione-sottoscrizione.In contrast with Service Bus queues, in which each message is processed by a single consumer, topics and subscriptions provide a "one-to-many" form of communication, using a publish/subscribe pattern. È possibile registrare più sottoscrizioni a un argomento.It is possible to register multiple subscriptions to a topic. Quando un messaggio viene inviato a un argomento, viene reso disponibile affinché ogni sottoscrizione possa gestirlo o elaborarlo in modo indipendente.When a message is sent to a topic, it is then made available to each subscription to handle/process independently.

La sottoscrizione a un argomento è simile a una coda virtuale che riceve copie dei messaggi che sono stati inviati all'argomento.A subscription to a topic resembles a virtual queue that receives copies of the messages that were sent to the topic. È possibile registrare regole di filtro per un argomento in base alla sottoscrizione, per poter filtrare o limitare quali messaggi relativi a un argomento vengono ricevuti dalle diverse sottoscrizioni dell'argomento.You can optionally register filter rules for a topic on a per-subscription basis, which enables you to filter or restrict which messages to a topic are received by which topic subscriptions.

Gli argomenti e le sottoscrizioni del bus di servizio consentono la scalabilità e l'elaborazione di grandi quantità di messaggi tra un numero elevato di utenti e applicazioni.Service Bus topics and subscriptions enable you to scale and process a very large number of messages across many users and applications.

Creare uno spazio dei nomiCreate a namespace

Per iniziare a usare gli argomenti e le sottoscrizioni del bus di servizio in Azure, è necessario creare prima di tutto uno spazio dei nomi del servizio.To begin using Service Bus topics and subscriptions in Azure, you must first create a service namespace. Uno spazio dei nomi fornisce un contenitore di ambito per fare riferimento alle risorse del bus di servizio all'interno dell'applicazione.A namespace provides a scoping container for addressing Service Bus resources within your application.

Per creare uno spazio dei nomi:To create a namespace:

  1. Accedere al portale di Azure.Log on to the Azure portal.
  2. Nel riquadro di spostamento sinistro del portale fare clic su Nuovo, quindi su Enterprise Integration e infine su Bus di servizio.In the left navigation pane of the portal, click New, then click Enterprise Integration, and then click Service Bus.
  3. Nella finestra di dialogo Crea spazio dei nomi immettere un nome per lo spazio dei nomi.In the Create namespace dialog, enter a namespace name. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.The system immediately checks to see if the name is available.
  4. Dopo aver verificato che il nome dello spazio dei nomi sia disponibile, scegliere il piano tariffario, ovvero Basic, Standard o Premium.After making sure the namespace name is available, choose the pricing tier (Basic, Standard, or Premium).
  5. Nel campo Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.In the Subscription field, choose an Azure subscription in which to create the namespace.
  6. Nel campo Gruppo di risorse scegliere un gruppo di risorse esistente nel quale risiederà lo spazio dei nomi oppure crearne uno nuovo.In the Resource group field, choose an existing resource group in which the namespace will live, or create a new one.
  7. In Localitàscegliere il paese o l'area in cui deve essere ospitato lo spazio dei nomi.In Location, choose the country or region in which your namespace should be hosted.

    Crea spazio dei nomi

  8. Selezionare il pulsante Create .Click the Create button. A questo punto, lo spazio dei nomi verrà creato e abilitato nel sistema.The system now creates your namespace and enables it. Potrebbero essere necessari alcuni minuti per consentire al sistema di effettuare il provisioning delle risorse per lo spazio dei nomi creato.You might have to wait several minutes as the system provisions resources for your account.

Ottenere le credenzialiObtain the credentials

  1. Nell'elenco degli spazi dei nomi fare clic sul nome dello spazio dei nomi appena creato.In the list of namespaces, click the newly created namespace name.
  2. Nel pannello Spazio dei nomi del bus di servizio fare clic su Criteri di accesso condiviso.In the Service Bus namespace blade, click Shared access policies.
  3. Nel pannello Criteri di accesso condivisi fare clic su RootManageSharedAccessKey.In the Shared access policies blade, click RootManageSharedAccessKey.

    connection-info

  4. Nel pannello Criteri: RootManageSharedAccessKey fare clic sul pulsante Copia accanto a Stringa di connessione - chiave primaria per copiare la stringa di connessione negli Appunti e usarla in un secondo momento.In the Policy: RootManageSharedAccessKey blade, click the copy button next to Connection string–primary key, to copy the connection string to your clipboard for later use.

    connection-string

Per iniziare a usare le entità di messaggistica del bus di servizio in Azure, prima di tutto è necessario creare uno spazio dei nomi con un nome univoco in Azure.To begin using Service Bus messaging entities in Azure, you must first create a namespace with a name that is unique across Azure. Uno spazio dei nomi fornisce un contenitore di ambito per fare riferimento alle risorse del bus di servizio all'interno dell'applicazione.A namespace provides a scoping container for addressing Service Bus resources within your application.

Per creare uno spazio dei nomi:To create a namespace:

  1. Accedere al portale di Azure.Log on to the Azure portal.
  2. Nel riquadro di spostamento sinistro del portale fare clic su Nuovo, quindi su Enterprise Integration e infine su Bus di servizio.In the left navigation pane of the portal, click New, then click Enterprise Integration, and then click Service Bus.
  3. Nella finestra di dialogo Crea spazio dei nomi immettere un nome per lo spazio dei nomi.In the Create namespace dialog, enter a namespace name. Verrà effettuato immediatamente un controllo sulla disponibilità del nome.The system immediately checks to see if the name is available.
  4. Dopo aver verificato che il nome dello spazio dei nomi sia disponibile, scegliere il piano tariffario, ovvero Basic, Standard o Premium.After making sure the namespace name is available, choose the pricing tier (Basic, Standard, or Premium).
  5. Nel campo Sottoscrizione scegliere una sottoscrizione di Azure in cui creare lo spazio dei nomi.In the Subscription field, choose an Azure subscription in which to create the namespace.
  6. Nel campo Gruppo di risorse scegliere un gruppo di risorse esistente nel quale risiederà lo spazio dei nomi oppure crearne uno nuovo.In the Resource group field, choose an existing resource group in which the namespace will live, or create a new one.
  7. In Localitàscegliere il paese o l'area in cui deve essere ospitato lo spazio dei nomi.In Location, choose the country or region in which your namespace should be hosted.

    Crea spazio dei nomi

  8. Fare clic su Crea.Click Create. A questo punto, lo spazio dei nomi verrà creato e abilitato nel sistema.The system now creates your namespace and enables it. Potrebbero essere necessari alcuni minuti per consentire al sistema di effettuare il provisioning delle risorse per lo spazio dei nomi creato.You might have to wait several minutes as the system provisions resources for your account.

Ottenere le credenziali di gestioneObtain the management credentials

Con la creazione di un nuovo spazio dei nomi verrà generata automaticamente una regola di firma di accesso condiviso iniziale con una coppia di chiavi primaria e secondaria associata che concede il controllo completo di tutti gli aspetti dello spazio dei nomi.Creating a new namespace will automatically generate an initial Shared Access Signature (SAS) rule with an associated pair of primary and secondary keys that grants full control over all aspects of the namespace. Vedere Autenticazione e autorizzazione del bus di servizio per informazioni su come creare altre regole con diritti più limitati per mittenti e destinatari normali.Refer to Service Bus authentication and authorization for how to create further rules with more constrained rights for regular senders and receivers. Per copiare la regola iniziale seguire questa procedura:To copy the initial rule, follow these steps:

  1. Nell'elenco degli spazi dei nomi fare clic sul nome dello spazio dei nomi appena creato.In the list of namespaces, click the newly created namespace name.
  2. Nel pannello dello spazio dei nomi fare clic su Criteri di accesso condivisi.In the namespace blade, click Shared access policies.
  3. Nel pannello Criteri di accesso condivisi fare clic su RootManageSharedAccessKey.In the Shared access policies blade, click RootManageSharedAccessKey.

    connection-info

  4. Nel pannello Criteri: RootManageSharedAccessKey fare clic sul pulsante Copia accanto a Stringa di connessione - chiave primaria per copiare la stringa di connessione negli Appunti e usarla in un secondo momento.In the Policy: RootManageSharedAccessKey blade, click the copy button next to Connection string–primary key, to copy the connection string to your clipboard for later use. Incollare questo valore nel Blocco note o in un'altra posizione temporanea.Paste this value into Notepad or some other temporary location.

    connection-string

  5. Ripetere il passaggio precedente e copiare e incollare il valore della chiave primaria in un percorso temporaneo per usarlo in seguito.Repeat the previous step, copying and pasting the value of Primary key to a temporary location for later use.

Creare un'applicazione RubyCreate a Ruby application

Per istruzioni, vedere Creare un'applicazione Ruby in Azure.For instructions, see Create a Ruby Application on Azure.

Configurare l'applicazione per l'uso del bus di servizioConfigure Your application to Use Service Bus

Per usare il bus di servizio, scaricare e usare il pacchetto Ruby di Azure, che comprende un set di pratiche librerie che comunicano con i servizi REST di archiviazione.To use Service Bus, download and use the Azure Ruby package, which includes a set of convenience libraries that communicate with the storage REST services.

Utilizzare RubyGems per ottenere il pacchettoUse RubyGems to obtain the package

  1. Usare un'interfaccia della riga di comando, ad esempio PowerShell (Windows), Terminal (Mac) o Bash (Unix).Use a command-line interface such as PowerShell (Windows), Terminal (Mac), or Bash (Unix).
  2. Digitare "gem install azure" nella finestra di comando per installare la gemma e le dipendenze.Type "gem install azure" in the command window to install the gem and dependencies.

Importare il pacchettoImport the package

Usando l'editor di testo preferito aggiungere quanto segue alla parte superiore del file Ruby dove si intende usare l'archiviazione:Using your favorite text editor, add the following to the top of the Ruby file in which you intend to use storage:

require "azure"

Configurare una stringa di connessione per il bus di servizioSet up a Service Bus connection

Usare il codice seguente per impostare i valori dello spazio dei nomi, il nome della chiave, la chiave, il firmatario e l'host:Use the following code to set the values of namespace, name of the key, key, signer and host:

Azure.configure do |config|
  config.sb_namespace = '<your azure service bus namespace>'
  config.sb_sas_key_name = '<your azure service bus access keyname>'
  config.sb_sas_key = '<your azure service bus access key>'
end
signer = Azure::ServiceBus::Auth::SharedAccessSigner.new
sb_host = "https://#{Azure.sb_namespace}.servicebus.windows.net"

Impostare il valore dello spazio dei nomi sul valore creato invece che sull'intero URL.Set the namespace value to the value you created rather than the entire URL. Ad esempio, usare "yourexamplenamespace" e non "yourexamplenamespace.servicebus.windows.net".For example, use "yourexamplenamespace", not "yourexamplenamespace.servicebus.windows.net".

Creare un argomentoCreate a topic

L'oggetto Azure::ServiceBusService consente di usare argomenti.The Azure::ServiceBusService object enables you to work with topics. Il codice seguente crea un oggetto Azure::ServiceBusService.The following code creates an Azure::ServiceBusService object. Per creare un argomento, usare il metodo create_topic().To create a topic, use the create_topic() method. L'esempio seguente crea un argomento o visualizza gli eventuali errori.The following example creates a topic or prints out the errors if there are any.

azure_service_bus_service = Azure::ServiceBus::ServiceBusService.new(sb_host, { signer: signer})
begin
  topic = azure_service_bus_service.create_queue("test-topic")
rescue
  puts $!
end

È anche possibile passare un oggetto Azure::ServiceBus::Topic con opzioni aggiuntive, che consente di eseguire l'override delle impostazioni degli argomenti predefinite, ad esempio la durata dei messaggi o la dimensione massima della coda.You can also pass an Azure::ServiceBus::Topic object with additional options, which enable you to override default topic settings such as message time to live or maximum queue size. L'esempio seguente illustra come impostare la dimensione massima della coda su 5 GB e una durata di 1 minuto:The following example shows setting the maximum queue size to 5 GB and time to live to 1 minute:

topic = Azure::ServiceBus::Topic.new("test-topic")
topic.max_size_in_megabytes = 5120
topic.default_message_time_to_live = "PT1M"

topic = azure_service_bus_service.create_topic(topic)

Creare sottoscrizioniCreate subscriptions

Le sottoscrizioni di un argomento vengono create anche con l'oggetto Azure::ServiceBusService.Topic subscriptions are also created with the Azure::ServiceBusService object. Le sottoscrizioni sono denominate e possono includere un filtro facoltativo che limita il set di messaggi recapitati alla coda virtuale della sottoscrizione.Subscriptions are named and can have an optional filter that restricts the set of messages delivered to the subscription's virtual queue.

Le sottoscrizioni sono persistenti e continueranno a esistere fintanto che esse, o l'argomento a cui sono associate, non vengono eliminate.Subscriptions are persistent and will continue to exist until either they, or the topic they are associated with, are deleted. Se l'applicazione contiene la logica per la creazione di una sottoscrizione, è innanzitutto necessario verificare se la sottoscrizione esiste già usando il metodo getSubscription.If your application contains logic to create a subscription, it should first check if the subscription already exists by using the getSubscription method.

Creare una sottoscrizione con il filtro (MatchAll) predefinitoCreate a subscription with the default (MatchAll) filter

Il filtro MatchAll è il filtro predefinito e viene usato se non vengono specificati altri filtri durante la creazione di una nuova sottoscrizione.The MatchAll filter is the default filter that is used if no filter is specified when a new subscription is created. Quando si usa il filtro MatchAll, tutti i messaggi pubblicati nell'argomento vengono inseriti nella coda virtuale della sottoscrizione.When the MatchAll filter is used, all messages published to the topic are placed in the subscription's virtual queue. Nell'esempio seguente viene creata una sottoscrizione denominata "all-messages" e viene usato il filtro predefinito MatchAll.The following example creates a subscription named "all-messages" and uses the default MatchAll filter.

subscription = azure_service_bus_service.create_subscription("test-topic", "all-messages")

Creare sottoscrizioni con i filtriCreate subscriptions with filters

È anche possibile definire i filtri che consentono di specificare quali messaggi inviati a un argomento devono essere presenti in una specifica sottoscrizione.You can also define filters that enable you to specify which messages sent to a topic should show up within a specific subscription.

Il tipo di filtro più flessibile tra quelli supportati dalle sottoscrizioni è Azure::ServiceBus::SqlFilter, che implementa un sottoinsieme di SQL92.The most flexible type of filter supported by subscriptions is the Azure::ServiceBus::SqlFilter, which implements a subset of SQL92. I filtri SQL agiscono sulle proprietà dei messaggi pubblicati nell'argomento.SQL filters operate on the properties of the messages that are published to the topic. Per altri dettagli sulle espressioni che è possibile usare con un filtro SQL, esaminare la sintassi di SqlFilter.For more details about the expressions that can be used with a SQL filter, review the SqlFilter syntax.

È possibile aggiungere filtri a una sottoscrizione usando il metodo create_rule() dell'oggetto Azure::ServiceBusService.You can add filters to a subscription by using the create_rule() method of the Azure::ServiceBusService object. Questo metodo consente di aggiungere nuovi filtri a una sottoscrizione esistente.This method enables you to add new filters to an existing subscription.

Poiché il filtro predefinito viene applicato automaticamente a tutte le nuove sottoscrizioni, è necessario prima rimuovere il filtro predefinito, altrimenti MatchAll eseguirà l'override di qualsiasi altro filtro specificato.Since the default filter is applied automatically to all new subscriptions, you must first remove the default filter, or the MatchAll will override any other filters you may specify. È possibile rimuovere la regola predefinita tramite il metodo delete_rule() nell'oggetto Azure::ServiceBusService.You can remove the default rule by using the delete_rule() method on the Azure::ServiceBusService object.

Nell'esempio seguente viene creata una sottoscrizione denominata "high-messages" con Azure::ServiceBus::SqlFilter che seleziona solo i messaggi in cui il valore della proprietà personalizzata message_number è maggiore di 3:The following example creates a subscription named "high-messages" with an Azure::ServiceBus::SqlFilter that only selects messages that have a custom message_number property greater than 3:

subscription = azure_service_bus_service.create_subscription("test-topic", "high-messages")
azure_service_bus_service.delete_rule("test-topic", "high-messages", "$Default")

rule = Azure::ServiceBus::Rule.new("high-messages-rule")
rule.topic = "test-topic"
rule.subscription = "high-messages"
rule.filter = Azure::ServiceBus::SqlFilter.new({
  :sql_expression => "message_number > 3" })
rule = azure_service_bus_service.create_rule(rule)

Analogamente, l'esempio seguente crea una sottoscrizione denominata low-messages con un filtro Azure::ServiceBus::SqlFilter che seleziona solo i messaggi in cui il valore della proprietà message_number è minore o uguale a 3:Similarly, the following example creates a subscription named low-messages with an Azure::ServiceBus::SqlFilter that only selects messages that have a message_number property less than or equal to 3:

subscription = azure_service_bus_service.create_subscription("test-topic", "low-messages")
azure_service_bus_service.delete_rule("test-topic", "low-messages", "$Default")

rule = Azure::ServiceBus::Rule.new("low-messages-rule")
rule.topic = "test-topic"
rule.subscription = "low-messages"
rule.filter = Azure::ServiceBus::SqlFilter.new({
  :sql_expression => "message_number <= 3" })
rule = azure_service_bus_service.create_rule(rule)

Un messaggio inviato a test-topic viene sempre recapitato ai ricevitori con sottoscrizione all'argomento all-messages e recapitato selettivamente ai ricevitori con sottoscrizioni agli argomenti high-messages e low-messages (a seconda del contenuto del messaggio).When a message is now sent to test-topic, it is always be delivered to receivers subscribed to the all-messages topic subscription, and selectively delivered to receivers subscribed to the high-messages and low-messages topic subscriptions (depending upon the message content).

Inviare messaggi a un argomentoSend messages to a topic

Per inviare un messaggio a un argomento del bus di servizio, l'applicazione deve usare il metodo send_topic_message() nell'oggetto Azure::ServiceBusService.To send a message to a Service Bus topic, your application must use the send_topic_message() method on the Azure::ServiceBusService object. I messaggi inviati ad argomenti del bus di servizio sono istanze degli oggetti Azure::ServiceBus::BrokeredMessage.Messages sent to Service Bus topics are instances of the Azure::ServiceBus::BrokeredMessage objects. Gli oggetti Azure::ServiceBus::BrokeredMessage includono un insieme di proprietà standard, ad esempio label e time_to_live, un dizionario usato per mantenere le proprietà personalizzate specifiche dell'applicazione e un corpo di dati di tipo stringa.Azure::ServiceBus::BrokeredMessage objects have a set of standard properties (such as label and time_to_live), a dictionary that is used to hold custom application-specific properties, and a body of string data. Un'applicazione può impostare il corpo del messaggio passando un valore stringa al metodo send_topic_message() in modo da popolare le proprietà standard necessarie con valori predefiniti.An application can set the body of the message by passing a string value to the send_topic_message() method and any required standard properties will be populated by default values.

Il seguente esempio illustra come inviare cinque messaggi di test a test-topic.The following example demonstrates how to send five test messages to test-topic. Si noti come il valore della proprietà personalizzata message_number di ogni messaggio varia nell'iterazione del ciclo, determinando la sottoscrizione che lo riceverà:Note that the message_number custom property value of each message varies on the iteration of the loop (this determines which subscription receives it):

5.times do |i|
  message = Azure::ServiceBus::BrokeredMessage.new("test message " + i,
    { :message_number => i })
  azure_service_bus_service.send_topic_message("test-topic", message)
end

Gli argomenti del bus di servizio supportano messaggi di dimensioni massime fino a 256 KB nel livello Standard e fino a 1 MB nel livello Premium.Service Bus topics support a maximum message size of 256 KB in the Standard tier and 1 MB in the Premium tier. Le dimensioni massime dell'intestazione, che include le proprietà standard e personalizzate dell'applicazione, non possono superare 64 KB.The header, which includes the standard and custom application properties, can have a maximum size of 64 KB. Non esiste alcun limite al numero di messaggi mantenuti in un argomento, mentre è prevista una limitazione alla dimensione totale dei messaggi di un argomento.There is no limit on the number of messages held in a topic but there is a cap on the total size of the messages held by a topic. Questa dimensione dell'argomento viene definita al momento della creazione, con un limite massimo di 5 GB.This topic size is defined at creation time, with an upper limit of 5 GB.

Ricevere messaggi da una sottoscrizioneReceive messages from a subscription

I messaggi vengono ricevuti da una sottoscrizione tramite il metodo receive_subscription_message() per l'oggetto Azure::ServiceBusService.Messages are received from a subscription using the receive_subscription_message() method on the Azure::ServiceBusService object. Per impostazione predefinita, i messaggi vengono letti (picco) e bloccati senza essere eliminati dalla sottoscrizione.By default, messages are read(peak) and locked without deleting it from the subscription. È possibile leggere ed eliminare il messaggio dalla sottoscrizione, impostando l'opzione peek_lock su false.You can read and delete the message from the subscription by setting the peek_lock option to false.

In base al comportamento predefinito, la lettura e l'eliminazione vengono incluse in un'operazione di ricezione suddivisa in due fasi, in modo da consentire anche il supporto di applicazioni che non possono tollerare messaggi mancanti.The default behavior makes the reading and deleting a two-stage operation, which also makes it possible to support applications that cannot tolerate missing messages. Quando il bus di servizio riceve una richiesta, individua il messaggio successivo da usare, lo blocca per impedirne la ricezione da parte di altri consumer e quindi lo restituisce all'applicazione.When Service Bus receives a request, it finds the next message to be consumed, locks it to prevent other consumers receiving it, and then returns it to the application. Dopo aver elaborato il messaggio o averlo archiviato in modo affidabile per una successiva elaborazione, l'applicazione esegue la seconda fase del processo di ricezione chiamando il metodo delete_subscription_message() e specificando il messaggio da eliminare come parametro.After the application finishes processing the message (or stores it reliably for future processing), it completes the second stage of the receive process by calling delete_subscription_message() method and providing the message to be deleted as a parameter. Il metodo delete_subscription_message() contrassegna il messaggio come usato e lo rimuove dalla sottoscrizione.The delete_subscription_message() method will mark the message as being consumed and remove it from the subscription.

Se il parametro :peek_lock è impostato su false, la lettura e l'eliminazione del messaggio costituiscono il modello più semplice, adatto a scenari in cui un'applicazione può tollerare la mancata elaborazione di un messaggio in caso di errore.If the :peek_lock parameter is set to false, reading and deleting the message becomes the simplest model, and works best for scenarios in which an application can tolerate not processing a message in the event of a failure. Per comprendere meglio questo meccanismo, si consideri uno scenario in cui il consumer invia la richiesta di ricezione e viene arrestato in modo anomalo prima dell'elaborazione.To understand this, consider a scenario in which the consumer issues the receive request and then crashes before processing it. Poiché il bus di servizio contrassegna il messaggio come utilizzato, quando l'applicazione viene riavviata e inizia a utilizzare nuovamente i messaggi, il messaggio utilizzato prima dell'arresto anomalo risulterà perso.Because Service Bus will have marked the message as being consumed, then when the application restarts and begins consuming messages again, it will have missed the message that was consumed prior to the crash.

L'esempio seguente illustra come ricevere ed elaborare messaggi tramite receive_subscription_message().The following example demonstrates how messages can be received and processed using receive_subscription_message(). Nell'esempio viene prima ricevuto ed eliminato un messaggio dalla sottoscrizione low-messages tramite :peek_lock impostato su false e successivamente viene ricevuto da high-messages e poi eliminato un altro messaggio tramite delete_subscription_message():The example first receives and deletes a message from the low-messages subscription by using :peek_lock set to false, then it receives another message from the high-messages and then deletes the message using delete_subscription_message():

message = azure_service_bus_service.receive_subscription_message(
  "test-topic", "low-messages", { :peek_lock => false })
message = azure_service_bus_service.receive_subscription_message(
  "test-topic", "high-messages")
azure_service_bus_service.delete_subscription_message(message)

Come gestire arresti anomali e messaggi illeggibili dell'applicazioneHow to handle application crashes and unreadable messages

Il bus di servizio fornisce funzionalità per il ripristino gestito automaticamente in caso di errori nell'applicazione o di problemi di elaborazione di un messaggio.Service Bus provides functionality to help you gracefully recover from errors in your application or difficulties processing a message. Se un'applicazione del ricevitore non è in grado di elaborare il messaggio per un qualsiasi motivo, può chiamare il metodo unlock_subscription_message() sull'oggetto Azure::ServiceBusService.If a receiver application is unable to process the message for some reason, then it can call the unlock_subscription_message() method on the Azure::ServiceBusService object. In questo modo, il bus di servizio sblocca il messaggio nella sottoscrizione rendendolo nuovamente disponibile per la ricezione da parte della stessa o da un'altra applicazione consumer.This causes Service Bus to unlock the message within the subscription and make it available to be received again, either by the same consuming application or by another consuming application.

Al messaggio bloccato nella sottoscrizione è anche associato un timeout. Se l'applicazione non riesce a elaborare il messaggio prima della scadenza del timeout, ad esempio a causa di un arresto anomalo, il bus di servizio sbloccherà automaticamente il messaggio rendendolo nuovamente disponibile per la ricezione.There is also a timeout associated with a message locked within the subscription, and if the application fails to process the message before the lock timeout expires (for example, if the application crashes), then Service Bus will unlock the message automatically and make it available to be received again.

In caso di arresto anomalo dell'applicazione dopo l'elaborazione del messaggio ma prima della chiamata del metodo delete_subscription_message(), il messaggio viene nuovamente recapitato all'applicazione al riavvio.In the event that the application crashes after processing the message but before the delete_subscription_message() method is called, then the message is redelivered to the application when it restarts. Questo processo di elaborazione viene spesso definito At-Least-Once per indicare che ogni messaggio verrà elaborato almeno una volta, ma che in determinate situazioni potrà essere recapitato una seconda volta.This is often called At Least Once Processing; that is, each message will be processed at least once but in certain situations the same message may be redelivered. Se lo scenario non tollera la doppia elaborazione, gli sviluppatori dovranno aggiungere logica aggiuntiva all'applicazione per gestire il secondo recapito del messaggio.If the scenario cannot tolerate duplicate processing, then application developers should add additional logic to their application to handle duplicate message delivery. A tale scopo viene spesso usata la proprietà message_id del messaggio, che rimane costante in tutti i tentativi di recapito.This logic is often achieved using the message_id property of the message, which will remain constant across delivery attempts.

Eliminare argomenti e sottoscrizioniDelete topics and subscriptions

Gli argomenti e le sottoscrizioni sono persistenti e devono essere eliminati in modo esplicito nel portale di Azure oppure a livello di codice.Topics and subscriptions are persistent, and must be explicitly deleted either through the Azure portal or programmatically. Il seguente esempio illustra come eliminare l'argomento denominato test-topic.The example below demonstrates how to delete the topic named test-topic.

azure_service_bus_service.delete_topic("test-topic")

Se si elimina un argomento, vengono eliminate anche tutte le sottoscrizioni registrate con l'argomento.Deleting a topic also deletes any subscriptions that are registered with the topic. Le sottoscrizioni possono essere eliminate anche in modo indipendente.Subscriptions can also be deleted independently. Il codice seguente dimostra come eliminare la sottoscrizione denominata high-messages dall'argomento test-topic:The following code demonstrates how to delete the subscription named high-messages from the test-topic topic:

azure_service_bus_service.delete_subscription("test-topic", "high-messages")

Passaggi successiviNext steps

A questo punto, dopo aver appreso le nozioni di base degli argomenti del bus di servizio, usare i seguenti collegamenti per altre informazioni.Now that you've learned the basics of Service Bus topics, follow these links to learn more.