Écrire directement dans le stockage

Article
12/21/2023

S'APPLIQUE À : SDK v4

Vous pouvez lire et écrire directement dans votre objet de stockage sans utiliser d’intergiciel ou d’objet de contexte. Cela peut convenir pour les données que votre bot utilise afin de préserver une conversation, ou les données provenant d'une source située en dehors du flux de conversation de votre bot. Dans ce modèle de stockage de données, plutôt que d'utiliser un gestionnaire d'états, les données sont lues directement à partir du stockage. Les exemples de code dans cet article vous montrent comment lire et écrire des données dans le stockage à l'aide de la mémoire, du Cosmos DB, d'Azure Blob et le stockage de transcription Azure Blob.

Remarque

Les kits SDK JavaScript, C# et Python Bot Framework continueront d’être pris en charge. Toutefois, le kit de développement logiciel (SDK) Java est mis hors service avec une prise en charge finale à long terme se terminant en novembre 2023.

Les bots existants créés avec le kit de développement logiciel (SDK) Java continueront de fonctionner.

Pour la nouvelle génération de bots, envisagez d’utiliser Microsoft Copilot Studio et lisez-en plus sur le choix de la solution copilote appropriée.

Pour plus d’informations, consultez Les futures versions de bot.

Prérequis

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.
Connaissance de la création d'un bot localement.
Les modèles Bot Framework SDK v4 pour Visual Studio (C#), Node.js ou Yeoman.

Remarque

Vous pouvez installer les modèles à partir de Visual Studio.

Dans le menu, sélectionnez extensions puis Gérer les extensions.
Dans la boîte de dialogue gérer les extensions, recherchez et installez les modèles kit de développement logiciel (SDK) de Bot Framework v4 pour Visual Studio.

Pour plus d'informations sur le déploiement de bots .NET sur Azure, consultez comment approvisionner et publier un bot.

À propos de cet exemple

L’exemple de code de cet article commence par la structure d’un bot d’écho de base, puis étend les fonctionnalités de ce bot par ajout de code (ci-dessous). Ce code étendu crée une liste pour conserver les entrées utilisateur au fur et à mesure qu'elles sont reçues. À chaque tour, la liste complète des entrées de l'utilisateur, enregistrée en mémoire, est répercutée vers l'utilisateur. La structure de données contenant la liste est alors modifiée pour être enregistrée dans le stockage. Différents types de stockage sont explorés lorsque des fonctionnalités supplémentaires sont ajoutées à cet exemple de code.

Stockage mémoire

Le kit SDK Bot Framework permet de stocker les entrées utilisateur en utilisant un stockage en mémoire. Étant donné que le stockage en mémoire est effacé à chaque redémarrage du bot, il convient mieux à des fins de test et n'est pas destiné à une utilisation en production. Les types de stockage persistant, tels que le stockage de base de données, sont plus adaptés aux bots de production.

Créer un bot de base

Le reste de cette rubrique s’appuie sur un bot Echo. Le code d'exemple du bot Echo peut être construit localement en suivant les instructions de démarrage rapide pour créer un bot.

Remplacez le code dans EchoBot.cs par le code suivant :

using System;
using System.Threading.Tasks;
using Microsoft.Bot.Builder;
using Microsoft.Bot.Schema;
using System.Collections.Generic;
using System.Linq;
using System.Threading;

// Represents a bot saves and echoes back user input.
public class EchoBot : ActivityHandler
{
   // Create local Memory Storage.
   private static readonly MemoryStorage _myStorage = new MemoryStorage();

   // Create cancellation token (used by Async Write operation).
   public CancellationToken cancellationToken { get; private set; }

   // Class for storing a log of utterances (text of messages) as a list.
   public class UtteranceLog : IStoreItem
   {
      // A list of things that users have said to the bot
      public List<string> UtteranceList { get; } = new List<string>();

      // The number of conversational turns that have occurred
      public int TurnNumber { get; set; } = 0;

      // Create concurrency control where this is used.
      public string ETag { get; set; } = "*";
   }

   // Echo back user input.
   protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
   {
      // preserve user input.
      var utterance = turnContext.Activity.Text;

      // Make empty local log-items list.
      UtteranceLog logItems = null;

      // See if there are previous messages saved in storage.
      try
      {
         string[] utteranceList = { "UtteranceLog" };
         logItems = _myStorage.ReadAsync<UtteranceLog>(utteranceList).Result?.FirstOrDefault().Value;
      }
      catch
      {
         // Inform the user an error occurred.
         await turnContext.SendActivityAsync("Sorry, something went wrong reading your stored messages!");
      }

      // If no stored messages were found, create and store a new entry.
      if (logItems is null)
      {
         // Add the current utterance to a new object.
         logItems = new UtteranceLog();
         logItems.UtteranceList.Add(utterance);

         // Set initial turn counter to 1.
         logItems.TurnNumber++;

         // Show user new user message.
         await turnContext.SendActivityAsync($"{logItems.TurnNumber}: The list is now: {string.Join(", ", logItems.UtteranceList)}");

         // Create dictionary object to hold received user messages.
         var changes = new Dictionary<string, object>();
         {
            changes.Add("UtteranceLog", logItems);
         }
         try
         {
            // Save the user message to your Storage.
            await _myStorage.WriteAsync(changes, cancellationToken);
         }
         catch
         {
            // Inform the user an error occurred.
            await turnContext.SendActivityAsync("Sorry, something went wrong storing your message!");
         }
      }
      // Else, our storage already contained saved user messages, add new one to the list.
      else
      {
         // add new message to list of messages to display.
         logItems.UtteranceList.Add(utterance);
         // increment turn counter.
         logItems.TurnNumber++;

         // show user new list of saved messages.
         await turnContext.SendActivityAsync($"{logItems.TurnNumber}: The list is now: {string.Join(", ", logItems.UtteranceList)}");

         // Create Dictionary object to hold new list of messages.
         var changes = new Dictionary<string, object>();
         {
            changes.Add("UtteranceLog", logItems);
         };

         try
         {
            // Save new list to your Storage.
            await _myStorage.WriteAsync(changes,cancellationToken);
         }
         catch
         {
            // Inform the user an error occurred.
            await turnContext.SendActivityAsync("Sorry, something went wrong storing your message!");
         }
      }
   }
}

Pour utiliser le fichier de configuration .env, votre bot a besoin d'un package supplémentaire. S'il n'est pas encore installé, obtenez le package .NET à partir de npm :

npm install --save dotenv

Modifiez le code dans index.js qui crée le dialogue principal. La ligne de code existante pour créer le dialogue principal est const myBot = new EchoBot();, elle doit être mise à jour pour permettre le transfert d'un objet de stockage au constructeur EchoBot afin que vous puissiez stocker les entrées l'utilisateur dans la mémoire interne du bot :

Vous devez tout d'abord ajouter une référence MemoryStorage dans botbuilder :

const { MemoryStorage } = require('botbuilder');

Créez ensuite l'objet de stockage de la mémoire et transférez-le au constructeur EchoBot :

const myStorage = new MemoryStorage();
const myBot = new EchoBot(myStorage);

Cela permet de transférer un objet MemoryStorage au constructeur EchoBot. Vous allez changer cela ultérieurement pour transférer un objet Cosmos DB ou un objet Stockage Blob.

Remplacez ensuite le code dans bot.js par le code suivant :

const { ActivityHandler, MemoryStorage } = require('botbuilder');
const restify = require('restify');

// Process incoming requests - adds storage for messages.
class EchoBot extends ActivityHandler {
    constructor(myStorage) {
        super();
        this.storage = myStorage;
        // See https://learn.microsoft.com/azure/bot-service/bot-builder-basics to learn more about the message and other activity types.
        this.onMessage(async turnContext => { console.log('this gets called (message)');
        await turnContext.sendActivity(`You said '${ turnContext.activity.text }'`);
        // Save updated utterance inputs.
        await logMessageText(this.storage, turnContext);
    });
        this.onConversationUpdate(async turnContext => { console.log('this gets called (conversation update)');
        await turnContext.sendActivity('Welcome, enter an item to save to your list.'); });
    }
}

// This function stores new user messages. Creates new utterance log if none exists.
async function logMessageText(storage, turnContext) {
    let utterance = turnContext.activity.text;
    // debugger;
    try {
        // Read from the storage.
        let storeItems = await storage.read(["UtteranceLogJS"])
        // Check the result.
        var UtteranceLogJS = storeItems["UtteranceLogJS"];
        if (typeof (UtteranceLogJS) != 'undefined') {
            // The log exists so we can write to it.
            storeItems["UtteranceLogJS"].turnNumber++;
            storeItems["UtteranceLogJS"].UtteranceList.push(utterance);
            // Gather info for user message.
            var storedString = storeItems.UtteranceLogJS.UtteranceList.toString();
            var numStored = storeItems.UtteranceLogJS.turnNumber;

            try {
                await storage.write(storeItems)
                await turnContext.sendActivity(`${numStored}: The list is now: ${storedString}`);
            } catch (err) {
                await turnContext.sendActivity(`Write failed of UtteranceLogJS: ${err}`);
            }
        }
        else{
            await turnContext.sendActivity(`Creating and saving new utterance log`);
            var turnNumber = 1;
            storeItems["UtteranceLogJS"] = { UtteranceList: [`${utterance}`], "eTag": "*", turnNumber }
            // Gather info for user message.
            var storedString = storeItems.UtteranceLogJS.UtteranceList.toString();
            var numStored = storeItems.UtteranceLogJS.turnNumber;

            try {
                await storage.write(storeItems)
                await turnContext.sendActivity(`${numStored}: The list is now: ${storedString}`);
            } catch (err) {
                await turnContext.sendActivity(`Write failed: ${err}`);
            }
        }
    }
    catch (err){
        await turnContext.sendActivity(`Read rejected. ${err}`);
    }
}

module.exports.EchoBot = EchoBot;

Remplacez le code dans echo_bot.py par le code suivant :

from botbuilder.core import ActivityHandler, TurnContext, StoreItem, MemoryStorage


class UtteranceLog(StoreItem):
    """
    Class for storing a log of utterances (text of messages) as a list.
    """

    def __init__(self):
        super(UtteranceLog, self).__init__()
        self.utterance_list = []
        self.turn_number = 0
        self.e_tag = "*"


class EchoBot(ActivityHandler):
    """
    Represents a bot saves and echoes back user input.
    """

    def __init__(self):
        self.storage = MemoryStorage()

    async def on_message_activity(self, turn_context: TurnContext):
        utterance = turn_context.activity.text

        # read the state object
        store_items = await self.storage.read(["UtteranceLog"])

        if "UtteranceLog" not in store_items:
            # add the utterance to a new state object.
            utterance_log = UtteranceLog()
            utterance_log.utterance_list.append(utterance)
            utterance_log.turn_number = 1
        else:
            # add new message to list of messages existing state object.
            utterance_log: UtteranceLog = store_items["UtteranceLog"]
            utterance_log.utterance_list.append(utterance)
            utterance_log.turn_number = utterance_log.turn_number + 1

        # Show user list of utterances.
        await turn_context.send_activity(f"{utterance_log.turn_number}: "
                                         f"The list is now: {','.join(utterance_log.utterance_list)}")

        try:
            # Save the user message to your Storage.
            changes = {"UtteranceLog": utterance_log}
            await self.storage.write(changes)
        except Exception as exception:
            # Inform the user an error occurred.
            await turn_context.send_activity("Sorry, something went wrong storing your message!")

Démarrer votre robot

Exécutez votre bot en local.

Démarrer l’émulateur et connecter votre robot

Installez Bot Framework Emulator Suivant, démarrez l'émulateur et connectez-vous à votre bot dans ledit émulateur :

Sélectionnez le lien Créer une nouvelle configuration de bot dans l'onglet Bienvenue de l'émulateur.
Renseignez les champs pour vous connecter à votre bot en utilisant les informations figurant dans la page web affichée lorsque vous avez démarré votre bot.

Interagir avec votre bot

Envoyez un message à votre bot. Le bot liste les messages qu’il a reçus.

Conversation avec le bot qui montre au bot la conservation d’une liste de messages de l’utilisateur.

La suite de cet article montre comment enregistrer dans un stockage persistant au lieu de la mémoire interne du bot.

Utilisation de Cosmos DB

Important

La classe de stockage Cosmos DB est dépréciée. Les conteneurs créés à l'origine avec CosmosDbStorage n'avaient pas de jeu de clés de partition et recevaient la clé de partition par défaut de _/partitionKey.

Les conteneurs créés avec le stockage Cosmos DB peuvent être utilisés avec le stockage partitionné Cosmos DB. Pour plus d’informations, consultez Partitionnement dans Azure Cosmos DB.

Notez également que, contrairement au stockage Cosmos DB hérité, le stockage partitionné Cosmos DB ne crée pas automatiquement une base de données dans votre compte Cosmos DB. Vous devez créer une base de données manuellement, mais ignorer manuellement la création d'un conteneur, car le CosmosDbPartitionedStorage crée le conteneur pour vous.

Maintenant que vous avez utilisé le stockage mémoire, nous allons mettre à jour le code pour utiliser Azure Cosmos DB. Cosmos DB est un service de base de données multimodèle mondialement distribué de Microsoft. Azure Cosmos DB vous permet de faire évoluer en toute flexibilité et de façon indépendante le débit et le stockage sur n’importe quel nombre de régions géographiques Azure. Il offre des garanties en termes de débit, de latence, de disponibilité et de cohérence avec des contrats SLA complets.

Configurez une ressource Cosmos DB

Pour utiliser Cosmos DB dans votre bot, vous devez créer une ressource de base de données avant d’aborder le code. Pour obtenir une description détaillée de la création d'une base de données et d'une application Cosmos DB, consultez le guide de démarrage rapide pour .NET, Node.js ou Python.

Créer un compte de base de données

Accédez au portail Azure pour créer un compte Azure Cosmos DB. Recherchez et sélectionnez Azure Cosmos DB.
Dans la page Azure Cosmos DB, sélectionnez Nouveau pour préparer la page Créer un compte Azure Cosmos DB.
Fournissez des valeurs pour les champs suivants :
1. Abonnement. Sélectionnez l’abonnement Azure à utiliser pour ce compte Azure Cosmos.
2. Groupe de ressources. Sélectionnez un groupe de ressources existant ou sélectionnez Créer nouveau, puis saisissez un nom pour le nouveau groupe de ressources.
3. Nom du compte. Entrez un nom pour identifier votre compte Azure Cosmos. Étant donné que documents.azure.com est ajouté au nom que vous fournissez pour créer votre URI, utilisez un nom unique. Respectez les recommandations suivantes :
  - Le nom doit être unique dans tout Azure.
  - Le nom doit compter entre 3 et 31 caractères.
  - Le nom ne peut inclure que des lettres minuscules, des chiffres et le caractère de trait d'union (-).
4. API. Sélectionnez Core(SQL)
5. Emplacement. Sélectionnez un emplacement le plus proche de vos utilisateurs pour leur donner l'accès le plus rapide possible aux données.
Sélectionnez Vérifier + Créer.
Une fois la validation effectuée, sélectionnez Créer.

La création du compte prend quelques minutes. Attendez que le portail affiche la page Félicitations ! Votre compte Azure Cosmos DB a été créé.

Ajouter une base de données

Remarque

Ne créez pas le conteneur vous-même. Votre bot le créera pour vous, en même temps que son client interne Cosmos DB, tout en veillant à ce qu'il soit correctement configuré pour le stockage de l'état du bot.

Naviguez vers la page Explorateur de données de votre compte Cosmos DB nouvellement créé, puis choisissez Nouvelle base de données dans le menu déroulant Nouveau conteneur. Un panneau s'ouvre alors sur le côté droit de la fenêtre, dans lequel vous pouvez saisir les détails de la nouvelle base de données.
Saisissez un identifiant pour votre nouvelle base de données et, éventuellement, définissez le débit (vous pourrez le changer ultérieurement), puis sélectionnez OK pour créer votre base de données. Notez cet ID de base de données, vous en aurez besoin par la suite pour configurer votre bot.
Maintenant que vous avez créé un compte et une base de données Cosmos DB, vous devez copier certaines des valeurs pour intégrer la nouvelle base de données dans votre bot. Pour les récupérer, accédez à l’onglet Clés dans les paramètres de base de données de votre compte Cosmos DB. Sur cette page, vous aurez besoin de votre URI (point de terminaison de Cosmos DB) et de votre CLÉ PRIMAIRE (clé d'autorisation).

Vous devez maintenant disposer d'un compte Cosmos DB avec une base de données et les valeurs suivantes prêtes à être utilisées dans vos paramètres de bot.

URI
Clé primaire
ID de base de données

Ajouter des informations de configuration Cosmos DB

Utilisez les détails que vous avez notés dans la section précédente de cet article pour définir votre point de terminaison, la clé d'autorisation, et l'identifiant de base de données. Enfin, vous devez attribuer un nom approprié au conteneur qui sera créé dans votre base de données pour stocker l’état de votre bot. Dans l'exemple ci-dessous, le conteneur Cosmos DB créé sera nommé « bot-storage ».

Ajoutez les informations suivantes à votre fichier de configuration.

appsettings.json

"CosmosDbEndpoint": "<your-CosmosDb-URI>",
"CosmosDbAuthKey": "<your-primary-key>",
"CosmosDbDatabaseId": "<your-database-id>",
"CosmosDbContainerId": "bot-storage"

Ajoutez les informations suivantes à votre fichier .env.

.env

CosmosDbEndpoint="<your-CosmosDb-URI>"
CosmosDbAuthKey="<your-primary-key>"
CosmosDbDatabaseId="<your-database-id>"
CosmosDbContainerId="bot-storage"

Ajoutez les informations suivantes à votre fichier de configuration.

config.py

COSMOS_DB_URI="<your-CosmosDb-URI>"
COSMOS_DB_PRIMARY_KEY="your-primary-key"
COSMOS_DB_DATABASE_ID="<your-database-id>"
COSMOS_DB_CONTAINER_ID="bot-storage"

Installation de packages Cosmos DB

Veillez à disposer des packages nécessaires pour Cosmos DB.

Installez le package NuGet Microsoft.Bot.Builder.Azure. Pour plus d'informations sur l'utilisation de NuGet, consultez Installer et gérer des packages dans Visual Studio à l'aide du gestionnaire de packages NuGet.

Ajoutez une référence à botbuilder-azure à l'aide de npm.

npm install --save botbuilder-azure

S'il n'est pas encore installé, obtenez le package .NET à partir de npm afin d'accéder à vos paramètres de fichier .env.

npm install --save dotenv

Vous pouvez ajouter une référence à botbuilder-azure dans votre projet via pip.

pip install botbuilder-azure

Implémentation de Cosmos DB

Remarque

La version 4.6 a introduit un nouveau fournisseur de stockage Cosmos DB, la classe de stockage partitionné Cosmos DB, tandis que la classe de stockage Cosmos DB d’origine est dépréciée. Les conteneurs créés avec le stockage Cosmos DB peuvent être utilisés avec le stockage partitionné Cosmos DB. Pour plus d’informations, consultez Partitionnement dans Azure Cosmos DB.

Contrairement au stockage Cosmos DB hérité, le stockage partitionné Cosmos DB ne crée pas automatiquement une base de données dans votre compte Cosmos DB. Vous devez créer une base de données manuellement, mais ignorer manuellement la création d'un conteneur, car le CosmosDbPartitionedStorage crée le conteneur pour vous.

L'exemple de code suivant s'exécute en utilisant le même code de bot l'échantillon de stockage en mémoire fourni ci-dessus, avec les exceptions énumérées ici. Les extraits de code ci-dessous illustrent une implémentation de stockage Cosmos DB pour « myStorage » qui remplace le stockage mémoire local.

Vous devez d'abord mettre à jour Startup.cs pour référencer la bibliothèque du bot builder Azure :

using Microsoft.Bot.Builder.Azure;

Ensuite, dans la méthode ConfigureServices de Startup.cs, créez l'objet CosmosDbPartitionedStorage. Il sera transmis au constructeur EchoBot par le biais de l'injection de dépendance.

// Use partitioned CosmosDB for storage, instead of in-memory storage.
services.AddSingleton<IStorage>(
    new CosmosDbPartitionedStorage(
        new CosmosDbPartitionedStorageOptions
        {
            CosmosDbEndpoint = Configuration.GetValue<string>("CosmosDbEndpoint"),
            AuthKey = Configuration.GetValue<string>("CosmosDbAuthKey"),
            DatabaseId = Configuration.GetValue<string>("CosmosDbDatabaseId"),
            ContainerId = Configuration.GetValue<string>("CosmosDbContainerId"),
            CompatibilityMode = false,
        }));

Dans EchoBot.cs, changez la déclaration private static readonly MemoryStorage _myStorage = new MemoryStorage(); de variable _myStorage par la valeur suivante :

// variable used to save user input to CosmosDb Storage.
private readonly IStorage _myStorage;

Transmettez ensuite l'objet IStorage au constructeur EchoBot :

public EchoBot(IStorage storage)
{
    if (storage is null) throw new ArgumentNullException();
    _myStorage = storage;
}

Ajoutez tout d'abord du code à votre fichier index.js pour vous permettre d'accéder aux valeurs de votre fichier env que vous avez saisies au préalable :

// initialized to access values in .env file.
const ENV_FILE = path.join(__dirname, '.env');
require('dotenv').config({ path: ENV_FILE });

Vous devez ensuite modifier index.js pour utiliser le stockage partitionné Cosmos DB au lieu du stockage interne Bot Frameworks. Toutes les modifications de code de cette section sont apportées dans index.js.

Ajoutez tout d'abord une référence à botbuilder-azure dans index.js. Cela vous donnera accès à la classe CosmosDbPartitionedStorage.

const { CosmosDbPartitionedStorage } = require('botbuilder-azure');

Créez ensuite un nouvel objet CosmosDbPartitionedStorage.

const myStorage = new CosmosDbPartitionedStorage({
    cosmosDbEndpoint: process.env.CosmosDbEndpoint,
    authKey: process.env.CosmosDbAuthKey,
    databaseId: process.env.CosmosDbDatabaseId,
    containerId: process.env.CosmosDbContainerId,
    compatibilityMode: false
});

Vous pouvez maintenant commenter ou supprimer la déclaration const myStorage que vous avez ajoutée précédemment, car vous n'enregistrez plus d'entrée utilisateur dans le stockage interne Bot Frameworks, mais plutôt dans Cosmos DB :

//const myStorage = new MemoryStorage();
const myBot = new EchoBot(myStorage);

L'exemple de code suivant s'exécute en utilisant le même code de bot l'échantillon de stockage en mémoire fourni ci-dessus, avec les exceptions énumérées ici.

CosmosDbPartitionedStorage et CosmosDbPartitionedConfig de botbuilder-azure sont nécessaires pour créer l'objet CosmosDBStorage.

echo_bot.py

from botbuilder.azure import CosmosDbPartitionedStorage, CosmosDbPartitionedConfig

Pour accéder aux paramètres dans config.py, vous allez importer DefaultConfig comme indiqué ci-dessous :

from config import DefaultConfig
CONFIG = DefaultConfig()

Décommentez le stockage en mémoire dans __init__, et remplacez-le par une référence à Cosmos DB. Utilisez l'URI (point de terminaison), la clé primaire (clé d'autorisation), l'identifiant de la base de données et l'identifiant du conteneur utilisés ci-dessus.

Supprimez ou commentez ensuite le code du stockage de la mémoire dans __init__ et ajoutez une référence aux informations de Cosmos DB à partir de config.py.

L'extrait de code ci-dessous illustre une implémentation de stockage Cosmos DB pour « stockage » qui remplace le stockage de la mémoire local.

echo_bot.py

def __init__(self):
    cosmos_config = CosmosDbPartitionedConfig(
        cosmos_db_endpoint=CONFIG.COSMOS_DB_URI,
        auth_key=CONFIG.COSMOS_DB_PRIMARY_KEY,
        database_id=CONFIG.COSMOS_DB_DATABASE_ID,
        container_id=CONFIG.COSMOS_DB_CONTAINER_ID,
        compatibility_mode = False
    )
    self.storage = CosmosDbPartitionedStorage(cosmos_config)

Démarrez votre bot Cosmos DB

Exécutez votre bot en local.

Testez votre bot Cosmos DB à l'aide de Bot Framework Emulator

Démarrez maintenant le Bot Framework Emulator et connectez-vous à votre bot :

Sélectionnez le lien créer une nouvelle configuration de bot dans l'onglet Bienvenue de l'émulateur.
Renseignez les champs pour vous connecter à votre bot en utilisant les informations figurant dans la page web affichée lorsque vous avez démarré votre bot.

Interagissez avec votre bot Cosmos DB

Envoyez un message à votre bot, et le bot va répertorier les messages qu’il reçoit.

Conversation avec le bot qui montre au bot la conservation d’une liste de messages de l’utilisateur.

Afficher vos données Cosmos DB

Une fois que vous avez exécuté votre bot et enregistré vos informations, nous pouvons visualiser les données stockées dans le portail Azure, sous l'onglet Explorateur de données.

Capture d’écran de l’Explorateur de données dans le Portail Azure.

Utilisation du stockage Blob

Le stockage Blob Azure est la solution de stockage d’objet de Microsoft pour le cloud. Le stockage Blob est optimisé pour stocker de grandes quantités de données non structurées, telles que des données texte ou binaires. Cette section explique comment créer un compte et un conteneur de stockage blob Azure, puis comment référencer votre conteneur de stockage blob à partir de votre bot.

Pour plus d'informations sur le stockage Blob, consultez la section Qu'est-ce que le stockage Blob d'Azure ?

Créer votre compte de stockage Blob

Pour utiliser le stockage Blob dans votre bot, vous devez configurer certaines choses avant d’aborder le code.

Dans le portail Azure, sélectionnez Tous les services.
Dans la section Découverte de la page Tous les services, sélectionnez Comptes de stockage.
Dans la page Comptes de stockage, sélectionnez Nouveau.
Dans le champ Abonnement, sélectionnez l'abonnement dans lequel vous souhaitez créer le compte de stockage.
Dans le champ Groupe de ressources, sélectionnez un groupe de ressources existant ou choisissez Créer, puis entrez un nom pour le nouveau groupe de ressources.
Dans le champ Nom du compte de stockage, entrez un nom pour le compte. Respectez les recommandations suivantes :
- Le nom doit être unique dans tout Azure.
- Le nom doit compter entre 3 et 24 caractères.
- Le nom ne peut contenir que des chiffres et des lettres minuscules.
Dans le champ Emplacement, sélectionnez l'emplacement du compte de stockage, ou utilisez l'emplacement par défaut.
Pour les autres paramètres, configurez ce qui suit :
- Performances : standard. En savoir plus sur les performances.
- Type de compte : BlobStorage. En savoir plus sur les comptes de stockage.
- Réplication : conservez le paramètre par défaut. En savoir plus sur la redondance.
Dans la section Détails du projet de la page Créer un compte de stockage, sélectionnez les valeurs souhaitées pour l'abonnement et le groupe de ressources.
Dans la section Détails de l'instance de la page Créer un compte de stockage, saisissez le nom du compte stockage, puis sélectionnez des valeurs pour l'emplacement, le genre de compte et la réplication.
Cliquez sur Vérifier + Créer pour passer en revue les paramètres de votre compte de stockage.
Une fois la validation effectuée, sélectionnez Créer.

Créer un conteneur de stockage d’objets blob

Une fois votre compte de stockage Blob créé, ouvrez-le, puis :

Sélectionnez Explorateur de stockage (aperçu).
Faites ensuite un clic droit sur CONTENEURS BLOB
Sélectionnez Créer un conteneur blob dans la liste déroulante.
Saisissez un nom dans le formulaire Nouveau conteneur. Vous utiliserez ce nom comme valeur de votre « nom de conteneur blob » pour donner accès à votre compte de stockage Blob. Respectez les recommandations suivantes :
- Ce nom peut contenir uniquement des lettres minuscules, des chiffres et des traits d'union.
- Ce nom doit commencer par une lettre ou un chiffre
- Chaque trait d'union doit être précédé et suivi d'un caractère valide autre que le trait d'union.
- Le nom doit compter entre 3 et 63 caractères.

Ajoutez des informations de configuration de stockage Blob

Retrouvez les clés de stockage Blob dont vous avez besoin pour configurer le stockage Blob de votre bot, comme indiqué ci-dessus :

Dans le portail Azure, ouvrez votre compte de stockage Blob et sélectionnez Clés d'accès dans la section Paramètres.
Pour configurer votre bot afin d'accéder à votre compte de stockage Blob, utilisez Chaîne de connexion comme valeur pour la chaîne de connexion blob.

Ajoutez les informations suivantes à votre fichier de configuration.

appsettings.json

"BlobConnectionString": "<your-blob-connection-string>",
"BlobContainerName": "<your-blob-container-name>",

Ajoutez les informations suivantes à votre fichier .env.

.env

BlobConnectionString="<your-blob-connection-string>"
BlobContainerName="<your-blob-container-name>"

Ajoutez les informations suivantes à votre fichier de configuration. Utilisez le même nom du conteneur et chaîne de connexion utilisés lors de la création de votre conteneur de stockage blob.

config.py

BLOB_CONNECTION_STRING="<your-blob-connection-string>"
BLOB_CONTAINER_NAME="<your-blob-container-name>"

Installation de packages de stockage blob

Si ce n'est pas déjà fait, installez les packages suivants :

Installez le package NuGet Microsoft.Bot.Builder.Azure.Blobs. Pour plus d'informations sur l'utilisation de NuGet, consultez Installer et gérer des packages dans Visual Studio à l'aide du gestionnaire de packages NuGet.

Ajoutez des références à botbuilder-azure-blobs dans votre projet via npm.

Remarque

Ce package npm s'appuie sur une installation de Python qui existe sur votre machine de développement. Si vous n'avez pas encore installé Python, vous pouvez trouver des ressources d'installation pour votre ordinateur sur Python.org.

npm install --save botbuilder-azure-blobs

S'il n'est pas encore installé, obtenez le package .NET à partir de npm afin d'accéder à vos paramètres de fichier .env.

npm install --save dotenv

Vous pouvez ajouter une référence à botbuilder-azure dans votre projet via pip.

pip install botbuilder-azure

Implémentation du stockage Blob

Le stockage blob est utilisé pour stocker Bot State.

Remarque

À partir de la version 4.10, Microsoft.Bot.Builder.Azure.AzureBlobStorage est déconseillé. Utilisez le nouveau Microsoft.Bot.Builder.Azure.Blobs.BlobsStorage à sa place.

L'exemple de code suivant s'exécute en utilisant le même code de bot l'échantillon de stockage en mémoire fourni ci-dessus, avec les exceptions énumérées ici.

Les extraits de code ci-dessous illustrent une implémentation de stockage blob pour « myStorage » qui remplace le stockage mémoire local.

Vous devez d’abord mettre à jour Startup.cs pour référencer la bibliothèque d’objets blob Azure du générateur de bots :

Startup.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Créez ensuite l'ConfigureServicesobjet dans la méthode BlobsStorage de Startup.cs, en lui transférant les valeurs de appsettings.json. Il sera transmis au constructeur EchoBot par le biais de l'injection de dépendance.

//Use Azure Blob storage, instead of in-memory storage.
services.AddSingleton<IStorage>(
    new BlobsStorage(
        Configuration.GetValue<string>("BlobConnectionString"),
        Configuration.GetValue<string>("BlobContainerName")
        ));

Vous devez d'abord mettre à jour EchoBot.cs pour référencer la bibliothèque Azure blobs de bot builder :

EchoBot.cs

using Microsoft.Bot.Builder.Azure.Blobs;

Supprimez ou commentez ensuite la ligne de code qui crée la variable MemoryStorage « private static readonly MemoryStorage _myStorage = new MemoryStorage(); » et créez une variable qui sera utilisée pour enregistrer l'entrée utilisateur dans le Stockage blob.

EchoBot.cs

// variable used to save user input to CosmosDb Storage.
private readonly IStorage _myStorage;

Transmettez ensuite l'objet IStorage au constructeur EchoBot :

public EchoBot(IStorage storage)
{
    if (storage is null) throw new ArgumentNullException();
    _myStorage = storage;
}

Une fois que votre stockage est défini pour pointer sur votre compte de stockage blob, le code de votre bot va maintenant stocker et récupérer des données depuis le stockage blob.

Toutes les modifications de code de cette section sont apportées dans index.js.

Ajoutez tout d'abord du code pour vous permettre d'accéder aux valeurs de votre fichier .env que vous avez saisies au préalable :

// initialized to access values in .env file.
const ENV_FILE = path.join(__dirname, '.env');
require('dotenv').config({ path: ENV_FILE });

Vous devez ensuite apporter des modifications à l'aide du stockage blob au lieu du stockage interne Bot Frameworks.

Ajoutez ensuite une référence à botbuilder-azure-blobs. Cela vous donne accès à l'API Stockage blob :

const { BlobsStorage } = require("botbuilder-azure-blobs");

Pour modifier votre code afin d'utiliser la classe BlobsStorage, changez votre déclaration myStorage comme suit :

const myStorage = new BlobsStorage(
    process.env.BlobConnectionString,
    process.env.BlobContainerName
);

Une fois que votre stockage est défini pour pointer sur votre compte de stockage blob, le code de votre bot va maintenant stocker et récupérer des données depuis le stockage blob.

L'exemple de code suivant s'exécute en utilisant le même code de bot l'échantillon de stockage en mémoire fourni ci-dessus, avec les exceptions énumérées ici.

Cela nécessite BlobStorage et BlobStorageSettings de botbuilder-azure.

echo_bot.py

from botbuilder.azure import BlobStorage, BlobStorageSettings

Pour accéder aux paramètres dans config.py, vous allez importer DefaultConfig comme indiqué ci-dessous :

from config import DefaultConfig
CONFIG = DefaultConfig()

Supprimez ou commentez ensuite le code du stockage mémoire dans __init__ et ajoutez une référence à vos informations de stockage d'objets blob à partir de config.py.

L'extrait de code ci-dessous illustre une implémentation de stockage d'objets blob qui remplace le stockage mémoire local.

echo_bot.py

def __init__(self):
    blob_settings = BlobStorageSettings(
        connection_string=CONFIG.BLOB_CONNECTION_STRING,
        container_name=CONFIG.BLOB_CONTAINER_NAME
    )
    self.storage = BlobStorage(blob_settings)

Une fois que votre stockage est défini pour pointer sur votre compte de stockage blob, le code de votre bot va maintenant stocker et récupérer des données depuis le stockage blob.

Démarrez votre bot de stockage d'objets blob

Exécutez votre bot en local.

Démarrez l'émulateur et connecte-vous à votre bot de stockage blob

Démarrez à présent l'émulateur, puis connectez-vous à votre bot dans l'émulateur :

Sélectionnez le lien Créer une nouvelle configuration de bot dans l'onglet « Bienvenue » de l'émulateur.
Renseignez les champs pour vous connecter à votre bot en utilisant les informations figurant dans la page web affichée lorsque vous avez démarré votre bot.

Interagissez avec votre bot de stockage blob

Envoyez un message à votre bot, suite à quoi le bot listera les messages qu’il reçoit.

Conversation avec le bot qui montre au bot la conservation d’une liste de messages de l’utilisateur.

Affichez vos données de stockage blob

Une fois que vous avez exécuté votre bot et enregistré vos informations, nous pouvons les afficher sous l'onglet Explorateur de stockage du Portail Azure.

Stockage de transcriptions d’objets blob

Le stockage de transcriptions d’objets blob Azure fournit une option de stockage spécialisée qui vous permet d’enregistrer et de récupérer facilement des conversations d’utilisateur sous la forme d’une transcription enregistrée. Le stockage de transcriptions d'objets blob Azure est utile pour capturer automatiquement les entrées utilisateur à examiner lors du débogage des performances de votre bot.

Remarque

Python ne prend actuellement pas en charge le stockage de transcriptions d'objets blob Azure. Même si JavaScript prend en charge le stockage de transcriptions d'objets blob, les instructions suivantes concernent uniquement C#.

Configurez un conteneur de stockage de transcription d'objets blob

Le stockage de transcriptions d’objets blob Azure peut utiliser le même compte de stockage Blob créé en suivant les étapes détaillées dans les sections « Créer votre compte de stockage Blob » et « Ajouter des informations de configuration ». Un conteneur est maintenant ajouté pour stocker vos transcriptions.

Capture d’écran de la création d’un conteneur d’objets blob à utiliser comme magasin de transcriptions.

Ouvrez votre compte de stockage d’objets blob Azure.
Sélectionnez Explorateur de stockage.
Cliquez avec le bouton droit sur BLOB CONTAINERS et sélectionnez Créer un conteneur d’objets blob.
Saisissez un nom pour votre conteneur de transcriptions, puis sélectionnez OK. (Nous avons saisi mybottranscripts.)

Implémentation du stockage de transcription d'objets blob

Le code suivant connecte le pointeur de stockage de transcriptions _myTranscripts à votre nouveau compte de stockage de transcriptions d’objets blob Azure. Pour créer ce lien avec un nouveau nom du conteneur, <votre-nom-de-conteneur-de-transcription-blob>, il crée un nouveau conteneur dans le stockage Blob pour contenir vos fichiers de transcription.

Le stockage de transcriptions blob est conçu pour stocker les transcriptions de bot.

Remarque

À partir de la version 4.10, Microsoft.Bot.Builder.Azure.AzureBlobTranscriptStore est déconseillé. Utilisez le nouveau Microsoft.Bot.Builder.Azure.Blobs.BlobsTranscriptStore à sa place.

echoBot.cs

using Microsoft.Bot.Builder.Azure.Blobs;

public class EchoBot : ActivityHandler
{
   ...

   private readonly BlobsTranscriptStore _myTranscripts = new BlobsTranscriptStore("<your-azure-storage-connection-string>", "<your-blob-transcript-container-name>");

   ...
}

Stockez les conversations utilisateur dans les transcriptions d'objets blob Azure

Une fois qu'un conteneur d'objets blob est disponible pour stocker les transcriptions, vous pouvez commencer à conserver les conversations de vos utilisateurs avec votre bot. Ces conversations peuvent être utilisées plus tard en tant qu’outil de débogage pour observer la façon dont les utilisateurs interagissent avec votre bot. Chaque émulateur Redémarrer la conversation lance la création d'une nouvelle liste de conversation de transcription. Le code suivant conserve les entrées de conversation utilisateur dans un fichier de transcription stocké.

La transcription actuelle est enregistrée à l’aide de LogActivityAsync.
Les transcriptions enregistrées sont récupérées à l’aide de ListTranscriptsAsync. Dans cet exemple de code, l'identifiant de chaque transcription stockée est enregistré dans une liste nommée « storedTranscripts ». Cette liste est utilisée ultérieurement pour gérer le nombre de transcriptions d’objet blob stockées que nous conservons.

echoBot.cs


protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    await _myTranscripts.LogActivityAsync(turnContext.Activity);

    List<string> storedTranscripts = new List<string>();
    PagedResult<Microsoft.Bot.Builder.TranscriptInfo> pagedResult = null;
    var pageSize = 0;
    do
    {
       pagedResult = await _myTranscripts.ListTranscriptsAsync("emulator", pagedResult?.ContinuationToken);
       pageSize = pagedResult.Items.Count();

       // transcript item contains ChannelId, Created, Id.
       // save the channelIds found by "ListTranscriptsAsync" to a local list.
       foreach (var item in pagedResult.Items)
       {
          storedTranscripts.Add(item.Id);
       }
    } while (pagedResult.ContinuationToken != null);

    ...
}

Gérer les transcriptions d’objet blob stockées

Les transcriptions stockées peuvent être utilisées comme outil de débogage, mais, au fil du temps, le nombre de transcriptions stockées peut dépasser le nombre que vous voulez conserver. Le code supplémentaire inclus ci-dessous utilise DeleteTranscriptAsync pour supprimer tous les éléments de transcription récupérés de votre magasin de transcriptions d’objet blob, sauf les trois derniers.

echoBot.cs


protected override async Task OnMessageActivityAsync(ITurnContext<IMessageActivity> turnContext, CancellationToken cancellationToken)
{
    await _myTranscripts.LogActivityAsync(turnContext.Activity);

    List<string> storedTranscripts = new List<string>();
    PagedResult<Microsoft.Bot.Builder.TranscriptInfo> pagedResult = null;
    var pageSize = 0;
    do
    {
       pagedResult = await _myTranscripts.ListTranscriptsAsync("emulator", pagedResult?.ContinuationToken);
       pageSize = pagedResult.Items.Count();

       // transcript item contains ChannelId, Created, Id.
       // save the channelIds found by "ListTranscriptsAsync" to a local list.
       foreach (var item in pagedResult.Items)
       {
          storedTranscripts.Add(item.Id);
       }
    } while (pagedResult.ContinuationToken != null);

    // Manage the size of your transcript storage.
    for (int i = 0; i < pageSize; i++)
    {
       // Remove older stored transcripts, save just the last three.
       if (i < pageSize - 3)
       {
          string thisTranscriptId = storedTranscripts[i];
          try
          {
             await _myTranscripts.DeleteTranscriptAsync("emulator", thisTranscriptId);
           }
           catch (System.Exception ex)
           {
              await turnContext.SendActivityAsync("Debug Out: DeleteTranscriptAsync had a problem!");
              await turnContext.SendActivityAsync("exception: " + ex.Message);
           }
       }
    }
    ...
}

Pour plus d'informations sur la classe, consultez le stockage de transcription d'objets blob Azure.

Informations supplémentaires

Gérer la concurrence à l’aide des étiquettes d’entité

Dans notre exemple de code de bot, nous définissons la propriété eTag de chaque IStoreItem sur *. L’élément eTag (étiquette d’entité) de votre objet de stockage est utilisé au sein de Cosmos DB pour gérer la concurrence. L’élément eTag indique à votre base de données ce qu’il faut faire si une autre instance du bot modifie l’objet de stockage sur lequel votre bot écrit.

La dernière écriture prévaut : autorise les remplacements

Une valeur de propriété eTag de l’astérisque (*) indique que celui qui prévaut est le dernier qui écrit. Lors de la création d'une nouvelle banque de données, vous pouvez définir eTag une propriété * pour indiquer que vous n'avez pas enregistré précédemment les données que vous écrivez, ou que vous souhaitez que le dernier auteur remplace toute propriété déjà enregistrée. Si la concurrence ne constitue pas un problème pour votre bot, le remplacement est autorisé si vous définissez la propriété eTag sur * pour toutes les données que vous écrivez.

Gérer la concurrence et empêcher les remplacements

Lorsque vous stockez vos données dans Cosmos DB, utilisez une valeur autre que * pour l’élément eTag si vous souhaitez empêcher l’accès simultané à une propriété et éviter de remplacer les modifications apportées par une autre instance du bot. Le bot reçoit une réponse d'erreur avec le message etag conflict key= quand il tente d'enregistrer des données d'état et que la valeur de l'élément eTag est différente de celle de l'élément qui se trouve dans le stockage eTag.

Par défaut, le magasin Cosmos DB vérifie que la propriété eTag d’un objet de stockage reste la même chaque fois qu’un bot écrit dessus, puis la met à jour avec une nouvelle valeur unique après chaque écriture. Si la propriété eTag d’écriture ne correspond pas à la propriété eTag de stockage, un autre robot ou thread a donc modifié les données.

Par exemple, si vous souhaitez que votre robot modifie une note enregistrée, mais que vous ne voulez pas qu’il remplace les modifications apportées par une autre instance du robot. Si une autre instance du robot a apporté des modifications, vous souhaitez que l’utilisateur modifie la version avec les dernières mises à jour.

Commencez par créer une classe qui implémente IStoreItem.

EchoBot.cs

public class Note : IStoreItem
{
    public string Name { get; set; }
    public string Contents { get; set; }
    public string ETag { get; set; }
}

Créez ensuite une première note avec un nouvel objet de stockage que vous a ajoutez à la banque.

EchoBot.cs

// create a note for the first time, with a non-null, non-* ETag.
var note = new Note { Name = "Shopping List", Contents = "eggs", ETag = "x" };

var changes = Dictionary<string, object>();
{
    changes.Add("Note", note);
};
await NoteStore.WriteAsync(changes, cancellationToken);

Accédez à la note et actualisez-la ultérieurement, en gardant le eTag que vous lisez dans la banque.

EchoBot.cs

var note = NoteStore.ReadAsync<Note>("Note").Result?.FirstOrDefault().Value;

if (note != null)
{
    note.Contents += ", bread";
    var changes = new Dictionary<string, object>();
    {
         changes.Add("Note1", note);
    };
    await NoteStore.WriteAsync(changes, cancellationToken);
}

Si la note a été actualisée dans la banque avant que vous n’écriviez vos modifications, l’appel à Write lance une exception.

Ajoutez une fonction d’assistance à la fin de votre bot, qui écrira une note de l’exemple dans un magasin de données. Commencez par créer l’objet myNoteData.

bot.js

// Helper function for writing a sample note to a data store
async function createSampleNote(storage, context) {
    var myNoteData = {
        name: "Shopping List",
        contents: "eggs",
        // If any Note file is already stored, the eTag field
        // must be set to "*" in order to allow writing without first reading the stored eTag
        // otherwise you'll likely get an exception indicating an eTag conflict.
        eTag: "*"
    }
}

Dans la createSampleNotefonction d'aide, initialisez un changes objet et ajoutez-y vos notes, puis écrivez-le dans le stockage.

bot.js

// Write the note data to the "Note" key
var changes = {};
changes["Note"] = myNoteData;
// Creates a file named Note, if it doesn't already exist.
// specifying eTag= "*" will overwrite any existing contents.
// The act of writing to the file automatically updates the eTag property
// The first time you write to Note, the eTag is changed from *, and file contents will become:
//    {"name":"Shopping List","contents":"eggs","eTag":"1"}
try {
     await storage.write(changes);
     var list = changes["Note"].contents;
     await context.sendActivity(`Successful created a note: ${list}`);
} catch (err) {
     await context.sendActivity(`Could not create note: ${err}`);
}

La fonction d’assistance est accessible à partir de la logique de votre bot en ajoutant l’appel suivant :

bot.js

// Save a note with etag.
await createSampleNote(storage, turnContext);

Une fois la note créée, pour l’extraire et la mettre à jour ultérieurement, nous créons une autre fonction d’assistance accessible quand l’utilisateur tape « update note » (mettre à jour la note).

bot.js

async function updateSampleNote(storage, context) {
    try {
        // Read in a note
        var note = await storage.read(["Note"]);
        console.log(`note.eTag=${note["Note"].eTag}\n note=${JSON.stringify(note)}`);
        // update the note that we just read
        note["Note"].contents += ", bread";
        console.log(`Updated note=${JSON.stringify(note)}`);

        try {
             await storage.write(note); // Write the changes back to storage
             var list = note["Note"].contents;
             await context.sendActivity(`Successfully updated note: ${list}`);
        } catch (err) {
             console.log(`Write failed: ${err}`);
        }
    }
    catch (err) {
        await context.sendActivity(`Unable to read the Note: ${err}`);
    }
}

Cette fonction d’assistance est accessible à partir de la logique de votre bot en ajoutant l’appel suivant :

bot.js

// Update a note with etag.
await updateSampleNote(storage, turnContext);

Si la note est mise à jour dans le magasin par un autre utilisateur avant que vous tentiez de mettre à jour vos modifications, la valeur eTag ne correspondra plus et l’appel à write lèvera une exception.

Commencez par créer une classe qui implémente StoreItem.

echo_bot.py

class Note(StoreItem):
    def __init__(self, name: str, contents: str, e_tag="*"):
        super(Note, self).__init__()
        self.name = name
        self.contents = contents
        self.e_tag = e_tag

Créez ensuite une première note avec un nouvel objet de stockage que vous a ajoutez à la banque.

echo_bot.py

# create a note for the first time, with a non-null, non-* ETag.
changes = {"Note": Note(name="Shopping List", contents="eggs", e_tag="x")}

await self.storage.write(changes)

Accédez à la note et actualisez-la ultérieurement, en gardant le eTag que vous lisez dans la banque.

echo_bot.py

store_items = await self.storage.read(["Note"])
    note = store_items["Note"]
    note.contents = note.contents + ", bread"

    changes = {"Note": note}
    await self.storage.write(changes)

Si la note a été actualisée dans la banque avant que vous n’écriviez vos modifications, l’appel à write lance une exception.

Pour gérer la concurrence, lisez toujours une propriété à partir du stockage, puis modifiez la propriété que vous lisez afin de conserver eTag. Si vous lisez les données de l’utilisateur dans la banque, la réponse contient la propriété de l’étiquette d’entité. Si vous modifiez les données et que vous enregistrez les nouvelles données dans la banque, votre requête doit inclure la propriété de l’étiquette d’entité qui indique la même valeur que celle que vous avez lue précédemment. Lorsque l’élément eTag d’un objet est défini à *, il est toutefois possible de l’enregistrer en remplaçant les autres modifications.

Étapes suivantes

Maintenant que vous savez comment lire et écrire directement à partir du stockage, voyons comment vous pouvez utiliser le gestionnaire d'état pour le faire à votre place.

Enregistrer l’état à l’aide des propriétés de la conversation et de l’utilisateur

Partager via

Écrire directement dans le stockage

Prérequis

À propos de cet exemple

Stockage mémoire

Créer un bot de base

Démarrer votre robot

Démarrer l’émulateur et connecter votre robot

Interagir avec votre bot

Utilisation de Cosmos DB

Configurez une ressource Cosmos DB

Créer un compte de base de données

Ajouter une base de données

Ajouter des informations de configuration Cosmos DB

Installation de packages Cosmos DB

Implémentation de Cosmos DB

Démarrez votre bot Cosmos DB

Testez votre bot Cosmos DB à l'aide de Bot Framework Emulator

Interagissez avec votre bot Cosmos DB

Afficher vos données Cosmos DB

Utilisation du stockage Blob

Créer votre compte de stockage Blob

Créer un conteneur de stockage d’objets blob

Ajoutez des informations de configuration de stockage Blob

Installation de packages de stockage blob

Implémentation du stockage Blob

Démarrez votre bot de stockage d'objets blob

Démarrez l'émulateur et connecte-vous à votre bot de stockage blob

Interagissez avec votre bot de stockage blob

Affichez vos données de stockage blob

Stockage de transcriptions d’objets blob

Configurez un conteneur de stockage de transcription d'objets blob

Implémentation du stockage de transcription d'objets blob

Stockez les conversations utilisateur dans les transcriptions d'objets blob Azure

Gérer les transcriptions d’objet blob stockées

Informations supplémentaires

Gérer la concurrence à l’aide des étiquettes d’entité

La dernière écriture prévaut : autorise les remplacements

Gérer la concurrence et empêcher les remplacements

Étapes suivantes

Ressources supplémentaires