Rychlý start: Vytvořit frontu služby Service Bus pomocí Azure PowershelluQuickstart: Use Azure PowerShell to create a Service Bus queue

Tento rychlý start popisuje, jak odesílat zprávy do fronty Service Bus a přijímat je. Používá se k tomu prostředí PowerShell, kde se vytvoří obor názvů pro zasílání zpráv a v tomto oboru názvů fronta. Dále je třeba získat v oboru názvů přihlašovací údaje pro autorizaci.This quickstart describes how to send and receive messages to and from a Service Bus queue, using PowerShell to create a messaging namespace and a queue within that namespace, and to obtain the authorization credentials on that namespace. Postup pak ukazuje, jak do této fronty odesílat zprávy a přijímat je z ní pomocí knihovny .NET Standard.The procedure then shows how to send and receive messages from this queue using the .NET Standard library.

Poznámka

Tento článek byl aktualizován, aby používal nový Azure PowerShell AZ Module.This article has been updated to use the new Azure PowerShell Az module. Stále můžete používat modul AzureRM, který bude dál přijímat opravy chyb, dokud nebude aspoň 2020. prosince.You can still use the AzureRM module, which will continue to receive bug fixes until at least December 2020. Další informace o novém rozhraní AZ Module a AzureRM Compatibility najdete v tématu představení nového Azure PowerShell AZ Module.To learn more about the new Az module and AzureRM compatibility, see Introducing the new Azure PowerShell Az module. Pokyny k instalaci přidaných modulů najdete v tématu Install Azure PowerShell.For Az module installation instructions, see Install Azure PowerShell.

Co jsou fronty služby Service Bus?What are Service Bus queues?

Fronty služby Service Bus podporují komunikační model zprostředkovaného zasílání zpráv.Service Bus queues support a brokered messaging communication model. Součásti distribuované aplikace při používání front nekomunikují navzájem přímo. Místo toho si zprávy vyměňují prostřednictvím fronty, která slouží jako zprostředkovatel.When using queues, components of a distributed application do not communicate directly with each other; instead they exchange messages via a queue, which acts as an intermediary (broker). Autor zprávy (odesílatel) předá zprávu do fronty a potom pokračuje v jejím zpracování.A message producer (sender) hands off a message to the queue and then continues its processing. Spotřebitel zprávy (příjemce) asynchronně přebírá zprávu z fronty a zpracovává ji.Asynchronously, a message consumer (receiver) pulls the message from the queue and processes it. Autor nemusí čekat na odpověď od příjemce, aby mohl pokračovat se zpracováním a odesláním dalších zpráv.The producer does not have to wait for a reply from the consumer in order to continue to process and send further messages. Fronty nabízejí doručování zpráv metodou FIFO (First In First Out) pro jednoho nebo několik konkurenčních spotřebitelů.Queues offer First In, First Out (FIFO) message delivery to one or more competing consumers. To znamená, že příjemci zprávy obvykle přijímají a zpracovávají v pořadí, ve kterém byly přidány do fronty, a každou zprávu přijme a zpracuje jenom jeden příjemce zprávy.That is, messages are typically received and processed by the receivers in the order in which they were added to the queue, and each message is received and processed by only one message consumer.

QueueConcepts

Fronty služby Service Bus představují univerzální technologii, kterou můžete použít pro celou řadu scénářů:Service Bus queues are a general-purpose technology that can be used for a wide variety of scenarios:

  • Komunikace mezi webovou rolí a rolí pracovního procesu ve vícevrstvé aplikaci Azure.Communication between web and worker roles in a multi-tier Azure application.
  • Komunikace mezi místními aplikacemi a aplikacemi hostovanými v Azure v případě hybridního řešení.Communication between on-premises apps and Azure-hosted apps in a hybrid solution.
  • Komunikace mezi součástmi distribuované aplikace spuštěné místně v různých organizacích nebo odděleních organizace.Communication between components of a distributed application running on-premises in different organizations or departments of an organization.

Použití fronty vám umožňuje snazší škálování aplikací a zvyšuje odolnost vaší architektury proti chybám.Using queues enables you to scale your applications more easily, and enable more resiliency to your architecture.

PožadavkyPrerequisites

Před tímto kurzem se ujistěte, že máte nainstalované tyto položky:To complete this tutorial, make sure you have installed:

Tento rychlý start vyžaduje použití nejnovější verze Azure PowerShellu.This quickstart requires that you are running the latest version of Azure PowerShell. Pokud PowerShell potřebujete nainstalovat nebo upgradovat, přečtěte si téma Instalace a konfigurace Azure PowerShellu.If you need to install or upgrade, see Install and Configure Azure PowerShell. Pokud máte zkušenosti s Azure Cloud Shell, můžete ji třeba použít bez nutnosti instalace prostředí Azure PowerShell na vašem počítači.If you are familiar with Azure Cloud Shell, you could use it without installing Azure PowerShell on your machine. Podrobnosti o službě Azure Cloud Shell, najdete v článku Přehled služby Azure Cloud ShellFor details about Azure Cloud Shell, see Overview of Azure Cloud Shell

Přihlásit se k AzureSign in to Azure

  1. Pokud jste to ještě neudělali, nainstalujte modul PowerShell služby Service Bus:First, install the Service Bus PowerShell module, if you haven't already:

    Install-Module Az.ServiceBus
    
  2. Spuštěním následujícího příkazu se přihlaste k Azure:Run the following command to sign in to Azure:

    Login-AzAccount
    
  3. Zadáním následujících příkazů nastavte aktuální kontext předplatného, případně zobrazte momentálně aktivní předplatné:Issue the following commands to set the current subscription context, or to see the currently active subscription:

    Select-AzSubscription -SubscriptionName "MyAzureSubName" 
    Get-AzContext
    

Zřízení prostředkůProvision resources

Do příkazového řádku PowerShell zadejte následující příkazy, kterými zřídíte prostředky služby Service Bus.From the PowerShell prompt, issue the following commands to provision Service Bus resources. Nezapomeňte všechny zástupné symboly nahradit příslušnými hodnotami:Be sure to replace all placeholders with the appropriate values:

# Create a resource group 
New-AzResourceGroup –Name my-resourcegroup –Location eastus

# Create a Messaging namespace
New-AzServiceBusNamespace -ResourceGroupName my-resourcegroup -NamespaceName namespace-name -Location eastus

# Create a queue 
New-AzServiceBusQueue -ResourceGroupName my-resourcegroup -NamespaceName namespace-name -Name queue-name -EnablePartitioning $False

# Get primary connection string (required in next step)
Get-AzServiceBusKey -ResourceGroupName my-resourcegroup -Namespace namespace-name -Name RootManageSharedAccessKey

Po spuštění rutiny Get-AzServiceBusKey zkopírujte vybraný připojovací řetězec a název fronty a vložte je do dočasného umístění, třeba do Poznámkového bloku.After the Get-AzServiceBusKey cmdlet runs, copy and paste the connection string and the queue name you selected, to a temporary location such as Notepad. Budete je potřebovat v dalším kroku.You will need it in the next step.

Odesílání a příjem zprávSend and receive messages

Pokud jste vytvořili obor názvů a frontu a máte potřebná pověření, můžete začít odesílat a přijímat zprávy.After the namespace and queue are created, and you have the necessary credentials, you are ready to send and receive messages. Kód si můžete zkontrolovat v této složce s ukázkami na GitHubu.You can examine the code in this GitHub sample folder.

Kód spustíte následovně:To run the code, do the following:

  1. Pomocí následujícího příkazu naklonujte úložiště Service Bus na GitHubu:Clone the Service Bus GitHub repository by issuing the following command:

    git clone https://github.com/Azure/azure-service-bus.git
    
  2. Přejděte do složky s ukázkou azure-service-bus\samples\DotNet\GettingStarted\BasicSendReceiveQuickStart\BasicSendReceiveQuickStart.Navigate to the sample folder azure-service-bus\samples\DotNet\GettingStarted\BasicSendReceiveQuickStart\BasicSendReceiveQuickStart.

  3. Pokud jste to ještě neudělali, získejte pomocí následující rutiny PowerShellu připojovací řetězec.If you have not done so already, obtain the connection string using the following PowerShell cmdlet. Zástupné texty my-resourcegroup a namespace-name nezapomeňte nahradit svými konkrétními hodnotami:Be sure to replace my-resourcegroup and namespace-name with your specific values: 

    Get-AzServiceBusKey -ResourceGroupName my-resourcegroup -Namespace namespace-name -Name RootManageSharedAccessKey
    
  4. Do příkazového řádku PowerShellu zadejte následující příkaz:At the PowerShell prompt, type the following command:

    dotnet build
    
  5. Přejděte do složky bin\Debug\netcoreapp2.0.Navigate to the bin\Debug\netcoreapp2.0 folder.

  6. Zadáním následujícího příkazu spusťte program.Type the following command to run the program. Nezapomeňte myConnectionString nahradit hodnotou, kterou jste předtím získali, a myQueueName nahraďte názvem vytvořené fronty:Be sure to replace myConnectionString with the value you previously obtained, and myQueueName with the name of the queue you created:

    dotnet BasicSendReceiveQuickStart.dll -ConnectionString "myConnectionString" -QueueName "myQueueName"
    
  7. Sledujte, jak se do fronty odešle deset zpráv a jak se následně z fronty přijmou:Observe 10 messages being sent to the queue, and subsequently received from the queue:

    výstup programu

Vyčištění prostředkůClean up resources

Spuštěním následujícího příkazu odeberte skupinu prostředků, obor názvů a všechny související prostředky:Run the following command to remove the resource group, namespace, and all related resources:

Remove-AzResourceGroup -Name my-resourcegroup

Vysvětlení vzorového kóduUnderstand the sample code

Tato část obsahuje další podrobnosti o chování ukázkového kódu.This section contains more details about what the sample code does.

Získání připojovacího řetězce a frontyGet connection string and queue

Název připojovacího řetězce a fronty jsou předány Main() metody jako argumenty příkazového řádku.The connection string and queue name are passed to the Main() method as command-line arguments. Metoda Main() deklaruje dvě proměnné řetězce, do kterých se tyto údaje načtou:Main() declares two string variables to hold these values:

static void Main(string[] args)
{
    string ServiceBusConnectionString = "";
    string QueueName = "";

    for (int i = 0; i < args.Length; i++)
    {
        var p = new Program();
        if (args[i] == "-ConnectionString")
        {
            Console.WriteLine($"ConnectionString: {args[i+1]}");
            ServiceBusConnectionString = args[i + 1]; 
        }
        else if(args[i] == "-QueueName")
        {
            Console.WriteLine($"QueueName: {args[i+1]}");
            QueueName = args[i + 1];
        }                
    }

    if (ServiceBusConnectionString != "" && QueueName != "")
        MainAsync(ServiceBusConnectionString, QueueName).GetAwaiter().GetResult();
    else
    {
        Console.WriteLine("Specify -Connectionstring and -QueueName to execute the example.");
        Console.ReadKey();
    }                            
}

Metoda Main() pak spustí asynchronní smyčku zpráv, MainAsync().The Main() method then starts the asynchronous message loop, MainAsync().

Smyčka zprávMessage loop

Metoda MainAsync() vytvoří frontu klienta s argumenty příkazového řádku, volá přijímající obslužné rutiny zpráv s názvem RegisterOnMessageHandlerAndReceiveMessages()a odesílá sadu zpráv:The MainAsync() method creates a queue client with the command-line arguments, calls a receiving message handler named RegisterOnMessageHandlerAndReceiveMessages(), and sends the set of messages:

static async Task MainAsync(string ServiceBusConnectionString, string QueueName)
{
    const int numberOfMessages = 10;
    queueClient = new QueueClient(ServiceBusConnectionString, QueueName);

    Console.WriteLine("======================================================");
    Console.WriteLine("Press any key to exit after receiving all the messages.");
    Console.WriteLine("======================================================");

    // Register QueueClient's MessageHandler and receive messages in a loop
    RegisterOnMessageHandlerAndReceiveMessages();

    // Send Messages
    await SendMessagesAsync(numberOfMessages);

    Console.ReadKey();

    await queueClient.CloseAsync();
}

Metoda RegisterOnMessageHandlerAndReceiveMessages() jednoduše nastaví některé možnosti obslužné rutiny zpráv a potom zavolá metodu RegisterMessageHandler() klienta fronty, která spustí příjem:The RegisterOnMessageHandlerAndReceiveMessages() method simply sets a few message handler options, then calls the queue client's RegisterMessageHandler() method, which starts the receiving:

static void RegisterOnMessageHandlerAndReceiveMessages()
{
    // Configure the MessageHandler Options in terms of exception handling, number of concurrent messages to deliver etc.
    var messageHandlerOptions = new MessageHandlerOptions(ExceptionReceivedHandler)
    {
        // Maximum number of Concurrent calls to the callback `ProcessMessagesAsync`, set to 1 for simplicity.
        // Set it according to how many messages the application wants to process in parallel.
        MaxConcurrentCalls = 1,

        // Indicates whether MessagePump should automatically complete the messages after returning from User Callback.
        // False below indicates the Complete will be handled by the User Callback as in `ProcessMessagesAsync` below.
        AutoComplete = false
    };

    // Register the function that will process messages
    queueClient.RegisterMessageHandler(ProcessMessagesAsync, messageHandlerOptions);
} 

Odesílání zprávSend messages

Operace vytvoření a odeslání zpráv probíhají v metodě SendMessagesAsync():The message creation and send operations occur in the SendMessagesAsync() method:

static async Task SendMessagesAsync(int numberOfMessagesToSend)
{
    try
    {
        for (var i = 0; i < numberOfMessagesToSend; i++)
        {
            // Create a new message to send to the queue
            string messageBody = $"Message {i}";
            var message = new Message(Encoding.UTF8.GetBytes(messageBody));

            // Write the body of the message to the console
            Console.WriteLine($"Sending message: {messageBody}");

            // Send the message to the queue
            await queueClient.SendAsync(message);
        }
    }
    catch (Exception exception)
    {
        Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
    }
}

Zpracování zprávProcess messages

Metoda ProcessMessagesAsync() rozpoznává, zpracovává a dokončuje příjem zpráv:The ProcessMessagesAsync() method acknowledges, processes, and completes the receipt of the messages:

static async Task ProcessMessagesAsync(Message message, CancellationToken token)
{
    // Process the message
    Console.WriteLine($"Received message: SequenceNumber:{message.SystemProperties.SequenceNumber} Body:{Encoding.UTF8.GetString(message.Body)}");

    // Complete the message so that it is not received again.
    await queueClient.CompleteAsync(message.SystemProperties.LockToken);
}

Poznámka

Můžete spravovat prostředky služby Service Bus s Service Bus Exploreru.You can manage Service Bus resources with Service Bus Explorer. Service Bus Exploreru umožňuje uživatelům připojit k oboru názvů služby Service Bus a správě entit pro zasílání zpráv snadno způsobem.The Service Bus Explorer allows users to connect to a Service Bus namespace and administer messaging entities in an easy manner. Tento nástroj nabízí pokročilé funkce, například funkce importu/exportu nebo možnost otestovat tématu, fronty, předplatná, služby pro přenos přes, notification hubs 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ší postupNext steps

V tomto článku jste vytvořil obor názvů služby Service Bus a další prostředky potřebné k odesílání a přijímání zpráv z fronty.In this article, you created a Service Bus namespace and other resources required to send and receive messages from a queue. Další informace o psaní kódu pro odesílání a příjem zpráv, pokračovat v kurzech odesílání a příjem zpráv oddílu.To learn more about writing code to send and receive messages, continue to the tutorials in the Send and receive messages section.