Partager via

Guide de démarrage rapide : utiliser Azure Redis dans Node.js

  • S’applique à: ✅ Azure Cache for Redis, ✅ Azure Managed Redis

Dans ce guide de démarrage rapide, vous incorporez Azure Managed Redis ou Azure Cache pour Redis dans une application Node.js. L’application a accès à un cache sécurisé et dédié accessible à partir de n’importe quelle application dans Azure.

Conditions préalables

Créer une instance Azure Managed Redis

  1. Pour créer une instance Redis managée Azure, connectez-vous au portail Azure et sélectionnez Créer une ressource.

  2. Dans la page Nouveau, dans la zone de recherche, tapez Azure Cache pour Redis.

  3. Sous l’onglet Nouveau cache Redis , configurez les paramètres de votre nouveau cache sur les bases .

    Réglage Choisir une valeur Descriptif
    Abonnement Dans la liste déroulante, sélectionnez votre abonnement. L’abonnement sous lequel créer cette nouvelle instance Redis managé Azure.
    Groupe de ressources Dans la liste déroulante, sélectionnez un groupe de ressources ou choisissez Créer nouveau, puis entrez un nouveau nom de groupe de ressources. Nom du groupe de ressources dans lequel créer votre cache et d’autres ressources. En plaçant toutes les ressources de votre application dans un seul groupe de ressources, vous pouvez facilement les gérer ou les supprimer ensemble.
    Nom Entrez un nom unique dans la région. Le nom du cache doit être une chaîne de 1 à 63 caractères qui, une fois associée au nom de région du cache contient uniquement des chiffres, des lettres ou des traits d’union. (Si le nom du cache est inférieur à 45 caractères, il peut fonctionner dans toutes les régions actuellement disponibles.) Le nom doit commencer et se terminer par un chiffre ou une lettre, et ne peut pas contenir de traits d’union consécutifs. Le nom d’hôte de votre instance de cache est \<DNS name\>.\<Azure region\>.redis.azure.net.
    Région Dans la liste déroulante, sélectionnez un emplacement. Redis managé Azure est disponible dans certaines régions Azure.
    Niveau données Sélectionnez in-memory pour les performances élevées ou Flash pour réduire les caches de performances Les niveaux en mémoire incluent l’équilibrage, l’optimisation de la mémoire et l’optimisation du calcul. Utilisez le niveau Flash pour utiliser le stockage de données en mémoire (RAM) et disque (SSD).
    Taille du cache Déroulez et sélectionnez une taille. La taille du cache dépend du niveau. La plus petite taille est un niveau équilibré. La taille la plus grande du niveau en mémoire est un niveau mémoire optimisé.
    Niveau de performance Faites défiler la liste déroulante et sélectionnez une préférence de performances. Les performances dépendent du nombre de processeurs virtuels. Le nombre de processeurs virtuels varie selon le niveau. Les instances optimisées pour le calcul ont le plus grand nombre de processeurs virtuels.

    Pour obtenir des conseils sur le choix du niveau de performances approprié, consultez Choisir le niveau approprié.

    Important

    Tous les niveaux de mémoire qui utilisent plus de 120 Go de stockage sont en aperçu public, y compris Memory Optimized M150 et plus ; Balanced B150 et plus ; et Compute Optimized X150 et plus. Tous ces niveaux et versions ultérieures sont en préversion publique.

    Tous les niveaux flash optimisés sont en préversion publique.

  4. Sélectionnez Suivant : Mise en réseau , puis sélectionnez un point de terminaison public ou un point de terminaison privé.

  5. Sélectionnez Suivant : Géoréplication active. Pour utiliser la géoréplication active, elle doit être activée pendant l’approvisionnement. Les caches sans géoréplication active ne peuvent pas être ajoutés ou joindre des groupes de géoréplication actifs ultérieurement. Pour plus d’informations, consultez Configurer la géoréplication active pour les instances d’Azure Managed Redis.

  6. Sélectionnez l’onglet Suivant : Avancé .

    Configurez les modules Redis que vous souhaitez ajouter à l’instance.

    Par défaut, pour un nouveau cache managé :

    • Microsoft Entra ID est activé.
    • L’authentification avec des clés d’accès est désactivée pour des raisons de sécurité.

    Important

    Pour bénéficier d’une sécurité optimale, nous vous recommandons d’utiliser si possible Microsoft Entra ID avec des identités managées pour autoriser les requêtes sur votre cache. L’autorisation avec Microsoft Entra ID et les identités managées offre davantage de sécurité et de facilité d’utilisation que l’autorisation par clé d’accès partagée. Pour plus d’informations sur l’utilisation d’identités managées avec votre cache, consultez Utiliser Microsoft Entra ID pour l’authentification du cache.

    Définir la stratégie de clustering :

    • Utiliser Enterprise pour utiliser RedisSearch ou d’autres modules
    • Utilisez OSS pour un cache en cluster.
    • Utilisez un cache non cluster (préversion) pour un cache non cluster.

    Pour plus d’informations sur le choix d’une stratégie de clustering, consultez Stratégie de clustering.

    Important

    Vous ne pouvez pas modifier la stratégie de clustering d’une instance Redis managée Azure une fois que vous l’avez créée. Si vous utilisez RediSearch, la stratégie de cluster Entreprise est requise et NoEviction est la seule stratégie d’éviction prise en charge.

    Important

    Si vous utilisez cette instance de cache dans un groupe de géoréplication, les stratégies d’éviction ne peuvent pas être modifiées une fois l’instance créée. Veillez à connaître les stratégies d’éviction de vos nœuds principaux avant de créer le cache. Pour plus d’informations sur la géoréplication active, consultez les Prérequis à la géoréplication active.

    Important

    Vous ne pouvez pas modifier les modules après avoir créé une instance de cache. Les modules doivent être activés au moment où vous créez une instance Azure Cache pour Redis. Il n’existe aucune option permettant d’activer la configuration d’un module après avoir créé un cache.

  7. Sélectionnez Suivant : Étiquettes et ignorez.

  8. Sélectionnez Suivant : Vérifier + créer.

  9. Passez en revue les paramètres, puis sélectionnez Créer.

    La création de l’instance Redis prend plusieurs minutes. Vous pouvez suivre la progression sur la page Vue d’ensemble de Redis managé Azure. Lorsque État indique En cours d’exécution, le cache est prêt pour utilisation.

Créer une instance Cache Redis Azure

  1. Dans le portail Azure, recherchez et sélectionnez Cache Azure pour Redis.

  2. Dans la page Cache Azure pour Redis , sélectionnez Créer un>cache Azure pour Redis.

  3. Sous l’onglet Informations de base de la page Nouveau cache Redis , configurez les paramètres suivants :

    • Abonnement : sélectionnez l'abonnement souhaité.
    • Groupe de ressources : sélectionnez un groupe de ressources, ou sélectionnez Créer et entrez un nouveau nom de groupe de ressources. La mise en place de toutes vos ressources d’application dans le même groupe de ressources vous permet de les gérer ou de les supprimer facilement ensemble.
    • Nom : entrez un nom de cache unique dans la région. Le nom doit :
      • Doit être une chaîne de 1 à 63 caractères.
      • Contiennent uniquement des chiffres, des lettres et des traits d’union.
      • Commencez et terminez par un nombre ou une lettre.
      • Ne pas contenir des traits d’union consécutifs.
    • Région : sélectionnez une région Azure près d’autres services qui utilisent votre cache.
    • Référence SKU du cache : sélectionnez une référence SKU pour déterminer les tailles disponibles, les performances et les fonctionnalités de votre cache.
    • Taille du cache : sélectionnez une taille de cache. Pour plus d’informations, consultez Présentation d’Azure Cache pour Redis.

    Capture d’écran montrant l’onglet Informations de base de la page Nouveau cache Redis.

  4. Sélectionnez l’onglet Mise en réseau , ou sélectionnez Suivant : Mise en réseau.

  5. Sous l’onglet Mise en réseau, sélectionnez une méthode de connectivité à utiliser pour le cache. Le point de terminaison privé est recommandé pour la sécurité. Si vous sélectionnez Point de terminaison privé, sélectionnez Ajouter un point de terminaison privé et créez le point de terminaison privé.

  6. Sélectionnez l’onglet Avancé , ou sélectionnez Suivant : Avancé.

  7. Dans le volet Avancé , configurez les options suivantes :

    • Sélectionnez Authentification Microsoft Entra ou Authentification par clés d’accès. L’authentification Microsoft Entra est activée par défaut.
    • Choisissez s’il faut activer le port non TLS.
    • Pour un cache Premium, vous pouvez configurer ou désactiver des zones de disponibilité. Vous ne pouvez pas désactiver les zones de disponibilité une fois le cache créé. Pour un cache Standard, les zones de disponibilité sont allouées automatiquement. Les zones de disponibilité ne sont pas disponibles pour la référence SKU de base.
    • Pour un cache Premium, configurez les paramètres pour le nombre de réplicas, le clustering et le nombre de partitions, l’identité managée affectée par le système et la persistance des données.

    L’image suivante montre l’onglet Avancé pour la référence SKU Standard.

    Capture d’écran montrant le volet Avancé pour un cache de référence SKU Standard.

    Important

    Utilisez l’ID Microsoft Entra avec des identités managées pour autoriser les demandes sur votre cache si possible. L’autorisation utilisant l’ID Microsoft Entra et l’identité managée offre une meilleure sécurité et est plus facile à utiliser que l’autorisation de clé d’accès partagé. Pour plus d’informations sur l’utilisation d’identités managées avec votre cache, consultez Utiliser Microsoft Entra ID pour l’authentification du cache.

  8. Si vous le souhaitez, sélectionnez l’onglet Balises ou sélectionnez Suivant : Balises, puis entrez les noms et les valeurs des balises pour catégoriser vos ressources de cache.

  9. Sélectionnez Vérifier + créer, puis une fois la validation réussie, sélectionnez Créer.

Le nouveau déploiement de cache prend plusieurs minutes. Vous pouvez surveiller la progression du déploiement sur la page Azure Cache pour Redis du portail. Lorsque l’état du cache s’affiche en cours d’exécution, le cache est prêt à être utilisé.

Installer la bibliothèque de client node-redis

La bibliothèque node-redis est le client Node.js primaire pour Redis. Vous pouvez installer le client avec npm en utilisant la commande suivante :

npm install redis

Créer une application Node.js pour accéder à un cache

Créez une application Node.js qui utilise l’ID Microsoft Entra ou les clés d’accès pour se connecter à une instance Redis managée Azure. Nous vous recommandons Microsoft Entra ID.

Utiliser l’authentification Microsoft Entra ID sur votre cache

Les caches Redis managés Azure ont l’authentification Microsoft Entra activée par défaut.

  1. Dans le portail Azure, sélectionnez le cache pour lequel vous voulez utiliser l’authentification basée sur des jetons Microsoft Entra.

  2. Dans le menu Ressource, sélectionnez Authentification.

  3. Sélectionnez Sélectionner un membre et entrez le nom d’un utilisateur valide. L’utilisateur que vous spécifiez est automatiquement associé à la stratégie d’accès Propriétaire des données par défaut lorsque vous sélectionnez Enregistrer. Vous pouvez également entrer une identité managée ou un principal de service pour vous connecter à votre instance de cache.

    Capture d’écran illustrant l’authentification sélectionnée dans le menu Ressources et l’activation de l’authentification Microsoft Entra cochée.

Pour plus d’informations sur l’utilisation de Microsoft Entra ID avec Azure CLI, consultez les pages de référence pour l’identité.

Installez la bibliothèque de client JavaScript Azure Identity

La bibliothèque d’authentification Microsoft (Microsoft Authentication Library/MSAL) vous permet d’acquérir des jetons de sécurité depuis l’identité Microsoft pour authentifier les utilisateurs. Il existe une bibliothèque de client d’identité Azure JavaScript qui utilise la MSAL pour fournir une prise en charge de l’authentification par jeton. Installez cette bibliothèque en utilisant npm :

npm install @azure/identity

Créer une application Node.js en utilisant Microsoft Entra ID

  1. Ajoutez les variables d’environnement pour votre Nom d’hôte et votre ID de principal de service, qui est l’ID d’objet de votre principal de service ou de votre utilisateur Microsoft Entra ID. Dans le portail Azure, recherchez le nom d’utilisateur.

    set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  2. Créez un fichier de script nommé redistest.js.

  3. Ajoutez l’exemple JavaScript suivant au fichier. Ce code vous montre comment se connecter à une instance Azure Managed Redis pour Redis à l’aide du nom d’hôte de cache et des variables d’environnement de la clé. Le code stocke et récupère également une valeur de chaîne dans le cache. Les commandes PING et CLIENT LIST sont également exécutées. Pour plus d’exemples d’utilisation de Redis avec le client node-redis, consultez https://redis.js.org/.

    const { createClient } = require("redis");
const { DefaultAzureCredential } = require("@azure/identity");

async function main() {
  // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
  const credential = new DefaultAzureCredential();
  const redisScope = "https://redis.azure.com/.default";

  // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
  let accessToken = await credential.getToken(redisScope);
  console.log("access Token", accessToken);

  // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
  const cacheConnection = createClient({
    username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
    password: accessToken.token,
    url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
    pingInterval: 100000,
    socket: { 
      tls: true,
      keepAlive: 0 
    },
  });

  cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
  await cacheConnection.connect();

  // PING command
  console.log("\nCache command: PING");
  console.log("Cache response : " + await cacheConnection.ping());

  // SET
  console.log("\nCache command: SET Message");
  console.log("Cache response : " + await cacheConnection.set("Message",
      "Hello! The cache is working from Node.js!"));

  // GET
  console.log("\nCache command: GET Message");
  console.log("Cache response : " + await cacheConnection.get("Message"));

  // Client list, useful to see if connection list is growing...
  console.log("\nCache command: CLIENT LIST");
  console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

  cacheConnection.disconnect();

  return "Done"
}

main().then((result) => console.log(result)).catch(ex => console.log(ex));

  4. Exécutez le script avec Node.js.

    node redistest.js

  5. La sortie de votre code ressemble à ceci.

    Cache command: PING
Cache response : PONG

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: SET Message
Cache response : OK

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: CLIENT LIST
Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Done

Créer un exemple d’application JavaScript avec réauthentification

Les jetons d’accès Microsoft Entra ID ont une durée de vie limitée, en moyenne 75 minutes. Pour maintenir une connexion à votre cache, vous devez actualiser le jeton. Cet exemple montre comment procéder en utilisant JavaScript.

  1. Créez un fichier de script nommé redistestreauth.js.

  2. Ajoutez l’exemple JavaScript suivant au fichier.

     const { createClient } = require("redis");
 const { DefaultAzureCredential } = require("@azure/identity");

 async function returnPassword(credential) {
     const redisScope = "https://redis.azure.com/.default";

     // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
     return credential.getToken(redisScope);
 }

 async function main() {
   // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
   const credential = new DefaultAzureCredential();
   let accessToken = await returnPassword(credential);

   // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
   let cacheConnection = createClient({
     username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
     password: accessToken.token,
     url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
     pingInterval: 100000,
     socket: { 
       tls: true,
       keepAlive: 0 
     },
   });

   cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
   await cacheConnection.connect();

   for (let i = 0; i < 3; i++) {
     try {
         // PING command
         console.log("\nCache command: PING");
         console.log("Cache response : " + await cacheConnection.ping());

         // SET
         console.log("\nCache command: SET Message");
         console.log("Cache response : " + await cacheConnection.set("Message",
             "Hello! The cache is working from Node.js!"));

         // GET
         console.log("\nCache command: GET Message");
         console.log("Cache response : " + await cacheConnection.get("Message"));

         // Client list, useful to see if connection list is growing...
         console.log("\nCache command: CLIENT LIST");
         console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
       break;
     } catch (e) {
       console.log("error during redis get", e.toString());
       if ((accessToken.expiresOnTimestamp <= Date.now())|| (redis.status === "end" || "close") ) {
         await redis.disconnect();
         accessToken = await returnPassword(credential);
         cacheConnection = createClient({
           username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
           password: accessToken.token,
           url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
           pingInterval: 100000,
           socket: {
             tls: true,
             keepAlive: 0
           },
         });
       }
     }
   }
 }

 main().then((result) => console.log(result)).catch(ex => console.log(ex));

  3. Exécutez le script avec Node.js.

    node redistestreauth.js

  4. La sortie de votre code ressemble à ceci.

     Cache command: PING
 Cache response : PONG

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: SET Message
 Cache response : OK

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: CLIENT LIST
 Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Remarque

Pour obtenir d’autres exemples d’utilisation de Microsoft Entra ID pour s’authentifier auprès de Redis en utilisant la bibliothèque node-redis, veuillez consulter ce référentiel GitHub

Créer une application Node.js pour accéder à un cache

Créez une applicationNode.js qui utilise Microsoft Entra ID ou des clés d’accès pour se connecter à un Azure Cache pour Redis. Nous vous recommandons Microsoft Entra ID.

Utiliser l’authentification Microsoft Entra ID sur votre cache

Les caches Redis managés Azure ont l’authentification Microsoft Entra activée par défaut.

  1. Dans le portail Azure, sélectionnez le cache pour lequel vous voulez utiliser l’authentification basée sur des jetons Microsoft Entra.

  2. Dans le menu Ressource, sélectionnez Authentification.

  3. Sélectionnez Sélectionner un membre et entrez le nom d’un utilisateur valide. L’utilisateur que vous spécifiez est automatiquement associé à la stratégie d’accès Propriétaire des données par défaut lorsque vous sélectionnez Enregistrer. Vous pouvez également entrer une identité managée ou un principal de service pour vous connecter à votre instance de cache.

    Capture d’écran illustrant l’authentification sélectionnée dans le menu Ressources et l’activation de l’authentification Microsoft Entra cochée.

Pour plus d’informations sur l’utilisation de Microsoft Entra ID avec Azure CLI, consultez les pages de référence pour l’identité.

Installez la bibliothèque de client JavaScript Azure Identity

La bibliothèque d’authentification Microsoft (Microsoft Authentication Library/MSAL) vous permet d’acquérir des jetons de sécurité depuis l’identité Microsoft pour authentifier les utilisateurs. Il existe une bibliothèque de client d’identité Azure JavaScript qui utilise la MSAL pour fournir une prise en charge de l’authentification par jeton. Installez cette bibliothèque en utilisant npm :

npm install @azure/identity

Créer une application Node.js en utilisant Microsoft Entra ID

  1. Ajoutez les variables d’environnement pour votre Nom d’hôte et votre ID de principal de service, qui est l’ID d’objet de votre principal de service ou de votre utilisateur Microsoft Entra ID. Dans le portail Azure, recherchez le nom d’utilisateur.

    set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  2. Créez un fichier de script nommé redistest.js.

  3. Ajoutez l’exemple JavaScript suivant au fichier. Ce code vous montre comment se connecter à une instance de cache Azure pour Redis à l’aide du nom d’hôte de cache et des variables d’environnement de la clé. Le code stocke et récupère également une valeur de chaîne dans le cache. Les commandes PING et CLIENT LIST sont également exécutées. Pour plus d’exemples d’utilisation de Redis avec le client node-redis, consultez https://redis.js.org/.

    const { createClient } = require("redis");
const { DefaultAzureCredential } = require("@azure/identity");

async function main() {
  // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
  const credential = new DefaultAzureCredential();
  const redisScope = "https://redis.azure.com/.default";

  // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
  let accessToken = await credential.getToken(redisScope);
  console.log("access Token", accessToken);

  // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
  const cacheConnection = createClient({
    username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
    password: accessToken.token,
    url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
    pingInterval: 100000,
    socket: { 
      tls: true,
      keepAlive: 0 
    },
  });

  cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
  await cacheConnection.connect();

  // PING command
  console.log("\nCache command: PING");
  console.log("Cache response : " + await cacheConnection.ping());

  // SET
  console.log("\nCache command: SET Message");
  console.log("Cache response : " + await cacheConnection.set("Message",
      "Hello! The cache is working from Node.js!"));

  // GET
  console.log("\nCache command: GET Message");
  console.log("Cache response : " + await cacheConnection.get("Message"));

  // Client list, useful to see if connection list is growing...
  console.log("\nCache command: CLIENT LIST");
  console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

  cacheConnection.disconnect();

  return "Done"
}

main().then((result) => console.log(result)).catch(ex => console.log(ex));

  4. Exécutez le script avec Node.js.

    node redistest.js

  5. La sortie de votre code ressemble à ceci.

    Cache command: PING
Cache response : PONG

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: SET Message
Cache response : OK

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: CLIENT LIST
Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Done

Créer un exemple d’application JavaScript avec réauthentification

Les jetons d’accès Microsoft Entra ID ont une durée de vie limitée, en moyenne 75 minutes. Pour maintenir une connexion à votre cache, vous devez actualiser le jeton. Cet exemple montre comment procéder en utilisant JavaScript.

  1. Créez un fichier de script nommé redistestreauth.js.

  2. Ajoutez l’exemple JavaScript suivant au fichier.

     const { createClient } = require("redis");
 const { DefaultAzureCredential } = require("@azure/identity");

 async function returnPassword(credential) {
     const redisScope = "https://redis.azure.com/.default";

     // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
     return credential.getToken(redisScope);
 }

 async function main() {
   // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
   const credential = new DefaultAzureCredential();
   let accessToken = await returnPassword(credential);

   // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
   let cacheConnection = createClient({
     username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
     password: accessToken.token,
     url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
     pingInterval: 100000,
     socket: { 
       tls: true,
       keepAlive: 0 
     },
   });

   cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
   await cacheConnection.connect();

   for (let i = 0; i < 3; i++) {
     try {
         // PING command
         console.log("\nCache command: PING");
         console.log("Cache response : " + await cacheConnection.ping());

         // SET
         console.log("\nCache command: SET Message");
         console.log("Cache response : " + await cacheConnection.set("Message",
             "Hello! The cache is working from Node.js!"));

         // GET
         console.log("\nCache command: GET Message");
         console.log("Cache response : " + await cacheConnection.get("Message"));

         // Client list, useful to see if connection list is growing...
         console.log("\nCache command: CLIENT LIST");
         console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
       break;
     } catch (e) {
       console.log("error during redis get", e.toString());
       if ((accessToken.expiresOnTimestamp <= Date.now())|| (redis.status === "end" || "close") ) {
         await redis.disconnect();
         accessToken = await returnPassword(credential);
         cacheConnection = createClient({
           username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
           password: accessToken.token,
           url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
           pingInterval: 100000,
           socket: {
             tls: true,
             keepAlive: 0
           },
         });
       }
     }
   }
 }

 main().then((result) => console.log(result)).catch(ex => console.log(ex));

  3. Exécutez le script avec Node.js.

    node redistestreauth.js

  4. La sortie de votre code ressemble à ceci.

     Cache command: PING
 Cache response : PONG

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: SET Message
 Cache response : OK

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: CLIENT LIST
 Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Remarque

Pour obtenir d’autres exemples d’utilisation de Microsoft Entra ID pour s’authentifier auprès de Redis en utilisant la bibliothèque node-redis, veuillez consulter ce référentiel GitHub

Nettoyer les ressources

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

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

Important

La suppression d’un groupe de ressources est irréversible. Quand vous supprimez un groupe de ressources, toutes les ressources qu’il contient sont supprimées définitivement. Veillez à ne pas supprimer accidentellement des ressources ou un groupe de ressources incorrects. Si vous avez créé les ressources dans un groupe de ressources existant contenant des ressources que vous souhaitez conserver, vous pouvez supprimer chaque ressource individuellement, au lieu de supprimer l’intégralité du groupe de ressources.

Pour supprimer un groupe de ressources

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

  2. Recherchez le groupe de ressources à supprimer.

    S’il existe de nombreux groupes de ressources, utilisez la zone Filtrer pour n’importe quel champ..., tapez le nom du groupe de ressources que vous avez créé pour cet article. Sélectionnez le groupe de ressources dans la liste des résultats.

    Capture d’écran montrant une liste de groupes de ressources à supprimer dans le volet de travail.

  3. Sélectionnez Supprimer le groupe de ressources.

  4. Vous êtes invité à confirmer la suppression du groupe de ressources. Saisissez le nom de votre groupe de ressources pour confirmer, puis sélectionnez Supprimer.

    Capture d’écran montrant un formulaire qui demande le nom de la ressource pour confirmer la suppression.

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

Obtenir l’exemple de code

Obtenez le guide de démarrage rapideNode.js sur GitHub.

Contenu connexe

Dans ce guide de démarrage rapide, vous avez appris à utiliser Azure Managed Redis ou Azure Cache pour Redis à partir d’une application Node.js. En savoir plus sur les offres Azure Redis :