Udostępnij za pośrednictwem

Szybki start: korzystanie z usługi Azure Redis w Node.js

  • Dotyczy: ✅ Azure Cache for Redis, ✅ Azure Managed Redis

W tym Szybkim starcie integrujesz Azure Managed Redis lub Azure Cache for Redis w aplikacji Node.js. Aplikacja ma dostęp do bezpiecznej dedykowanej pamięci podręcznej dostępnej z poziomu dowolnej aplikacji na platformie Azure.

Wymagania wstępne

Tworzenie wystąpienia usługi Redis zarządzanej platformy Azure

  1. Aby utworzyć wystąpienie usługi Azure Managed Redis, zaloguj się do witryny Azure Portal i wybierz pozycję Utwórz zasób.

  2. Na stronie Nowy w polu wyszukiwania wpisz Azure Cache for Redis.

  3. Na karcie Nowa pamięć podręczna Redis Cache skonfiguruj ustawienia nowej pamięci podręcznej w obszarze Podstawy.

    Ustawienia Wybierz wartość Opis
    Subskrypcja Z listy rozwijanej wybierz subskrypcję. Subskrypcja, w ramach której ma zostać utworzone to nowe wystąpienie usługi Azure Managed Redis.
    Grupa zasobów Z listy rozwijanej i wybierz grupę zasobów lub wybierz pozycję Utwórz nową i wprowadź nową nazwę grupy zasobów. Nazwa grupy zasobów, w której ma zostać utworzona pamięć podręczna i inne zasoby. Umieszczając wszystkie zasoby aplikacji w jednej grupie zasobów, można je łatwo zarządzać lub usuwać razem.
    Nazwa Wprowadź nazwę unikatową w regionie. Nazwa pamięci podręcznej musi być ciągiem z zakresu od 1 do 63 znaków w połączeniu z nazwą regionu pamięci podręcznej, która zawiera tylko cyfry, litery lub łączniki. (Jeśli nazwa pamięci podręcznej jest mniejsza niż 45 znaków, powinna działać we wszystkich aktualnie dostępnych regionach). Nazwa musi zaczynać się i kończyć cyfrą lub literą i nie może zawierać kolejnych łączników. Nazwa hosta wystąpienia
    Region Rozwiń listę rozwijaną i wybierz lokalizację. Usługa Azure Managed Redis jest dostępna w wybranych regionach świadczenia usługi Azure.
    Warstwa danych Wybierz opcję W pamięci , aby uzyskać wysoką wydajność, lub Pamięć flash w celu uzyskania mniejszej wydajności pamięci podręcznej Warstwy w pamięci obejmują Zrównoważoną, Zoptymalizowaną dla pamięci i Zoptymalizowaną dla obliczeń. Użyj warstwy Flash, do magazynowania danych w pamięci (RAM) i na dysku (SSD).
    Rozmiar pamięci podręcznej Otwórz listę rozwijaną i wybierz rozmiar. Rozmiar pamięci podręcznej zależy od warstwy. Najmniejszy rozmiar to poziom zrównoważony. Rozmiar największej warstwy w pamięci to warstwa zoptymalizowana pod kątem pamięci.
    Wydajność Z listy rozwijanej wybierz preferencję wydajności. Wydajność zależy od liczby procesorów wirtualnych. Liczba procesorów wirtualnych różni się w zależności od warstwy. Zoptymalizowane pod kątem obliczeń ma najwięcej vCPU.

    Aby uzyskać wskazówki dotyczące wybierania odpowiedniej warstwy wydajności, zobacz Wybieranie odpowiedniej warstwy.

    Ważne

    Wszystkie warstwy pamięci korzystające z ponad 120 GB miejsca do magazynowania są dostępne w publicznej wersji zapoznawczej, w tym zoptymalizowane pod kątem pamięci M150 i wyższe; zrównoważone B150 i wyższe; oraz zoptymalizowane pod kątem obliczeń X150 i wyższe. Wszystkie te warstwy i wyższe są dostępne w publicznej wersji zapoznawczej.

    Wszystkie warstwy zoptymalizowane pod kątem technologii Flash są w publicznej wersji zapoznawczej.

  4. Wybierz pozycję Dalej: Sieć i wybierz publiczny punkt końcowy lub prywatny punkt końcowy.

  5. Wybierz pozycję Dalej: Aktywna replikacja geograficzna. Aby można było używać aktywnej replikacji geograficznej, należy ją włączyć podczas aprowizacji. Pamięci podręczne bez aktywnej replikacji geograficznej nie mogą być później dodawane ani dołączać do aktywnych grup replikacji geograficznej. Aby uzyskać więcej informacji, zobacz Konfigurowanie aktywnej replikacji geograficznej dla wystąpień usługi Azure Managed Redis.

  6. Wybierz kartę Dalej: Zaawansowane .

    Skonfiguruj moduły Redis, które chcesz dodać do instancji.

    Domyślnie dla nowej zarządzanej pamięci podręcznej:

    • Identyfikator entra firmy Microsoft jest włączony.
    • Uwierzytelnianie kluczy dostępu jest wyłączone ze względów bezpieczeństwa.

    Ważne

    W celu uzyskania optymalnego bezpieczeństwa zalecamy użycie identyfikatora Entra firmy Microsoft z tożsamościami zarządzanymi w celu autoryzowania żądań względem pamięci podręcznej, jeśli to możliwe. Autoryzacja za pomocą Microsoft Entra ID i tożsamości zarządzanych zapewnia lepsze zabezpieczenia i łatwość użytkowania w porównaniu z autoryzacją za pomocą współdzielonego klucza dostępu. Aby uzyskać więcej informacji na temat używania tożsamości zarządzanych z pamięcią podręczną, zobacz Użyj Microsoft Entra ID do uwierzytelniania pamięci podręcznej.

    Ustaw zasady klastrowania:

    • Użyj rozwiązania Enterprise , aby użyć usługi RedisSearch lub innych modułów
    • Użyj OSS dla klastrowanej pamięci podręcznej.
    • Użyj Nieklasterowana (wersja zapoznawcza) dla nieklasterowanej pamięci podręcznej.

    Aby uzyskać więcej informacji na temat wybierania zasad klastrowania, zobacz Zasady klastra.

    Ważne

    Nie można zmienić zasad klastrowania wystąpienia usługi Azure Managed Redis po jego utworzeniu. Jeśli używasz narzędzia RediSearch, wymagane są zasady klastra przedsiębiorstwa i NoEviction są jedynymi obsługiwanymi zasadami eksmisji.

    Ważne

    Jeśli używasz tego wystąpienia pamięci podręcznej w grupie replikacji geograficznej, nie można zmienić zasad eksmisji po utworzeniu wystąpienia. Pamiętaj, aby przed utworzeniem pamięci podręcznej znać zasady eksmisji węzłów podstawowych. Aby uzyskać więcej informacji na temat aktywnej replikacji geograficznej, zobacz Wymagania wstępne aktywnej replikacji geograficznej.

    Ważne

    Nie można zmieniać modułów po utworzeniu wystąpienia pamięci podręcznej. Moduły muszą być włączone w momencie tworzenia wystąpienia usługi Azure Cache for Redis. Nie ma możliwości włączenia konfiguracji modułu po utworzeniu pamięci podręcznej.

  7. Wybierz pozycję Dalej: Tagi i pomiń.

  8. Wybierz Dalej: Przejrzyj i utwórz.

  9. Przejrzyj ustawienia i wybierz pozycję Utwórz.

    Utworzenie wystąpienia usługi Redis trwa kilka minut. Postęp można monitorować na stronie Omówienie usługi Azure Managed Redis. Gdy stan jest wyświetlany jako Uruchomiono, pamięć podręczna jest gotowa do użycia.

Tworzenie wystąpienia usługi Azure Cache for Redis

  1. W witrynie Azure Portal wyszukaj i wybierz pozycję Azure Cache for Redis.

  2. Na stronie Azure Cache for Redis wybierz pozycję Utwórz>usługę Azure Cache for Redis.

  3. Na karcie Podstawowe na stronie Nowa pamięć podręczna Redis skonfiguruj następujące ustawienia:

    • Subskrypcja: wybierz subskrypcję, której chcesz użyć.
    • Grupa zasobów: wybierz grupę zasobów lub wybierz pozycję Utwórz nową i wprowadź nową nazwę grupy zasobów. Umieszczenie wszystkich zasobów aplikacji w tej samej grupie zasobów umożliwia łatwe zarządzanie nimi i usuwanie ich razem.
    • Nazwa: wprowadź unikatową nazwę cache w regionie. Nazwa musi:
      • Powinien być ciągiem znaków od 1 do 63.
      • Zawierają tylko cyfry, litery i łączniki.
      • Początek i koniec cyfrą lub literą.
      • Nie zawiera kolejnych łączników.
    • Region: wybierz region świadczenia usługi Azure w pobliżu innych usług korzystających z pamięci podręcznej.
    • Jednostka SKU pamięci podręcznej: wybierz jednostkę SKU , aby określić dostępne rozmiary, wydajność i funkcje pamięci podręcznej.
    • Rozmiar pamięci podręcznej: wybierz rozmiar pamięci podręcznej. Aby uzyskać więcej informacji, zobacz Omówienie usługi Azure Cache for Redis.

    Zrzut ekranu przedstawiający zakładkę Podstawowe na stronie Nowej pamięci podręcznej Redis.

  4. Wybierz kartę Sieć lub wybierz pozycję Dalej: Sieć.

  5. Na karcie Sieć wybierz metodę łączności do użycia dla pamięci podręcznej. Prywatny punkt końcowy jest zalecany w przypadku zabezpieczeń. Jeśli wybierzesz pozycję Prywatny punkt końcowy, wybierz pozycję Dodaj prywatny punkt końcowy i utwórz prywatny punkt końcowy.

  6. Wybierz kartę Zaawansowane lub wybierz pozycję Dalej: Zaawansowane.

  7. W okienku Zaawansowane skonfiguruj następujące opcje:

    • Wybierz Microsoft Entra Authentication lub Uwierzytelnianie za pomocą kluczy dostępu. Uwierzytelnianie Entra firmy Microsoft jest domyślnie włączone.
    • Wybierz, czy chcesz włączyć port inny niż TLS.
    • W przypadku pamięci podręcznej Premium można skonfigurować lub wyłączyć strefy dostępności. Po utworzeniu pamięci podręcznej nie można wyłączyć stref dostępności. W przypadku pamięci podręcznej w warstwie Standard strefy dostępności są przydzielane automatycznie. Strefy dostępności nie są dostępne dla SKU w wersji Basic.
    • W przypadku pamięci podręcznej Premium skonfiguruj ustawienia dotyczące liczby replik, klastrowania i liczby fragmentów, tożsamości zarządzanej przypisanej przez system i trwałości danych.

    Na poniższym obrazie przedstawiono kartę Zaawansowane dla SKU Standard.

    Zrzut ekranu przedstawiający okienko Zaawansowane dla pamięci podręcznej SKU o standardowej konfiguracji.

    Ważne

    Jeśli to możliwe, użyj Microsoft Entra ID i tożsamości zarządzanych do autoryzowania żądań uzyskania dostępu do pamięci podręcznej. Autoryzacja przy użyciu identyfikatora Entra firmy Microsoft i tożsamości zarządzanej zapewnia lepsze zabezpieczenia i jest łatwiejsza niż autoryzacja klucza dostępu współdzielonego. Aby uzyskać więcej informacji na temat używania tożsamości zarządzanych z pamięcią podręczną, zobacz Użyj Microsoft Entra ID do uwierzytelniania pamięci podręcznej.

  8. Opcjonalnie wybierz kartę Tagi lub wybierz pozycję Dalej: Tagi, a następnie wprowadź nazwy tagów i wartości, aby kategoryzować zasoby pamięci podręcznej.

  9. Wybierz pozycję Przejrzyj i utwórz, a po zakończeniu walidacji wybierz pozycję Utwórz.

Wdrożenie nowej pamięci podręcznej trwa kilka minut. Postęp wdrażania można monitorować na stronie Azure Cache for Redis w portalu. Gdy w obszarze Stan pamięci podręcznej jest wyświetlana wartość Uruchomiono, pamięć podręczna jest gotowa do użycia.

Instalowanie biblioteki klienta node-redis

Biblioteka node-redis jest podstawowym klientem Node.js dla usługi Redis. Klienta można zainstalować za pomocą narzędzia npm , używając następującego polecenia:

npm install redis

Tworzenie aplikacji Node.js w celu uzyskania dostępu do pamięci podręcznej

Utwórz aplikację Node.js, która używa identyfikatora Entra firmy Microsoft lub kluczy dostępu do łączenia się z wystąpieniem usługi Azure Managed Redis. Zalecamy użycie identyfikatora Entra firmy Microsoft.

Używanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

Menedżerowane przez Azure pamięci podręczne Redis mają domyślnie włączone uwierzytelnianie Microsoft Entra.

  1. W witrynie Azure Portal wybierz pamięć podręczną, w której chcesz użyć uwierzytelniania opartego na tokenach firmy Microsoft.

  2. Wybierz pozycję Uwierzytelnianie z menu Zasób.

  3. Wybierz pozycję Wybierz członka i wprowadź nazwę prawidłowego użytkownika. Wprowadzony użytkownik jest automatycznie przypisywany zasad dostępu właściciela danych domyślnie po wybraniu pozycji Zapisz. Możesz również wprowadzić tożsamość zarządzaną lub jednostkę usługi, aby nawiązać połączenie z wystąpieniem pamięci podręcznej.

    Zrzut ekranu przedstawiający uwierzytelnianie wybrane w menu zasobów i zaznaczoną opcję Włącz uwierzytelnianie firmy Microsoft Entra.

Aby uzyskać informacje na temat korzystania z identyfikatora Entra firmy Microsoft z interfejsem wiersza polecenia platformy Azure, zobacz strony referencyjne dotyczące tożsamości.

Instalowanie biblioteki klienta usługi Azure Identity w języku JavaScript

Biblioteka Microsoft Authentication Library (MSAL) umożliwia uzyskiwanie tokenów zabezpieczających z tożsamości firmy Microsoft w celu uwierzytelniania użytkowników. Dostępna jest biblioteka klienta tożsamości platformy Azure w języku JavaScript, która zapewnia obsługę uwierzytelniania tokenu przy użyciu biblioteki MSAL. Zainstaluj tę bibliotekę przy użyciu polecenia npm:

npm install @azure/identity

Tworzenie nowej aplikacji Node.js przy użyciu identyfikatora Entra firmy Microsoft

  1. Dodaj zmienne środowiskowe dla nazwy hosta i identyfikatora jednostki usługi, który jest identyfikatorem obiektu jednostki usługi lub użytkownika entra firmy Microsoft. W witrynie Azure Portal wyszukaj nazwę użytkownika.

    set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  2. Utwórz nowy plik skryptu o nazwie redistest.js.

  3. Dodaj do pliku poniższy przykład kodu JavaScript. Ten kod pokazuje, jak nawiązać połączenie z wystąpieniem usługi Azure Managed Redis przy użyciu nazwy hosta pamięci podręcznej i kluczowych zmiennych środowiskowych. W kodzie jest również przechowywana i pobierana wartość ciągu w pamięci podręcznej. Następuje wykonanie poleceń PING i CLIENT LIST. Aby uzyskać więcej przykładów używania usługi Redis z klientem node-redis , zobacz https://redis.js.org/.

    const { createClient } = require("redis");
const { DefaultAzureCredential } = require("@azure/identity");

async function main() {
  // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
  const credential = new DefaultAzureCredential();
  const redisScope = "https://redis.azure.com/.default";

  // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
  let accessToken = await credential.getToken(redisScope);
  console.log("access Token", accessToken);

  // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
  const cacheConnection = createClient({
    username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
    password: accessToken.token,
    url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
    pingInterval: 100000,
    socket: { 
      tls: true,
      keepAlive: 0 
    },
  });

  cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
  await cacheConnection.connect();

  // PING command
  console.log("\nCache command: PING");
  console.log("Cache response : " + await cacheConnection.ping());

  // SET
  console.log("\nCache command: SET Message");
  console.log("Cache response : " + await cacheConnection.set("Message",
      "Hello! The cache is working from Node.js!"));

  // GET
  console.log("\nCache command: GET Message");
  console.log("Cache response : " + await cacheConnection.get("Message"));

  // Client list, useful to see if connection list is growing...
  console.log("\nCache command: CLIENT LIST");
  console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

  cacheConnection.disconnect();

  return "Done"
}

main().then((result) => console.log(result)).catch(ex => console.log(ex));

  4. Uruchom skrypt języka Node.js.

    node redistest.js

  5. Dane wyjściowe kodu wyglądają następująco.

    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

Tworzenie przykładowej aplikacji JavaScript przy użyciu ponownego uwierzytelniania

Tokeny dostępu identyfikatora Entra firmy Microsoft mają ograniczoną żywotność, średnio 75 minut. Aby zachować połączenie z pamięcią podręczną, należy odświeżyć token. W tym przykładzie pokazano, jak to zrobić przy użyciu języka JavaScript.

  1. Utwórz nowy plik skryptu o nazwie redistestreauth.js.

  2. Dodaj do pliku poniższy przykład kodu JavaScript.

     const { createClient } = require("redis");
 const { DefaultAzureCredential } = require("@azure/identity");

 async function returnPassword(credential) {
     const redisScope = "https://redis.azure.com/.default";

     // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
     return credential.getToken(redisScope);
 }

 async function main() {
   // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
   const credential = new DefaultAzureCredential();
   let accessToken = await returnPassword(credential);

   // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
   let cacheConnection = createClient({
     username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
     password: accessToken.token,
     url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
     pingInterval: 100000,
     socket: { 
       tls: true,
       keepAlive: 0 
     },
   });

   cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
   await cacheConnection.connect();

   for (let i = 0; i < 3; i++) {
     try {
         // PING command
         console.log("\nCache command: PING");
         console.log("Cache response : " + await cacheConnection.ping());

         // SET
         console.log("\nCache command: SET Message");
         console.log("Cache response : " + await cacheConnection.set("Message",
             "Hello! The cache is working from Node.js!"));

         // GET
         console.log("\nCache command: GET Message");
         console.log("Cache response : " + await cacheConnection.get("Message"));

         // Client list, useful to see if connection list is growing...
         console.log("\nCache command: CLIENT LIST");
         console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
       break;
     } catch (e) {
       console.log("error during redis get", e.toString());
       if ((accessToken.expiresOnTimestamp <= Date.now())|| (redis.status === "end" || "close") ) {
         await redis.disconnect();
         accessToken = await returnPassword(credential);
         cacheConnection = createClient({
           username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
           password: accessToken.token,
           url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
           pingInterval: 100000,
           socket: {
             tls: true,
             keepAlive: 0
           },
         });
       }
     }
   }
 }

 main().then((result) => console.log(result)).catch(ex => console.log(ex));

  3. Uruchom skrypt języka Node.js.

    node redistestreauth.js

  4. Dane wyjściowe kodu wyglądają następująco.

     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

Uwaga / Notatka

Aby uzyskać dodatkowe przykłady użycia identyfikatora Entra firmy Microsoft do uwierzytelniania w usłudze Redis przy użyciu biblioteki node-redis, zobacz to repozytorium GitHub

Tworzenie aplikacji Node.js w celu uzyskania dostępu do pamięci podręcznej

Utwórz aplikację Node.js, która używa identyfikatora Entra firmy Microsoft lub kluczy dostępu do nawiązywania połączenia z usługą Azure Cache for Redis. Zalecamy użycie identyfikatora Entra firmy Microsoft.

Używanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

Menedżerowane przez Azure pamięci podręczne Redis mają domyślnie włączone uwierzytelnianie Microsoft Entra.

  1. W witrynie Azure Portal wybierz pamięć podręczną, w której chcesz użyć uwierzytelniania opartego na tokenach firmy Microsoft.

  2. Wybierz pozycję Uwierzytelnianie z menu Zasób.

  3. Wybierz pozycję Wybierz członka i wprowadź nazwę prawidłowego użytkownika. Wprowadzony użytkownik jest automatycznie przypisywany zasad dostępu właściciela danych domyślnie po wybraniu pozycji Zapisz. Możesz również wprowadzić tożsamość zarządzaną lub jednostkę usługi, aby nawiązać połączenie z wystąpieniem pamięci podręcznej.

    Zrzut ekranu przedstawiający uwierzytelnianie wybrane w menu zasobów i zaznaczoną opcję Włącz uwierzytelnianie firmy Microsoft Entra.

Aby uzyskać informacje na temat korzystania z identyfikatora Entra firmy Microsoft z interfejsem wiersza polecenia platformy Azure, zobacz strony referencyjne dotyczące tożsamości.

Instalowanie biblioteki klienta usługi Azure Identity w języku JavaScript

Biblioteka Microsoft Authentication Library (MSAL) umożliwia uzyskiwanie tokenów zabezpieczających z tożsamości firmy Microsoft w celu uwierzytelniania użytkowników. Dostępna jest biblioteka klienta tożsamości platformy Azure w języku JavaScript, która zapewnia obsługę uwierzytelniania tokenu przy użyciu biblioteki MSAL. Zainstaluj tę bibliotekę przy użyciu polecenia npm:

npm install @azure/identity

Tworzenie nowej aplikacji Node.js przy użyciu identyfikatora Entra firmy Microsoft

  1. Dodaj zmienne środowiskowe dla nazwy hosta i identyfikatora jednostki usługi, który jest identyfikatorem obiektu jednostki usługi lub użytkownika entra firmy Microsoft. W witrynie Azure Portal wyszukaj nazwę użytkownika.

    set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

  2. Utwórz nowy plik skryptu o nazwie redistest.js.

  3. Dodaj do pliku poniższy przykład kodu JavaScript. W tym kodzie pokazano sposób podłączania do wystąpienia usługi Azure Cache for Redis przy użyciu nazwy hosta w pamięci podręcznej i kluczowych zmiennych środowiskowych. W kodzie jest również przechowywana i pobierana wartość ciągu w pamięci podręcznej. Następuje wykonanie poleceń PING i CLIENT LIST. Aby uzyskać więcej przykładów używania usługi Redis z klientem node-redis , zobacz https://redis.js.org/.

    const { createClient } = require("redis");
const { DefaultAzureCredential } = require("@azure/identity");

async function main() {
  // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
  const credential = new DefaultAzureCredential();
  const redisScope = "https://redis.azure.com/.default";

  // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
  let accessToken = await credential.getToken(redisScope);
  console.log("access Token", accessToken);

  // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
  const cacheConnection = createClient({
    username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
    password: accessToken.token,
    url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
    pingInterval: 100000,
    socket: { 
      tls: true,
      keepAlive: 0 
    },
  });

  cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
  await cacheConnection.connect();

  // PING command
  console.log("\nCache command: PING");
  console.log("Cache response : " + await cacheConnection.ping());

  // SET
  console.log("\nCache command: SET Message");
  console.log("Cache response : " + await cacheConnection.set("Message",
      "Hello! The cache is working from Node.js!"));

  // GET
  console.log("\nCache command: GET Message");
  console.log("Cache response : " + await cacheConnection.get("Message"));

  // Client list, useful to see if connection list is growing...
  console.log("\nCache command: CLIENT LIST");
  console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

  cacheConnection.disconnect();

  return "Done"
}

main().then((result) => console.log(result)).catch(ex => console.log(ex));

  4. Uruchom skrypt języka Node.js.

    node redistest.js

  5. Dane wyjściowe kodu wyglądają następująco.

    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

Tworzenie przykładowej aplikacji JavaScript przy użyciu ponownego uwierzytelniania

Tokeny dostępu identyfikatora Entra firmy Microsoft mają ograniczoną żywotność, średnio 75 minut. Aby zachować połączenie z pamięcią podręczną, należy odświeżyć token. W tym przykładzie pokazano, jak to zrobić przy użyciu języka JavaScript.

  1. Utwórz nowy plik skryptu o nazwie redistestreauth.js.

  2. Dodaj do pliku poniższy przykład kodu JavaScript.

     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. Uruchom skrypt języka Node.js.

    node redistestreauth.js

  4. Dane wyjściowe kodu wyglądają następująco.

     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

Uwaga / Notatka

Aby uzyskać dodatkowe przykłady użycia identyfikatora Entra firmy Microsoft do uwierzytelniania w usłudze Redis przy użyciu biblioteki node-redis, zobacz to repozytorium GitHub

Uprzątnij zasoby

Jeśli chcesz nadal korzystać z zasobów utworzonych w tym artykule, zachowaj grupę zasobów.

W przeciwnym razie, jeśli skończysz z zasobami, możesz usunąć utworzoną grupę zasobów platformy Azure, aby uniknąć naliczania opłat.

Ważne

Usunięcie grupy zasobów jest nieodwracalne. Jeśli usuniesz grupę zasobów, wszystkie zawarte w niej zasoby zostaną trwale usunięte. Uważaj, aby nie usunąć przypadkowo niewłaściwych zasobów lub grupy zasobów. Jeśli zasoby zostały utworzone w istniejącej grupie zasobów zawierającej zasoby, które chcesz zachować, możesz usunąć każdy zasób indywidualnie zamiast usuwać grupę zasobów.

Aby usunąć grupę zasobów

  1. Zaloguj się do witryny Azure Portal, a następnie wybierz pozycję Grupy zasobów.

  2. Wybierz grupę zasobów, którą chcesz usunąć.

    Jeśli istnieje wiele grup zasobów, użyj pola Filtruj dla dowolnego pola... wpisz nazwę grupy zasobów utworzonej dla tego artykułu. Wybierz grupę zasobów na liście wyników.

    Zrzut ekranu przedstawiający listę grup zasobów do usunięcia w okienku roboczym.

  3. Wybierz pozycję Usuń grupę zasobów.

  4. Poproszono Cię o potwierdzenie usunięcia grupy zasobów. Wpisz nazwę grupy zasobów w celu potwierdzenia, a następnie wybierz pozycję Usuń.

    Zrzut ekranu przedstawiający formularz, który wymaga nazwy zasobu w celu potwierdzenia usunięcia.

Po krótkim czasie grupa zasobów i wszystkie jej zasoby zostaną usunięte.

Pobieranie przykładowego kodu

Uzyskaj przewodnik Szybki start Node.js w witrynie GitHub.

Treści powiązane

W tym przewodniku szybkiego startu pokazano, jak używać usługi Azure Managed Redis lub Azure Cache for Redis w aplikacji Node.js. Dowiedz się więcej o ofertach usługi Azure Redis: