Rychlý start: Použití Azure Redis v Node.js

Článek
12/19/2024

V tomto rychlém startu zahrnete azure Managed Redis (Preview) nebo Azure Cache for Redis do Node.js aplikace. Aplikace má přístup k zabezpečené vyhrazené mezipaměti, která je přístupná z libovolné aplikace v Azure.

Požadavky

Předplatné Azure – vytvoření bezplatného předplatného
Node.js nainstalovaná – pokud chcete nainstalovat Node.js, přečtěte si článek Instalace Node.js ve Windows , kde najdete pokyny k instalaci Node a npm na počítač s Windows.

Vytvoření instance Azure Managed Redis (Preview)

Pokud chcete vytvořit instanci Azure Managed Redis (Preview), přihlaste se k webu Azure Portal a vyberte Vytvořit prostředek.
Na stránce Nový zadejte do vyhledávacího pole Azure Cache for Redis.

Na stránce New Redis Cache nakonfigurujte nastavení pro novou mezipaměť.

Nastavení	Zvolit hodnotu	Popis
Předplatné	Rozevírací seznam a vyberte své předplatné.	Předplatné, ve kterém se má tato nová instance Azure Managed Redis vytvořit.
Skupina prostředků	Rozevírací seznam a vyberte skupinu prostředků nebo vyberte Vytvořit novou a zadejte nový název skupiny prostředků.	Název skupiny prostředků, ve které chcete vytvořit mezipaměť a další prostředky. Když umístíte všechny prostředky aplikace do jedné skupiny prostředků, můžete je snadno spravovat nebo odstraňovat společně.
Název DNS	Zadejte název, který je v oblasti jedinečný.	Název mezipaměti musí být řetězec mezi 1 a 63 znaky v kombinaci s názvem oblasti mezipaměti, který obsahuje pouze číslice, písmena nebo pomlčky. (Pokud je název mezipaměti kratší než 45 znaků, měl by fungovat ve všech aktuálně dostupných oblastech.) Název musí začínat a končit číslicí nebo písmenem a nesmí obsahovat po sobě jdoucí pomlčky. Název hostitele vaší instance mezipaměti je `\<DNS name\>.\<Azure region\>.redis.azure.net`.
Místo	Rozevírací seznam a výběr umístění	Azure Managed Redis je k dispozici ve vybraných oblastech Azure.
Typ mezipaměti	Rozevírací seznam a vyberte úroveň výkonu a velikost mezipaměti.	Úroveň určuje výkon instance Redis, zatímco velikost mezipaměti určuje paměť dostupnou k ukládání dat. Pokyny k výběru správné úrovně výkonu najdete v tématu Volba správné úrovně.

Snímek obrazovky znázorňující kartu Základy Azure Managed Redis

Vyberte Další: Sítě a vyberte veřejný nebo privátní koncový bod.
Vyberte Další: Upřesnit.

Nakonfigurujte všechny moduly Redis, které wan chcete přidat do instance.

Ve výchozím nastavení pro novou spravovanou mezipaměť:
- Je povoleno ID Microsoft Entra.
- Ověřování přístupových klíčů je zakázáno z bezpečnostních důvodů.
Důležité

Pro zajištění optimálního zabezpečení doporučujeme použít ID Microsoft Entra se spravovanými identitami k autorizaci požadavků v mezipaměti, pokud je to možné. Autorizace pomocí Microsoft Entra ID a spravovaných identit poskytuje vynikající zabezpečení a snadné použití prostřednictvím autorizace sdíleného přístupového klíče. Další informace o používání spravovaných identit s mezipamětí naleznete v tématu Použití MICROSOFT Entra ID pro ověřování mezipaměti.

Nastavte zásady clusteringu na Enterprise pro neclusterovanou mezipaměť nebo na OSS pro clusterovanou mezipaměť. Další informace o výběru zásad clusteringu najdete v tématu Zásady clusteru.

Pokud používáte aktivní geografickou replikaci, musí být nakonfigurovaná během vytváření. Další informace najdete v tématu Konfigurace aktivní geografické replikace pro instance Azure Managed Redis.

Důležité

Po vytvoření nemůžete změnit zásady clusteringu instance Azure Managed Redis (Preview). Pokud používáte RediSearch, vyžaduje se zásada podnikového clusteru a NoEviction je to jediná podporovaná zásada vyřazení.

Důležité

Pokud tuto instanci mezipaměti používáte ve skupině geografické replikace, zásady vyřazení nelze po vytvoření instance změnit. Před vytvořením mezipaměti nezapomeňte znát zásady vyřazení primárních uzlů. Další informace o aktivní geografické replikaci najdete v tématu Požadavky na aktivní geografickou replikaci.

Důležité

Po vytvoření instance mezipaměti nemůžete měnit moduly. Moduly musí být povolené v době, kdy vytvoříte instanci Azure Cache for Redis. Po vytvoření mezipaměti není možné povolit konfiguraci modulu.
Vyberte Další: Značky a přeskočte.
Vyberte Další: Zkontrolovat a vytvořit.
Zkontrolujte nastavení a vyberte Vytvořit.

Vytvoření instance Redis trvá několik minut. Průběh můžete sledovat na stránce přehledu Azure Managed Redis. Když se stav zobrazí jako Spuštěno, je mezipaměť připravená k použití.

Vytvoření instance Azure Cache for Redis

Pokud chcete vytvořit mezipaměť, přihlaste se k webu Azure Portal. V nabídce portálu vyberte Vytvořit prostředek.
V podokně Začínáme zadejte azure Cache for Redis na panelu hledání. Ve výsledcích hledání vyhledejte Azure Cache for Redis a pak vyberte Vytvořit.

V podokně New Redis Cache na kartě Základy nakonfigurujte pro mezipaměť následující nastavení:

Nastavení	Akce	Popis
Předplatné	Vyberte své předplatné Azure.	Předplatné, které se má použít k vytvoření nové instance Azure Cache for Redis.
Skupina prostředků	Vyberte skupinu prostředků nebo vyberte Vytvořit novou a zadejte název nové skupiny prostředků.	Název skupiny prostředků, ve které chcete vytvořit mezipaměť a další prostředky. Když umístíte všechny prostředky aplikace do jedné skupiny prostředků, můžete je snadno spravovat nebo odstraňovat společně.
Název DNS	Zadejte jedinečný název.	Název mezipaměti musí být řetězec 1 až 63 znaků, který obsahuje jenom číslice, písmena a pomlčky. Název musí začínat a končit číslem nebo písmenem a nesmí obsahovat po sobě jdoucí pomlčky. Název hostitele vaší instance mezipaměti je `\<DNS name>.redis.cache.windows.net`.
Místo	Vyberte umístění.	Oblast Azure, která je blízko jiných služeb, které používají vaši mezipaměť.
Skladová položka mezipaměti	Vyberte skladovou položku.	Skladová položka určuje velikost, výkon a parametry funkcí, které jsou k dispozici pro mezipaměť. Další informace najdete v přehledu služby Azure Cache for Redis.
Velikost mezipaměti	Vyberte velikost mezipaměti.	Další informace najdete v přehledu služby Azure Cache for Redis.

Vyberte kartu Sítě nebo vyberte Další: Sítě.
Na kartě Sítě vyberte metodu připojení, která se má použít pro mezipaměť.
Vyberte kartu Upřesnit nebo vyberte Další: Upřesnit.
V podokně Upřesnit ověřte nebo vyberte metodu ověřování na základě následujících informací:
- Ve výchozím nastavení je pro novou mezipaměť Basic, Standard nebo Premium povolená služba Microsoft Entra Authentication a ověřování přístupových klíčů je zakázané.
- U mezipamětí Basic nebo Standard můžete zvolit výběr pro port jiného typu než TLS.
- U mezipamětí Standard a Premium můžete povolit zóny dostupnosti. Po vytvoření mezipaměti nemůžete zakázat zóny dostupnosti.
- Pro mezipaměť Premium nakonfigurujte nastavení pro port bez protokolu TLS, clustering, spravovanou identitu a trvalost dat.
Důležité

Pro zajištění optimálního zabezpečení doporučujeme použít ID Microsoft Entra se spravovanými identitami k autorizaci požadavků v mezipaměti, pokud je to možné. Autorizace pomocí Microsoft Entra ID a spravovaných identit poskytuje vynikající zabezpečení a snadné použití prostřednictvím autorizace sdíleného přístupového klíče. Další informace o používání spravovaných identit s mezipamětí naleznete v tématu Použití MICROSOFT Entra ID pro ověřování mezipaměti.
(Volitelné) Vyberte kartu Značky nebo vyberte Další: Značky.
(Volitelné) Na kartě Značky zadejte název a hodnotu značky , pokud chcete zařadit prostředek mezipaměti do kategorií.
Vyberte tlačítko Zkontrolovat a vytvořit.

Na kartě Zkontrolovat a vytvořit Azure vaši konfiguraci automaticky ověří.
Jakmile se zobrazí zelená zpráva o úspěšném ověření, vyberte Vytvořit.

Během několika minut dojde k novému nasazení mezipaměti. Průběh nasazení můžete monitorovat v podokně Přehled služby Azure Cache for Redis. Když se zobrazí stav Spuštěno, je mezipaměť připravená k použití.

Instalace klientské knihovny node-redis

Knihovna node-redis je primárním klientem Node.js pro Redis. Klienta s npm můžete nainstalovat pomocí následujícího příkazu:

npm install redis

Vytvoření aplikace Node.js pro přístup k mezipaměti

Vytvořte Node.js aplikaci, která pro připojení k instanci Azure Managed Redis (Preview) používá buď ID Microsoft Entra, nebo přístupové klíče. Doporučujeme používat ID Microsoft Entra.

Ověřování Microsoft Entra ID (doporučeno)
Ověřování přístupového klíče

Použití ověřování Microsoft Entra ID v mezipaměti

Mezipaměti Azure Redis s výjimkou úrovní Enterprise a Enterprise Flash mají ve výchozím nastavení povolené ověřování Microsoft Entra. Přístupové klíče jsou ve výchozím nastavení zakázané.

Důležité

Microsoft doporučuje používat ověřování Microsoft Entra ID pro nejbezpečnější ověřování místo použití hesel nebo přístupových klíčů. Ověřování popsané v této části článku používá přístupové klíče, které vyžadují velmi vysoký stupeň důvěryhodnosti v aplikaci a nese rizika, která nejsou přítomna při použití ID Microsoft Entra. Přístup v tomto dokumentu použijte pouze v případě, že ověřování POMOCÍ ID Microsoft Entra není možné.

Na webu Azure Portal vyberte mezipaměť, do které chcete použít ověřování založené na tokenech Microsoft Entra.
V nabídce Prostředek vyberte Ověřování .
Vyberte vybrat člena a zadejte jméno platného uživatele. Uživatel, který zadáte, se automaticky přiřadí zásadám přístupu vlastníka dat ve výchozím nastavení, když vyberete Uložit. Můžete také zadat spravovanou identitu nebo instanční objekt pro připojení k instanci mezipaměti.

Informace o použití ID Microsoft Entra s Azure CLI najdete na referenčních stránkách pro identitu.

Instalace klientské knihovny Azure Identity v JavaScriptu

Knihovna MSAL (Microsoft Authentication Library) umožňuje získat tokeny zabezpečení z identity Microsoftu k ověřování uživatelů. K dispozici je javascriptová klientská knihovna identit Azure, která k zajištění podpory ověřování tokenů používá knihovnu MSAL. Nainstalujte tuto knihovnu pomocí npm:

npm install @azure/identity

Vytvoření nové aplikace Node.js pomocí ID Microsoft Entra

Přidejte proměnné prostředí pro název hostitele a ID instančního objektu, což je ID objektu instančního objektu nebo uživatele Microsoft Entra ID. Na webu Azure Portal vyhledejte uživatelské jméno.
```
set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Vytvořte nový soubor skriptu s názvem redistest.js.

Přidejte následující příklad JavaScriptu do souboru. Tento kód ukazuje, jak se připojit k instanci Azure Managed Redis pomocí názvu hostitele mezipaměti a klíčových proměnných prostředí. Kód také ukládá a načítá hodnotu řetězce v mezipaměti. Spouští se také příkazy PING a CLIENT LIST. Další příklady použití Redis s klientem node-redis najdete v tématu 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));

Spusťte skript s Node.js.
```
node redistest.js
```

Výstup kódu vypadá takto.

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

Vytvoření ukázkové javascriptové aplikace s opětovným ověřením

Přístupové tokeny Microsoft Entra ID mají omezenou životnost, což je průměr 75 minut. Pokud chcete udržovat připojení k mezipaměti, musíte token aktualizovat. Tento příklad ukazuje, jak to provést pomocí JavaScriptu.

Vytvořte nový soubor skriptu s názvem redistestreauth.js.

Přidejte následující příklad JavaScriptu do souboru.

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

Spusťte skript s Node.js.
```
node redistestreauth.js
```

Výstup kódu vypadá takto.

 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

Poznámka:

Další příklady použití Microsoft Entra ID k ověření ve službě Redis pomocí knihovny node-redis najdete v tomto úložišti GitHub.

Důležité

Načtení názvu hostitele, portů a přístupových klíčů z webu Azure Portal

K připojení serveru Azure Cache for Redis potřebuje klient mezipaměti název hostitele, porty a klíč pro mezipaměť. Někteří klienti mohou tyto položky označovat trochu odlišnými názvy. Název hostitele, porty a klíče můžete získat z webu Azure Portal.

Přístupové klíče získáte tak, že v nabídce Prostředek vyberete Možnost Ověřování . Pak vyberte kartu Přístupové klávesy .
Pokud chcete získat název hostitele a porty pro vaši mezipaměť, vyberte v nabídce Prostředek přehled . Název hostitele je ve formátu DNS name.redis.cache.windows.net>.<

Přidejte proměnné prostředí pro NÁZEV HOSTITELE a primární přístupový klíč. Místo zahrnutí citlivých informací přímo do kódu použijte tyto proměnné z kódu.

set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set AZURE_MANAGED_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Připojení k mezipaměti

Poznámka:

Nevytvádejte nové připojení pro každou operaci v kódu. Raději co nejvíce připojení použijte opakovaně.

Vytvoření nové aplikace Node.js

Vytvořte nový soubor skriptu s názvem redistest.js.

Přidejte následující příklad JavaScriptu do souboru.

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

Tento kód ukazuje, jak se připojit k instanci Azure Cache for Redis pomocí názvu hostitele mezipaměti a klíčových proměnných prostředí. Kód také ukládá a načítá hodnotu řetězce v mezipaměti. Spouští se také příkazy PING a CLIENT LIST. Pro další příklady použití Redis pomocí klienta node_redis se podívejte na https://redis.js.org/.

Spusťte skript s Node.js.
```
node redistest.js
```

Příklad výstupu

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

Vytvoření aplikace Node.js pro přístup k mezipaměti

Vytvořte Node.js aplikaci, která pro připojení ke službě Azure Cache for Redis používá BUĎ ID Microsoft Entra, nebo přístupové klíče. Doporučujeme používat ID Microsoft Entra.

Ověřování Microsoft Entra ID (doporučeno)
Ověřování přístupového klíče

Použití ověřování Microsoft Entra ID v mezipaměti

Důležité

Na webu Azure Portal vyberte mezipaměť, do které chcete použít ověřování založené na tokenech Microsoft Entra.
V nabídce Prostředek vyberte Ověřování .
Vyberte vybrat člena a zadejte jméno platného uživatele. Uživatel, který zadáte, se automaticky přiřadí zásadám přístupu vlastníka dat ve výchozím nastavení, když vyberete Uložit. Můžete také zadat spravovanou identitu nebo instanční objekt pro připojení k instanci mezipaměti.

Informace o použití ID Microsoft Entra s Azure CLI najdete na referenčních stránkách pro identitu.

Instalace klientské knihovny Azure Identity v JavaScriptu

npm install @azure/identity

Vytvoření nové aplikace Node.js pomocí ID Microsoft Entra

Přidejte proměnné prostředí pro název hostitele a ID instančního objektu, což je ID objektu instančního objektu nebo uživatele Microsoft Entra ID. Na webu Azure Portal vyhledejte uživatelské jméno.
```
set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Vytvořte nový soubor skriptu s názvem redistest.js.

Přidejte následující příklad JavaScriptu do souboru. Tento kód ukazuje, jak se připojit k instanci Azure Cache for Redis pomocí názvu hostitele mezipaměti a klíčových proměnných prostředí. Kód také ukládá a načítá hodnotu řetězce v mezipaměti. Spouští se také příkazy PING a CLIENT LIST. Další příklady použití Redis s klientem node-redis najdete v tématu 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));

Spusťte skript s Node.js.
```
node redistest.js
```

Výstup kódu vypadá takto.

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

Vytvoření ukázkové javascriptové aplikace s opětovným ověřením

Vytvořte nový soubor skriptu s názvem redistestreauth.js.

Přidejte následující příklad JavaScriptu do souboru.

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

Spusťte skript s Node.js.
```
node redistestreauth.js
```

Výstup kódu vypadá takto.

 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

Poznámka:

Další příklady použití Microsoft Entra ID k ověření ve službě Redis pomocí knihovny node-redis najdete v tomto úložišti GitHub.

Načtení názvu hostitele, portů a přístupových klíčů z webu Azure Portal

Přístupové klíče získáte tak, že v nabídce Prostředek vyberete Možnost Ověřování . Pak vyberte kartu Přístupové klávesy .
Pokud chcete získat název hostitele a porty pro vaši mezipaměť, vyberte v nabídce Prostředek přehled . Název hostitele je ve formátu DNS name.redis.cache.windows.net>.<

Přidejte proměnné prostředí pro NÁZEV HOSTITELE a primární přístupový klíč. Místo zahrnutí citlivých informací přímo do kódu použijte tyto proměnné z kódu.

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Připojení k mezipaměti

Poznámka:

Nevytvádejte nové připojení pro každou operaci v kódu. Raději co nejvíce připojení použijte opakovaně.

Vytvoření nové aplikace Node.js

Vytvořte nový soubor skriptu s názvem redistest.js.

Přidejte následující příklad JavaScriptu do souboru.

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

Spusťte skript s Node.js.
```
node redistest.js
```

Příklad výstupu

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

Vyčištění prostředků

Pokud chcete dál používat prostředky, které jste vytvořili v tomto článku, ponechte skupinu prostředků.

Jinak pokud jste s prostředky hotovi, můžete odstranit skupinu prostředků Azure, kterou jste vytvořili, abyste se vyhnuli poplatkům.

Důležité

Odstranění skupiny prostředků je nevratné. Při odstranění skupiny prostředků se všechny prostředky, které obsahuje, trvale odstraní. Ujistěte se, že nechtěně neodstraníte nesprávnou skupinu prostředků nebo prostředky. Pokud jste prostředky vytvořili v existující skupině prostředků, která obsahuje prostředky, které chcete zachovat, můžete každý prostředek odstranit jednotlivě místo odstranění skupiny prostředků.

Odstranění skupiny prostředků

Přihlaste se k portálu Azure Portal a potom vyberte Skupiny prostředků.
Vyberte skupinu prostředků, kterou chcete odstranit.

Pokud existuje mnoho skupin prostředků, použijte filtr pro jakékoli pole... zadejte název skupiny prostředků, kterou jste vytvořili pro tento článek. V seznamu výsledků vyberte skupinu prostředků.
Vyberte Odstranit skupinu prostředků.
Zobrazí se výzva k potvrzení odstranění skupiny prostředků. Potvrďte odstranění zadáním názvu vaší skupiny prostředků a vyberte Odstranit.

Po chvíli se skupina prostředků včetně všech prostředků, které obsahuje, odstraní.

Získání ukázkového kódu

Získejte rychlý start pro Node.js na GitHubu.

V tomto rychlém startu jste zjistili, jak používat Azure Managed Redis (Preview) nebo Azure Cache for Redis z Node.js aplikace. Další informace o nabídkách Azure Redis:

Sdílet prostřednictvím

Rychlý start: Použití Azure Redis v Node.js

Požadavky

Vytvoření instance Azure Managed Redis (Preview)

Vytvoření instance Azure Cache for Redis

Instalace klientské knihovny node-redis

Vytvoření aplikace Node.js pro přístup k mezipaměti

Použití ověřování Microsoft Entra ID v mezipaměti

Instalace klientské knihovny Azure Identity v JavaScriptu

Vytvoření nové aplikace Node.js pomocí ID Microsoft Entra

Vytvoření ukázkové javascriptové aplikace s opětovným ověřením

Načtení názvu hostitele, portů a přístupových klíčů z webu Azure Portal

Připojení k mezipaměti

Vytvoření nové aplikace Node.js

Vytvoření aplikace Node.js pro přístup k mezipaměti

Použití ověřování Microsoft Entra ID v mezipaměti

Instalace klientské knihovny Azure Identity v JavaScriptu

Vytvoření nové aplikace Node.js pomocí ID Microsoft Entra

Vytvoření ukázkové javascriptové aplikace s opětovným ověřením

Načtení názvu hostitele, portů a přístupových klíčů z webu Azure Portal

Připojení k mezipaměti

Vytvoření nové aplikace Node.js

Vyčištění prostředků

Odstranění skupiny prostředků

Získání ukázkového kódu

Váš názor

Další materiály

Sdílet prostřednictvím

Rychlý start: Použití Azure Redis v Node.js

Požadavky

Vytvoření instance Azure Managed Redis (Preview)

Vytvoření instance Azure Cache for Redis

Instalace klientské knihovny node-redis

Vytvoření aplikace Node.js pro přístup k mezipaměti

Použití ověřování Microsoft Entra ID v mezipaměti

Instalace klientské knihovny Azure Identity v JavaScriptu

Vytvoření nové aplikace Node.js pomocí ID Microsoft Entra

Vytvoření ukázkové javascriptové aplikace s opětovným ověřením

Vytvoření aplikace Node.js pro přístup k mezipaměti

Použití ověřování Microsoft Entra ID v mezipaměti

Instalace klientské knihovny Azure Identity v JavaScriptu

Vytvoření nové aplikace Node.js pomocí ID Microsoft Entra

Vytvoření ukázkové javascriptové aplikace s opětovným ověřením

Vyčištění prostředků

Odstranění skupiny prostředků

Získání ukázkového kódu

Související obsah

Váš názor

Další materiály