Cvičení – odesílání a příjem zpráv pomocí fronty

10 min

Rozhodli jste se použít frontu Service Bus ke zpracování zpráv o jednotlivých prodejích mezi mobilní aplikací, kterou používají vaši pracovníci prodeje, a webovou službou hostovaným v Azure, která ukládá podrobnosti o každém prodeji v instanci služby Azure SQL Database.

V předchozím cvičení jste implementovali potřebné objekty ve vašem předplatném Azure. Teď chcete napsat kód, který bude zprávy do této fronty odesílat a zase je z ní načítat.

V této lekci vytvoříte dvě konzolové aplikace: jedna aplikace umístí zprávy do fronty služby Service Bus a jedna aplikace načte zprávy z fronty služby Service Bus. Obě aplikace jsou součástí jednoho řešení .NET Core.

Získání připojovací řetězec do oboru názvů služby Service Bus

Pro přístup k oboru názvů služby Service Bus a použití fronty v rámci tohoto oboru názvů musíte ve dvou konzolových aplikacích nakonfigurovat dva údaje:

Koncový bod pro váš obor názvů
Sdílený přístupový klíč pro ověřování

Tyto hodnoty můžete získat z připojovací řetězec.

V okně Cloud Shellu na pravé straně obrazovky vyberte ikonu Další (...) a pak vyberte Nastavení>přejít na klasickou verzi.

Spusťte následující příkaz a nahraďte <namespace-name> ho oborem názvů služby Service Bus, který jste vytvořili v posledním cvičení.

az servicebus namespace authorization-rule keys list \
    --resource-group "<rgn>[sandbox resource group name]</rgn>" \
    --name RootManageSharedAccessKey \
    --query primaryConnectionString \
    --output tsv \
    --namespace-name <namespace-name>

Poslední řádek v odpovědi je připojovací řetězec, který obsahuje koncový bod pro váš obor názvů a sdílený přístupový klíč. Měl by vypadat podobně jako v následujícím příkladu:

Endpoint=sb://example.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=xxxxxxxx

Zkopírujte připojovací řetězec z Cloud Shellu. Tento připojovací řetězec budete potřebovat několikrát v tomto modulu, takže si ho možná budete chtít uložit někde po ruce.

Klonování a otevření úvodní aplikace

Poznámka:

Pro zjednodušení vám následující úlohy pomůžou pevně zakódovat připojovací řetězec v Program.cs souboru obou konzolových aplikací. V produkční aplikaci byste měli použít konfigurační soubor nebo Azure Key Vault k uložení připojovací řetězec.

Spuštěním následujícího příkazu v Cloud Shellu naklonujte řešení projektu Git:
```
cd ~
git clone https://github.com/MicrosoftDocs/mslearn-connect-services-together.git
```
Spuštěním následujícího příkazu přejděte do složky Start v naklonovaném projektu a otevřete editor Cloud Shellu:
```
cd ~/mslearn-connect-services-together/implement-message-workflows-with-service-bus/src/start
code .
```

Napsání kódu pro odeslání zprávy do fronty

V editoru Cloud Shell otevřete privatemessagesender /Program.cs a vyhledejte následující řádek kódu:
```
const string ServiceBusConnectionString = "";
```
Vložte připojovací řetězec uvedený v uvozovkách.
Pokud jste pro název fronty použili jiný název než salesmessages , aktualizujte hodnotu vlastnosti QueueName v kódu:
```
const string QueueName = "salesmessages";
```

Chcete-li dokončit komponentu, která odesílá zprávy o prodeji, je nutné přidat await operátor, který pozastaví vyhodnocení asynchronní metody, dokud asynchronní operace nebude dokončena. Vyhledejte metodu SendSalesMessageAsync() . V této metodě najděte následující řádek kódu:

// Create a Service Bus client here

Nahraďte tento řádek kódu následujícím kódem:

// By leveraging "await using", the DisposeAsync method will be called automatically once the client variable goes out of scope. 
// In more realistic scenarios, you would want to store off a class reference to the client (rather than a local variable) so that it can be used throughout your program.

await using var client = new ServiceBusClient(ServiceBusConnectionString);

SendSalesMessageAsync() V metodě vyhledejte následující řádek kódu:
```
// Create a sender here
```
Nahraďte tento komentář následujícím kódem:
```
await using ServiceBusSender sender = client.CreateSender(QueueName);
```

try...catch V bloku najděte následující řádek kódu:

// Create and send a message here

Nahraďte tento řádek kódu následujícími řádky kódu:

string messageBody = $"$10,000 order for bicycle parts from retailer Adventure Works.";
var message = new ServiceBusMessage(messageBody);

Vložte následující kód na nový řádek přímo pod to, co jste právě přidali, aby se zpráva zobrazila v konzole:
```
Console.WriteLine($"Sending message: {messageBody}");
```
Na další řádek vložte následující kód:
```
await sender.SendMessageAsync(message);
```

Pokud chcete likvidovat odesílatele a klientské objekty, najděte na konci souboru následující komentář:

// Close the connection to the sender here

Tento řádek nahraďte následujícím kódem:

finally
{
    // Calling DisposeAsync on client types is required to ensure that network
    // resources and other unmanaged objects are properly cleaned up.
    await sender.DisposeAsync();
    await client.DisposeAsync();
}

Zkontrolujte, jestli se konečný kód pro privatemessagesender/Program.cs podobá následujícímu příkladu:

using System;
using System.Text;
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;

namespace privatemessagesender
{
    class Program
    {
        const string ServiceBusConnectionString = "Endpoint=sb://example.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=xxxxxx";
        const string QueueName = "salesmessages";

        static void Main(string[] args)
        {
            Console.WriteLine("Sending a message to the Sales Messages queue...");
            SendSalesMessageAsync().GetAwaiter().GetResult();
            Console.WriteLine("Message was sent successfully.");
        }

        static async Task SendSalesMessageAsync()
        {
            await using var client = new ServiceBusClient(ServiceBusConnectionString);

            await using ServiceBusSender sender = client.CreateSender(QueueName);
            try
            {
                string messageBody = $"$10,000 order for bicycle parts from retailer Adventure Works.";
                var message = new ServiceBusMessage(messageBody);
                Console.WriteLine($"Sending message: {messageBody}");
                await sender.SendMessageAsync(message);
            }
            catch (Exception exception)
            {
                Console.WriteLine($"{DateTime.Now} :: Exception: {exception.Message}");
            }
            finally
            {
                // Calling DisposeAsync on client types is required to ensure that network
                // resources and other unmanaged objects are properly cleaned up.
                await sender.DisposeAsync();
                await client.DisposeAsync();
            }
        }
    }
}

Stisknutím Ctrl+S uložte změny a stisknutím Ctrl+Q zavřete editor.

Odeslání zprávy do fronty

Spuštěním následujícího příkazu v Cloud Shellu odešlete zprávu o prodeji. První řádek zajistí, že jste ve správné cestě.
```
cd ~/mslearn-connect-services-together/implement-message-workflows-with-service-bus/src/start
dotnet run --project ./privatemessagesender
```
Poznámka:

Při prvním spuštění aplikací v tomto cvičení povolte dotnet obnovení balíčků ze vzdálených zdrojů a sestavení aplikací.

Při spuštění programu se zprávy vytisknou do konzoly, která indikuje, že aplikace odesílá zprávu:
```
Sending a message to the Sales Messages queue...
Sending message: $10,000 order for bicycle parts from retailer Adventure Works.
Message was sent successfully.
```
Po dokončení aplikace spusťte následující příkaz a nahraďte <název> oboru názvů názvem vašeho oboru názvů služby Service Bus. Tento příkaz vrátí počet zpráv, které jsou ve frontě.
```
az servicebus queue show \
    --resource-group "<rgn>[sandbox resource group name]</rgn>" \
    --name salesmessages \
    --query messageCount \
    --namespace-name <namespace-name>
```
dotnet run Spusťte příkaz z kroku 1 znovu a pak příkaz spusťte servicebus queue show znovu. Při každém spuštění aplikace dotnet se do fronty přidá nová zpráva. Při každém spuštění příkazu Azure se zobrazí messageCount zvýšení.

Napsání kódu pro příjem zpráv z fronty

Spuštěním následujícího příkazu znovu otevřete editor:
```
code .
```
V editoru otevřete privatemessagereceiver /Program.cs a najděte následující řádek kódu:
```
const string ServiceBusConnectionString = "";
```
Mezi uvozovky vložte připojovací řetězec, které jste si uložili dříve.
Vyhledejte metodu ReceiveSalesMessageAsync() . V této metodě najděte následující řádek kódu:
```
// Create a Service Bus client that will authenticate using a connection string
```
Tento řádek nahraďte následujícím kódem:
```
var client = new ServiceBusClient(ServiceBusConnectionString);
```

Pokud chcete nakonfigurovat možnosti zpracování zpráv, vyhledejte následující řádek kódu:

// Create the options to use for configuring the processor

Nahraďte tento řádek následujícími řádky kódu:

var processorOptions = new ServiceBusProcessorOptions
{
    MaxConcurrentCalls = 1,
    AutoCompleteMessages = false
};

Pokud chcete vytvořit procesor, najděte následující řádek kódu:

// Create a processor that we can use to process the messages

Tento řádek nahraďte následujícím kódem:

await using ServiceBusProcessor processor = client.CreateProcessor(QueueName, processorOptions);

Pokud chcete konfigurovat obslužné rutiny, vyhledejte následující řádek kódu:

// Configure the message and error handler to use

Tento řádek nahraďte následujícím kódem:

processor.ProcessMessageAsync += MessageHandler;
processor.ProcessErrorAsync += ErrorHandler;

Chcete-li zahájit zpracování, vyhledejte následující řádek kódu:
```
// Start processing
```
Tento řádek nahraďte následujícím kódem:
```
await processor.StartProcessingAsync();
```
Pokud chcete připojení ke službě Service Bus zavřít, vyhledejte následující řádek kódu:
```
// Close the processor here
```
Tento řádek nahraďte následujícím kódem:
```
await processor.CloseAsync();
```

Zkontrolujte kód v MessageHandler metodě:

// handle received messages
static async Task MessageHandler(ProcessMessageEventArgs args)
{
    // extract the message
    string body = args.Message.Body.ToString();

    // print the message
    Console.WriteLine($"Received: {body}");

    // complete the message so that message is deleted from the queue. 
    await args.CompleteMessageAsync(args.Message);
}

Zkontrolujte kód v ErrorHandler metodě:

// handle any errors when receiving messages
static Task ErrorHandler(ProcessErrorEventArgs args)
{
    // print the exception message
    Console.WriteLine(args.Exception.ToString());
    return Task.CompletedTask;
}

Zkontrolujte, jestli se konečný kód pro privatemessagereceiver/Program.cs podobá následujícímu příkladu:

using System;
using System.Text;
using System.Threading.Tasks;
using Azure.Messaging.ServiceBus;

namespace privatemessagereceiver
{
    class Program
    {

        const string ServiceBusConnectionString = "Endpoint=sb://<examplenamespace.servicebus.windows.net/;SharedAccessKeyName=RootManageSharedAccessKey;SharedAccessKey=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
        const string QueueName = "salesmessages";

        static void Main(string[] args)
        {

            ReceiveSalesMessageAsync().GetAwaiter().GetResult();

        }

        static async Task ReceiveSalesMessageAsync()
        {

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


            var client = new ServiceBusClient(ServiceBusConnectionString);

            var processorOptions = new ServiceBusProcessorOptions
            {
                MaxConcurrentCalls = 1,
                AutoCompleteMessages = false
            };

            await using ServiceBusProcessor processor = client.CreateProcessor(QueueName, processorOptions);

            processor.ProcessMessageAsync += MessageHandler;
            processor.ProcessErrorAsync += ErrorHandler;


            await processor.StartProcessingAsync();

            Console.Read();

            await processor.CloseAsync();

        }

        // handle received messages
        static async Task MessageHandler(ProcessMessageEventArgs args)
        {
            string body = args.Message.Body.ToString();
            Console.WriteLine($"Received: {body}");

            // complete the message. messages is deleted from the queue. 
            await args.CompleteMessageAsync(args.Message);
        }

        // handle any errors when receiving messages
        static Task ErrorHandler(ProcessErrorEventArgs args)
        {
            Console.WriteLine(args.Exception.ToString());
            return Task.CompletedTask;
        }
    }
}

Stisknutím Ctrl+S uložte změny a stisknutím Ctrl+Q zavřete editor.

Přijetí zprávy z fronty

Pokud chcete spustit komponentu, která obdrží zprávu o prodeji, spusťte tento příkaz v Cloud Shellu:
```
dotnet run --project privatemessagereceiver
```
Zkontrolujte oznámení v Cloud Shellu. Na webu Azure Portal přejděte do oboru názvů služby Service Bus a zkontrolujte graf Zpráv :
```
Received: $10,000 order for bicycle parts from retailer Adventure Works.
```
Až uvidíte, že zprávy byly přijaty v Cloud Shellu, stisknutím klávesy Enter aplikaci zastavte.

Kontrola počtu zpráv

Spuštěním následujícího kódu potvrďte, že všechny zprávy byly z fronty odebrány, a nezapomeňte nahradit <název> oboru názvů vaším oborem názvů služby Service Bus.

az servicebus queue show \
    --resource-group "<rgn>[sandbox resource group name]</rgn>" \
    --name salesmessages \
    --query messageCount \
    --namespace-name <namespace-name>

Výstup bude v 0 případě, že byly odebrány všechny zprávy.

Napsali jste kód, který odesílá zprávu o individuálním prodeji do fronty služby Service Bus. V distribuované aplikaci Salesforce byste měli tento kód napsat do mobilní aplikace, kterou používají pracovníci prodeje na zařízeních.

Napsali jste také kód, který obdrží zprávu z fronty služby Service Bus. V distribuované aplikaci Salesforce byste měli napsat tento kód ve webové službě, která běží v Azure a zpracovává přijaté zprávy.

Cvičení – odesílání a příjem zpráv pomocí fronty

Získání připojovací řetězec do oboru názvů služby Service Bus

Klonování a otevření úvodní aplikace

Napsání kódu pro odeslání zprávy do fronty

Odeslání zprávy do fronty

Napsání kódu pro příjem zpráv z fronty

Přijetí zprávy z fronty

Kontrola počtu zpráv

Váš názor