Envoyer des messages à une rubrique Azure Service Bus et recevoir des messages à partir d’abonnements à la rubrique (Python)

Article
02/06/2024

Dans ce tutoriel, vous allez effectuer les étapes suivantes :

Créer un espace de noms Service Bus à l’aide du Portail Azure.
Créer une rubrique Service Bus à l’aide du Portail Azure.
Créer un abonnement Service Bus vers cette rubrique à l’aide du Portail Azure.
Écrivez une application Python pour utiliser le package azure-servicebus et effectuer les tâches suivantes :
- Envoyer un ensemble de messages à la rubrique.
- Recevoir les messages de l’abonnement.

Notes

Ce guide de démarrage rapide fournit des instructions pas à pas pour un scénario simple qui consiste à envoyer un lot de messages à une rubrique Service Bus et à recevoir ces messages à partir d’un abonnement de la rubrique. Vous trouverez des exemples Python prédéfinis pour Azure Service Bus dans le dépôt du kit SDK Azure pour Python sur GitHub.

Prérequis

Un abonnement Azure.
Python 3.8 ou version ultérieure

Remarque

Ce tutoriel utilise des exemples que vous pouvez copier et exécuter avec Python. Pour obtenir des instructions sur la création d’une application Python, consultez Créer et déployer une application Python sur un site web Azure. Pour plus d’informations sur l’installation des packages utilisés dans ce tutoriel, consultez le Guide d’installation de Python.

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 :

Connectez-vous au portail Azure.
Accédez à la page Tous les services.
Dans la barre de navigation à gauche, sélectionnez Intégration dans la liste des catégories, passez votre curseur sur Service Bus, puis cliquez le bouton + dans la vignette Service Bus.
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.
Une fois le déploiement de la ressource réussi, sélectionnez Accéder à la ressource dans la page de déploiement.
Vous voyez la page d’accueil de votre espace de noms Service Bus.

Créer une rubrique à l’aide du Portail Azure

Dans la page Espace de noms Service Bus, sélectionnez Rubriques dans le menu de gauche.
Sélectionnez + Rubrique dans la barre d’outils.
Entrez un nom pour la rubrique. Conservez les valeurs par défaut des autres options.
Sélectionnez Create (Créer).

Créer un abonnement à la rubrique

Sélectionnez la rubrique que vous avez créée dans la section précédente.
Dans la page Rubrique Service Bus, dans la barre d’outils, sélectionnez + Abonnement.
Dans la page Créer un abonnement, procédez comme suit :
1. Entrez S1 pour le nom de l’abonnement.
2. Entrez 3 pour Nombre maximal de remises.
3. Ensuite, sélectionnez Créer pour créer l’abonnement.

Authentifier l’application sur Azure

Ce guide de démarrage pratique vous montre deux façons de vous connecter à Azure Service Bus : sans mot de passe et avec une 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 à vous soucier d’avoir une chaîne de connexion codée en dur dans votre code, dans un fichier config ni 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 avec Azure, vous trouverez peut-être l’option 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 Authentification et autorisation. Pour en savoir plus sur l’authentification sans mot de passe, reportez-vous à la page de présentation.

Sans mot de passe (recommandé)
Chaîne de connexion

Attribuer des rôles à votre utilisateur Microsoft Entra

Lors du développement localement, assurez-vous que le compte d’utilisateur qui se connecte à Azure Service Bus dispose des autorisations appropriées. Vous aurez besoin du rôle Propriétaire de données Azure Service Bus pour envoyer et recevoir des messages. Pour vous attribuer ce rôle, vous aurez 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. Découvrez les étendues disponibles pour les attributions de rôles dans la page vue d’ensemble de l’étendue.

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 des privilèges minimum pour accorder aux utilisateurs uniquement les autorisations minimales nécessaires à 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 ci-dessous pour autoriser l’accès à un espace de noms Service Bus :

Propriétaire de données Azure Service Bus : ce rôle permet l’accès aux données de l’espace de noms Service Bus et de ses entités (files d’attente, rubriques, abonnements et 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 autoriser l’accès en envoi à l’espace de noms Service Bus et à ses entités.
Récepteur de données Azure Service Bus : utilisez ce rôle pour autoriser l’accès en réception à l’espace 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. Il permet à une application exécutée dans le contexte de votre compte d’utilisateur d’envoyer des messages à une file d’attente ou à une rubrique et d’en recevoir auprès d’une file d’attente ou de l’abonnement d’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, cela 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.

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.
Dans la page vue d’ensemble, sélectionnez Contrôle d’accès (IAM) dans le menu de gauche.
Sur la page Contrôle d’accès (IAM), sélectionnez l’onglet Attributions de rôles.
Sélectionnez + Ajouter dans le menu supérieur, puis Ajouter une attribution de rôle dans le menu déroulant résultant.
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.
Sous Attribuer l’accès à, sélectionnez Utilisateur, groupe ou principal de service, puis sélectionnez + Sélectionner des membres.
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.
Sélectionnez Vérifier + affecter pour accéder à la page finale, puis Vérifier + attribuer à nouveau pour terminer le processus.

Pour suivre ce guide de démarrage rapide à l’aide de l’authentification sans mot de passe et de votre propre compte Azure :

Installez Azure CLI.
Connectez-vous avec votre compte Azure au terminal ou à l’invite de commandes avec az login.
Utilisez le même compte quand vous ajouterez le rôle approprié à votre ressource plus tard dans le tutoriel.
Exécutez le code du tutoriel dans le même terminal ou la même invite de commandes.

Important

Veillez à vous connecter avec az login. La classe DefaultAzureCredential du code sans mot de passe utilise les informations d’identification Azure CLI pour s’authentifier avec Microsoft Entra ID.

Pour utiliser le code sans mot de passe, vous devez spécifier un :

espace de noms Service Bus complet, par exemple : <espacedenoms-service-bus>.servicebus.windows.net
nom de rubrique
subscription name

Utiliser pip pour installer les packages

Sans mot de passe (recommandé)
Chaîne de connexion

Pour installer les packages Python nécessaires à ce tutoriel Service Bus, ouvrez une invite de commandes comprenant Python dans son chemin. Remplacez le répertoire par le dossier où vous souhaitez placer vos exemples.

Installez les packages :

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

Pour installer les packages Python nécessaires à ce tutoriel Service Bus, ouvrez une invite de commandes comprenant Python dans son chemin. Remplacez le répertoire par le dossier où vous souhaitez placer vos exemples.
Installez le package :
```
pip install azure-servicebus
```

Envoi de messages à une rubrique

L’exemple de code suivant montre comment envoyer un lot de messages à une rubrique Service Bus. Pour plus d’informations, consultez les commentaires du code.

Ouvrez votre éditeur favori, tel que Visual Studio Code, créez un fichier send.py et ajoutez-y le code suivant.

Sans mot de passe (recommandé)
Chaîne de connexion

Ajoutez les instructions import suivantes.

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

Ajoutez les constantes et définissez des informations d’identification.
```
FULLY_QUALIFIED_NAMESPACE = "FULLY_QUALIFIED_NAMESPACE"
TOPIC_NAME = "TOPIC_NAME"

credential = DefaultAzureCredential()
```
Important
- Remplacez FULLY_QUALIFIED_NAMESPACE par l’espace de noms complet de votre espace de noms Service Bus.
- et remplacez TOPIC_NAME par le nom de la rubrique.
Dans le code précédent, vous avez utilisé la classe DefaultAzureCredential de la bibliothèque de client Azure Identity. Quand l’application s’exécute localement durant le développement, DefaultAzureCredential découvre et s’authentifie automatiquement auprès d’Azure à l’aide du compte avec lequel vous vous êtes connecté à Azure CLI. Quand l’application est déployée sur Azure, DefaultAzureCredential peut authentifier votre application auprès de Microsoft Entra ID via une identité managée sans aucun changement du code.
Ajoutez une méthode pour envoyer un message unique.
```
async def send_single_message(sender):
    # Create a Service Bus message
    message = ServiceBusMessage("Single Message")
    # send the message to the topic
    await sender.send_messages(message)
    print("Sent a single message")
```
L’expéditeur est un objet qui agit en tant que client pour la rubrique que vous avez créée. Vous le créerez ultérieurement et l’enverrez en tant qu’argument à cette fonction.

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

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

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 topic
        await sender.send_messages(batch_message)
    print("Sent a batch of 10 messages")

Créez un client Service Bus, puis un objet expéditeur de rubrique 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 Topic Sender object to send messages to the topic
        sender = servicebus_client.get_topic_sender(topic_name=TOPIC_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()

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

Ajoutez les instructions import suivantes.

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

Ajoutez les constantes suivantes.
```
NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STRING"
TOPIC_NAME = "TOPIC_NAME"
```
Important
- Remplacez NAMESPACE_CONNECTION_STRING par la chaîne de connexion de votre espace de noms,
- et remplacez TOPIC_NAME par le nom de la rubrique.
Ajoutez une méthode pour envoyer un message unique.
```
async def send_single_message(sender):
    # Create a Service Bus message
    message = ServiceBusMessage("Single Message")
    # send the message to the topic
    await sender.send_messages(message)
    print("Sent a single message")
```
L’expéditeur est un objet qui agit en tant que client pour la rubrique que vous avez créée. Vous le créerez ultérieurement et l’enverrez en tant qu’argument à cette fonction.

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

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

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 topic
        await sender.send_messages(batch_message)
    print("Sent a batch of 10 messages")

Créez un client Service Bus, puis un objet expéditeur de rubrique 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 Topic Sender object to send messages to the topic
        sender = servicebus_client.get_topic_sender(topic_name=TOPIC_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)

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

Réception des messages d’un abonnement

L’exemple de code suivant vous montre comment recevoir les messages d’un abonnement. Ce code reçoit continuellement de nouveaux messages jusqu’à ce qu’il n’en reçoive plus pendant cinq (max_wait_time) secondes.

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

Sans mot de passe (recommandé)
Chaîne de connexion

Comme dans l’exemple d’envoi, ajoutez des instructions import, définissez des constantes que vous devez remplacer 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"
SUBSCRIPTION_NAME = "SUBSCRIPTION_NAME"
TOPIC_NAME = "TOPIC_NAME"

credential = DefaultAzureCredential()

Créez un client Service Bus, puis un objet récepteur d’abonnement pour recevoir les 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:

        async with servicebus_client:
            # get the Subscription Receiver object for the subscription
            receiver = servicebus_client.get_subscription_receiver(topic_name=TOPIC_NAME, 
            subscription_name=SUBSCRIPTION_NAME, max_wait_time=5)
            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 subscription
                    await receiver.complete_message(msg)
        # Close credential when no longer needed.
        await credential.close()

Appelez la méthode run .
```
asyncio.run(run())
```

Comme dans l’exemple d’envoi, ajoutez des instructions import et définissez des constantes que vous devez remplacer par vos propres valeurs.

import asyncio
from azure.servicebus.aio import ServiceBusClient

NAMESPACE_CONNECTION_STR = "NAMESPACE_CONNECTION_STRING"
SUBSCRIPTION_NAME = "SUBSCRIPTION_NAME"
TOPIC_NAME = "TOPIC_NAME"

Créez un client Service Bus, puis un objet récepteur d’abonnement pour recevoir les 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 Subscription Receiver object for the subscription
            receiver = servicebus_client.get_subscription_receiver(topic_name=TOPIC_NAME, 
            subscription_name=SUBSCRIPTION_NAME, max_wait_time=5)
            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 subscription
                    await receiver.complete_message(msg)

Appelez la méthode run .
```
asyncio.run(run())
```

Exécuter l’application

Ouvrez une invite de commandes comprenant Python dans son chemin, puis exécutez le code pour envoyer et recevoir les messages d’un abonnement sous une rubrique.

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 ces chiffres ne s’affichent pas, actualisez la page après quelques minutes.

Nombre de messages entrants et sortants

Sélectionnez la rubrique dans le volet inférieur pour afficher la page Rubrique Service Bus de votre rubrique. Dans cette page, vous devez voir trois messages entrants et trois messages sortants dans le graphique Messages.

Messages entrants et sortants

Dans cette page, si vous sélectionnez un abonnement, vous accédez à la page Abonnement Service Bus. Elle indique entre autres le nombre de messages actifs et le nombre de messages de lettres mortes. Dans cet exemple, tous les messages ont été reçus ; le nombre de messages actifs est donc égal à zéro.

Nombre de messages actifs

Si vous commentez le code de réception, le nombre de messages actifs sera égal à 16.

Nombre de messages actifs - aucune réception

Étapes suivantes

Voir la documentation et les exemples suivants :

Bibliothèque de client Azure Service Bus pour Python
Exemples.
- Le dossier sync_samples contient des exemples qui montrent comment interagir avec Service Bus de manière synchrone. Dans ce guide de démarrage rapide, vous avez utilisé cette méthode.
- Le dossier async_samples contient des exemples qui montrent comment interagir avec Service Bus de manière asynchrone.
Documentation de référence sur azure-servicebus

Partager via