Exercice : envoyer et recevoir des messages dans une file d’attente Service Bus à l’aide de .NET.

30 minutes

Dans cet exercice, vous apprenez à effectuer les opérations suivantes :

créer un espace de noms Service Bus, ainsi qu’une file d’attente, à l’aide d’Azure CLI ;
Créer une application console .NET pour envoyer et recevoir des messages à partir de la file d’attente.

Prérequis

Un compte Azure avec un abonnement actif. Si vous n’en avez pas, vous pouvez vous inscrire à une évaluation gratuite dans la page https://azure.com/free.
Visual Studio Code sur l’une des plateformes prises en charge.
Extension C# pour Visual Studio Code.
.NET 8 est l’infrastructure cible pour cet exercice.

Dans cette section, vous ouvrez votre terminal et vous créez des variables utilisées dans le reste de l’exercice afin de faciliter l’entrée de commande et la création d’un nom de ressource unique.

Lancez l’Azure Cloud Shell, puis sélectionnez Bash et l’environnement.
Créez les variables utilisées dans les commandes Azure CLI. Remplacez <myLocation> par une région près de vous.
```
myLocation=<myLocation>
myNameSpaceName=az204svcbus$RANDOM
```

Créer des ressources Azure

Créez un groupe de ressources pour contenir les ressources Azure que vous créez.
```
az group create --name az204-svcbus-rg --location $myLocation
```
Créez un espace de noms de messagerie Service Bus. La commande suivante crée un espace de noms à l’aide de la variable que vous avez créée précédemment. L’opération prend quelques minutes.
```
az servicebus namespace create \
    --resource-group az204-svcbus-rg \
    --name $myNameSpaceName \
    --location $myLocation
```

Créer une file d’attente Service Bus

az servicebus queue create --resource-group az204-svcbus-rg \
    --namespace-name $myNameSpaceName \
    --name az204-queue

Récupérer la chaîne de connexion pour l’espace de noms Service Bus

Ouvrez le portail Azure et accédez au groupe de ressources az204-svcbus-rg.
Sélectionnez la ressource az204svcbus que vous avez créée.
Dans la section Paramètres, sélectionnez Stratégies d’accès partagé, puis la stratégie RootManageSharedAccessKey.
Copiez la Chaîne de connexion principale à partir de la boîte de dialogue qui s’ouvre, puis enregistrez-la dans un fichier, ou laissez le portail ouvert et copiez la clé si nécessaire.

Créer une application console pour envoyer des messages à la file d’attente

Ouvrez un terminal local et créez un répertoire nommé az204svcbus, accédez-y, puis exécutez la commande pour lancer Visual Studio Code.
```
code .
```
Ouvrez le terminal dans Visual Studio Code en sélectionnant Terminal > Nouveau terminal dans la barre de menus, puis exécutez les commandes suivantes pour créer l’application console et ajouter le package Azure.Messaging.ServiceBus.
```
dotnet new console
dotnet add package Azure.Messaging.ServiceBus
```
Dans Program.cs, ajoutez les instructions using suivantes en haut du fichier, après l’instruction using en cours.
```
using Azure.Messaging.ServiceBus;
```

Ajoutez les variables suivantes au code et définissez la variable connectionString sur la chaîne de connexion que vous avez obtenue plus tôt.

// connection string to your Service Bus namespace
string connectionString = "<CONNECTION STRING>";

// name of your Service Bus topic
string queueName = "az204-queue";

Ajoutez le code suivant sous les variables que vous venez d’ajouter. Pour plus d’informations, consultez les commentaires du code.

// the client that owns the connection and can be used to create senders and receivers
ServiceBusClient client;

// the sender used to publish messages to the queue
ServiceBusSender sender;

// Create the clients that we'll use for sending and processing messages.
client = new ServiceBusClient(connectionString);
sender = client.CreateSender(queueName);

// create a batch 
using ServiceBusMessageBatch messageBatch = await sender.CreateMessageBatchAsync();

for (int i = 1; i <= 3; i++)
{
    // try adding a message to the batch
    if (!messageBatch.TryAddMessage(new ServiceBusMessage($"Message {i}")))
    {
        // if an exception occurs
        throw new Exception($"Exception {i} has occurred.");
    }
}

try
{
    // Use the producer client to send the batch of messages to the Service Bus queue
    await sender.SendMessagesAsync(messageBatch);
    Console.WriteLine($"A batch of three messages has been published to the queue.");
}
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();
}

Console.WriteLine("Follow the directions in the exercise to review the results in the Azure portal.");
Console.WriteLine("Press any key to continue");
Console.ReadKey();

Enregistrez le fichier et exécutez la commande dotnet build pour vous assurer qu’il n’y a pas d’erreur.
Exécutez le programme à l’aide de la commande dotnet run et attendez l’affichage du message de confirmation suivant. Appuyez alors sur n’importe quelle touche pour quitter le programme.
```
A batch of three messages has been published to the queue.
```

Passer en revue les résultats

Connectez-vous au portail Azure et accédez à votre espace de noms Service Bus.
Sélectionnez Files d’attente dans la section Entités du volet de navigation, puis sélectionnez az204-queue dans la liste.
Sélectionnez Service Bus Explorer dans le volet de navigation File d’attente Service Bus.
Sélectionnez Aperçu depuis le début. Les trois messages qui ont été envoyés s’affichent alors.

Mettre à jour le projet pour recevoir les messages de la file d’attente

Dans cette section, vous mettez à jour le programme de façon à recevoir les messages de la file d’attente.

Ajoutez le code suivant à la fin du code existant. Pour plus d’informations, consultez les commentaires du code.

ServiceBusProcessor processor;
client = new ServiceBusClient(connectionString);

// create a processor that we can use to process the messages
processor = client.CreateProcessor(queueName, new ServiceBusProcessorOptions());

try
{
    // add handler to process messages
    processor.ProcessMessageAsync += MessageHandler;

    // add handler to process any errors
    processor.ProcessErrorAsync += ErrorHandler;

    // start processing 
    await processor.StartProcessingAsync();

    Console.WriteLine("Wait for a minute and then press any key to end the processing");
    Console.ReadKey();

    // stop processing 
    Console.WriteLine("\nStopping the receiver...");
    await processor.StopProcessingAsync();
    Console.WriteLine("Stopped receiving messages");
}
finally
{
    // Calling DisposeAsync on client types is required to ensure that network
    // resources and other unmanaged objects are properly cleaned up.
    await processor.DisposeAsync();
    await client.DisposeAsync();
}

// handle received messages
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
Task ErrorHandler(ProcessErrorEventArgs args)
{
    Console.WriteLine(args.Exception.ToString());
    return Task.CompletedTask;
}

Utilisez la commande dotnet build pour vous assurer qu’il n’y a pas d’erreur.
Utilisez la commande dotnet run pour exécuter l’application. Il envoie trois autres messages à la file d’attente, puis récupère les six messages. Appuyez sur n’importe quelle touche pour arrêter le récepteur et l’application.
```
Wait for a minute and then press any key to end the processing
Received: Message 1
Received: Message 2
Received: Message 3
Received: Message 1
Received: Message 2
Received: Message 3

Stopping the receiver...
Stopped receiving messages
```
Notes

L’application ayant envoyé deux lots de messages avant de les récupérer, vous devez voir deux lots de trois messages représentés dans la sortie.
Revenez au portail et sélectionnez à nouveau Aperçu depuis le début. Notez qu’aucun message n’apparaît dans la file d’attente, puisque nous les avons tous récupérés.

Nettoyer les ressources

Lorsque les ressources ne sont plus nécessaires, vous pouvez utiliser la commande az group delete dans le service Azure Cloud Shell pour supprimer le groupe de ressources.

az group delete --name az204-svcbus-rg --no-wait