Démarrage rapide : Envoyer des messages vers et recevoir des messages à partir de files d’attente Azure Service Bus (Python)

• C#
• Java
• JavaScript
• Python

Cet article fournit des instructions pas à pas pour un scénario simple d’envoi de messages à une file d’attente Service Bus et de leur réception. Vous trouverez des exemples JavaScript et TypeScript prédéfinis pour Azure Service Bus dans le référentiel Azure SDK pour Python sur GitHub.

Dans ce guide de démarrage rapide, vous :

• Créer un espace de noms Service Bus à l’aide du Portail Azure.

• Créer une file d’attente Service Bus à l’aide du portail Azure.

• Écrivez du code Python pour utiliser le package azure-servicebus dans :

  • Envoyer un ensemble de messages à la file d’attente
  • Recevoir ces messages de la file d’attente.

Si vous débutez avec le service, consultez la vue d’ensemble de Service Bus avant de commencer.

Prérequis

• Un abonnement Azure. Pour suivre ce guide de démarrage rapide, vous avez besoin d’un compte Azure. Vous pouvez activer vos crédits Azure mensuels pour les abonnés Visual Studio ou vous inscrire à un compte gratuit.

• Python 3.8 ou version ultérieure

Sans mot de passe (recommandé)

Pour utiliser ce guide de démarrage rapide avec votre propre compte Azure :

• Installez Azure CLI, qui fournit l’authentification sans mot de passe à votre ordinateur de développement.
• Connectez-vous avec votre compte Azure au terminal ou à l’invite de commandes avec az login.
• Utilisez le même compte lorsque vous ajoutez le rôle de données approprié à votre ressource.
• Exécutez le code dans le même terminal ou la même invite de commande.
• Notez le nom de la file d’attente de votre espace de noms Service Bus. Vous en avez besoin dans le code.

Chaîne de connexion

Notez les valeurs suivantes, que vous utilisez dans le code :

• Chaîne de connexion de l’espace de noms Service Bus
• File d’attente de l’espace de noms Service Bus que vous avez créée

Ce guide de démarrage rapide fonctionne avec des exemples que vous pouvez copier et exécuter à l’aide de Python. Pour obtenir des instructions sur la création d’une application Python, consultez Démarrage rapide : Déployer une application web Python sur Azure App Service. Pour plus d’informations sur l’installation de packages utilisés dans ce guide de démarrage rapide, consultez Comment installer des packages de bibliothèque Azure pour Python.

Créer un espace de noms dans le Portail Azure

Pour commencer à utiliser des entités de messagerie Service Bus dans Azure, créez un espace de noms avec un nom unique dans Azure. Un espace de noms fournit un conteneur de délimitation pour les ressources Service Bus, telles que les files d’attente et les sujets, dans votre application.

Pour créer un espace de noms :

1. Connectez-vous au portail Azure.

2. Sélectionnez le menu volant en haut à gauche et accédez à la page Tous les services.

3. Dans la barre de navigation de gauche, sélectionnez Intégration.

4. Faites défiler vers le bas jusqu'à services de messagerie>Service Bus et sélectionnez Créer.

   

5. Dans l’onglet Informations de base de la page Créer un espace de noms , procédez comme suit :

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

   2. Pour Groupe de ressources, choisissez un groupe de ressources existant ou créez-en un.

   3. Entrez un nom d’espace de noms qui répond aux conventions d’affectation de noms 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 peut pas se termine par -sb ou -mgmt.

   4. Pour Emplacement, choisissez la région pour 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.

      Si vous sélectionnez le niveau Premium , vous pouvez activer la géoréplication pour l’espace de noms. La fonctionnalité de géoréplication garantit que les métadonnées et les données d’un espace de noms sont répliquées en continu d’une région primaire vers une ou plusieurs régions secondaires.

      Important

      Si vous voulez utiliser des rubriques et des abonnements, choisissez Standard ou Premium. Les rubriques et les 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 le niveau de 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.

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

   

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

   

Créer une file d’attente dans le portail Azure

1. Dans la page Espace de noms Service Bus, dans le menu de navigation à gauche, développez Entités, puis sélectionnez Files d’attente.

2. Sur la page Files d’attente dans la barre d’outils, sélectionnez + File d’attente.

3. Entrez un nom pour la file d’attente. Conservez les autres valeurs par défaut.

4. Cliquez sur Créer.

   

Authentifier l’application sur Azure

Cet article vous montre deux façons de vous connecter à Azure Service Bus : sans mot de passe et chaîne de connexion.

La première option vous explique comment utiliser votre principal de sécurité dans Microsoft Entra ID et le contrôle d’accès en fonction du rôle (RBAC) pour vous connecter à un espace de noms Service Bus. Vous n’avez pas besoin d’avoir une chaîne de connexion codée en dur dans votre code, dans un fichier de configuration ou dans un stockage sécurisé comme Azure Key Vault.

La deuxième option consiste à se servir d’une chaîne de connexion pour se connecter à un espace de noms Service Bus. Si vous débutez dans Azure, vous trouverez peut-être l’option de chaîne de connexion plus facile à suivre. Nous vous recommandons d’utiliser l’option sans mot de passe dans les applications réelles et les environnements de production. Pour plus d’informations, consultez l’authentification et l’autorisation Service Bus. Pour en savoir plus sur l’authentification sans mot de passe, consultez Authentifier les applications .NET.

Sans mot de passe (recommandé)

Attribuer des rôles à votre utilisateur Microsoft Entra

Lorsque vous développez localement, assurez-vous que le compte d’utilisateur qui se connecte à Azure Service Bus dispose des autorisations appropriées. Vous avez besoin du rôle Propriétaire des données Azure Service Bus pour envoyer et recevoir des messages. Pour vous attribuer ce rôle, vous avez besoin du rôle Administrateur de l’accès utilisateur ou d’un autre rôle qui inclut l’action Microsoft.Authorization/roleAssignments/write .

Vous pouvez attribuer des rôles RBAC Azure à un utilisateur à l’aide du Portail Azure, Azure CLI ou Azure PowerShell. Pour en savoir plus sur les étendues disponibles pour les attributions de rôles, consultez Comprendre l’étendue du RBAC Azure.

L’exemple suivant attribue le rôle Azure Service Bus Data Owner à votre compte d’utilisateur, qui fournit un accès complet aux ressources Azure Service Bus. Dans un scénario réel, suivez le principe du privilège minimum pour accorder aux utilisateurs uniquement les autorisations minimales nécessaires pour un environnement de production plus sécurisé.

Rôles Azure intégrés pour Azure Service Bus

Pour Azure Service Bus, la gestion des espaces de noms et de toutes les ressources associées via le Portail Azure et l’API de gestion des ressources Azure est déjà protégée à l’aide du modèle Azure RBAC. Azure fournit les rôles Azure intégrés suivants pour autoriser l’accès à un espace de noms Service Bus :

• Propriétaire des données Azure Service Bus : permet l’accès aux données à l’espace de noms Service Bus et à ses entités, notamment les files d’attente, les rubriques, les abonnements et les filtres. Un membre de ce rôle peut envoyer et recevoir des messages à partir de files d’attente ou de rubriques et d’abonnements.
• Expéditeur de données Azure Service Bus : utilisez ce rôle pour accorder l’accès à l’espace send de noms Service Bus et à ses entités.
• Récepteur de données Azure Service Bus : utilisez ce rôle pour accorder l’accès à l’espace receive de noms Service Bus et à ses entités.

Si vous souhaitez créer un rôle personnalisé, consultez Droits requis pour les opérations Service Bus.

Ajouter un utilisateur Microsoft Entra au rôle Propriétaire Azure Service Bus

Ajoutez votre nom d’utilisateur Microsoft Entra au rôle Propriétaire de données Azure Service Bus au niveau de l’espace de noms Service Bus. Cette configuration permet à une application qui s’exécute dans le contexte de votre compte d’utilisateur d’envoyer des messages à une file d’attente ou à une rubrique. Il peut recevoir des messages d’une file d’attente ou d’un abonnement à une rubrique.

Important

Dans la plupart des cas, la propagation de l’attribution de rôle dans Azure peut prendre une ou deux minutes. Dans de rares cas, il peut prendre jusqu’à huit minutes. Si vous recevez des erreurs d’authentification lorsque vous exécutez votre code pour la première fois, patientez quelques instants et réessayez.

1. Si la page Espace de noms Service Bus n’est pas ouverte sur le Portail Azure, recherchez votre espace de noms Service Bus à l’aide de la barre de recherche principale ou du volet de navigation de gauche.

2. Dans la page Vue d’ensemble , sélectionnez Contrôle d’accès (IAM) dans le menu de gauche.

3. Sur la page Contrôle d’accès (IAM), sélectionnez l’onglet Attributions de rôles.

4. Sélectionnez + Ajouter dans le menu supérieur, puis Ajoutez une attribution de rôle.

   

5. Utilisez la zone de recherche pour filtrer les résultats sur le rôle souhaité. Pour cet exemple, recherchez Azure Service Bus Data Owner et sélectionnez le résultat correspondant. Ensuite, choisissez Suivant.

6. Sous Attribuer l’accès à, sélectionnez Utilisateur, groupe ou principal de service, puis sélectionnez + Sélectionner des membres.

7. Dans la boîte de dialogue, recherchez votre nom d’utilisateur Microsoft Entra (généralement votre adresse e-mail utilisateur@domaine), puis choisissez Sélectionner en bas de la boîte de dialogue.

8. Sélectionnez Vérifier + affecter pour accéder à la page finale, puis Vérifier + attribuer à nouveau pour terminer le processus.

Chaîne de connexion

Obtenir la chaîne de connexion

La création d’un espace de noms génère automatiquement une stratégie SAS (Shared Access Signature) initiale avec des clés primaires et secondaires. Il crée des chaînes de connexion primaires et secondaires qui accordent chacun un contrôle total sur tous les aspects de l’espace de noms. Pour plus d’informations sur la création de règles avec des droits plus limités pour les expéditeurs et les récepteurs réguliers, consultez l’authentification et l’autorisation Service Bus.

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 , dans le menu de gauche, développez Paramètres, puis sélectionnez Stratégies d’accès partagé.

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.

Utiliser pip pour installer les packages

Sans mot de passe (recommandé)

1. Pour installer les packages Python nécessaires à ce démarrage rapide Service Bus, ouvrez une fenêtre d’invite de commandes comprenant Python dans son chemin.

2. Remplacez le répertoire par le dossier où vous souhaitez placer vos exemples.

3. Installez les packages suivants :

   pip install azure-servicebus
   pip install azure-identity
   pip install aiohttp
   

Chaîne de connexion

1. Pour installer les packages Python nécessaires à ce démarrage rapide Service Bus, ouvrez une fenêtre d’invite de commandes comprenant Python dans son chemin.

2. Remplacez le répertoire par le dossier où vous souhaitez placer vos exemples.

3. Installez le package suivant :

   pip install azure-servicebus
   

Envoi de messages à une file d'attente

L’exemple de code suivant illustre comment envoyer un message à une file d’attente. Ouvrez un éditeur de texte, tel que Visual Studio Code, créez un fichier send.py et ajoutez-y le code suivant.

Sans mot de passe (recommandé)

1. Ajoutez des instructions import.

   import asyncio
   from azure.servicebus.aio import ServiceBusClient
   from azure.servicebus import ServiceBusMessage
   from azure.identity.aio import DefaultAzureCredential
   

2. Ajoutez des constantes et définissez des informations d’identification.

   FULLY_QUALIFIED_NAMESPACE = "FULLY_QUALIFIED_NAMESPACE"
   QUEUE_NAME = "QUEUE_NAME"
   
   credential = DefaultAzureCredential()
   

   Important

   • Remplacez FULLY_QUALIFIED_NAMESPACE par l’espace de noms complet de votre espace de noms Service Bus.
   • et remplacez QUEUE_NAME par le nom de la file d’attente.

3. Ajoutez une méthode pour envoyer un message unique.

   async def send_single_message(sender):
       # Create a Service Bus message and send it to the queue
       message = ServiceBusMessage("Single Message")
       await sender.send_messages(message)
       print("Sent a single message")
   

   L’expéditeur est un objet qui agit en tant que client pour la file d’attente que vous avez créée. Vous la créez ultérieurement et envoyez-la en tant qu’argument à cette fonction.

4. Ajoutez une méthode pour envoyer une liste de messages.

   async def send_a_list_of_messages(sender):
       # Create a list of messages and send it to the queue
       messages = [ServiceBusMessage("Message in list") for _ in range(5)]
       await sender.send_messages(messages)
       print("Sent a list of 5 messages")
   

5. Ajoutez une méthode pour envoyer un lot de messages.

   async def send_batch_message(sender):
       # Create a batch of messages
       async with sender:
           batch_message = await sender.create_message_batch()
           for _ in range(10):
               try:
                   # Add a message to the batch
                   batch_message.add_message(ServiceBusMessage("Message inside a ServiceBusMessageBatch"))
               except ValueError:
                   # ServiceBusMessageBatch object reaches max_size.
                   # New ServiceBusMessageBatch object can be created here to send more data.
                   break
           # Send the batch of messages to the queue
           await sender.send_messages(batch_message)
       print("Sent a batch of 10 messages")
   

6. Créez un client Service Bus, puis un objet expéditeur de file d’attente pour envoyer des messages.

   async def run():
       # create a Service Bus client using the credential
       async with ServiceBusClient(
           fully_qualified_namespace=FULLY_QUALIFIED_NAMESPACE,
           credential=credential,
           logging_enable=True) as servicebus_client:
           # get a Queue Sender object to send messages to the queue
           sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
           async with sender:
               # send one message
               await send_single_message(sender)
               # send a list of messages
               await send_a_list_of_messages(sender)
               # send a batch of messages
               await send_batch_message(sender)
   
           # Close credential when no longer needed.
           await credential.close()
   

7. Appelez la méthode run et affichez un message.

   asyncio.run(run())
   print("Done sending messages")
   print("-----------------------")
   

Chaîne de connexion

1. Ajoutez des instructions import.

   import asyncio
   from azure.servicebus.aio import ServiceBusClient
   from azure.servicebus import ServiceBusMessage
   

2. Ajoutez des constantes.

   NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STR"
   QUEUE_NAME = "QUEUE_NAME"
   

   Important

   • Remplacez NAMESPACE_CONNECTION_STR par la chaîne de connexion de votre espace de noms Service Bus,
   • et remplacez QUEUE_NAME par le nom de la file d’attente.

3. Ajoutez une méthode pour envoyer un message unique.

   async def send_single_message(sender):
       # Create a Service Bus message and send it to the queue
       message = ServiceBusMessage("Single Message")
       await sender.send_messages(message)
       print("Sent a single message")
   

   L’expéditeur est un objet qui agit en tant que client pour la file d’attente que vous avez créée. Vous la créez ultérieurement et envoyez-la en tant qu’argument à cette fonction.

4. Ajoutez une méthode pour envoyer une liste de messages.

   async def send_a_list_of_messages(sender):
       # Create a list of messages and send it to the queue
       messages = [ServiceBusMessage("Message in list") for _ in range(5)]
       await sender.send_messages(messages)
       print("Sent a list of 5 messages")
   

5. Ajoutez une méthode pour envoyer un lot de messages.

   async def send_batch_message(sender):
       # Create a batch of messages
       async with sender:
           batch_message = await sender.create_message_batch()
           for _ in range(10):
               try:
                   # Add a message to the batch
                   batch_message.add_message(ServiceBusMessage("Message inside a ServiceBusMessageBatch"))
               except ValueError:
                   # ServiceBusMessageBatch object reaches max_size.
                   # New ServiceBusMessageBatch object can be created here to send more data.
                   break
           # Send the batch of messages to the queue
           await sender.send_messages(batch_message)
       print("Sent a batch of 10 messages")
   

6. Créez un client Service Bus, puis un objet expéditeur de file d’attente pour envoyer des messages.

   async def run():
       # create a Service Bus client using the connection string
       async with ServiceBusClient.from_connection_string(
           conn_str=NAMESPACE_CONNECTION_STR,
           logging_enable=True) as servicebus_client:
           # Get a Queue Sender object to send messages to the queue
           sender = servicebus_client.get_queue_sender(queue_name=QUEUE_NAME)
           async with sender:
               # Send one message
               await send_single_message(sender)
               # Send a list of messages
               await send_a_list_of_messages(sender)
               # Send a batch of messages
               await send_batch_message(sender)
   

7. Appelez la méthode run et affichez un message.

   asyncio.run(run())
   print("Done sending messages")
   print("-----------------------")
   

Réception des messages d'une file d'attente

L’exemple de code suivant illustre comment recevoir des messages d’une file d’attente. Le code affiché reçoit de nouveaux messages jusqu’à ce qu’il n’en reçoive plus pendant 5 (max_wait_time) secondes.

Ouvrez un éditeur de texte, tel que Visual Studio Code, créez un fichier recv.py et ajoutez-y le code suivant.

Sans mot de passe (recommandé)

1. À l’instar de l’exemple send.py, ajoutez des instructions import. Remplacez les constantes par vos propres valeurs et définissez des informations d’identification.

   import asyncio
   
   from azure.servicebus.aio import ServiceBusClient
   from azure.identity.aio import DefaultAzureCredential
   
   FULLY_QUALIFIED_NAMESPACE = "FULLY_QUALIFIED_NAMESPACE"
   QUEUE_NAME = "QUEUE_NAME"
   
   credential = DefaultAzureCredential()
   

2. Créez un client Service Bus, puis un objet récepteur de file d’attente pour recevoir des messages.

   async def run():
       # create a Service Bus client using the connection string
       async with ServiceBusClient(
           fully_qualified_namespace=FULLY_QUALIFIED_NAMESPACE,
           credential=credential,
           logging_enable=True) as servicebus_client:
   
           async with servicebus_client:
               # get the Queue Receiver object for the queue
               receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
               async with receiver:
                   received_msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
                   for msg in received_msgs:
                       print("Received: " + str(msg))
                       # complete the message so that the message is removed from the queue
                       await receiver.complete_message(msg)
   
           # Close credential when no longer needed.
           await credential.close()
   

3. Appelez la méthode run .

   asyncio.run(run())
   

Chaîne de connexion

1. À l’instar de l’exemple send.py , ajoutez import des instructions et définissez des constantes qui utilisent vos propres valeurs.

   import asyncio
   from azure.servicebus.aio import ServiceBusClient
   
   NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STR"
   QUEUE_NAME = "QUEUE_NAME"
   

2. Créez un client Service Bus, puis un objet récepteur de file d’attente pour recevoir des messages.

   async def run():
       # create a Service Bus client using the connection string
       async with ServiceBusClient.from_connection_string(
           conn_str=NAMESPACE_CONNECTION_STR,
           logging_enable=True) as servicebus_client:
   
           async with servicebus_client:
               # get the Queue Receiver object for the queue
               receiver = servicebus_client.get_queue_receiver(queue_name=QUEUE_NAME)
               async with receiver:
                   received_msgs = await receiver.receive_messages(max_wait_time=5, max_message_count=20)
                   for msg in received_msgs:
                       print("Received: " + str(msg))
                       # complete the message so that the message is removed from the queue
                       await receiver.complete_message(msg)
   

3. Appelez la méthode run .

   asyncio.run(run())
   

Exécuter l’application

Ouvrez une invite de commandes avec Python dans son chemin, puis exécutez le code pour envoyer et recevoir des messages de la file d’attente.

python send.py; python recv.py

Vous devez normalement voir la sortie suivante :

Sent a single message
Sent a list of 5 messages
Sent a batch of 10 messages
Done sending messages
-----------------------
Received: Single Message
Received: Message in list
Received: Message in list
Received: Message in list
Received: Message in list
Received: Message in list
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch
Received: Message inside a ServiceBusMessageBatch

Dans le portail Azure, accédez à votre espace de noms Service Bus. Dans la page Vue d’ensemble, vérifiez que le nombre de messages entrants et sortants est égal à 16. Si vous ne voyez pas le nombre, attendez quelques minutes, puis actualisez la page.

Sélectionnez la file d’attente dans cette page Vue d’ensemble pour accéder à la page File d’attente Service Bus. Vous pouvez également voir le nombre de messages entrants et sortants dans cette page, ainsi que d’autres informations telles que la taille actuelle de la file d’attente et le nombre de messages actifs.

Contenu connexe

Voir la documentation et les exemples suivants :

• Bibliothèque de client Azure Service Bus pour Python

• Échantillons

  • Le dossier sync_samples contient des exemples qui montrent comment interagir avec Service Bus de manière synchrone.
  • Le dossier async_samples contient des exemples qui montrent comment interagir avec Service Bus de manière asynchrone. Dans ce guide de démarrage rapide, vous avez utilisé cette méthode.

• Documentation de référence sur azure-servicebus