Condividi tramite

Guida introduttiva: Usare Cache di Azure per Redis con un'app Node.js

  • Articolo

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

Prerequisiti

Creare una cache

  1. Per creare una cache, accedere al portale di Azure. Nel menu del portale selezionare Crea una risorsa.

    Screenshot che mostra l'opzione Crea una risorsa evidenziata nel riquadro di spostamento a sinistra nel portale di Azure.

  2. Nel riquadro Attività iniziali immettere Cache di Azure per Redis nella barra di ricerca. Nei risultati della ricerca trovare Cache di Azure per Redis e quindi selezionare Crea.

    Screenshot che mostra Azure Marketplace con Cache di Azure per Redis nella casella di ricerca e il pulsante Crea evidenziato.

  3. Nel riquadro Nuova cache Redis, nella scheda Informazioni di base configurare le impostazioni seguenti per la cache:

    Impostazione Azione Descrizione
    Abbonamento Seleziona la tua sottoscrizione di Azure. Sottoscrizione da usare per creare la nuova istanza della cache di Azure per Redis.
    Gruppo di risorse Selezionare un gruppo di risorse oppure selezionare Crea nuovo e immettere un nuovo nome del 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 DNS Immettere un nome univoco. Il nome della cache deve essere una stringa compresa tra 1 e 63 caratteri contenente solo numeri, lettere o trattini. 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>.redis.cache.windows.net.
    Location Selezionare una località. Un'area di Azure vicina ad altri servizi che usano la cache.
    SKU della cache Selezionare uno SKU. Lo SKU determina le dimensioni, le prestazioni e i parametri delle funzionalità disponibili per la cache. Per altre informazioni, vedere la panoramica su Cache Redis di Azure.
    Dimensioni della cache Selezionare le dimensioni della cache. Per altre informazioni, vedere la panoramica su Cache Redis di Azure.

  4. Selezionare la scheda Rete oppure selezionare Avanti: Rete.

  5. Nella scheda Rete selezionare un metodo di connettività da usare per la cache.

  6. Selezionare la scheda Avanzate o Avanti: Avanzate.

  7. Nel riquadro Avanzate verificare o selezionare un metodo di autenticazione in base alle informazioni seguenti:

    Screenshot che mostra il riquadro Avanzate e le opzioni disponibili per la selezione.

    • Per impostazione predefinita, per una nuova cache Basic, Standard o Premium, l'Autenticazione di Microsoft Entra è abilitata e l'Autenticazione delle chiavi di accesso è disabilitata.
    • Per le cache Basic o Standard, è possibile scegliere la selezione di una porta non TLS.
    • Per le cache Standard e Premium, è possibile scegliere di abilitare le zone di disponibilità. Non è possibile disabilitare le zone di disponibilità dopo la creazione della cache.
    • Per una cache Premium, configurare le impostazioni per la porta non TLS, il clustering, l'identità gestita e la persistenza dei dati.

    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 Microsoft Entra ID e le identità gestite offre sicurezza e facilità d'uso superiori rispetto all'autorizzazione con chiave di accesso condiviso. Per altre informazioni sull'uso delle identità gestite con le cache, vedere Usare Microsoft Entra ID per l'autenticazione della cache.

  8. (Facoltativo) Selezionare la scheda Tag o selezionare Avanti: Tag.

  9. (Facoltativo) Nella scheda Tag immettere un nome e un valore di tag per classificare la risorsa della cache.

  10. Selezionare il pulsante Rivedi e crea.

    Nella scheda Rivedi e crea Azure convalida automaticamente la configurazione.

  11. Quando viene visualizzato il messaggio verde di Convalida superata, selezionare Crea.

Una nuova distribuzione della cache richiede diversi minuti. È possibile monitorare lo stato di avanzamento della distribuzione nel riquadro Panoramica di Cache di Azure per Redis. Quando Stato mostra 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 usando npm e il comando seguente:

npm install redis

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 a Cache di Azure per Redis. È consigliabile usare Microsoft Entra ID.

Abilitare l'autenticazione di Microsoft Entra ID nella cache

Per una cache esistente, verificare prima di tutto se l'autenticazione di Microsoft Entra è abilitata. Altrimenti seguire questa procedura per abilitare l'autenticazione di Microsoft Entra. È consigliabile usare Microsoft Entra ID per l'autenticazione nelle applicazioni.

  1. Nel portale di Azure selezionare l'istanza della cache di Azure per Redis in cui si vuole usare l'autenticazione basata su token di Microsoft Entra.

  2. Nel menu del servizio, in Impostazioni, seleziona Autenticazione.

  3. Nel riquadro Autenticazione verificare se è selezionata la casella di controllo Abilita autenticazione di Microsoft Entra. In caso affermativo, è possibile passare alla sezione successiva.

  4. In caso contrario, selezionare la casella di controllo Abilita autenticazione di Microsoft Entra. Immettere quindi il nome di un utente valido. Seleziona Salva. Al nome utente immesso vengono assegnati automaticamente i criteri di accesso al proprietario dei dati.

    È anche possibile immettere un'identità gestita o un'entità servizio per connettersi alla cache.

    Screenshot che mostra l'opzione Autenticazione selezionata nel menu del servizio e la casella di controllo Abilita autenticazione di Microsoft Entra selezionata.

  5. In una finestra di dialogo viene chiesto se si vuole aggiornare la configurazione e si è informati che il completamento dell'aggiornamento richiede alcuni minuti. Selezionare Sì.

    Importante

    Al termine dell'operazione di abilitazione, i nodi nella cache vengono riavviati per caricare la nuova configurazione. È consigliabile completare questa operazione durante la finestra di manutenzione standard o al di fuori dell'orario di ufficio di punta. Il processo può richiedere fino a 30 minuti.

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

Installare la libreria client di Identità di Azure per JavaScript

La libreria client di Identità di Azure per JavaScript usa la Libreria di autenticazione Microsoft (MSAL) necessaria per fornire il supporto per l'autenticazione tramite token. Installare la libreria usando npm:

npm install @azure/identity

Creare un'app Node.js usando Microsoft Entra ID

  1. Aggiungere variabili di ambiente per il nome host e l'ID entità servizio.

    L'ID entità servizio è l'ID oggetto dell'entità servizio o dell'utente Microsoft Entra ID. Nel portale di Azure questo valore viene visualizzato come Nome utente.

    set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  2. Creare un 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 Node-Redis.

    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 usando Node.js:

    node redistest.js

  5. Verificare che l'output del codice sia simile all'esempio 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 di circa 75 minuti. Per mantenere una connessione alla cache, è necessario aggiornare il token.

Questo esempio illustra come aggiornare il token usando JavaScript:

  1. Creare un 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 usando Node.js:

    node redistestreauth.js

  4. Verificare la presenza di output simile all'esempio 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

Nota

Per altri esempi su come usare Microsoft Entra ID per eseguire l'autenticazione a Redis tramite la libreria node-redis, vedere il repository GitHub node-redis.

Pulire le risorse

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

In alternativa, per evitare addebiti relativi alle risorse, se si è terminato di usare le risorse è possibile eliminare il gruppo di risorse di Azure creato.

Avviso

L'eliminazione di un gruppo di risorse è irreversibile. Quando si elimina un gruppo di risorse, tutte le risorse al suo interno 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 risorse da mantenere, è possibile eliminare ogni singola risorsa individualmente anziché l'intero gruppo.

Eliminare un gruppo di risorse

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

  2. Selezionare il gruppo di risorse da eliminare.

    Se sono presenti molti gruppi di risorse, in Filtra per qualsiasi campo immettere il nome del gruppo di risorse creato per completare questo articolo. Nell'elenco dei risultati della ricerca selezionare il gruppo di risorse.

    Screenshot che mostra un elenco di gruppi di risorse tra cui scegliere quello da eliminare.

  3. Selezionare Elimina gruppo di risorse.

  4. Nel riquadro Elimina un gruppo di risorse immettere il nome del gruppo di risorse per confermare, quindi selezionare Elimina.

    Screenshot che mostra una casella che richiede l'immissione del nome della risorsa per confermare l'eliminazione.

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

Scaricare il codice di esempio

Ottenere l'esempio di avvio rapido di Node.js su GitHub.

Contenuto correlato