Snabbstart: Använda Azure Redis i Node.js

Artikel
12/19/2024

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

Förutsättningar

Azure-prenumeration – skapa en kostnadsfritt
Node.js installerat – Information om hur du installerar Node.js finns i Installera Node.js i Windows för instruktioner om hur du installerar Node och npm på en Windows-dator.

Skapa en Azure Managed Redis-instans (förhandsversion)

Om du vill skapa en Azure Managed Redis-instans (förhandsversion) loggar du in på Azure Portal och väljer Skapa en resurs.
På sidan Nytt skriver du Azure Cache for Redis i sökrutan.

På sidan Ny Redis Cache konfigurerar du inställningarna för din nya cache.

Inställning	Välj ett värde	beskrivning
Abonnemang	Listrutan och välj din prenumeration.	Den prenumeration som den nya Azure Managed Redis-instansen ska skapas under.
Resursgrupp	Listrutan och välj en resursgrupp eller välj Skapa ny och ange ett nytt resursgruppsnamn.	Namn på den resursgrupp där cacheminnet och andra resurser ska skapas. Genom att placera alla dina appresurser i en resursgrupp kan du enkelt hantera eller ta bort dem tillsammans.
DNS-namn	Ange ett namn som är unikt i regionen.	Cachenamnet måste vara en sträng mellan 1 och 63 tecken när det kombineras med cachens regionnamn som endast innehåller siffror, bokstäver eller bindestreck. (Om cachenamnet är mindre än 45 tecken bör det fungera i alla tillgängliga regioner.) Namnet måste börja och sluta med ett tal eller en bokstav och får inte innehålla bindestreck i följd. Värdnamnet för cacheinstansen är `\<DNS name\>.\<Azure region\>.redis.azure.net`.
Plats	Listrutan och välj en plats.	Azure Managed Redis är tillgängligt i valda Azure-regioner.
Cachetyp	Listrutan och välj prestandanivå och cachestorlek.	Nivån avgör prestanda för Redis-instansen, medan cachestorleken avgör vilket minne som är tillgängligt för lagring av data. Information om hur du väljer rätt prestandanivå finns i Välja rätt nivå

Skärmbild som visar fliken Azure Managed Redis Basics.

Välj Nästa: Nätverk och välj antingen en offentlig eller privat slutpunkt.
Välj Nästa: Avancerat.

Konfigurera alla Redis-moduler som du vill lägga till i instansen.

Som standard för en ny hanterad cache:
- Microsoft Entra-ID är aktiverat.
- Autentisering av åtkomstnycklar är inaktiverat av säkerhetsskäl.
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.

Ange Klustringsprincip till Företag för en icke-grupperad cache eller till OSS för en klustrad cache. Mer information om hur du väljer klustringsprincip finns i Klusterprincip.

Om du använder aktiv geo-replikering måste den konfigureras när den skapas. Mer information finns i Konfigurera aktiv geo-replikering för Azure Managed Redis-instanser.

Viktigt!

Du kan inte ändra klustringsprincipen för en Azure Managed Redis-instans (förhandsversion) när du har skapat den. Om du använder RediSearch krävs enterprise-klusterprincipen och NoEviction är den enda borttagningsprincipen som stöds.

Viktigt!

Om du använder den här cacheinstansen i en geo-replikeringsgrupp kan borttagningsprinciper inte ändras när instansen har skapats. Se till att känna till borttagningsprinciperna för dina primära noder innan du skapar cacheminnet. Mer information om aktiv geo-replikering finns i Krav för aktiv geo-replikering.

Viktigt!

Du kan inte ändra moduler när du har skapat en cacheinstans. Moduler måste aktiveras när du skapar en Azure Cache for Redis-instans. Det finns inget alternativ för att aktivera konfigurationen av en modul när du har skapat en cache.
Välj Nästa: Taggar och hoppa över.
Välj Nästa: Granska + skapa.
Granska inställningarna och välj Skapa.

Det tar flera minuter för Redis-instansen att skapa. Du kan övervaka förloppet på översiktssidan för Azure Managed Redis. När Status visas som Körs är cachen redo att användas.

Skapa en Azure Cache for Redis-instans

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 npm med hjälp av 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 en Azure Managed Redis-instans (förhandsversion). Vi rekommenderar att du använder Microsoft Entra-ID.

Microsoft Entra ID-autentisering (rekommenderas)
Åtkomstnyckelautentisering

Använda Microsoft Entra-ID-autentisering i cacheminnet

Azure Redis-cacheminnen, förutom Enterprise- och Enterprise Flash-nivåer, har Microsoft Entra-autentisering aktiverat som standard. Åtkomstnycklar är inaktiverade som standard.

Viktigt!

Microsoft rekommenderar att du använder Microsoft Entra-ID-autentisering för den säkraste autentiseringsupplevelsen i stället för att använda lösenord eller åtkomstnycklar. Autentiseringen som beskrivs i det här avsnittet i artikeln använder åtkomstnycklar, som kräver en mycket hög grad av förtroende för programmet och medför risker som inte finns när du använder Microsoft Entra-ID. Använd metoden i det här dokumentet endast när Microsoft Entra ID-autentisering inte är genomförbar.

I Azure Portal väljer du den cache där du vill använda Microsoft Entra-tokenbaserad autentisering.
Välj Autentisering på resursmenyn.
Välj Välj medlem och ange namnet på en giltig användare. Användaren som du anger tilldelas automatiskt åtkomstprincip för dataägare som standard när du väljer Spara. Du kan också ange en hanterad identitet eller tjänstens huvudnamn för att ansluta till cacheinstansen.

Information om hur du använder Microsoft Entra-ID med Azure CLI finns i referenssidorna för identitet.

Installera JavaScript Azure Identity-klientbiblioteket

Med Microsoft Authentication Library (MSAL) kan du hämta säkerhetstoken från Microsoft-identiteten för att autentisera användare. Det finns ett JavaScript Azure-identitetsklientbibliotek som använder MSAL för att tillhandahålla stöd för tokenautentisering. Installera det här biblioteket med :npm

npm install @azure/identity

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

Lägg till miljövariabler för ditt värdnamn och tjänsthuvudnamns-ID, vilket är objekt-ID för tjänstens huvudnamn eller användare i Microsoft Entra. Leta efter användarnamnet i Azure Portal.
```
set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Skapa en ny 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 Managed 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 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));

Kör skriptet med Node.js.
```
node redistest.js
```

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 med omautentisering

Microsoft Entra ID-åtkomsttoken har en begränsad livslängd, i genomsnitt 75 minuter. För att upprätthålla en anslutning till cacheminnet måste du uppdatera token. Det här exemplet visar hur du gör detta med Hjälp av JavaScript.

Skapa en ny skriptfil med namnet redistestreauth.js.

Lägg till följande JavaScript-exempel 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_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));

Kör skriptet med Node.js.
```
node redistestreauth.js
```

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

Kommentar

Ytterligare exempel på hur du använder Microsoft Entra-ID för att autentisera till Redis med hjälp av node-redis-biblioteket finns i den här GitHub-lagringsplatsen

Viktigt!

Hämta värdnamn, portar och åtkomstnycklar från Azure Portal

För att ansluta din Azure Cache for Redis-server behöver cacheklienten värdnamnet, portarna och en nyckel för cachen. Vissa klienter kan hänvisa till dessa objekt med namn som skiljer sig något. Du kan hämta värdnamnet, portarna och nycklarna från Azure Portal.

Om du vill hämta åtkomstnycklarna väljer du Autentisering på resursmenyn. Välj sedan fliken Åtkomstnycklar .
Om du vill hämta värdnamnet och portarna för cacheminnet väljer du Översikt på resursmenyn. Värdnamnet är av formatet DNS name.redis.cache.windows.net>.<

Lägg till miljövariabler för HOST NAME och primär åtkomstnyckel. Använd dessa variabler från koden i stället för att inkludera känslig information direkt i koden.

set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set AZURE_MANAGED_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 JavaScript-exempel i filen.

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

Den här koden visar hur du ansluter till en Azure Cache for Redis-instans med hjälp av cache-värdnamnet 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 på https://redis.js.org/.

Kör skriptet med Node.js.
```
node redistest.js
```

Exempel på utdata.

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 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 en Azure Cache for Redis. Vi rekommenderar att du använder Microsoft Entra-ID.

Microsoft Entra ID-autentisering (rekommenderas)
Åtkomstnyckelautentisering

Använda Microsoft Entra-ID-autentisering i cacheminnet

Azure Redis-cacheminnen, förutom Enterprise- och Enterprise Flash-nivåer, har Microsoft Entra-autentisering aktiverat som standard. Åtkomstnycklar är inaktiverade som standard.

Viktigt!

I Azure Portal väljer du den cache där du vill använda Microsoft Entra-tokenbaserad autentisering.
Välj Autentisering på resursmenyn.
Välj Välj medlem och ange namnet på en giltig användare. Användaren som du anger tilldelas automatiskt åtkomstprincip för dataägare som standard när du väljer Spara. Du kan också ange en hanterad identitet eller tjänstens huvudnamn för att ansluta till cacheinstansen.

Information om hur du använder Microsoft Entra-ID med Azure CLI finns i referenssidorna för identitet.

Installera JavaScript Azure Identity-klientbiblioteket

npm install @azure/identity

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

Lägg till miljövariabler för ditt värdnamn och tjänsthuvudnamns-ID, vilket är objekt-ID för tjänstens huvudnamn eller användare i Microsoft Entra. Leta efter användarnamnet i Azure Portal.
```
set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Skapa en ny 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 cache-värdnamnet 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 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));

Kör skriptet med Node.js.
```
node redistest.js
```

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 med omautentisering

Skapa en ny skriptfil med namnet redistestreauth.js.

Lägg till följande JavaScript-exempel 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 Node.js.
```
node redistestreauth.js
```

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

Kommentar

Ytterligare exempel på hur du använder Microsoft Entra-ID för att autentisera till Redis med hjälp av node-redis-biblioteket finns i den här GitHub-lagringsplatsen

Hämta värdnamn, portar och åtkomstnycklar från Azure Portal

Om du vill hämta åtkomstnycklarna väljer du Autentisering på resursmenyn. Välj sedan fliken Åtkomstnycklar .
Om du vill hämta värdnamnet och portarna för cacheminnet väljer du Översikt på resursmenyn. Värdnamnet är av formatet DNS name.redis.cache.windows.net>.<

Lägg till miljövariabler för HOST NAME och primär åtkomstnyckel. 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 JavaScript-exempel 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));

Kör skriptet med Node.js.
```
node redistest.js
```

Exempel på utdata.

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.

Om du är klar med resurserna kan du ta bort den Azure-resursgrupp som du skapade för att undvika avgifter.

Viktigt!

Att ta bort en resursgrupp kan inte ångras. När du tar bort en resursgrupp tas alla resurser som ingår i den bort permanent. Kontrollera att du inte av misstag tar bort fel resursgrupp eller resurser. Om du har skapat resurserna i en befintlig resursgrupp som innehåller 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 du vill ta bort.

Om det finns många resursgrupper använder du rutan Filter för alla fält... och skriver namnet på resursgruppen som du skapade för den här artikeln. Välj resursgruppen i resultatlistan.
Välj Ta bort resursgrupp.
Du blir ombedd att bekräfta borttagningen av resursgruppen. Skriv namnet på din resursgrupp för att bekräfta och välj sedan Ta bort.

Efter en liten stund tas resursgruppen och de resurser som finns i den bort.

Hämta exempelkoden

Hämta snabbstarten för Node.js på GitHub.

I den här snabbstarten har du lärt dig hur du använder antingen Azure Managed Redis (förhandsversion) eller Azure Cache for Redis från ett Node.js program. Läs mer om Azure Redis-erbjudanden:

Dela via

Snabbstart: Använda Azure Redis i Node.js

Förutsättningar

Skapa en Azure Managed Redis-instans (förhandsversion)

Skapa en Azure Cache for Redis-instans

Installera nod-redis-klientbiblioteket

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

Använda Microsoft Entra-ID-autentisering i cacheminnet

Installera JavaScript Azure Identity-klientbiblioteket

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

Skapa en JavaScript-exempelapp med omautentisering

Hämta värdnamn, portar och åtkomstnycklar från Azure Portal

Ansluta till cachen

Skapa en ny Node.js-app

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

Använda Microsoft Entra-ID-autentisering i cacheminnet

Installera JavaScript Azure Identity-klientbiblioteket

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

Skapa en JavaScript-exempelapp med omautentisering

Hämta värdnamn, portar och åtkomstnycklar från Azure Portal

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 Redis i Node.js

Förutsättningar

Skapa en Azure Managed Redis-instans (förhandsversion)

Skapa en Azure Cache for Redis-instans

Installera nod-redis-klientbiblioteket

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

Använda Microsoft Entra-ID-autentisering i cacheminnet

Installera JavaScript Azure Identity-klientbiblioteket

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

Skapa en JavaScript-exempelapp med omautentisering

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

Använda Microsoft Entra-ID-autentisering i cacheminnet

Installera JavaScript Azure Identity-klientbiblioteket

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

Skapa en JavaScript-exempelapp med omautentisering

Rensa resurser

Ta bort en resursgrupp

Hämta exempelkoden

Relaterat innehåll

Feedback

Ytterligare resurser