Guida introduttiva: Usare Azure Redis in Node.js

In questa guida introduttiva si incorpora Azure Redis gestito o Azure Cache per Redis in un'app Node.js. L'app ha accesso a una cache sicura e dedicata accessibile da qualsiasi applicazione all'interno di Azure.

Prerequisiti

• Sottoscrizione di Azure: crearne una gratuitamente
• Node.js installato: per installare Node.js, vedere Installare Node.js in Windows per istruzioni su come installare Node e npm in un computer Windows.

Creare un'istanza di Redis gestita di Azure

1. Per creare un'istanza di Redis gestita di Azure, accedere al portale di Azure e selezionare Crea una risorsa.

2. Nella casella di ricerca della pagina Nuovo digitare cache di Azure per Redis.

3. Nella scheda Nuova cache Redis configurare le impostazioni per la nuova cache in Informazioni di base.

   Impostazione	Scegliere un valore	Descrizione
   Abbonamento	Nell'elenco a discesa selezionare la sottoscrizione.	Sottoscrizione in cui creare questa nuova istanza di Redis gestita di Azure.
   Gruppo di risorse	Nell'elenco a discesa selezionare un gruppo di risorse oppure scegliere Crea nuovo e immettere il nome di un nuovo gruppo di risorse.	Nome del gruppo di risorse in cui creare la cache e altre risorse. L'inserimento di tutte le risorse di un'app in un unico gruppo di risorse ne semplifica la gestione o l'eliminazione.
   Nome	Immettere un nome univoco nell'area.	Il nome della cache deve essere una stringa compresa tra 1 e 63 caratteri in combinazione con il nome dell'area della cache che contiene solo numeri, lettere o trattini. Se il nome della cache è composto da meno di 45 caratteri, deve funzionare in tutte le aree attualmente disponibili. Il nome deve iniziare e terminare con un numero o una lettera e non può contenere trattini consecutivi. Il nome host dell'istanza della cache è \<DNS name\>.\<Azure region\>.redis.azure.net.
   Regione	Nell'elenco a discesa selezionare una località.	Redis gestito di Azure è disponibile nelle aree di Azure selezionate.
   Livello dati	Selezionare In memoria per prestazioni elevate o Flash per le cache con prestazioni inferiori	I livelli in memoria includono Bilanciato, Ottimizzato per la memoria e Ottimizzato per il calcolo. Usare il livello Flash per usare l'archiviazione dati in memoria (RAM) e su disco (SSD).
   Dimensioni cache	Apri il menu a tendina e seleziona una dimensione.	Le dimensioni della cache dipendono dal livello. La dimensione più piccola è un livello bilanciato. La dimensione massima del livello in memoria è il livello Ottimizzato per la Memoria.
   Prestazioni	Apri il menu a tendina e seleziona una preferenza per le prestazioni.	Le prestazioni dipendono dal numero di vCPU. Il numero di vCPU varia a seconda del livello. Compute ottimizzato ha il maggior numero di vCPU.

   Per indicazioni sulla scelta del livello di prestazioni corretto, vedere Scelta del livello corretto.

   Importante

   Tutti i livelli in memoria che usano più di 120 GB di spazio di archiviazione sono disponibili in anteprima pubblica, inclusi M150 ottimizzati per la memoria e superiori; B150 bilanciati e superiori; X150 ottimizzati per il calcolo e superiori. Tutti questi livelli e versioni successive sono disponibili in anteprima pubblica.

   Tutti i livelli con ottimizzazione flash sono disponibili in anteprima pubblica.

4. Selezionare Avanti: Rete e selezionare un endpoint pubblico o un endpoint privato.

5. Selezionare Avanti: Replica geografica attiva. Per usare la replica geografica attiva, è necessario abilitarla durante il provisioning. Le cache senza replica geografica attiva non possono essere aggiunte o aggiunte a gruppi di replica geografica attiva in un secondo momento. Per altre informazioni, vedere Configurare la replica geografica attiva per le istanze di Redis gestite di Azure.

6. Selezionare la scheda Avanti: Avanzate .

   Configurare tutti i moduli Redis da aggiungere all'istanza di .

   Per impostazione predefinita, per una nuova cache gestita:

   • L'ID Microsoft Entra è abilitato.
   • L'autenticazione delle chiavi di accesso è disabilitata per motivi di sicurezza.

   Importante

   Per una protezione ottimale, è consigliabile usare Microsoft Entra ID con identità gestite per autorizzare le richieste nella cache ogni volta che è possibile. L'autorizzazione tramite l'ID e le identità gestite di Microsoft Entra offre sicurezza e facilità d'uso superiori rispetto all'autorizzazione della chiave di accesso condiviso. Per altre informazioni sull'uso di identità gestite con la cache, vedere Usare l'ID Microsoft Entra per l'autenticazione della cache.

   Impostare i criteri di clustering:

   • Usare Enterprise per usare RedisSearch o altri moduli
   • Usare OSS per una cache in cluster.
   • Utilizzare non-cluster (Anteprima) per una cache non-cluster.

   Per altre informazioni sulla scelta dei criteri di clustering, vedere Criteri del cluster.

   Importante

   Non è possibile modificare i criteri di clustering di un'istanza di Redis gestita di Azure dopo averlo creato. Se si usa RediSearch, è necessario il criterio cluster Enterprise ed NoEviction è l'unico criterio di rimozione supportato.

   Importante

   Se si usa questa istanza della cache in un gruppo di replica geografica, non è possibile modificare i criteri di rimozione dopo la creazione dell'istanza. Assicurarsi di conoscere i criteri di rimozione dei nodi primari prima di creare la cache. Per altre informazioni sulla replica geografica attiva, vedere Prerequisiti per la replica geografica attiva.

   Importante

   Non è possibile modificare i moduli dopo aver creato un'istanza della cache. I moduli devono essere abilitati al momento della creazione di un'istanza di cache di Azure per Redis. Non è possibile abilitare la configurazione di un modulo dopo la creazione di una cache.

7. Selezionare Avanti: Tag e ignorare.

8. Selezionare Avanti: Revisiona e crea.

9. Rivedere le impostazioni e selezionare Crea.

   La creazione dell'istanza di Redis richiede alcuni minuti. È possibile monitorare lo stato di avanzamento nella pagina Panoramica di Redis gestita di Azure. Quando l'elemento Stato indica In esecuzione, la cache è pronta per l'uso.

Creare un'istanza di Azure Cache per Redis

1. Nel portale di Azure, cerca e seleziona Azure Cache per Redis.

2. Nella pagina Cache Redis di Azure selezionare Crea>Cache Redis di Azure.

3. Nella scheda Informazioni di base della pagina Nuova cache Redis configurare le impostazioni seguenti:

   • Sottoscrizione: selezionare la sottoscrizione da usare.
   • Gruppo di risorse: selezionare un gruppo di risorse oppure selezionare Crea nuovo e immettere un nuovo nome del gruppo di risorse. L'inserimento di tutte le risorse dell'app nello stesso gruppo di risorse consente di gestirle o eliminarle facilmente.
   • Nome: immettere un nome di cache univoco nell'area. Il nome deve:
     • Essere una stringa da 1 a 63 caratteri.
     • Contengono solo numeri, lettere e trattini.
     • Iniziare e terminare con un numero o una lettera.
     • Non contenere trattini consecutivi.
   • Area: selezionare un'area di Azure vicino ad altri servizi che usano la cache.
   • SKU cache: selezionare uno SKU per determinare le dimensioni, le prestazioni e le funzionalità disponibili per la cache.
   • Dimensioni cache: selezionare una dimensione della cache. Per altre informazioni, vedere la panoramica su Cache Redis di Azure.

   

4. Selezionare la scheda Rete oppure Avanti: Rete.

5. Nella scheda Rete selezionare un metodo di connettività da usare per la cache. L'endpoint privato è consigliato per la sicurezza. Se si seleziona Endpoint privato, selezionare Aggiungi endpoint privato e creare l'endpoint privato.

6. Selezionare la scheda Avanzate oppure Avanti: Avanzate.

7. Nel riquadro Avanzate configurare le opzioni seguenti:

   • Selezionare Autenticazione di Microsoft Entra o Autenticazione delle chiavi di accesso. L'autenticazione di Microsoft Entra è abilitata per impostazione predefinita.
   • Scegliere se abilitare la porta non TLS.
   • Per una cache Premium, è possibile configurare o disabilitare le zone di disponibilità. Non è possibile disabilitare le zone di disponibilità dopo la creazione della cache. Per una cache Standard, le zone di disponibilità vengono allocate automaticamente. Le zone di disponibilità non sono disponibili per lo SKU Basic.
   • Per una cache Premium, configurare le impostazioni per il numero di repliche, la funzionalità di clustering, il numero di partizioni, l'identità gestita assegnata dal sistema e la persistenza dei dati.

   L'immagine seguente mostra la scheda Avanzate per lo SKU Standard.

   

   Importante

   Usare Microsoft Entra ID con identità gestite per autorizzare le richieste nella cache, se possibile. L'autorizzazione con l'ID e l'identità gestita di Microsoft Entra garantisce una maggiore sicurezza ed è più facile da usare rispetto all'autorizzazione della chiave di accesso condiviso. Per altre informazioni sull'uso di identità gestite con la cache, vedere Usare l'ID Microsoft Entra per l'autenticazione della cache.

8. Facoltativamente, selezionare la scheda Tag o selezionare Avanti: Tag e immettere i nomi e i valori dei tag per classificare le risorse della cache.

9. Selezionare Rivedi e crea e una volta superata la convalida selezionare Crea.

La nuova distribuzione della cache richiede alcuni minuti. È possibile monitorare lo stato di avanzamento della distribuzione nella pagina Cache Redis di Azure del portale. Quando lo stato della cache viene visualizzato In esecuzione, la cache è pronta per l'uso.

Installare la libreria client node-redis

La libreria node-redis è il client Node.js primario per Redis. È possibile installare il client con npm usando il comando seguente:

npm install redis

Creare un'app Node.js per accedere a una cache

Creare un'app Node.js che usa Microsoft Entra ID o chiavi di accesso per connettersi a un'istanza di Redis gestita di Azure. È consigliabile usare Microsoft Entra ID.

Autenticazione Microsoft Entra ID (scelta consigliata)

Usare l'autenticazione di Microsoft Entra ID nella cache

Per impostazione predefinita, le cache Redis gestite di Azure dispongono dell'autenticazione di Microsoft Entra authentication abilitata.

1. Nella portale di Azure selezionare la cache in cui si vuole usare l'autenticazione basata su token di Microsoft Entra.

2. Selezionare Autenticazione dal menu Risorsa.

3. Selezionare Seleziona membro e immettere il nome di un utente valido. All'utente immesso viene assegnato automaticamente il criterio di accesso Proprietario dei dati per impostazione predefinita quando si seleziona Salva. È anche possibile immettere un'identità gestita o un'entità servizio per connettersi all'istanza della cache.

   

Per informazioni sull'uso di Microsoft Entra ID con l'interfaccia della riga di comando di Azure, vedere le pagine di riferimento per l'identità.

Installare la libreria client di Identità di Azure JavaScript

Microsoft Authentication Library (MSAL) consente di acquisire token di sicurezza dall'identità Microsoft per autenticare gli utenti. È disponibile una libreria client di identità di JavaScript di Azure disponibile che usa MSAL per fornire il supporto per l'autenticazione dei token. Installare questa libreria tramite npm:

npm install @azure/identity

Creare una nuova app Node.js usando Microsoft Entra ID

1. Aggiungere variabili di ambiente per il nome host e l'ID entità servizio, ovvero l'ID oggetto dell'entità servizio o dell'utente Microsoft Entra ID. Nella portale di Azure cercare il nome utente.

   set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
   set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   

2. Creare un nuovo file script denominato redistest.js.

3. Aggiungere lo script JavaScript di esempio seguente al file. Questo codice illustra come connettersi a un'istanza di Redis gestita di Azure usando il nome host della cache e le variabili di ambiente chiave. Il codice, inoltre, archivia e recupera un valore stringa nella cache. Vengono anche eseguiti i comandi PING e CLIENT LIST. Per altri esempi relativi all'uso di Redis con il client node_redis, vedere 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. Eseguire lo script con Node.js.

   node redistest.js
   

5. L'output del codice è simile al seguente.

   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
   

Creare un'app JavaScript di esempio con la riautenticazione

I token di accesso a Microsoft Entra ID hanno una durata limitata, in media 75 minuti. Per mantenere una connessione alla cache, è necessario aggiornare il token. Questo esempio illustra come eseguire questa operazione usando JavaScript.

1. Creare un nuovo file script denominato redistestreauth.js.

2. Aggiungere lo script JavaScript di esempio seguente al file.

    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. Eseguire lo script con Node.js.

   node redistestreauth.js
   

4. L'output del codice è simile al seguente.

    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
   
   

Annotazioni

Per altri esempi di uso di Microsoft Entra ID per l'autenticazione a Redis tramite la libreria node-redis, vedere questo repository GitHub

Autenticazione tramite chiave di accesso

Importante

Microsoft consiglia di usare l'autenticazione con ID Entra di Microsoft per l'esperienza di autenticazione più sicura anziché usare password o chiavi di accesso. Le chiavi di accesso richiedono un elevato grado di attendibilità nell'applicazione e comportano rischi non presenti quando si usa Microsoft Entra ID. Usare le chiavi di accesso solo quando l'autenticazione di Microsoft Entra ID non è valida.

Recuperare il nome host, le porte e le chiavi di accesso dal portale di Azure

Per connettere il server Cache Redis di Azure, il client della cache deve avere il nome host, le porte e una chiave per la cache. Alcuni client possono fare riferimento a questi elementi usando nomi leggermente diversi. È possibile ottenere il nome host, le porte e le chiavi dal portale di Azure.

• Per ottenere il nome host e le porte per la cache, selezionare Panoramica dal menu Risorsa . Il nome host è nel formato <DNS name>.redis.cache.windows.net.

  

• Per ottenere le chiavi di accesso, selezionare Autenticazione dal menu Risorsa . Quindi, selezionare la scheda Chiavi di accesso.

  

Aggiungere le variabili di ambiente per il nome host e la chiave di accesso primaria. Usare queste variabili dal codice invece di includere le informazioni riservate direttamente nel codice.

set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set AZURE_MANAGED_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Connettersi alla cache

Annotazioni

Non creare un nuova connessione per ogni operazione nel codice. Riutilizzare invece le connessioni quanto più possibile.

Creare una nuova app Node.js

1. Creare un nuovo file script denominato redistest.js.

2. Aggiungere lo script JavaScript di esempio seguente al file.

   const redis = require("redis");
   
   // Environment variables for cache
   const cacheHostName = process.env.AZURE_MANAGED_REDIS_HOST_NAME;
   const cachePassword = process.env.AZURE_MANAGED_REDIS_ACCESS_KEY;
   
   if(!cacheHostName) throw Error("AZURE_MANAGED_REDIS_HOST_NAME is empty")
   if(!cachePassword) throw Error("AZURE_MANAGED_REDIS_ACCESS_KEY is empty")
   
   async function testCache() {
   
       // Connection configuration
       const cacheConnection = redis.createClient({
           // redis for TLS
           url: `redis://${cacheHostName}:10000`,
           password: cachePassword
       });
   
       // Connect to Redis
       await cacheConnection.connect();
   
       // PING command
       console.log("\nCache command: PING");
       console.log("Cache response : " + await cacheConnection.ping());
   
       // GET
       console.log("\nCache command: GET Message");
       console.log("Cache response : " + await cacheConnection.get("Message"));
   
       // SET
       console.log("\nCache command: SET Message");
       console.log("Cache response : " + await cacheConnection.set("Message",
           "Hello! The cache is working from Node.js!"));
   
       // GET again
       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"]));
   
       // Disconnect
       cacheConnection.disconnect()
   
       return "Done"
   }
   
   testCache().then((result) => console.log(result)).catch(ex => console.log(ex));
   

   Questo codice mostra come connettersi a un'istanza di Cache Redis di Azure usando il nome host della cache e le variabili di ambiente chiave. Il codice, inoltre, archivia e recupera un valore stringa nella cache. Vengono anche eseguiti i comandi PING e CLIENT LIST. Per altri esempi relativi all'uso di Redis con il client node_redis, vedere https://redis.js.org/.

3. Eseguire lo script con Node.js.

   node redistest.js
   

4. Esempio dell'output.

   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
   

Creare un'app Node.js per accedere a una cache

Creare un'app Node.js nella quale si utilizzino Microsoft Entra ID o le chiavi di accesso per connettersi alla cache di Azure per Redis. È consigliabile usare Microsoft Entra ID.

Autenticazione Microsoft Entra ID (scelta consigliata)

Usare l'autenticazione di Microsoft Entra ID nella cache

Per impostazione predefinita, le cache Redis gestite di Azure dispongono dell'autenticazione di Microsoft Entra authentication abilitata.

1. Nella portale di Azure selezionare la cache in cui si vuole usare l'autenticazione basata su token di Microsoft Entra.

2. Selezionare Autenticazione dal menu Risorsa.

3. Selezionare Seleziona membro e immettere il nome di un utente valido. All'utente immesso viene assegnato automaticamente il criterio di accesso Proprietario dei dati per impostazione predefinita quando si seleziona Salva. È anche possibile immettere un'identità gestita o un'entità servizio per connettersi all'istanza della cache.

   

Per informazioni sull'uso di Microsoft Entra ID con l'interfaccia della riga di comando di Azure, vedere le pagine di riferimento per l'identità.

Installare la libreria client di Identità di Azure JavaScript

Microsoft Authentication Library (MSAL) consente di acquisire token di sicurezza dall'identità Microsoft per autenticare gli utenti. È disponibile una libreria client di identità di JavaScript di Azure disponibile che usa MSAL per fornire il supporto per l'autenticazione dei token. Installare questa libreria tramite npm:

npm install @azure/identity

Creare una nuova app Node.js usando Microsoft Entra ID

1. Aggiungere variabili di ambiente per il nome host e l'ID entità servizio, ovvero l'ID oggetto dell'entità servizio o dell'utente Microsoft Entra ID. Nella portale di Azure cercare il nome utente.

   set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
   set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
   

2. Creare un nuovo file script denominato redistest.js.

3. Aggiungere lo script JavaScript di esempio seguente al file. Questo codice mostra come connettersi a un'istanza di Cache Redis di Azure usando il nome host della cache e le variabili di ambiente chiave. Il codice, inoltre, archivia e recupera un valore stringa nella cache. Vengono anche eseguiti i comandi PING e CLIENT LIST. Per altri esempi relativi all'uso di Redis con il client node_redis, vedere 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. Eseguire lo script con Node.js.

   node redistest.js
   

5. L'output del codice è simile al seguente.

   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
   

Creare un'app JavaScript di esempio con la riautenticazione

I token di accesso a Microsoft Entra ID hanno una durata limitata, in media 75 minuti. Per mantenere una connessione alla cache, è necessario aggiornare il token. Questo esempio illustra come eseguire questa operazione usando JavaScript.

1. Creare un nuovo file script denominato redistestreauth.js.

2. Aggiungere lo script JavaScript di esempio seguente al file.

    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. Eseguire lo script con Node.js.

   node redistestreauth.js
   

4. L'output del codice è simile al seguente.

    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
   
   

Annotazioni

Per altri esempi di uso di Microsoft Entra ID per l'autenticazione a Redis tramite la libreria node-redis, vedere questo repository GitHub

Autenticazione tramite chiave di accesso

Recuperare il nome host, le porte e le chiavi di accesso dal portale di Azure

Per connettere il server Cache Redis di Azure, il client della cache deve avere il nome host, le porte e una chiave per la cache. Alcuni client possono fare riferimento a questi elementi usando nomi leggermente diversi. È possibile ottenere il nome host, le porte e le chiavi dal portale di Azure.

• Per ottenere il nome host e le porte per la cache, selezionare Panoramica dal menu Risorsa . Il nome host è nel formato <DNS name>.redis.cache.windows.net.

  

• Per ottenere le chiavi di accesso, selezionare Autenticazione dal menu Risorsa . Quindi, selezionare la scheda Chiavi di accesso.

  

Aggiungere le variabili di ambiente per il nome host e la chiave di accesso primaria. Usare queste variabili dal codice invece di includere le informazioni riservate direttamente nel codice.

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Connettersi alla cache

Annotazioni

Non creare un nuova connessione per ogni operazione nel codice. Riutilizzare invece le connessioni quanto più possibile.

Creare una nuova app Node.js

1. Creare un nuovo file script denominato redistest.js.

2. Aggiungere lo script JavaScript di esempio seguente al file.

   const redis = require("redis");
   
   // Environment variables for cache
   const cacheHostName = process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME;
   const cachePassword = process.env.AZURE_CACHE_FOR_REDIS_ACCESS_KEY;
   
   if(!cacheHostName) throw Error("AZURE_CACHE_FOR_REDIS_HOST_NAME is empty")
   if(!cachePassword) throw Error("AZURE_CACHE_FOR_REDIS_ACCESS_KEY is empty")
   
   async function testCache() {
   
       // Connection configuration
       const cacheConnection = redis.createClient({
           // redis for TLS
           url: `redis://${cacheHostName}:6380`,
           password: cachePassword
       });
   
       // Connect to Redis
       await cacheConnection.connect();
   
       // PING command
       console.log("\nCache command: PING");
       console.log("Cache response : " + await cacheConnection.ping());
   
       // GET
       console.log("\nCache command: GET Message");
       console.log("Cache response : " + await cacheConnection.get("Message"));
   
       // SET
       console.log("\nCache command: SET Message");
       console.log("Cache response : " + await cacheConnection.set("Message",
           "Hello! The cache is working from Node.js!"));
   
       // GET again
       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"]));
   
       // Disconnect
       cacheConnection.disconnect()
   
       return "Done"
   }
   
   testCache().then((result) => console.log(result)).catch(ex => console.log(ex));
   

   Questo codice mostra come connettersi a un'istanza di Cache Redis di Azure usando il nome host della cache e le variabili di ambiente chiave. Il codice, inoltre, archivia e recupera un valore stringa nella cache. Vengono anche eseguiti i comandi PING e CLIENT LIST. Per altri esempi relativi all'uso di Redis con il client node_redis, vedere https://redis.js.org/.

3. Eseguire lo script con Node.js.

   node redistest.js
   

4. Esempio dell'output.

   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
   

Pulire le risorse

Per continuare a usare le risorse create in questo articolo, mantenere il gruppo di risorse.

In caso contrario, se le risorse sono state completate, per evitare addebiti è possibile eliminare il gruppo di risorse di Azure creato.

Importante

L'eliminazione di un gruppo di risorse è irreversibile. Quando si elimina un gruppo di risorse, tutte le risorse in esso contenute vengono eliminate in modo permanente. Assicurarsi di non eliminare accidentalmente il gruppo di risorse sbagliato o le risorse errate. Se le risorse sono state create all'interno di un gruppo di risorse esistente che contiene anche elementi da mantenere, è possibile eliminare ogni singolo elemento a sinistra anziché eliminare il gruppo di risorse.

Per eliminare un gruppo di risorse

1. Accedere al portale di Azure e selezionare Gruppi di risorse.

2. Scegliere il gruppo di risorse da eliminare.

   Se sono presenti molti gruppi di risorse, usare la casella Filtro per qualsiasi campo... e digitare il nome del gruppo di risorse creato per questo articolo. Nell’elenco dei risultati selezionare il gruppo di risorse.

   

3. Selezionare Elimina gruppo di risorse.

4. Verrà chiesto di confermare l'eliminazione del gruppo di risorse. Digitare il nome del gruppo di risorse per confermare e quindi selezionare Elimina.

   

Dopo qualche istante, il gruppo di risorse e tutte le risorse che contiene vengono eliminati.

Scaricare il codice di esempio

Ottenere il Node.js di avvio rapido in GitHub.

Contenuti correlati

In questa guida introduttiva si è appreso come usare Azure Managed Redis o Azure Cache per Redis da un'applicazione Node.js. Altre informazioni sulle offerte di Azure Redis:

• Panoramica di Redis gestito di Azure
• Panoramica della cache di Azure per Redis