Come usare gli argomenti e le sottoscrizioni del bus di servizio con Node.jsHow to Use Service Bus topics and subscriptions with Node.js

Questa guida descrive come usare gli argomenti e le sottoscrizioni del bus di servizio da applicazioni Node.js.This guide describes how to use Service Bus topics and subscriptions from Node.js applications. Gli scenari presentati includono la creazione di argomenti e sottoscrizioni, la creazione di filtri per le sottoscrizioni, l'invio di messaggi a un argomento, la ricezione di messaggi da una sottoscrizione e l'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 su argomenti e sottoscrizioni, vedere la sezione Passaggi successivi.For more information about 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

Creare un'applicazione Node.jsCreate a Node.js application

Creare un'applicazione Node.js vuota.Create a blank Node.js application. Per istruzioni sulla creazione di un'applicazione Node.js, vedere Creare un'app Web Node.js nel servizio app di Azure oppure Creazione e distribuzione di un'applicazione Node.js a un servizio cloud di Azure con Windows PowerShell o Sito Web con WebMatrix.For instructions on creating a Node.js application, see [Create and deploy a Node.js application to an Azure Web Site], Node.js Cloud Service using Windows PowerShell, or Web Site with WebMatrix.

Configurare l'applicazione per l'uso del bus di servizioConfigure your application to use Service Bus

Per usare il bus di servizio, scaricare il pacchetto Azure Node.js,To use Service Bus, download the Node.js Azure package. che include un set di librerie di riferimento che comunicano con i servizi REST del bus di servizio.This package includes a set of libraries that communicate with the Service Bus REST services.

Usare Node Package Manager (NPM) per ottenere il pacchettoUse Node Package Manager (NPM) to obtain the package

  1. Usare un'interfaccia della riga di comando come PowerShell (Windows,) Terminal (Mac,) o Bash (Unix) e spostarsi nella cartella in cui è stata creata l'applicazione di esempio.Use a command-line interface such as PowerShell (Windows,) Terminal (Mac,) or Bash (Unix), navigate to the folder where you created your sample application.
  2. Digitare npm install azure nella finestra di comando, che dovrebbe restituire l'output seguente:Type npm install azure in the command window, which should result in the following output:

        azure@0.7.5 node_modules\azure
    ├── dateformat@1.0.2-1.2.3
    ├── xmlbuilder@0.4.2
    ├── node-uuid@1.2.0
    ├── mime@1.2.9
    ├── underscore@1.4.4
    ├── validator@1.1.1
    ├── tunnel@0.0.2
    ├── wns@0.5.3
    ├── xml2js@0.2.7 (sax@0.5.2)
    └── request@2.21.0 (json-stringify-safe@4.0.0, forever-agent@0.5.0, aws-sign@0.3.0, tunnel-agent@0.3.0, oauth-sign@0.3.0, qs@0.6.5, cookie-jar@0.3.0, node-uuid@1.4.0, http-signature@0.9.11, form-data@0.0.8, hawk@0.13.1)
    
  3. È possibile eseguire manualmente il comando ls per verificare che sia stata creata una cartella node_modules.You can manually run the ls command to verify that a node_modules folder was created. In tale cartella trovare il pacchetto azure, che contiene le librerie necessarie per accedere agli argomenti del bus di servizio.Inside that folder find the azure package, which contains the libraries you need to access Service Bus topics.

Importare il moduloImport the module

Usando il Blocco note o un altro editor di testo, aggiungere quanto segue alla parte superiore del file server.js dell'applicazione:Using Notepad or another text editor, add the following to the top of the server.js file of the application:

var azure = require('azure');

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

Il modulo Azure legge la variabile di ambiente AZURE_SERVICEBUS_CONNECTION_STRING per la stringa di connessione ottenuta dal passaggio "Ottenere le credenziali" precedente.The Azure module reads the environment variable AZURE_SERVICEBUS_CONNECTION_STRING for the connection string that you obtained from the earlier step, "Obtain the credentials". Se questa variabile di ambiente non è impostata, è necessario specificare le informazioni relative all'account durante la chiamata di createServiceBusService.If this environment variable is not set, you must specify the account information when calling createServiceBusService.

Per un esempio di impostazione delle variabili di ambiente per un servizio cloud di Azure, vedere Servizio cloud Node.js con Archiviazione.For an example of setting the environment variables for an Azure Cloud Service, see Node.js Cloud Service with Storage.

Per un esempio di impostazione delle variabili di ambiente per un sito Web di Azure, vedere Creazione di un'applicazione Web Node.js con Archiviazione.For an example of setting the environment variables for an Azure Website, see Node.js Web Application with Storage.

Creare un argomentoCreate a topic

L'oggetto ServiceBusService consente di usare gli argomenti.The ServiceBusService object enables you to work with topics. Il codice seguente consente di creare un oggetto ServiceBusService.The following code creates a ServiceBusService object. Aggiungerlo nella parte superiore del file server.js dopo l'istruzione per l'importazione del modulo azure:Add it near the top of the server.js file, after the statement to import the azure module:

var serviceBusService = azure.createServiceBusService();

Chiamando createTopicIfNotExists nell'oggetto ServiceBusService, verrà restituito l'argomento specificato, se esistente, oppure verrà creato un nuovo argomento con il nome specificato.By calling createTopicIfNotExists on the ServiceBusService object, the specified topic will be returned (if it exists,) or a new topic with the specified name will be created. Il codice seguente usa createTopicIfNotExists per connettersi all'argomento denominato MyTopic o crearlo:The following code uses createTopicIfNotExists to create or connect to the topic named MyTopic:

serviceBusService.createTopicIfNotExists('MyTopic',function(error){
    if(!error){
        // Topic was created or exists
        console.log('topic created or exists.');
    }
});

Il metodo createServiceBusService supporta anche opzioni aggiuntive che consentono di eseguire l'override delle impostazioni predefinite degli argomenti, come la durata (TTL) dei messaggi o le dimensioni massime dell'argomento.The createServiceBusService method also supports additional options, which enable you to override default topic settings such as message time to live or maximum topic size. L'esempio seguente illustra come impostare la dimensione massima dell'argomento su 5 GB con una durata di 1 minuto:The following example sets the maximum topic size to 5GB with a time to live of 1 minute:

var topicOptions = {
        MaxSizeInMegabytes: '5120',
        DefaultMessageTimeToLive: 'PT1M'
    };

serviceBusService.createTopicIfNotExists('MyTopic', topicOptions, function(error){
    if(!error){
        // topic was created or exists
    }
});

FiltriFilters

Le operazioni di filtro facoltative possono essere applicate alle operazioni eseguite usando ServiceBusService.Optional filtering operations can be applied to operations performed using ServiceBusService. Le operazioni di filtro possono includere la registrazione, la ripetizione automatica dei tentativi e così via. I filtri sono oggetti che implementano un metodo con la firma:Filtering operations can include logging, automatically retrying, etc. Filters are objects that implement a method with the signature:

function handle (requestOptions, next)

Dopo aver eseguito la pre-elaborazione sulle opzioni della richiesta, il metodo chiama next passando un callback con la firma seguente:After performing preprocessing on the request options, the method calls next, passing a callback with the following signature:

function (returnObject, finalCallback, next)

Dopo l'elaborazione di returnObject (ossia della risposta della richiesta al server), questo callback deve richiamare next, se esistente, per continuare a elaborare altri filtri o in caso contrario richiamare finalCallback per terminare la chiamata al servizio.In this callback, and after processing the returnObject (the response from the request to the server), the callback needs to either invoke next if it exists to continue processing other filters or invoke finalCallback otherwise, to end the service invocation.

In Azure SDK per Node.js sono inclusi due filtri che implementano la logica di ripetizione dei tentativi. Sono ExponentialRetryPolicyFilter e LinearRetryPolicyFilter.Two filters that implement retry logic are included with the Azure SDK for Node.js, ExponentialRetryPolicyFilter and LinearRetryPolicyFilter. Il codice seguente consente di creare un oggetto ServiceBusService che usa ExponentialRetryPolicyFilter:The following creates a ServiceBusService object that uses the ExponentialRetryPolicyFilter:

var retryOperations = new azure.ExponentialRetryPolicyFilter();
var serviceBusService = azure.createServiceBusService().withFilter(retryOperations);

Creare sottoscrizioniCreate subscriptions

È possibile creare le sottoscrizioni di un argomento anche con l'oggetto ServiceBusService.Topic subscriptions are also created with the 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.

Nota

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, è prima di tutto 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 "AllMessages" e viene usato il filtro predefinito MatchAll.The following example creates a subscription named 'AllMessages' and uses the default MatchAll filter.

serviceBusService.createSubscription('MyTopic','AllMessages',function(error){
    if(!error){
        // subscription created
    }
});

Creare sottoscrizioni con i filtriCreate subscriptions with filters

È anche possibile creare filtri che consentono di definire l'ambito dei messaggi inviati a un argomento che devono essere visualizzati in una specifica sottoscrizione dell'argomento.You can also create filters that allow you to scope which messages sent to a topic should show up within a specific topic subscription.

Il tipo di filtro più flessibile tra quelli supportati dalle sottoscrizioni è SqlFilter, che implementa un subset di SQL92.The most flexible type of filter supported by subscriptions is the 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.SqlExpression.For more details about the expressions that can be used with a SQL filter, review the SqlFilter.SqlExpression syntax.

È possibile aggiungere filtri a una sottoscrizione con il metodo createRule dell'oggetto ServiceBusService.Filters can be added to a subscription by using the createRule method of the ServiceBusService object. Questo metodo consente di aggiungere nuovi filtri a una sottoscrizione esistente.This method allows you to add new filters to an existing subscription.

Nota

Poiché il filtro predefinito viene applicato automaticamente a tutte le nuove sottoscrizioni, è necessario prima di tutto rimuovere il filtro predefinito, altrimenti MatchAll eseguirà l'override di qualsiasi altro filtro specificato.Because 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 con il metodo deleteRule dell'oggetto ServiceBusService.You can remove the default rule by using the deleteRule method of the ServiceBusService object.

L'esempio seguente crea una sottoscrizione denominata HighMessages con un filtro SqlFilter che seleziona solo i messaggi che hanno una proprietà messagenumber personalizzata con valore maggiore di 3:The following example creates a subscription named HighMessages with a SqlFilter that only selects messages that have a custom messagenumber property greater than 3:

serviceBusService.createSubscription('MyTopic', 'HighMessages', function (error){
    if(!error){
        // subscription created
        rule.create();
    }
});
var rule={
    deleteDefault: function(){
        serviceBusService.deleteRule('MyTopic',
            'HighMessages',
            azure.Constants.ServiceBusConstants.DEFAULT_RULE_NAME,
            rule.handleError);
    },
    create: function(){
        var ruleOptions = {
            sqlExpressionFilter: 'messagenumber > 3'
        };
        rule.deleteDefault();
        serviceBusService.createRule('MyTopic',
            'HighMessages',
            'HighMessageFilter',
            ruleOptions,
            rule.handleError);
    },
    handleError: function(error){
        if(error){
            console.log(error)
        }
    }
}

Analogamente, l'esempio seguente crea una sottoscrizione denominata LowMessages con un filtro SqlFilter che seleziona solo i messaggi che hanno una proprietà messagenumber con valore minore o uguale a 3:Similarly, the following example creates a subscription named LowMessages with a SqlFilter that only selects messages that have a messagenumber property less than or equal to 3:

serviceBusService.createSubscription('MyTopic', 'LowMessages', function (error){
    if(!error){
        // subscription created
        rule.create();
    }
});
var rule={
    deleteDefault: function(){
        serviceBusService.deleteRule('MyTopic',
            'LowMessages',
            azure.Constants.ServiceBusConstants.DEFAULT_RULE_NAME,
            rule.handleError);
    },
    create: function(){
        var ruleOptions = {
            sqlExpressionFilter: 'messagenumber <= 3'
        };
        rule.deleteDefault();
        serviceBusService.createRule('MyTopic',
            'LowMessages',
            'LowMessageFilter',
            ruleOptions,
            rule.handleError);
    },
    handleError: function(error){
        if(error){
            console.log(error)
        }
    }
}

Un messaggio inviato a MyTopic verrà sempre recapitato ai ricevitori con sottoscrizione all'argomento AllMessages e recapitato selettivamente ai ricevitori con sottoscrizioni agli argomenti HighMessages e LowMessages (a seconda del contenuto del messaggio).When a message is now sent to MyTopic, it will always be delivered to receivers subscribed to the AllMessages topic subscription, and selectively delivered to receivers subscribed to the HighMessages and LowMessages topic subscriptions (depending upon the message content).

Come inviare messaggi a un argomentoHow to send messages to a topic

Per inviare un messaggio a un argomento del bus di servizio, l'applicazione deve usare il metodo sendTopicMessage dell'oggetto ServiceBusService.To send a message to a Service Bus topic, your application must use the sendTopicMessage method of the ServiceBusService object. I messaggi inviati ad argomenti del bus di servizio sono oggetti BrokeredMessage.Messages sent to Service Bus topics are BrokeredMessage objects. Gli oggetti BrokeredMessage includono un set di proprietà standard, ad esempio Label e TimeToLive, un dizionario usato per contenere le proprietà personalizzate specifiche dell'applicazione e un corpo di dati di tipo stringa.BrokeredMessage objects have a set of standard properties (such as Label and TimeToLive), 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 a sendTopicMessage e popolare le proprietà standard necessarie con i valori predefiniti.An application can set the body of the message by passing a string value to the sendTopicMessage and any required standard properties will be populated by default values.

Il seguente esempio illustra come inviare cinque messaggi di test a MyTopic.The following example demonstrates how to send five test messages to MyTopic. Si noti che il valore della proprietà messagenumber di ogni messaggio varia nell'iterazione del ciclo, determinando quali sottoscrizioni lo riceveranno:Note that the messagenumber property value of each message varies on the iteration of the loop (this will determine which subscriptions receive it):

var message = {
    body: '',
    customProperties: {
        messagenumber: 0
    }
}

for (i = 0;i < 5;i++) {
    message.customProperties.messagenumber=i;
    message.body='This is Message #'+i;
    serviceBusService.sendTopicMessage(topic, message, function(error) {
      if (error) {
        console.log(error);
      }
    });
}

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 usando il metodo receiveSubscriptionMessage nell'oggetto ServiceBusService.Messages are received from a subscription using the receiveSubscriptionMessage method on the ServiceBusService object. Per impostazione predefinita, i messaggi vengono eliminati dalla sottoscrizione non appena vengono letti. È tuttavia possibile leggere (visualizzare) e bloccare il messaggio senza eliminarlo dalla sottoscrizione impostando il parametro facoltativo isPeekLock su true.By default, messages are deleted from the subscription as they are read; however, you can read (peek) and lock the message without deleting it from the subscription by setting the optional parameter isPeekLock to true.

Il comportamento predefinito di lettura ed eliminazione del messaggio nell'ambito dell'operazione di ricezione costituisce il modello più semplice ed è adatto per scenari in cui un'applicazione può tollerare la mancata elaborazione di un messaggio in caso di errore.The default behavior of reading and deleting the message as part of the receive operation is 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.

Se il parametro isPeekLock è impostato su true, l'operazione di ricezione viene suddivisa in due fasi, in modo da consentire il supporto di applicazioni che non possono tollerare messaggi mancanti.If the isPeekLock parameter is set to true, the receive becomes a two stage operation, which 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 deleteMessage 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 deleteMessage method and providing the message to be deleted as a parameter. Il metodo deleteMessage contrassegna il messaggio come usato e lo rimuove dalla sottoscrizione.The deleteMessage method will mark the message as being consumed and remove it from the subscription.

L'esempio seguente illustra come ricevere ed elaborare messaggi tramite receiveSubscriptionMessage.The following example demonstrates how messages can be received and processed using receiveSubscriptionMessage. L'esempio prima di tutto riceve ed elimina un messaggio dalla sottoscrizione "LowMessages" e quindi riceve un messaggio dalla sottoscrizione "HighMessages" con il parametro isPeekLock impostato su true.The example first receives and deletes a message from the 'LowMessages' subscription, and then receives a message from the 'HighMessages' subscription using isPeekLock set to true. Elimina infine il messaggio usando deleteMessage:It then deletes the message using deleteMessage:

serviceBusService.receiveSubscriptionMessage('MyTopic', 'LowMessages', function(error, receivedMessage){
    if(!error){
        // Message received and deleted
        console.log(receivedMessage);
    }
});
serviceBusService.receiveSubscriptionMessage('MyTopic', 'HighMessages', { isPeekLock: true }, function(error, lockedMessage){
    if(!error){
        // Message received and locked
        console.log(lockedMessage);
        serviceBusService.deleteMessage(lockedMessage, function (deleteError){
            if(!deleteError){
                // Message deleted
                console.log('message has been deleted.');
            }
        })
    }
});

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 ricevente non riesce a elaborare il messaggio per qualsiasi motivo, può chiamare il metodo unlockMessage nell'oggetto ServiceBusService.If a receiver application is unable to process the message for some reason, then it can call the unlockMessage method on the ServiceBusService object. In questo modo, il bus di servizio sbloccherà il messaggio nella sottoscrizione rendendolo nuovamente disponibile per la ricezione da parte della stessa applicazione consumer o da un'altra.This will cause 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 unlocks the message automatically and makes it available to be received again.

In caso di arresto anomalo dell'applicazione dopo l'elaborazione del messaggio ma prima della chiamata del metodo deleteMessage, il messaggio verrà nuovamente recapitato all'applicazione al riavvio.In the event that the application crashes after processing the message but before the deleteMessage method is called, then the message will be redelivered to the application when it restarts. Questo processo di elaborazione viene spesso definito di tipo 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à MessageId del messaggio, che rimane costante in tutti i tentativi di recapito.This is often achieved using the MessageId 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. L'esempio seguente illustra come eliminare l'argomento denominato MyTopic:The following example demonstrates how to delete the topic named MyTopic:

serviceBusService.deleteTopic('MyTopic', function (error) {
    if (error) {
        console.log(error);
    }
});

Se si elimina un argomento, verranno eliminate anche tutte le sottoscrizioni registrate con l'argomento.Deleting a topic will also delete any subscriptions that are registered with the topic. Le sottoscrizioni possono essere eliminate anche in modo indipendente.Subscriptions can also be deleted independently. L'esempio seguente illustra come eliminare una sottoscrizione denominata HighMessages dall'argomento MyTopic:The following example shows how to delete a subscription named HighMessages from the MyTopic topic:

serviceBusService.deleteSubscription('MyTopic', 'HighMessages', function (error) {
    if(error) {
        console.log(error);
    }
});

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.