Application multiniveau .NET avec les files d’attente Azure Service Bus

Le développement pour Microsoft Azure est simple grâce à Visual Studio et au Kit de développement logiciel (SDK) Azure gratuit pour .NET. Ce didacticiel vous guide lors de la création d’une application qui utilise plusieurs ressources Azure s’exécutant dans votre environnement local.

Vous allez apprendre à effectuer les tâches suivantes :

• configuration de votre ordinateur pour le développement Azure avec un seul téléchargement et une seule installation ;
• utilisation de Visual Studio pour développer pour Azure ;
• création d'une application multiniveau dans Azure avec les rôles Web et les rôles de travail ;
• Communication entre niveaux à l’aide des files d’attente Service Bus.

Notes

Pour suivre ce tutoriel, vous avez besoin d’un compte Azure. Vous pouvez activer les avantages de votre abonnement MSDN ou vous inscrire pour un compte gratuit.

Dans ce tutoriel, vous allez générer et exécuter l’application multiniveau dans un service cloud Azure. Le composant frontal est un rôle web ASP.NET MVC et le composant principal est un rôle de travail qui utilise une file d’attente Service Bus. Vous pouvez créer la même application multiniveau avec le composant frontal comme projet web déployé sur un site web Azure au lieu d’un service cloud. Vous pouvez également essayer le didacticiel Application hybride .NET locale/dans le cloud.

La capture d’écran suivante présente l’application terminée.

Vue d’ensemble du scénario : communication entre les rôles

Pour envoyer une commande en traitement, le composant frontal d’interface utilisateur qui s’exécute dans le rôle web doit communiquer avec la logique centrale qui s’exécute dans le rôle de travail. Cet exemple utilise la messagerie Service Bus pour la communication entre les niveaux.

L’utilisation de la messagerie Service Bus entre les niveaux Web et central découple les deux composants. À l’inverse de la messagerie directe (TCP ou HTTP), le niveau web ne se connecte pas directement au niveau central. En effet, il envoie (push) des unités de travail, sous forme de messages, à Service Bus, qui les conserve de manière fiable jusqu’à ce que le niveau central soit prêt à les consommer et à les traiter.

Service Bus fournit deux entités pour prendre en charge la messagerie répartie : les files d’attente et les rubriques. Avec les files d'attente, chaque message envoyé à la file d'attente est utilisé par un seul destinataire. Les rubriques prennent en charge le modèle de publication/d’abonnement, dans lequel chaque message publié est mis à la disposition d’un abonnement inscrit dans la rubrique. Chaque abonnement gère de façon logique sa propre file d’attente de messages. Les abonnements peuvent également être configurés avec des règles de filtrage, qui ne transmettent à la file d’attente de l’abonnement que les messages correspondant aux critères du filtre. L’exemple suivant utilise les files d’attente Service Bus.

Ce mécanisme de communication présente plusieurs avantages par rapport à la messagerie directe :

• Découplage temporel. Quand vous utilisez le modèle de messagerie asynchrone, les producteurs et les consommateurs n’ont pas besoin d’être en ligne en même temps. Service Bus stocke de manière fiable les messages jusqu'à ce que le destinataire soit prêt à les recevoir. Ceci permet aux composants de l’application distribuée d’être déconnectés, soit volontairement, par exemple pour des raisons de maintenance, soit en raison de l’échec d’un composant, sans que le système dans sa globalité soit affecté. De plus, l’application qui utilise les messages peut n’avoir besoin d’être en ligne que quelques fois par jour.

• Nivellement de charge. Dans de nombreuses applications, la charge système varie dans le temps, alors que le temps de traitement nécessaire à chaque élément de travail est normalement constant. L'ajout d'une file d'attente entre les producteurs et les consommateurs des messages fait que l'application de destination (le rôle de travail) n'a besoin d'être configurée que pour une charge de travail moyenne, plutôt que pour une charge de travail maximale. La file d’attente s’allonge et se raccourcit en fonction de la charge entrante. Ceci permet de faire des économies en termes d'infrastructures nécessaires pour faire face à la charge de travail de l'application.

• Équilibrage de charge : À mesure que la charge augmente, d'autres processus de travail peuvent être ajoutés pour lire les éléments de la file d'attente. Chaque message est traité par un seul des processus de travail. De plus, cet équilibrage de la charge basé sur l’extraction permet une utilisation optimale des ordinateurs de travail, même si ceux-ci diffèrent en termes de puissance de traitement, car ils tirent (pull) les messages au maximum de leur capacité. Ce modèle est souvent appelé modèle consommateur concurrent.

  

Les sections qui suivent présentent le code de mise en œuvre de cette architecture.

Prérequis

Dans ce tutoriel, vous allez utiliser l’authentification Microsoft Entra pour créer des objets ServiceBusClient et ServiceBusAdministrationClient. Vous utiliserez également DefaultAzureCredential, et pour l’utiliser, vous devez effectuer les étapes suivantes pour tester l’application localement dans un environnement de développement.

1. Inscrire une application dans Microsoft Entra ID.
2. Ajoutez l’application au rôle Service Bus Data Owner.
3. Définissez les variables d’environnement AZURE-CLIENT-ID, AZURE-TENANT-ID ET AZURE-CLIENT-SECRET. Pour obtenir des instructions, consultez cet article.

Pour obtenir la liste des rôles intégrés Service Bus, consultez la section Rôles intégrés Azure pour Service Bus.

Créer un espace de noms

La première étape consiste à créer un espace de noms et à obtenir une clé de signature d’accès partagé (SAP) pour ce dernier. Un espace de noms fournit une limite d’application pour chaque application exposée via Service Bus. Le système génère automatiquement une clé SAP lors de la création d’un espace de noms. La combinaison du nom de l’espace de noms et de la clé SAP fournit à Service Bus des informations d’identification permettant d’authentifier l’accès à une application.

Créer un espace de noms dans le Portail Azure

Pour commencer à utiliser des entités de messagerie Service Bus dans Azure, vous devez d’abord créer un espace de noms avec un nom unique dans Azure. Un espace de noms fournit un conteneur d’étendue pour les ressources du Service Bus (files d’attente, thèmes, etc.) au sein de votre application.

Pour créer un espace de noms :

1. Connectez-vous au portail Azure.

2. Accédez à la page Tous les services.

3. Dans la barre de navigation de gauche, sélectionnez Intégration dans la liste des catégories, pointez avec la souris sur Service Bus, puis sélectionnez le bouton + dans la vignette Service Bus.

   

4. Dans l’étiquette De base de la page Créer un espace de noms, suivez ces étapes :

   1. Pour l’option Abonnement, choisissez un abonnement Azure dans lequel créer l’espace de noms.

   2. Pour l’option Groupe de ressources, choisissez un groupe de ressources existant dans lequel l’espace de noms sera utilisé, ou créez-en un nouveau.

   3. Entrez un nom pour l’espace de noms. Le nom de l’espace de noms doit respecter les conventions de nommage suivantes :

      • Le nom doit être unique dans tout Azure. Le système vérifie immédiatement si le nom est disponible.
      • Le nom doit inclure entre 6 et 50 caractères.
      • Le nom ne peut contenir que des lettres, des chiffres et des traits d’union (« - »).
      • Le nom doit commencer par une lettre, et se terminer par une lettre ou un chiffre.
      • Le nom ne se termine ni par « -sb » ni par « -mgmt ».

   4. Pour l’option Emplacement, choisissez la région dans laquelle héberger votre espace de noms.

   5. Pour le Niveau tarifaire, sélectionnez le SKU (De base, Standard ou Premium) destiné à l’espace de noms. Pour ce guide de démarrage rapide, sélectionnez Standard.

      Important

      Si vous voulez utiliser des rubriques et des abonnements, choisissez Standard ou Premium. Les rubriques/abonnements ne sont pas pris en charge dans le niveau tarifaire De base.

      Si vous avez sélectionné le SKU Premium, précisez le nombre d’unité de messagerie. Le niveau Premium isole les ressources au niveau du processeur et de la mémoire, ce qui permet d’exécuter chaque charge de travail de manière isolée. Ce conteneur de ressources est appelé unité de messagerie. Un espace de noms Premium a au moins une unité de messagerie. Vous pouvez sélectionner 1, 2, 4, 8 ou 16 unités de messagerie pour chaque espace de noms Service Bus Premium. Pour plus d’informations, consultez Messagerie Service Bus Premium.

   6. Au bas de la page, sélectionnez Examiner et créer.

      

   7. Dans la page Vérifier + créer, passez en revue les paramètres, puis sélectionnez Créer.

5. Une fois le déploiement de la ressource réussi, sélectionnez Accéder à la ressource dans la page de déploiement.

   

6. Vous voyez la page d’accueil de votre espace de noms Service Bus.

   

Obtenir la chaîne de connexion à l’espace de noms (portail Azure)

La création d’un espace de noms génère automatiquement une première stratégie de signature d’accès partagé (SAS) avec des clés primaires et secondaires, ainsi que des chaînes de connexion primaires et secondaires, qui donnent chacune un contrôle total sur tous les aspects de l’espace de noms. Consultez Authentification et autorisation Service Bus pour plus d’information sur la façon de créer des règles avec des droits plus restreints pour les expéditeurs et destinataires réguliers.

Un client peut utiliser la chaîne de connexion pour se connecter à l’espace de noms Service Bus. Pour copier la chaîne de connexion primaire pour votre espace de noms, suivez ces étapes :

1. Dans la page Espace de noms Service Bus, sélectionnez Stratégies d’accès partagé dans le menu de gauche.

2. Dans la page Stratégies d’accès partagé, sélectionnez RootManageSharedAccessKey.

3. Dans la fenêtre Stratégie : RootManageSharedAccessKey, cliquez sur le bouton Copier situé en regard de Chaîne de connexion primaire, pour copier la chaîne de connexion dans le presse-papiers pour une utilisation ultérieure. Copiez cette valeur dans le Bloc-notes ou un autre emplacement temporaire.

   

   Vous pouvez utiliser cette page pour copier la clé primaire, la clé secondaire, la chaîne de connexion primaire et la chaîne de connexion secondaire.

Création d'un rôle web

Dans cette section, vous générez le composant frontal de votre application. Tout d’abord, vous créez les pages affichées par votre application. Ensuite, ajoutez le code permettant d’envoyer les éléments à une file d’attente Service Bus et d’afficher les informations d’état de la file d’attente.

Créer le projet

1. Lancez Visual Studio avec des privilèges d’administrateur. Pour cela, cliquez avec le bouton droit sur l’icône du programme Visual Studio, puis sélectionnez Exécuter en tant qu’administrateur. L’Émulateur de calcul Azure, présenté plus loin dans cet article, nécessite que Visual Studio soit démarré avec des privilèges d’administrateur.

   Dans Visual Studio, dans le menu Fichier, sélectionnez Nouveau, puis Projet.

2. Dans la page Modèles, suivez ces étapes :

   1. Sélectionnez C# en guise de langage de programmation.

   2. Sélectionnez Cloud pour le type de projet.

   3. Sélectionnez Azure Cloud Service.

   4. Cliquez sur Suivant.

      

3. Nommez le projet MultiTierApp, sélectionnez l’emplacement du projet, puis Créer.

   

4. Dans la page Rôles, double-cliquez sur Rôle web ASP.NET, puis sélectionnez OK.

   

5. Passez la souris sur WebRole1 sous Solution Azure Cloud Service, cliquez sur l’icône en forme de crayon et renommez le rôle Web FrontendWebRole. Sélectionnez ensuite OK. (Entrez bien « Frontend » avec un « e » minuscule, et non « FrontEnd ».)

   

6. Dans la boîte de dialogue Créer une application web ASP.NET, sélectionnez MVC, puis sélectionnez Créer.

   

7. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur Références dans le projet FrontendWebRole, puis sélectionnez Gérer les packages NuGet.

8. Sélectionnez l’onglet Parcourir, puis recherchez Azure.Messaging.ServiceBus. Sélectionnez le package Azure.Messaging.ServiceBus, sélectionnez Installer, puis acceptez les conditions d’utilisation.

   

   Notez que les assemblys client nécessaires sont maintenant référencés et que certains nouveaux fichiers de code ont été ajoutés.

9. Suivez les mêmes étapes pour ajouter le package NuGet Azure.Identity au projet.

10. Dans l’Explorateur de solutions, développez FrontendWebRole, cliquez avec le bouton droit sur Modèles et sélectionnez Ajouter, puis sélectionnez Classe. Dans la zone Nom, saisissez le nom OnlineOrder.cs. Sélectionnez ensuite Ajouter.

Écriture du code de votre rôle Web

Dans cette section, vous créez les différentes pages affichées par votre application.

1. Dans le fichier OnlineOrder.cs dans Visual Studio, remplacez la définition d'espace de noms existante par le code suivant :

   namespace FrontendWebRole.Models
   {
       public class OnlineOrder
       {
           public string Customer { get; set; }
           public string Product { get; set; }
       }
   }
   

2. Dans l’Explorateur de solutions, double-cliquez sur Controllers\HomeController.cs. Ajoutez les instructions using suivantes au début du fichier pour inclure les espaces de noms pour le modèle que vous venez de créer, ainsi que Service Bus.

    using FrontendWebRole.Models;
    using Azure.Messaging.ServiceBus;    
   

3. Également dans le fichier HomeController.cs dans Visual Studio, remplacez la définition d'espace de noms existante par le code suivant. Ce code contient des méthodes pour gérer l’envoi d’éléments dans la file d’attente.

   namespace FrontendWebRole.Controllers
   {
       public class HomeController : Controller
       {
           public ActionResult Index()
           {
               // Simply redirect to Submit, since Submit will serve as the
               // front page of this application.
               return RedirectToAction("Submit");
           }
   
           public ActionResult About()
           {
               return View();
           }
   
           // GET: /Home/Submit.
           // Controller method for a view you will create for the submission
           // form.
           public ActionResult Submit()
           {
               // Will put code for displaying queue message count here.
   
               return View();
           }
   
           // POST: /Home/Submit.
           // Controller method for handling submissions from the submission
           // form.
           [HttpPost]
           // Attribute to help prevent cross-site scripting attacks and
           // cross-site request forgery.  
           [ValidateAntiForgeryToken]
           public ActionResult Submit(OnlineOrder order)
           {
               if (ModelState.IsValid)
               {
                   // Will put code for submitting to queue here.
   
                   return RedirectToAction("Submit");
               }
               else
               {
                   return View(order);
               }
           }
       }
   }
   

4. Dans le menu Générer, sélectionnez Générer la solution pour vérifier que votre travail est correct.

5. Maintenant, créez l’affichage de la méthode Submit() créée auparavant. Cliquez avec le bouton droit dans la méthode Submit() (la surcharge de Submit() qui n’accepte aucun paramètre) dans le fichier HomeController.cs, puis choisissez Ajouter une vue.

6. Dans la boîte de dialogue Ajouter un nouvel élément généré automatiquement, sélectionnez Ajouter.

7. Dans la boîte de dialogue Ajouter une vue, procédez comme suit :

   1. Dans la liste Modèle, choisissez Créer.

   2. Dans la liste Classe de modèle, sélectionnez la classe OnlineOrder.

   3. Sélectionnez Ajouter.

      

8. À présent, modifiez le nom affiché de votre application. Dans l’Explorateur de solutions, double-cliquez sur le fichier Views\Shared\_Layout.cshtml pour l’ouvrir dans l’éditeur Visual Studio.

9. Remplacez toutes les occurrences de Mon application ASP.NET par Northwind Traders Products.

10. Supprimez les liens Home, About et Contact. Supprimez le code en surbrillance :

    

11. Enfin, modifiez la page d'envoi pour inclure des informations sur la file d'attente. Dans l’Explorateur de solutions, double-cliquez sur le fichier Views\Home\Submit.cshtml pour l’ouvrir dans l’éditeur de Visual Studio. Ajoutez la ligne suivante après <h2>Submit</h2>. À ce stade, ViewBag.MessageCount est vide. Vous le remplirez plus tard.

    <p>Current number of orders in queue waiting to be processed: @ViewBag.MessageCount</p>
    

12. Vous avez maintenant implémenté votre interface utilisateur. Vous pouvez appuyer sur F5 pour exécuter votre application et vérifier qu’elle apparaît bien comme vous le souhaitez.

    

Écriture de code pour l'envoi d'éléments dans une file d'attente Service Bus

Maintenant, ajoutez le code pour envoyer des éléments dans une file d’attente. Tout d’abord, vous créez une classe qui contient les informations de connexion à votre file d’attente Service Bus. Ensuite, initialisez votre connexion à partir de Global.aspx.cs. Enfin, mettez à jour le code d’envoi que vous avez créé précédemment dans HomeController.cs pour qu’il envoie réellement les éléments dans une file d’attente Service Bus.

1. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur FrontendWebRole (sur le projet, et non sur le rôle). Sélectionnez Ajouter, puis Classe.

2. Donnez le nom QueueConnector.cs à la classe. Sélectionnez Ajouter pour créer la classe.

3. Maintenant, ajoutez le code qui encapsule les informations de connexion et initialise la connexion à une file d’attente Service Bus. Remplacez tout le contenu de QueueConnector.cs par le code suivant, puis saisissez des valeurs pour your Service Bus namespace (nom de votre espace de noms) et yourKey qui correspond à la clé primaire précédemment obtenue à partir du portail Azure.

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Web;
    using System.Threading.Tasks;
    using Azure.Messaging.ServiceBus;
    using Azure.Messaging.ServiceBus.Administration;
   
   namespace FrontendWebRole
   {
        public static class QueueConnector
        {
            // object to send messages to a Service Bus queue
            internal static ServiceBusSender SBSender;
   
            // object to create a queue and get runtime properties (like message count) of queue
            internal static ServiceBusAdministrationClient SBAdminClient;
   
            // Fully qualified Service Bus namespace
            private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";
   
            // The name of your queue.
            internal const string QueueName = "OrdersQueue";
   
            public static async Task Initialize()
            {
                // Create a Service Bus client that you can use to send or receive messages
                ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());
   
                // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
                SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());
   
                // create the OrdersQueue if it doesn't exist already
                if (!(await SBAdminClient.QueueExistsAsync(QueueName)))
                {
                    await SBAdminClient.CreateQueueAsync(QueueName);
                }
   
                // create a sender for the queue 
                SBSender = SBClient.CreateSender(QueueName);    
            }
        }    
   }
   

4. Ensuite, assurez-vous que votre méthode Initialize est bien appelée. Dans l’Explorateur de solutions, double-cliquez sur Global.asax\Global.asax.cs.

5. Ajoutez la ligne de code suivante à la fin de la méthode Application_Start.

    FrontendWebRole.QueueConnector.Initialize().Wait();
   

6. Enfin, mettez à jour le code web que vous avez créé précédemment, pour envoyer des éléments dans la file d'attente. Dans l’Explorateur de solutions, double-cliquez sur Controllers\HomeController.cs.

7. Mettez à jour la méthode Submit() (la surcharge qui n’accepte aucun paramètre) comme suit pour obtenir le nombre de messages dans la file d’attente.

        public ActionResult Submit()
        {
            QueueRuntimeProperties properties = QueueConnector.adminClient.GetQueueRuntimePropertiesAsync(QueueConnector.queueName).Result;
            ViewBag.MessageCount = properties.ActiveMessageCount;
   
            return View();
        }
   

8. Mettez à jour la méthode Submit(OnlineOrder order) (la surcharge qui accepte un paramètre) comme suit pour envoyer des informations de commande à la file d’attente.

        public ActionResult Submit(OnlineOrder order)
        {
            if (ModelState.IsValid)
            {
                // create a message 
                var message = new ServiceBusMessage(new BinaryData(order));
   
                // send the message to the queue
                QueueConnector.sbSender.SendMessageAsync(message);
   
                return RedirectToAction("Submit");
            }
            else
            {
                return View(order);
            }
        }
   

9. Vous pouvez maintenant réexécuter l'application. À chaque fois que vous envoyez une commande, le nombre de messages augmente.

   

Création du rôle de travail

Vous allez maintenant créer le rôle de travail qui traite les commandes envoyées. Cet exemple utilise le modèle de projet Visual Studio Rôle de travail avec file d’attente Service Bus. Vous avez déjà obtenu les informations d’identification requises à partir du portail.

1. Assurez-vous d’avoir connecté Visual Studio à votre compte Azure.

2. Dans Visual Studio, dans l’Explorateur de solutions, cliquez avec le bouton droit sur le dossier Rôles sous le projet MultiTierApp.

3. SélectionnezAjouter, puis Nouveau projet de rôle de travail. La boîte de dialogue Ajouter un nouveau projet de rôle s’affiche.

   

4. Dans la boîte de dialogue Ajouter un nouveau projet de rôle , sélectionnez Rôle de travail. Ne sélectionnez pas Rôle de travail avec file d’attente Service Bus, car cela génère du code qui utilise le kit de développement logiciel (SDK) Service Bus hérité.

   

5. Dans la boîte de dialogue Nom, saisissez le nom de projet OrderProcessingRole. Sélectionnez ensuite Ajouter.

6. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur le projet OrderProcessingRole, puis sélectionnez Gérer les packages NuGet.

7. Sélectionnez l’onglet Parcourir, puis recherchez Azure.Messaging.ServiceBus. Sélectionnez le package Azure.Messaging.ServiceBus, sélectionnez Installer, puis acceptez les conditions d’utilisation.

   

8. Suivez les mêmes étapes pour ajouter le package NuGet Azure.Identity au projet.

9. Créez une classe OnlineOrderpour représenter les commandes à mesure que vous les traitez dans la file d’attente. Vous pouvez réutiliser une classe que vous avez déjà créée. Dans l’Explorateur de solutions, cliquez avec le bouton droit sur la classe OrderProcessingRole (sur l’icône de la classe, non sur le rôle). Sélectionnez Ajouter, puis Élément existant.

10. Accédez au sous-dossier FrontendWebRole\Models, puis double-cliquez sur OnlineOrder.cs pour l’ajouter à ce projet.

11. Ajoutez l’instruction using suivante au fichier WorkerRole.cs dans le projet OrderProcessingRole.

    using FrontendWebRole.Models;
    using Azure.Messaging.ServiceBus;
    using Azure.Messaging.ServiceBus.Administration; 
    

12. Dans WorkerRole.cs, ajoutez les propriétés suivantes.

    Important

    Utilisez la chaîne de connexion pour l’espace de noms que vous avez noté dans le cadre des prérequis.

        // Fully qualified Service Bus namespace
        private const string FullyQualifiedNamespace = "<SERVICE BUS NAMESPACE NAME>.servicebus.windows.net";
    
        // The name of your queue.
        private const string QueueName = "OrdersQueue";
    
        // Service Bus Receiver object to receive messages message the specific queue
        private ServiceBusReceiver SBReceiver;
    
    

13. Mettez à jour la méthode OnStart pour créer un objet ServiceBusClient, puis un objet ServiceBusReceiver pour recevoir des messages de OrdersQueue.

        public override bool OnStart()
        {
            // Create a Service Bus client that you can use to send or receive messages
            ServiceBusClient SBClient = new ServiceBusClient(FullyQualifiedNamespace, new DefaultAzureCredential());
    
            CreateQueue(QueueName).Wait();
    
            // create a receiver that we can use to receive the message
            SBReceiver = SBClient.CreateReceiver(QueueName);
    
            return base.OnStart();
        }
        private async Task CreateQueue(string queueName)
        {
            // Create a Service Bus admin client to create queue if it doesn't exist or to get message count
            ServiceBusAdministrationClient SBAdminClient = new ServiceBusAdministrationClient(FullyQualifiedNamespace, new DefaultAzureCredential());
    
            // create the OrdersQueue if it doesn't exist already
            if (!(await SBAdminClient.QueueExistsAsync(queueName)))
            {
                await SBAdminClient.CreateQueueAsync(queueName);
            }
        }
    

14. Mettez à jour la méthode RunAsync pour inclure le code pour recevoir des messages.

        private async Task RunAsync(CancellationToken cancellationToken)
        {
            // TODO: Replace the following with your own logic.
            while (!cancellationToken.IsCancellationRequested)
            {
                // receive message from the queue
                ServiceBusReceivedMessage receivedMessage = await SBReceiver.ReceiveMessageAsync();
    
                if (receivedMessage != null)
                {
                    Trace.WriteLine("Processing", receivedMessage.SequenceNumber.ToString());
    
                    // view the message as an OnlineOrder
                    OnlineOrder order = receivedMessage.Body.ToObjectFromJson<OnlineOrder>();
                    Trace.WriteLine(order.Customer + ": " + order.Product, "ProcessingMessage");
    
                    // complete message so that it's removed from the queue
                    await SBReceiver.CompleteMessageAsync(receivedMessage);
                }
            }
        }
    

15. Vous avez terminé l’application. Vous pouvez tester l’application complète en cliquant avec le bouton droit sur le projet MultiTierApp dans l’Explorateur de solutions, puis en sélectionnant Définir comme projet de démarrageet en appuyant sur F5. Le nombre de messages n’augmente pas, car le rôle de travail traite les éléments de la file d’attente et les marque comme terminés. Vous pouvez voir le résultat du suivi de votre rôle de travail en affichant l'interface utilisateur de l'émulateur de calcul Azure. Pour cela, cliquez avec le bouton droit sur l’icône de l’émulateur dans la zone de notification de la barre des tâches, puis sélectionnez l’interface utilisateur de l’émulateur de calcul Azure.

    

    

Étapes suivantes

Pour en savoir plus sur Service Bus, consultez les ressources suivantes :

• Prise en main des files d’attente Service Bus
• Page du service Service Bus