Snabbstart: Använda Azure Cache for Redis med en Node.js-app

Artikel
10/16/2024

I den här snabbstarten införlivar du Azure Cache for Redis i en Node.js-app för åtkomst till en säker, dedikerad cache som är tillgänglig från alla program i Azure.

Förutsättningar

En Azure-prenumeration. Skapa en kostnadsfritt
Node.js installerat. Information om hur du installerar Node och npm på en Windows-dator finns i Installera Node.js i Windows.

Skapa en cache

Om du vill skapa en cache loggar du in på Azure Portal. På portalmenyn väljer du Skapa en resurs.
I fönstret Kom igång anger du Azure Cache for Redis i sökfältet. I sökresultaten letar du upp Azure Cache for Redis och väljer sedan Skapa.

I fönstret Ny Redis Cache på fliken Grundläggande konfigurerar du följande inställningar för din cache:

Inställning	Åtgärd	beskrivning
Abonnemang	Välj din Azure-prenumerationen.	Prenumerationen som ska användas för att skapa den nya instansen av Azure Cache for Redis.
Resursgrupp	Välj en resursgrupp eller välj Skapa ny och ange ett nytt resursgruppsnamn.	Ett namn på resursgruppen där du kan skapa cacheminnet och andra resurser. Genom att placera alla dina appresurser i en resursgrupp kan du enkelt hantera eller ta bort dem tillsammans.
DNS-namn	Ange ett unikt namn.	Cachenamnet måste vara en sträng på 1 till 63 tecken som endast innehåller siffror, bokstäver och bindestreck. Namnet måste börja och sluta med ett tal eller en bokstav, och det får inte innehålla bindestreck i följd. Värdnamnet för cacheinstansen är `\<DNS name>.redis.cache.windows.net`.
Plats	Välj en plats.	En Azure-region som ligger nära andra tjänster som använder din cache.
Cache-SKU	Välj en SKU.	SKU:n avgör vilka storleks-, prestanda- och funktionsparametrar som är tillgängliga för cachen. Mer information finns i Översikt över Azure Cache for Redis.
Cachestorlek	Välj en cachestorlek.	Mer information finns i Översikt över Azure Cache for Redis.

Välj fliken Nätverk eller välj Nästa: Nätverk.
På fliken Nätverk väljer du en anslutningsmetod som ska användas för cacheminnet.
Välj fliken Avancerat eller välj Nästa: Avancerat.
I fönstret Avancerat kontrollerar eller väljer du en autentiseringsmetod baserat på följande information:
- Som standard aktiveras Microsoft Entra-autentisering för en ny Basic-, Standard- eller Premium-cache och åtkomstnycklarnas autentisering inaktiveras.
- För Basic- eller Standard-cacheminnen kan du välja valet för en icke-TLS-port.
- För Standard- och Premium-cacheminnen kan du välja att aktivera tillgänglighetszoner. Du kan inte inaktivera tillgänglighetszoner när cacheminnet har skapats.
- För en Premium-cache konfigurerar du inställningarna för icke-TLS-port, klustring, hanterad identitet och datapersistence.
Viktigt!

För optimal säkerhet rekommenderar vi att du använder Microsoft Entra-ID med hanterade identiteter för att auktorisera begäranden mot din cache om möjligt. Auktorisering med hjälp av Microsoft Entra-ID och hanterade identiteter ger överlägsen säkerhet och användarvänlighet för auktorisering av delad åtkomstnyckel. Mer information om hur du använder hanterade identiteter med din cache finns i Använda Microsoft Entra-ID för cacheautentisering.
(Valfritt) Välj fliken Taggar eller välj Nästa: Taggar.
(Valfritt) På fliken Taggar anger du ett taggnamn och värde om du vill kategorisera cacheresursen.
Välj knappen Granska + skapa.

På fliken Granska + skapa verifierar Azure automatiskt din konfiguration.
När det gröna verifieringsmeddelandet har skickats väljer du Skapa.

En ny cachedistribution sker under flera minuter. Du kan övervaka förloppet för distributionen i översiktsfönstret Azure Cache for Redis. När Status visar Körs är cachen redo att användas.

Installera nod-redis-klientbiblioteket

Node-redis-biblioteket är den primära Node.js-klienten för Redis. Du kan installera klienten med hjälp av npm och följande kommando:

npm install redis

Skapa en Node.js app för att komma åt en cache

Skapa en Node.js app som använder antingen Microsoft Entra-ID eller åtkomstnycklar för att ansluta till Azure Cache for Redis. Vi rekommenderar att du använder Microsoft Entra-ID.

Microsoft Entra ID-autentisering (rekommenderas)
Åtkomstnyckelautentisering

Aktivera Microsoft Entra-ID-autentisering i cacheminnet

För en befintlig cache kontrollerar du först om Microsoft Entra-autentisering är aktiverat. Om det inte är det slutför du följande steg för att aktivera Microsoft Entra-autentisering. Vi rekommenderar att du använder Microsoft Entra-ID för autentisering i dina program.

I Azure Portal väljer du den Azure Cache for Redis-instans där du vill använda Microsoft Entra-tokenbaserad autentisering.
På tjänstmenyn går du till Inställningar och väljer Autentisering.
I fönstret Autentisering kontrollerar du om kryssrutan Aktivera Microsoft Entra-autentisering är markerad. I så fall kan du gå vidare till nästa avsnitt.
Annars markerar du kryssrutan Aktivera Microsoft Entra-autentisering . Ange sedan namnet på en giltig användare. Välj Spara. Det användarnamn som du anger tilldelas automatiskt åtkomstprincipen för dataägare.

Du kan också ange en hanterad identitet eller ett huvudnamn för tjänsten för att ansluta till din cache.
I en dialogruta får du frågan om du vill uppdatera konfigurationen och du får information om att det tar flera minuter att slutföra uppdateringen. Välj Ja.

Viktigt!

När aktiveringsåtgärden är klar startar noderna i cacheminnet om för att läsa in den nya konfigurationen. Vi rekommenderar att du slutför den här åtgärden under standardunderhållsperioden eller utanför din rusningstid. Processen kan ta upp till 30 minuter.

Information om hur du använder Microsoft Entra-ID med Azure CLI finns på identitetsreferenssidorna.

Installera Azure Identity-klientbiblioteket för JavaScript

Azure Identity-klientbiblioteket för JavaScript använder det nödvändiga Microsoft Authentication Library (MSAL) för att tillhandahålla stöd för tokenautentisering. Installera biblioteket med npm:

npm install @azure/identity

Skapa en Node.js app med hjälp av Microsoft Entra-ID

Lägg till miljövariabler för värdnamnet och tjänstens huvudnamns-ID.

Tjänstens huvudnamns-ID är objekt-ID:t för tjänstens huvudnamn eller användare i Microsoft Entra. I Azure Portal visas det här värdet som Användarnamn.
```
set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Skapa en skriptfil med namnet redistest.js.

Lägg till följande JavaScript-exempel i filen. Den här koden visar hur du ansluter till en Azure Cache for Redis-instans med hjälp av cachens värdnamn och viktiga miljövariabler. Koden lagrar och hämtar även ett strängvärde i cacheminnet. Kommandona PING och CLIENT LIST körs också. Fler exempel på hur du använder Redis med node-redis-klienten finns i 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));

Kör skriptet med hjälp av Node.js:
```
node redistest.js
```

Kontrollera att kodens utdata ser ut så här:

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

Skapa en JavaScript-exempelapp som har omautentisering

Microsoft Entra ID-åtkomsttoken har en begränsad livslängd på cirka 75 minuter. För att upprätthålla en anslutning till cacheminnet måste du uppdatera token.

Det här exemplet visar hur du uppdaterar token med hjälp av JavaScript:

Skapa en skriptfil med namnet redistestreauth.js.

Lägg till följande exempel på JavaScript i filen:

 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));

Kör skriptet med hjälp av Node.js:
```
node redistestreauth.js
```

Sök efter utdata som liknar det här exemplet:

 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

Kommentar

Fler exempel på hur du använder Microsoft Entra-ID för att autentisera till Redis via node-redis-biblioteket finns i GitHub-lagringsplatsen node-redis.

Hämta värdnamnet, portarna och åtkomstnyckeln

För att ansluta till Azure Cache for Redis-servern behöver cacheklienten cachens värdnamn, portar och en åtkomstnyckel. Vissa klienter kan referera till dessa objekt med hjälp av lite olika namn. Du kan hämta värdnamnet, portarna och nycklarna i Azure Portal.

Så här hämtar du en åtkomstnyckel för din cache:
1. I Azure Portal går du till cacheminnet.
2. På tjänstmenyn går du till Inställningar och väljer Autentisering.
3. I fönstret Autentisering väljer du fliken Åtkomstnycklar .
4. Om du vill kopiera värdet för en åtkomstnyckel väljer du ikonen Kopiera i nyckelfältet.
Så här hämtar du värdnamnet och portarna för cachen:
1. I Azure Portal går du till cacheminnet.
2. På tjänstmenyn väljer du Översikt.
3. Under Essentials, för Värdnamn, väljer du ikonen Kopiera för att kopiera värdnamnets värde. Värdnamnets värde har formuläret <DNS name>.redis.cache.windows.net.
4. För Portar väljer du ikonen Kopiera för att kopiera portvärdena.

Lägg till miljövariabler för värdnamnet och den primära åtkomstnyckeln. Använd dessa variabler från koden i stället för att inkludera känslig information direkt i koden.

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Ansluta till cachen

Kommentar

Skapa ingen ny anslutning för varje åtgärd i koden. Återanvänd istället anslutningar så mycket som möjligt.

Skapa en ny Node.js-app

Skapa en ny skriptfil med namnet redistest.js.

Lägg till följande exempel på JavaScript i filen:

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));

Den här koden visar hur du ansluter till en Azure Cache for Redis-instans med hjälp av cachens värdnamn och viktiga miljövariabler. Koden lagrar och hämtar även ett strängvärde i cacheminnet. Kommandona PING och CLIENT LIST körs också. Fler exempel på hur du använder Redis med node_redis-klienten finns i Node-Redis.

Kör skriptet med hjälp av Node.js:
```
node redistest.js
```

Kontrollera att utdata ser ut ungefär som i det här exemplet:

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

Rensa resurser

Om du vill fortsätta att använda de resurser som du skapade i den här artikeln behåller du resursgruppen.

Annars kan du ta bort den Azure-resursgrupp som du skapade om du är klar med resurserna för att undvika kostnader som är relaterade till resurserna.

Varning

Att ta bort en resursgrupp kan inte ångras. När du tar bort en resursgrupp tas alla resurser i resursgruppen bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna i en befintlig resursgrupp som har resurser som du vill behålla kan du ta bort varje resurs individuellt i stället för att ta bort resursgruppen.

Ta bort en resursgrupp

Logga in på Azure-portalen och välj Resursgrupper.
Välj den resursgrupp som ska tas bort.

Om det finns många resursgrupper anger du namnet på den resursgrupp som du skapade för att slutföra den här artikeln i Filtrera efter valfritt fält. I listan med sökresultat väljer du resursgruppen.
Välj Ta bort resursgrupp.
I fönstret Ta bort en resursgrupp anger du namnet på resursgruppen som ska bekräftas och väljer sedan Ta bort.

Inom en liten stund tas resursgruppen och alla dess resurser bort.

Hämta exempelkoden

Hämta Node.js snabbstartsexempel på GitHub.

Skapa en ASP.NET webbapp som använder en Azure Cache for Redis

Dela via

Snabbstart: Använda Azure Cache for Redis med en Node.js-app

Förutsättningar

Skapa en cache

Installera nod-redis-klientbiblioteket

Skapa en Node.js app för att komma åt en cache

Aktivera Microsoft Entra-ID-autentisering i cacheminnet

Installera Azure Identity-klientbiblioteket för JavaScript

Skapa en Node.js app med hjälp av Microsoft Entra-ID

Skapa en JavaScript-exempelapp som har omautentisering

Hämta värdnamnet, portarna och åtkomstnyckeln

Ansluta till cachen

Skapa en ny Node.js-app

Rensa resurser

Ta bort en resursgrupp

Hämta exempelkoden

Feedback

Ytterligare resurser

Dela via

Snabbstart: Använda Azure Cache for Redis med en Node.js-app

Förutsättningar

Skapa en cache

Installera nod-redis-klientbiblioteket

Skapa en Node.js app för att komma åt en cache

Aktivera Microsoft Entra-ID-autentisering i cacheminnet

Installera Azure Identity-klientbiblioteket för JavaScript

Skapa en Node.js app med hjälp av Microsoft Entra-ID

Skapa en JavaScript-exempelapp som har omautentisering

Rensa resurser

Ta bort en resursgrupp

Hämta exempelkoden

Relaterat innehåll

Feedback

Ytterligare resurser