Tutoriel : Démarrage avec les déclencheurs et les liaisons Azure Functions dans Azure Cache pour Redis

Ce didacticiel montre comment implémenter des déclencheurs de base avec Azure Cache pour Redis et Azure Functions. Il vous guide tout au long de l'utilisation de Visual Studio Code (VS Code) pour écrire et déployer une fonction Azure en C#.

Dans ce tutoriel, vous allez apprendre à :

Prérequis

• Un abonnement Azure. Si vous n’avez pas d’abonnement Azure, créez un compte gratuit.
• Visual Studio Code.

Configurer une instance Azure Cache pour Redis

Créez une nouvelle instance Azure Cache pour Redis à l'aide du Portail Microsoft Azure ou de votre outil CLI préféré. Ce didacticiel utilise une instance C1 Standard, ce qui constitue un bon point de départ. Utilisez le guide de démarrage rapide pour commencer.

Les paramètres par défaut doivent suffire. Ce didacticiel utilise un point de terminaison public pour la démonstration, mais nous vous recommandons d'utiliser un point de terminaison privé pour tout ce qui est en production.

La création du cache peut prendre quelques minutes. Vous pouvez passer à la section suivante pendant que le processus se termine.

Configurer Visual Studio Code

1. Si vous n'avez pas installé l'extension Azure Functions pour VS Code, recherchez Azure Functions dans le menu EXTENSIONS, puis sélectionnez Installer. Si vous n'avez pas installé l'extension C#, installez-la également.

   

2. Accédez à l'onglet Azure. Connectez-vous à votre compte Azure.

3. Créez un dossier local sur votre ordinateur pour y stocker le projet que vous générez. Ce didacticiel utilise RedisAzureFunctionDemo comme exemple.

4. Dans l'onglet Azure, créez une nouvelle application de fonction en sélectionnant l'icône représentant un éclair dans le coin supérieur droit de l'onglet Espace de travail.

5. Sélectionnez Créer une fonction....

   

6. Sélectionnez le dossier que vous avez créé pour démarrer la création d'un nouveau projet Azure Functions. Vous obtenez plusieurs invites à l’écran. Sélectionnez :

   • C# comme langage.
   • .NET 8.0 Isolé LTS comme runtime .NET.
   • Ignorer pour le moment en tant que modèle de projet.

   Si vous n'avez pas installé le SDK .NET Core, vous êtes invité à le faire.

   Important

   Pour les fonctions .NET, il est recommandé d’utiliser le modèle de Worker isolé plutôt que le modèle in-process. Pour une comparaison des modèles in-process et du travailleur isolé, consultez les Différences entre le modèle de Worker isolé et le modèle in-process pour .NET sur Azure Functions. Cet échantillon utilise le modèle de Worker isolé.

7. Vérifiez que le nouveau projet apparaît dans le volet EXPLORER.

   

Installer le package NuGet nécessaire

Vous devez installer Microsoft.Azure.Functions.Worker.Extensions.Redis, le package NuGet pour l’extension Redis qui permet aux notifications d’espace de clés Redis d’être utilisées comme déclencheurs dans Azure Functions.

Installez ce package en accédant à l’onglet Terminal dans VS Code et en entrant la commande suivante :

dotnet add package Microsoft.Azure.Functions.Worker.Extensions.Redis --prerelease

Configuration du cache

1. Accédez à votre instance Azure Cache pour Redis nouvellement créée.

2. Accédez à votre cache dans le Portail Microsoft Azure, puis :

   1. Dans le menu des ressources, sélectionnez Paramètres avancés.

   2. Faites défiler jusqu'à la zone notify-keyspace-events et entrez KEA.

      KEA est une chaîne de configuration qui active les notifications d'espace de clés pour toutes les clés et tous les événements. Pour plus d'informations sur les chaînes de configuration d'espace de clés, consultez la documentation Redis.

   3. Sélectionnez Enregistrer en haut de la fenêtre.

   

3. Recherchez Clés d’accès dans le menu Ressource, puis notez ou copiez le contenu de la case Chaîne de connexion principale. Cette chaîne est utilisée pour se connecter au cache.

   

Configurer l’exemple de code pour les déclencheurs Redis

1. Dans VS Code, ajoutez un fichier appelé Common.cs au projet. Cette classe est utilisée pour permettre l’analyse de la réponse sérialisée JSON pour PubSubTrigger.

2. Copiez et collez le code suivant dans le fichier Common.cs :

   public class Common
   {
       public const string connectionString = "redisConnectionString";
   
       public class ChannelMessage
       {
           public string SubscriptionChannel { get; set; }
           public string Channel { get; set; }
           public string Message { get; set; }
       }
   }
   

3. Ajoutez un fichier appelé RedisTriggers.cs au projet.

4. Copiez et collez l'exemple de code suivant dans le nouveau fichier :

   using Microsoft.Extensions.Logging;
   using Microsoft.Azure.Functions.Worker;
   using Microsoft.Azure.Functions.Worker.Extensions.Redis;
   
   public class RedisTriggers
   {
       private readonly ILogger<RedisTriggers> logger;
   
       public RedisTriggers(ILogger<RedisTriggers> logger)
       {
           this.logger = logger;
       }
   
       // PubSubTrigger function listens to messages from the 'pubsubTest' channel.
       [Function("PubSubTrigger")]
       public void PubSub(
       [RedisPubSubTrigger(Common.connectionString, "pubsubTest")] Common.ChannelMessage channelMessage)
       {
       logger.LogInformation($"Function triggered on pub/sub message '{channelMessage.Message}' from channel '{channelMessage.Channel}'.");
       }
   
       // KeyeventTrigger function listens to key events from the 'del' operation.
       [Function("KeyeventTrigger")]
       public void Keyevent(
           [RedisPubSubTrigger(Common.connectionString, "__keyevent@0__:del")] Common.ChannelMessage channelMessage)
       {
           logger.LogInformation($"Key '{channelMessage.Message}' deleted.");
       }
   
       // KeyspaceTrigger function listens to key events on the 'keyspaceTest' key.
       [Function("KeyspaceTrigger")]
       public void Keyspace(
           [RedisPubSubTrigger(Common.connectionString, "__keyspace@0__:keyspaceTest")] Common.ChannelMessage channelMessage)
       {
           logger.LogInformation($"Key 'keyspaceTest' was updated with operation '{channelMessage.Message}'");
       }
   
       // ListTrigger function listens to changes to the 'listTest' list.
       [Function("ListTrigger")]
       public void List(
           [RedisListTrigger(Common.connectionString, "listTest")] string response)
       {
           logger.LogInformation(response);
       }
   
       // StreamTrigger function listens to changes to the 'streamTest' stream.
       [Function("StreamTrigger")]
       public void Stream(
           [RedisStreamTrigger(Common.connectionString, "streamTest")] string response)
       {
           logger.LogInformation(response);
       }
   }
   

5. Ce tutoriel montre plusieurs façons de se déclencher sur l'activité Redis :

   • PubSubTrigger, qui se déclenche lorsqu'une activité est publiée sur le canal Pub/Sub nommé pubsubTest.
   • KeyspaceTrigger, qui est basé sur le déclencheur Pub/Sub. Utilisez-le pour rechercher les modifications apportées à la clé keyspaceTest.
   • KeyeventTrigger, qui est également basé sur le déclencheur Pub/Sub. Utilisez-le pour rechercher toute utilisation de la commande DEL.
   • ListTrigger, qui recherche les modifications apportées à la liste listTest.
   • StreamTrigger, qui recherche les modifications apportées au flux streamTest.

Vous connecter à votre cache

1. Pour déclencher l'activité Redis, vous devez transmettre la chaîne de connexion de votre instance de cache. Ces informations sont stockées dans le fichier local.settings.json qui a été automatiquement créé dans votre dossier. Nous vous recommandons d'utiliser le fichier de paramètres locaux comme meilleure pratique de sécurité.

2. Pour vous connecter à votre cache, ajoutez une section ConnectionStrings dans le fichier local.settings.json, puis ajoutez votre chaîne de connexion à l'aide du paramètre redisConnectionString. La section devrait ressembler à cet exemple :

   {
     "IsEncrypted": false,
     "Values": {
       "AzureWebJobsStorage": "",
       "FUNCTIONS_WORKER_RUNTIME": "dotnet-isolated",
       "redisConnectionString": "<your-connection-string>"
     }
   }
   

   Le code de Common.cs recherche cette valeur lorsqu’il est exécuté localement :

   public const string connectionString = "redisConnectionString";
   

Générer et exécuter le code localement

1. Basculez vers l’onglet Exécuter et déboguer dans VS Code et sélectionnez la flèche verte pour déboguer le code localement. Si vous n'avez pas installé les outils principaux d'Azure Functions, vous êtes invité à le faire. Dans ce cas, vous devrez redémarrer VS Code après l'installation.

2. Le code devrait être généré avec succès. Vous pouvez suivre sa progression dans la sortie du terminal.

3. Pour tester la fonctionnalité de déclencheur, essayez de créer et de supprimer la clé keyspaceTest.

   Vous pouvez utiliser la méthode de votre choix pour vous connecter au cache. Un moyen simple consiste à utiliser l'outil de console intégré dans le portail Azure Cache pour Redis. Accédez à l'instance de cache dans le Portail Microsoft Azure, puis sélectionnez Console pour l'ouvrir.

   

   Une fois la console ouverte, essayez les commandes suivantes :

   • SET keyspaceTest 1
   • SET keyspaceTest 2
   • DEL keyspaceTest
   • PUBLISH pubsubTest testMessage
   • LPUSH listTest test
   • XADD streamTest * name Clippy

   

4. Confirmez que les déclencheurs sont activés dans le terminal.

   

Ajouter des liaisons Redis

Les liaisons ajoutent un moyen simplifié de lire ou d’écrire des données stockées sur votre instance Redis. Pour illustrer l’avantage des liaisons, nous ajoutons deux autres fonctions. L’une est appelée SetGetter. Elle se déclenche chaque fois qu’une clé est définie et renvoie la nouvelle valeur de la clé à l’aide d’une liaison d’entrée. L’autre se nomme StreamSetter. Elle se déclenche lorsqu’un nouvel élément est ajouté au flux myStream et utilise une liaison de sortie pour écrire la valeur true dans la clé newStreamEntry.

1. Ajoutez un fichier appelé RedisBindings.cs au projet.

2. Copiez et collez l'exemple de code suivant dans le nouveau fichier :

   using Microsoft.Extensions.Logging;
   using Microsoft.Azure.Functions.Worker;
   using Microsoft.Azure.Functions.Worker.Extensions.Redis;
   
   public class RedisBindings
   {
       private readonly ILogger<RedisBindings> logger;
   
       public RedisBindings(ILogger<RedisBindings> logger)
       {
           this.logger = logger;
       }
   
       //This example uses the PubSub trigger to listen to key events on the 'set' operation. A Redis Input binding is used to get the value of the key being set.
       [Function("SetGetter")]
       public void SetGetter(
           [RedisPubSubTrigger(Common.connectionString, "__keyevent@0__:set")] Common.ChannelMessage channelMessage,
           [RedisInput(Common.connectionString, "GET {Message}")] string value)
       {
           logger.LogInformation($"Key '{channelMessage.Message}' was set to value '{value}'");
       }
   
       //This example uses the PubSub trigger to listen to key events to the key 'key1'. When key1 is modified, a Redis Output binding is used to set the value of the 'key1modified' key to 'true'.
       [Function("SetSetter")]
       [RedisOutput(Common.connectionString, "SET")]
       public string SetSetter(
           [RedisPubSubTrigger(Common.connectionString, "__keyspace@0__:key1")] Common.ChannelMessage channelMessage)
       {
           logger.LogInformation($"Key '{channelMessage.Message}' was updated. Setting the value of 'key1modified' to 'true'");
           return $"key1modified true";
       }
   }
   

3. Basculez vers l’onglet Exécuter et déboguer dans VS Code et sélectionnez la flèche verte pour déboguer le code localement. Le code devrait être généré avec succès. Vous pouvez suivre sa progression dans la sortie du terminal.

4. Pour tester la fonctionnalité de liaison d’entrée, essayez de définir une nouvelle valeur pour n’importe quelle clé, par exemple à l’aide de la commande SET hello world. Vous devez voir que la fonction SetGetter déclenche et renvoie la valeur mise à jour.

5. Pour tester la fonctionnalité de liaison de sortie, essayez d’ajouter un nouvel élément au flux myStream à l’aide de la commande XADD myStream * item Order1. Notez que la fonction StreamSetter s’est déclenché lors de l’entrée du nouveau flux et définissez la valeur true sur une autre clé appelée newStreamEntry. Cette commande set déclenche également la fonction SetGetter.

Déployer du code sur une fonction Azure

1. Créez une nouvelle fonction Azure :

   1. Revenez à l'onglet Azure et développez votre abonnement.

   2. Cliquez avec le bouton droit sur Function App, puis sélectionnez Créer une Function App dans Azure (Advanced).

   

2. Vous obtenez plusieurs invites d'informations pour configurer la nouvelle application de fonction :

   • Entrez un nom unique.
   • Sélectionnez .NET 8 isolé comme pile d’exécution.
   • Sélectionnez Linux ou Windows (l'un ou l'autre fonctionne).
   • Sélectionnez un groupe de ressources existant ou nouveau pour contenir l'application de fonction.
   • Sélectionnez la même région que votre instance de cache.
   • Sélectionnez Premium comme plan d'hébergement.
   • Créez un nouveau plan Azure App Service.
   • Sélectionnez le niveau tarifaire EP1.
   • Sélectionnez un compte de stockage existant ou créez-en un.
   • Créez une ressource Application Insights. Vous utilisez la ressource pour confirmer que le déclencheur fonctionne.

   Important

   Les déclencheurs Redis ne sont actuellement pas pris en charge sur les fonctions de consommation.

3. Attendez quelques minutes que la nouvelle application de fonction soit créée. Il apparaît sous Function App dans votre abonnement. Cliquez avec le bouton droit sur la nouvelle Function App, puis sélectionnez Deploy to Function App.

   

4. L’application se génère et démarre le déploiement. Vous pouvez suivre sa progression dans la fenêtre de sortie.

Ajouter des informations de chaîne de connexion

1. Dans le portail Azure, accédez à votre nouvelle application de fonction et sélectionnez Variables d’environnement dans le menu de ressources.

2. Dans le volet de travail, accédez aux Paramètres de l’application.

3. Pour Nom, entrez redisConnectionString.

4. Pour Value, entrez votre chaîne de connexion.

5. Sélectionnez Appliquer sur la page pour confirmer.

6. Accédez au volet Vue d’ensemble et sélectionnez Redémarrer pour redémarrer l’application de fonction avec les informations de chaîne de connexion.

Tester vos déclencheurs et liaisons

1. Une fois le déploiement terminé et les informations de chaîne de connexion ajoutées, ouvrez votre application de fonction dans le Portail Microsoft Azure. Sélectionnez ensuite Log Stream dans le menu des ressources.

2. Attendez que Log Analytics se connecte, puis utilisez la console Redis pour activer l'un des déclencheurs. Confirmez que les déclencheurs sont enregistrés ici.

   

Nettoyer les ressources

Si vous souhaitez continuer à utiliser les ressources que vous avez créées dans cet article, conservez le groupe de ressources.

Sinon, pour éviter les frais liées aux ressources, si vous en avez terminé avec les ressources, vous pouvez supprimer le groupe de ressources Azure que vous avez créé.

Supprimer un groupe de ressources

1. Connectez-vous au Portail Azure, puis sélectionnez Groupes de ressources.

2. Sélectionnez le groupe de ressources à supprimer.

   S’il existe de nombreux groupes de ressources, dans Filtrer pour n’importe quel champ, entrez le nom du groupe de ressources que vous avez créé pour effectuer les étapes de cet article. Dans la liste des résultats de recherche, sélectionnez le groupe de ressources.

   

3. Sélectionnez Supprimer le groupe de ressources.

4. Dans le volet Supprimer un groupe de ressources, entrez le nom de votre groupe de ressources pour confirmer, puis sélectionnez Supprimer.

   

Après quelques instants, le groupe de ressources et toutes ses ressources sont supprimés.

Contenu connexe

• Vue d’ensemble des fonctions Azure pour Azure Cache pour Redis
• Créer un cache d’écriture différée à l’aide d’Azure Functions