Skip to content
Learni
Voir tous les tutoriels
Microsoft 365

Comment créer un bot Microsoft Teams avec Node.js en 2026

Read in English

Introduction

Microsoft Teams est bien plus qu'un outil de collaboration : c'est une plateforme extensible où les bots automatisent les tâches quotidiennes, comme répondre aux messages ou gérer des workflows. En 2026, avec l'essor de l'IA et des intégrations hybrides, créer un bot personnalisé booste la productivité des équipes. Ce tutoriel intermédiaire vous guide pas à pas pour développer un bot echo avancé avec Node.js et le Bot Framework SDK. Il gère les messages, les commandes slash et les Adaptive Cards pour une UX riche.

Pourquoi c'est crucial ? Les bots Teams traitent des millions d'interactions par jour chez les entreprises. Vous apprendrez à configurer l'app dans Azure AD, rédiger un manifest précis, coder un bot résilient et le déployer sur Azure. Résultat : un bot production-ready en moins d'une heure, scalable et sécurisé. Idéal pour les devs fullstack voulant monétiser des extensions Teams. (128 mots)

Prérequis

  • Node.js 20+ installé
  • Compte Microsoft 365 Developer (gratuit via developer.microsoft.com)
  • Azure Portal access (compte gratuit suffisant)
  • Connaissances de base en TypeScript/Node.js et REST APIs
  • Visual Studio Code avec extensions Node.js et Azure
  • ngrok pour tests locaux (optionnel mais recommandé)

Initialiser le projet Node.js

terminal
mkdir teams-bot && cd teams-bot
npm init -y
npm install botbuilder restify dotenv @microsoft/teamsfx-cli
npm install -D @types/node @types/restify typescript ts-node
npx tsc --init
npm install -g @microsoft/teamsfx-cli

Cette commande crée un projet Node.js dédié, installe le Bot Framework SDK pour gérer les conversations Teams, Restify comme serveur HTTP léger, et dotenv pour les secrets. TeamsFx CLI facilite la config manifest. Évitez npm audit fix pour ne pas casser les deps Bot Framework ; testez toujours en local d'abord.

Configurer l'application dans Azure AD

Accédez à portal.azure.com > App registrations > New registration.

  • Name : MonBotTeams2026
  • Supported account types : Accounts in any organizational directory
  • Redirect URI : Web, https://token.botframework.com/.auth/web/redirect
Notez l'Application (client) ID et générez un Client secret (Certificates & secrets). Créez un Bot Channels Registration dans Azure Bot Service :
  • Liez l'App ID et secret.
  • Messaging endpoint : https://votre-ngrok-url/api/messages (à updater plus tard).
Copiez le Microsoft App ID et App Password. Analogie : c'est comme un passeport pour votre bot dans l'écosystème Microsoft.

Créer le fichier de configuration .env

.env
MICROSOFT_APP_ID=votre_app_id_azure
MICROSOFT_APP_PASSWORD=votre_app_password
BOT_ID=votre_app_id_azure
BOT_PASSWORD=votre_app_password
PORT=3978

Ce fichier stocke les secrets Azure de manière sécurisée, chargés via dotenv. Remplacez par vos vraies valeurs. Piège courant : oublier de gitignore .env ; ajoutez-le à .gitignore pour éviter les fuites de credentials en prod.

Développer le code principal du bot

src/bot.ts
import * as restify from 'restify';
import { BotFrameworkAdapter, MemoryStorage, ConversationState, UserState } from 'botbuilder';
import * as dotenv from 'dotenv';
import { TeamsActivityHandler, TeamsInfo, CardFactory, MessageFactory, AttachmentLayoutTypes } from 'botbuilder';

dotenv.config();

const server = restify.createServer();
server.use(restify.plugins.bodyParser());

const adapter = new BotFrameworkAdapter({
  appId: process.env.MICROSOFT_APP_ID,
  appPassword: process.env.MICROSOFT_APP_PASSWORD
});

const memoryStorage = new MemoryStorage();
const conversationState = new ConversationState(memoryStorage);
const userState = new UserState(memoryStorage);

class TeamsBot extends TeamsActivityHandler {
  constructor(conversationState: ConversationState, userState: UserState) {
    super();
    this.onMessage(async (context, next) => {
      const text = context.activity.text;
      if (text.includes('/help')) {
        const card = CardFactory.adaptiveCard({
          type: 'AdaptiveCard',
          version: '1.5',
          body: [{ type: 'TextBlock', text: 'Bot echo: répète vos messages ! /help pour aide.' }]
        });
        await context.sendActivity(MessageFactory.attachment(card));
      } else {
        await context.sendActivity(`Echo: ${text}`);
      }
      await next();
    });

    this.onMembersAdded(async (context, next) => {
      const membersAdded = context.activity.membersAdded;
      const welcomeText = 'Bonjour ! Tapez /help pour commencer.';
      for (let cnt = 0; cnt < membersAdded.length; ++cnt) {
        if (membersAdded[cnt].id !== context.activity.recipient.id) {
          await context.sendActivity(MessageFactory.text(welcomeText));
        }
      }
      await next();
    });
  }
}

const bot = new TeamsBot(conversationState, userState);

adapter.onTurnError = async (context, error) => {
  console.error(`\n [onTurnError]: ${error}`);
  await context.sendTraceActivity(
    'OnTurnError Trace',
    `${error}`,
    'https://www.botframework.com/schemas/error',
    'TurnError'
  );
  await context.sendActivity('Désolé, une erreur est survenue.');
};

server.post('/api/messages', (req, res) => {
  adapter.processActivity(req, res, async (context) => {
    await bot.run(context);
  });
});

server.listen(process.env.PORT || 3978, () => {
  console.log(`\nServer up at: http://localhost:${process.env.PORT || 3978}`);
});

Ce bot étend TeamsActivityHandler pour gérer messages, joins et erreurs. Il écho les textes, répond à /help avec une Adaptive Card, et utilise MemoryStorage pour états temporaires. Piège : toujours implémenter onTurnError pour logs ; en prod, remplacez par CosmosDB storage pour persistance.

Compiler et tester localement

Ajoutez à tsconfig.json : "module": "commonjs", "target": "es2020". Lancez npx ts-node src/bot.ts. Utilisez ngrok : ngrok http 3978 pour un URL public. Mettez à jour le Messaging endpoint dans Azure Bot Service avec https://votre-ngrok.ngrok.io/api/messages.

Side-load le bot dans Teams : Developer Portal > Apps > New app > Upload manifest (prochain code). Testez : le bot accueille, écho et montre cards. Analogie : comme un majordome virtuel qui anticipe les besoins.

Générer et personnaliser le manifest Teams

manifest/teams-manifest.json
{
  "$schema": "https://developer.microsoft.com/json-schemas/teams/v1.16/MicrosoftTeams.schema.json",
  "manifestVersion": "1.16",
  "version": "1.0.0",
  "id": "votre_app_id_azure",
  "packageName": "com.monbot.teamsbot2026",
  "developer": {
    "name": "Learni Dev",
    "websiteUrl": "https://learni-group.com",
    "privacyUrl": "https://privacy.example.com",
    "termsOfUseUrl": "https://terms.example.com"
  },
  "icons": {
    "color": "color.png",
    "outline": "outline.png"
  },
  "name": {
    "short": "Bot Echo 2026",
    "full": "Bot Microsoft Teams Echo Avancé"
  },
  "description": {
    "short": "Bot qui écho vos messages",
    "full": "null"
  },
  "accentColor": "#FFFFFF",
  "bots": [
    {
      "botId": "votre_app_id_azure",
      "scopes": ["personal", "team", "groupchat"],
      "supportsFiles": false,
      "isNotificationOnly": false,
      "supportsCalling": false,
      "supportsVideo": false
    }
  ],
  "permissions": ["identity", "messageTeamMembers"],
  "validDomains": ["token.botframework.com", "votre-ngrok.ngrok.io"]
}

Ce manifest définit l'app Teams : ID Azure, scopes (personal/team), permissions pour identity. Remplacez IDs et ajoutez icons (128x128 PNG). Zippé en .zip, il permet le side-loading. Piège : validez le JSON via Teams Validator ; oubliez pas validDomains pour CORS.

Déployer sur Azure App Service

terminal-deploy
git init
git add .
git commit -m "Initial bot"

# Via Azure CLI (az login d'abord)
az group create --name rg-teamsbot --location westeurope
az appservice plan create --name plan-teamsbot --resource-group rg-teamsbot --sku B1 --is-linux
az webapp create --resource-group rg-teamsbot --plan plan-teamsbot --name monteamsbot2026 --runtime "NODE|20-lts"

# Déployer
az webapp deployment source config-local-git --name monteamsbot2026 --resource-group rg-teamsbot

# Mettre à jour endpoint Azure Bot
az bot channel update-teams --name MonBotAzure --resource-group rg-teamsbot --endpoint https://monteamsbot2026.azurewebsites.net/api/messages

Ces commandes créent un App Service Linux scalable, déploient via Git local et updatent le channel Teams. Utilisez B1 pour starter (gratuit-ish). Piège : assurez NODE|20 runtime ; testez HTTPS endpoint avant prod.

Valider et publier l'app

Zippez manifest/ (avec icons) > Developer Portal > Apps > Upload > Publish. Testez en prod Teams. Pour certification Microsoft : soumettez via Partner Center (exige tests avancés).

Bonnes pratiques

  • Sécurisez les secrets : Utilisez Azure Key Vault en prod, jamais hardcodé.
  • Gestion d'états : Passez à CosmosDB ou BlobStorage pour >100 users simultanés.
  • Adaptive Cards Designer : Validez UI via adaptivecards.io.
  • Logging : Intégrez Application Insights pour traces.
  • Rate limiting : Ajoutez middleware Restify pour éviter abus.

Erreurs courantes à éviter

  • Endpoint non HTTPS : Teams requiert SSL ; ngrok free OK pour dev, pas prod.
  • Scopes manquants : Vérifiez manifest pour 'team' si multi-users.
  • App ID mismatch : Bot ID == Azure App ID, double-check.
  • Pas d'onTurnError : Crashez sans ; toujours catcher exceptions.

Pour aller plus loin

Maîtrisez les Proactive Messages, AI avec Azure OpenAI ou Graph API pour users/teams. Consultez la doc officielle Bot Framework et nos formations Learni sur Microsoft 365. Prochain niveau : bots avec Power Virtual Agents.