Introduction
Azure Service Bus est un service de messagerie cloud de Microsoft conçu pour une communication asynchrone fiable entre applications. Contrairement aux files d'attente simples comme celles de RabbitMQ, il offre des fonctionnalités avancées telles que les sessions, les messages morts (dead-letter queues), les transactions et une scalabilité automatique. En 2026, avec l'essor des microservices et des architectures event-driven, maîtriser Service Bus est essentiel pour éviter les couplages serrés et gérer des pics de charge.
Ce tutoriel beginner vous guide pas à pas pour créer un namespace, une queue, et implémenter l'envoi/réception de messages avec le SDK Node.js. Imaginez une application e-commerce : les commandes sont envoyées à une queue Service Bus, traitées par un worker indépendant, évitant les blocages. À la fin, vous aurez un setup production-ready. Temps estimé : 30 minutes. Préparez votre compte Azure gratuit.
Prérequis
- Compte Azure gratuit (créez-en un sur portal.azure.com)
- Azure CLI installé (téléchargez via
winget install -e --id Microsoft.AzureCLIsur Windows ou docs) - Node.js 20+ et npm
- Éditeur comme VS Code
- Une souscription Azure active (la gratuite suffit pour ce tuto)
Connexion Azure et création du namespace
az login
az account set --subscription "Votre Subscription ID" # Remplacez par votre ID de souscription
az group create --name rg-servicebus-tutorial --location "East US"
az servicebus namespace create --resource-group rg-servicebus-tutorial --name monnamespaceunique2026 --location "East US" --sku Standard
az servicebus namespace authorization-rule create --resource-group rg-servicebus-tutorial --namespace-name monnamespaceunique2026 --name RootManageSharedAccessKeyCe script vous connecte à Azure, crée un groupe de ressources et un namespace Service Bus Standard (qui supporte les topics/sessions). Remplacez 'monnamespaceunique2026' par un nom unique globalement (ajoutez des chiffres). La règle d'autorisation 'RootManageSharedAccessKey' génère la connection string primaire. Vérifiez le nom unique via az servicebus namespace list pour éviter les erreurs de duplication.
Récupérer la connection string et créer la queue
CONNECTION_STRING=$(az servicebus namespace authorization-rule keys list --resource-group rg-servicebus-tutorial --namespace-name monnamespaceunique2026 --name RootManageSharedAccessKey --query primaryConnectionString -o tsv)
echo "Connection String: $CONNECTION_STRING" > .env
az servicebus queue create --resource-group rg-servicebus-tutorial --namespace-name monnamespaceunique2026 --name ma-queue-tutorial --enable-session false --max-size-in-mb 1024Ici, on extrait la connection string primaire et on la stocke dans .env pour sécurité (ne commitez jamais en prod). La queue 'ma-queue-tutorial' est créée avec 1 Go max, sans sessions pour ce beginner tuto. Utilisez enable-session true plus tard pour ordonner les messages par ID de session. Copiez la string pour les codes suivants.
Initialiser le projet Node.js et installer le SDK
mkdir servicebus-tutorial && cd servicebus-tutorial
npm init -y
npm install @azure/service-bus @azure/identity dotenv
touch send.ts receive.ts .env
tsc --init # Configure TypeScript si désiré, ou utilisez ts-nodeOn crée un projet Node.js, installe le SDK officiel Azure Service Bus (v7+ en 2026), dotenv pour charger .env, et identity pour auth avancée. Les fichiers send.ts/receive.ts seront nos scripts principaux. Exécutez avec npx ts-node send.ts après codage. Évitez les versions anciennes du SDK qui manquent de support async/await.
Script complet pour envoyer des messages
import { ServiceBusClient } from "@azure/service-bus";
import * as dotenv from "dotenv";
dotenv.config();
const connectionString = process.env.CONNECTION_STRING!;
const queueName = "ma-queue-tutorial";
async function sendMessages() {
const sbClient = new ServiceBusClient(connectionString);
const sender = sbClient.createSender(queueName);
try {
// Envoi d'un message simple
await sender.sendMessages({ body: "Bonjour Azure Service Bus !" });
console.log("Message envoyé.");
// Envoi de 3 messages avec propriétés
const messages = [
{ body: "Message 1", messageId: "msg1", userProperties: { priority: "high" } },
{ body: "Message 2", messageId: "msg2" },
{ body: "Message 3", messageId: "msg3", timeToLiveInSeconds: 300 }
];
await sender.sendMessages(messages);
console.log("Batch de 3 messages envoyé.");
} finally {
await sender.close();
await sbClient.close();
}
}
sendMessages().catch((err) => {
console.error("Erreur:", err);
process.exit(1);
});Ce script charge la connection string depuis .env, crée un sender pour la queue, et envoie un message simple + un batch avec ID, propriétés custom (userProperties) et TTL (timeToLiveInSeconds). Le bloc finally assure la fermeture des clients pour éviter les fuites mémoire. En prod, wrappez dans un try-catch global et loggez avec un logger comme Winston.
Script complet pour recevoir et traiter des messages
import { ServiceBusClient } from "@azure/service-bus";
import * as dotenv from "dotenv";
dotenv.config();
const connectionString = process.env.CONNECTION_STRING!;
const queueName = "ma-queue-tutorial";
async function receiveMessages() {
const sbClient = new ServiceBusClient(connectionString);
const receiver = sbClient.createReceiver(queueName, { receiveMode: "peekLock" });
try {
const messages = await receiver.receiveMessages(10, { maxWaitTimeInMs: 5000 });
for (const message of messages) {
console.log(`Message ID: ${message.messageId}, Body: ${message.body}, Properties:`, message.applicationProperties);
// Simuler traitement
await new Promise(r => setTimeout(r, 1000));
// Completer (ack) le message
await receiver.completeMessage(message);
console.log(`Message ${message.messageId} traité et acké.");
}
} finally {
await receiver.close();
await sbClient.close();
}
}
receiveMessages().catch((err) => {
console.error("Erreur:", err);
process.exit(1);
});Utilisez 'peekLock' pour verrouiller les messages pendant traitement (vs 'receiveAndDelete' pour fire-and-forget). receiveMessages(10) attend max 5s pour 10 messages. Après traitement simulé, completeMessage() les supprime de la queue. Si crash, ils reviennent en dead-letter après lockDuration (défaut 30s). Ajoutez abandonMessage() pour retry ou deadLetterMessage() pour erreurs fatales.
Nettoyage des ressources Azure
az servicebus queue delete --resource-group rg-servicebus-tutorial --namespace-name monnamespaceunique2026 --name ma-queue-tutorial
az servicebus namespace delete --resource-group rg-servicebus-tutorial --name monnamespaceunique2026 --yesSupprimez la queue puis le namespace pour éviter des coûts (Standard ~0.05$/h). L'option --yes skippe la confirmation. Vérifiez via portal.azure.com que tout est parti. En prod, utilisez Azure Resource Manager templates (ARM/Bicep) pour IaC au lieu de CLI manuelle.
Bonnes pratiques
- Sécurisez les credentials : Utilisez Azure Managed Identity ou SAS tokens au lieu de connection strings en prod. Stockez en Key Vault.
- Gestion des sessions : Activez pour ordonner les messages liés (e.g., par userId) avec createSessionReceiver.
- Monitoring : Intégrez Application Insights pour tracker les métriques (throughput, dead-letters) via Azure Portal > Metrics.
- Scalabilité : Choisissez Premium SKU pour >5TB/namespace et partitioning auto.
- Batching : Envoyez/recevez en lots jusqu'à 100 messages pour optimiser le débit.
Erreurs courantes à éviter
- Namespace non unique : Azure rejette avec 'NamespaceAlreadyExists'. Ajoutez timestamp ou UUID au nom.
- Oubli de close() : Provoque exhaustion de connexions AMQP. Toujours finally {} ou try-with-resources.
- ReceiveMode erroné : 'peekLock' sans complete/abandon laisse les messages bloqués indéfiniment.
- Pas de retry policy : Implémentez exponential backoff pour transient errors (e.g., NetworkTransientError).
Pour aller plus loin
Passez aux topics/subscriptions pour pub/sub : Docs Azure Service Bus Topics. Explorez dead-letter queues et transactions. Pour du .NET, voir le SDK officiel. Maîtrisez Bicep pour IaC. Découvrez nos formations Learni sur Azure pour certifs AZ-204. Pratiquez sur Azure Sandbox gratuit.