Rychlý Start: použití Service Busch front v Azure pomocí Node. js a balíčku Azure-SbQuickstart: Use Service Bus queues in Azure with Node.js and the azure-sb package

V tomto kurzu se naučíte vytvářet aplikace v Node. js pro posílání zpráv a příjem zpráv z fronty Azure Service Bus pomocí balíčku Azure-SB .In this tutorial, you learn how to create Node.js applications to send messages to and receive messages from an Azure Service Bus queue using the azure-sb package. Ukázky se napíší v JavaScriptu a používají modul Azure Node. js, který interně používá balíček Azure-Sb.The samples are written in JavaScript and use the Node.js Azure module which internally uses the azure-sb package.

Balíček Azure-SB používá Service Bus rozhraní REST runtime API.The azure-sb package uses Service Bus REST run-time APIs. Pomocí nového @azure/service-bus , který používá rychlejší Protokol AMQP 1,0, můžete získat rychlejší práci.You can get a faster experience using the new @azure/service-bus which uses the faster AMQP 1.0 protocol. Další informace o novém balíčku najdete v tématu Jak používat Service Bus fronty s Node. js a @azure/service-bus balíčkem. v opačném případě pokračujte ve čtení a zjistěte, jak používat balíček Azure .To learn more about the new package, see How to use Service Bus queues with Node.js and @azure/service-bus package, otherwise continue reading to see how to use the azure package.

PožadavkyPrerequisites

  • Předplatné Azure.An Azure subscription. K dokončení tohoto kurzu potřebujete mít účet Azure.To complete this tutorial, you need an Azure account. Můžete aktivovat výhody pro předplatitele MSDN nebo si zaregistrovat bezplatný účet.You can activate your MSDN subscriber benefits or sign up for a free account.
  • Pokud nemáte frontu, ve které byste mohli pracovat, postupujte podle kroků v tématu použití Azure Portal k vytvoření fronty Service Bus .If you don't have a queue to work with, follow steps in the Use Azure portal to create a Service Bus queue article to create a queue.
    1. Přečtěte si rychlý přehled Service Busch front.Read the quick overview of Service Bus queues.

    2. Vytvořte obor názvůService Bus.Create a Service Bus namespace.

    3. Získá připojovací řetězec.Get the connection string.

      Poznámka

      V tomto kurzu vytvoříte frontu v oboru názvů Service Bus pomocí Node. js.You will create a queue in the Service Bus namespace by using Node.js in this tutorial.

Vytvoření aplikace Node.jsCreate a Node.js application

Vytvořte prázdnou aplikaci Node. js.Create a blank Node.js application. Pokyny k vytvoření aplikace Node. js najdete v tématu Vytvoření a nasazení aplikace Node. js na web Azurenebo cloudovou službu Node. js pomocí prostředí Windows PowerShell.For instructions on how to create a Node.js application, see Create and deploy a Node.js application to an Azure Website, or Node.js Cloud Service using Windows PowerShell.

Konfigurace aplikace pro použití Service BusConfigure your application to use Service Bus

Pokud chcete použít Azure Service Bus, Stáhněte a použijte balíček Azure Node. js.To use Azure Service Bus, download and use the Node.js Azure package. Tento balíček obsahuje sadu knihoven, které komunikují se službou Service Bus REST.This package includes a set of libraries that communicate with the Service Bus REST services.

K získání balíčku použijte Správce balíčků Node (NPM).Use Node Package Manager (NPM) to obtain the package

  1. Pomocí příkazového okna prostředí Windows PowerShell pro Node. js přejděte na uzel c:\\Sbqueues\složku WebRole1 , ve které jste vytvořili ukázkovou aplikaci.Use the Windows PowerShell for Node.js command window to navigate to the c:\node\sbqueues\WebRole1 folder in which you created your sample application.

  2. Do příkazového okna zadejte npm Install Azure , které by měly mít za následek výstup podobný následujícímu příkladu:Type npm install azure in the command window, which should result in output similar to the following example:

    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. Můžete ručně spustit příkaz ls a ověřit, že se vytvořila složka node_modules.You can manually run the ls command to verify that a node_modules folder was created. V této složce najděte balíček Azure obsahující knihovny, které potřebujete pro přístup k Service Bus frontám.Inside that folder, find the azure package, which contains the libraries you need to access Service Bus queues.

Importovat modulImport the module

Pomocí poznámkového bloku nebo jiného textového editoru přidejte do horní části souboru Server. js aplikace následující text:Using Notepad or another text editor, add the following to the top of the server.js file of the application:

var azure = require('azure');

Nastavení Azure Service Busho připojeníSet up an Azure Service Bus connection

Modul Azure přečte proměnnou prostředí AZURE_SERVICEBUS_CONNECTION_STRING a získá informace potřebné pro připojení k Service Bus.The Azure module reads the environment variable AZURE_SERVICEBUS_CONNECTION_STRING to obtain information required to connect to Service Bus. Pokud tato proměnná prostředí není nastavena, je nutné zadat informace o účtu při volání createServiceBusService.If this environment variable isn't set, you must specify the account information when calling createServiceBusService.

Příklad nastavení proměnných prostředí v Azure Portal webu Azure najdete v tématu Webová aplikace Node. js s úložištěm.For an example of setting the environment variables in the Azure portal for an Azure Website, see Node.js Web Application with Storage.

Vytvoření frontyCreate a queue

Objekt ServiceBusService vám umožní pracovat s frontami Service Bus.The ServiceBusService object enables you to work with Service Bus queues. Následující kód vytvoří objekt ServiceBusService .The following code creates a ServiceBusService object. Přidejte ho poblíž horní části souboru Server. js po příkazu pro import modulu Azure:Add it near the top of the server.js file, after the statement to import the Azure module:

var serviceBusService = azure.createServiceBusService();

Zavoláním createQueueIfNotExists v objektu ServiceBusService se vrátí zadaná fronta (pokud existuje), nebo se vytvoří nová fronta se zadaným názvem.By calling createQueueIfNotExists on the ServiceBusService object, the specified queue is returned (if it exists), or a new queue with the specified name is created. Následující kód používá createQueueIfNotExists k vytvoření nebo připojení k frontě s názvem myqueue:The following code uses createQueueIfNotExists to create or connect to the queue named myqueue:

serviceBusService.createQueueIfNotExists('myqueue', function(error){
    if(!error){
        // Queue exists
    }
});

Metoda createServiceBusService také podporuje další možnosti, které umožňují přepsat výchozí nastavení fronty, jako je například doba zprávy na hodnotu Live nebo maximální velikost fronty.The createServiceBusService method also supports additional options, which enable you to override default queue settings such as message time to live or maximum queue size. Následující příklad nastaví maximální velikost fronty na 5 GB a hodnotu TTL (Time to Live) 1 minute:The following example sets the maximum queue size to 5 GB, and a time to live (TTL) value of 1 minute:

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

serviceBusService.createQueueIfNotExists('myqueue', queueOptions, function(error){
    if(!error){
        // Queue exists
    }
});

FiltryFilters

Volitelné operace filtrování lze použít na operace prováděné pomocí ServiceBusService.Optional filtering operations can be applied to operations performed using ServiceBusService. Operace filtrování můžou zahrnovat protokolování, automatické opakování atd. Filtry jsou objekty, které implementují metodu s podpisem:Filtering operations can include logging, automatically retrying, etc. Filters are objects that implement a method with the signature:

function handle (requestOptions, next)

Po provedení předběžného zpracování na možnostech žádosti musí metoda volat nexta předávat zpětné volání s následujícím podpisem:After doing its pre-processing on the request options, the method must call next, passing a callback with the following signature:

function (returnObject, finalCallback, next)

V tomto zpětném volání a po zpracování returnObject (odpověď z požadavku na server), zpětné volání musí buď vyvolat next, pokud existuje, aby pokračoval v zpracování jiných filtrů, nebo vyvolat finalCallback, což ukončí vyvolání služby.In this callback, and after processing the returnObject (the response from the request to the server), the callback must either invoke next if it exists to continue processing other filters, or invoke finalCallback, which ends the service invocation.

K dispozici jsou dva filtry, které implementují logiku opakování, do sady Azure SDK pro Node. js ExponentialRetryPolicyFilter a LinearRetryPolicyFilter.Two filters that implement retry logic are included with the Azure SDK for Node.js, ExponentialRetryPolicyFilter and LinearRetryPolicyFilter. Následující kód vytvoří objekt ServiceBusService, který používá ExponentialRetryPolicyFilter:The following code creates a ServiceBusService object that uses the ExponentialRetryPolicyFilter:

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

Zasílání zpráv do frontySend messages to a queue

Chcete-li odeslat zprávu do fronty Service Bus, aplikace zavolá metodu sendQueueMessage v objektu ServiceBusService .To send a message to a Service Bus queue, your application calls the sendQueueMessage method on the ServiceBusService object. Zprávy odeslané do (a přijaté z) Service Bus fronty jsou objekty BrokeredMessage a mají sadu standardních vlastností (například Label a TimeToLive), slovník, který se používá k uložení vlastních vlastností specifických pro aplikaci a tělo libovolných aplikačních dat.Messages sent to (and received from) Service Bus queues are BrokeredMessage objects, and 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 arbitrary application data. Aplikace může nastavit tělo zprávy předáním řetězce jako zprávy.An application can set the body of the message by passing a string as the message. Všechny požadované standardní vlastnosti se naplní výchozími hodnotami.Any required standard properties are populated with default values.

Následující příklad ukazuje, jak odeslat zkušební zprávu do fronty s názvem myqueue pomocí sendQueueMessage:The following example demonstrates how to send a test message to the queue named myqueue using sendQueueMessage:

var message = {
    body: 'Test message',
    customProperties: {
        testproperty: 'TestValue'
    }};
serviceBusService.sendQueueMessage('myqueue', message, function(error){
    if(!error){
        // message sent
    }
});

Fronty Service Bus podporují maximální velikost zprávy 256 KB na úrovni Standard a 1 MB na úrovni Premium.Service Bus queues support a maximum message size of 256 KB in the Standard tier and 1 MB in the Premium tier. Hlavička, která obsahuje standardní a vlastní vlastnosti aplikace, může mít velikost až 64 KB.The header, which includes the standard and custom application properties, can have a maximum size of 64 KB. Počet zpráv držených ve frontě není nijak omezený, ale celková velikost zpráv držených ve frontě je příliš velká.There's no limit on the number of messages held in a queue but there's a cap on the total size of the messages held by a queue. Velikost fronty se definuje při vytvoření, maximální limit je 5 GB.This queue size is defined at creation time, with an upper limit of 5 GB. Další informace o kvótách najdete v tématu Service Bus kvóty.For more information about quotas, see Service Bus quotas.

Přijímání zpráv z frontyReceive messages from a queue

Zprávy jsou přijímány z fronty pomocí metody receiveQueueMessage v objektu ServiceBusService .Messages are received from a queue using the receiveQueueMessage method on the ServiceBusService object. Ve výchozím nastavení se zprávy při čtení z fronty odstraňují. Můžete si však přečíst (prohlížet) a uzamknout zprávu bez jejich odstranění z fronty nastavením volitelného parametru isPeekLock na hodnotu true.By default, messages are deleted from the queue as they are read; however, you can read (peek) and lock the message without deleting it from the queue by setting the optional parameter isPeekLock to true.

Výchozím chováním při čtení a odstraňování zprávy jako součást operace Receive je nejjednodušší model a funguje nejlépe ve scénářích, ve kterých aplikace může tolerovat nezpracovávání zprávy, když dojde k selhání.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 when a failure occurs. Pro pochopení tohoto chování Vezměte v úvahu situaci, ve které spotřebitel vydá žádost o přijetí, a poté dojde k chybě před jejím zpracováním.To understand this behavior, consider a scenario in which the consumer issues the receive request and then crashes before processing it. Vzhledem k tomu, že Service Bus bude zprávu označovat jako spotřebovaná, a když se aplikace znovu spustí a začne znovu přijímat zprávy, vynechá se zpráva, která byla spotřebována před chybou.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 before the crash.

Pokud je parametr isPeekLock nastaven na hodnotu true, obdrží se v průběhu operace dvě fáze, která umožňuje podporovat aplikace, které neumožňují tolerovat chybějící zprávy.If the isPeekLock parameter is set to true, the receive becomes a two stage operation, which makes it possible to support applications that can't tolerate missing messages. Když Service Bus přijme požadavek, najde zprávu, která je na řadě ke spotřebování, uzamkne ji proti spotřebování jinými spotřebiteli a vrátí ji do aplikace.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. Poté, co aplikace dokončí zpracování zprávy (nebo je uloží spolehlivě pro budoucí zpracování), dokončí druhou fázi procesu Receive voláním metody deleteMessage a zadáním zprávy, která se má odstranit jako parametr.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. Metoda deleteMessage označí zprávu jako spotřebou a odebere ji z fronty.The deleteMessage method marks the message as being consumed and removes it from the queue.

Následující příklad ukazuje, jak přijímat a zpracovávat zprávy pomocí receiveQueueMessage.The following example demonstrates how to receive and process messages using receiveQueueMessage. Příklad nejprve přijme a odstraní zprávu a potom obdrží zprávu s použitím isPeekLock nastavenou na hodnotu true, a potom zprávu odstraní pomocí deleteMessage:The example first receives and deletes a message, and then receives a message using isPeekLock set to true, then deletes the message using deleteMessage:

serviceBusService.receiveQueueMessage('myqueue', function(error, receivedMessage){
    if(!error){
        // Message received and deleted
    }
});
serviceBusService.receiveQueueMessage('myqueue', { isPeekLock: true }, function(error, lockedMessage){
    if(!error){
        // Message received and locked
        serviceBusService.deleteMessage(lockedMessage, function (deleteError){
            if(!deleteError){
                // Message deleted
            }
        });
    }
});

Zpracování pádů aplikace a nečitelných zprávHow to handle application crashes and unreadable messages

Service Bus poskytuje funkce, které vám pomůžou se elegantně zotavit z chyb v aplikaci nebo vyřešit potíže se zpracováním zprávy.Service Bus provides functionality to help you gracefully recover from errors in your application or difficulties processing a message. Pokud aplikace příjemce z nějakého důvodu nemůže zprávu zpracovat, může volat metodu unlockMessage v objektu 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. způsobí Service Bus odemčení zprávy ve frontě a její zpřístupnění pro opětovné přijetí, a to buď pomocí stejné aplikace, nebo jiné náročné aplikace.it will cause Service Bus to unlock the message within the queue and make it available to be received again, either by the same consuming application or by another consuming application.

Je také časový limit přidružený ke zprávě uzamčený ve frontě a pokud aplikace nedokáže zpracovat zprávu před vypršením časového limitu zámku (například pokud dojde k selhání aplikace), Service Bus bude automaticky odemknout a nastavit k dispozici pro opětovné přijetí.There's also a timeout associated with a message locked within the queue, 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.

V případě, že dojde k chybě aplikace po zpracování zprávy, ale před zavoláním metody deleteMessage, bude zpráva doručena do aplikace při restartu.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. Tento přístup se často označuje aspoň jednou při zpracování, to znamená, že každá zpráva se zpracuje alespoň jednou, ale v některých situacích může být stejná zpráva znovu dodána.This approach 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. Pokud scénář nemůže tolerovat duplicitní zpracování, vývojáři aplikací by měli do své aplikace přidat další logiku pro zpracování duplicitního doručování zpráv.If the scenario can't tolerate duplicate processing, then application developers should add additional logic to their application to handle duplicate message delivery. Často se dosahuje pomocí vlastnosti MessageID zprávy, která zůstane v rámci pokusů o doručení konstantní.It's often achieved using the MessageId property of the message, which will remain constant across delivery attempts.

Poznámka

Prostředky Service Bus můžete spravovat pomocí Service Bus Exploreru.You can manage Service Bus resources with Service Bus Explorer. Service Bus Explorer umožňuje uživatelům připojit se k oboru názvů Service Bus a snadno spravovat entity zasílání zpráv.The Service Bus Explorer allows users to connect to a Service Bus namespace and administer messaging entities in an easy manner. Tento nástroj poskytuje pokročilé funkce, jako jsou funkce importu a exportu, nebo možnost testovat témata, fronty, odběry, služby Relay, centra oznámení a centra událostí.The tool provides advanced features like import/export functionality or the ability to test topic, queues, subscriptions, relay services, notification hubs and events hubs.

Další krokyNext steps

Další informace o frontách najdete v následujících zdrojích informací.To learn more about queues, see the following resources.