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

Artykuł
11/19/2024

W tym przewodniku Szybki start dołączasz usługę Azure Managed Redis (wersja zapoznawcza) lub Azure Cache for Redis do 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

Subskrypcja platformy Azure — utwórz jedną bezpłatnie
Node.js zainstalowane — aby zainstalować Node.js, zobacz Instalowanie Node.js w systemie Windows , aby uzyskać instrukcje dotyczące sposobu instalowania środowiska Node i narzędzia npm na komputerze z systemem Windows.

Tworzenie wystąpienia usługi Azure Managed Redis (wersja zapoznawcza)

Aby utworzyć wystąpienie usługi Azure Managed Redis (wersja zapoznawcza), zaloguj się do witryny Azure Portal i wybierz pozycję Utwórz zasób.
Na stronie Nowy wybierz pozycję Bazy danych, a następnie wybierz pozycję Azure Cache for Redis.

Na stronie Nowa pamięć podręczna Redis Cache skonfiguruj ustawienia nowej pamięci podręcznej.

Ustawienie	Wybierz wartość	opis
Subskrypcja	Z listy rozwijanej i 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 DNS	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 pamięci podręcznej to `\<DNS name\>.\<Azure region\>.redis.azure.net`.
Lokalizacja	Z listy rozwijanej i wybierz lokalizację.	Usługa Azure Managed Redis jest dostępna w wybranych regionach świadczenia usługi Azure.
Typ pamięci podręcznej	Z listy rozwijanej wybierz warstwę wydajności i rozmiar pamięci podręcznej.	Warstwa określa wydajność wystąpienia usługi Redis, podczas gdy rozmiar pamięci podręcznej określa pamięć dostępną do przechowywania danych. Aby uzyskać wskazówki dotyczące wybierania odpowiedniej warstwy wydajności, zobacz Chosing prawej warstwy

Zrzut ekranu przedstawiający kartę Podstawy usługi Azure Managed Redis.

Wybierz pozycję Dalej: Sieć i wybierz publiczny lub prywatny punkt końcowy.
Wybierz pozycję Dalej: Zaawansowane. W tym miejscu można skonfigurować wszystkie moduły usługi Redis do dodania do wystąpienia.

Ustaw zasady klastrowania na Enterprise dla nieklastrowanej pamięci podręcznej lub na system operacyjny dla klastrowanej pamięci podręcznej. Aby uzyskać więcej informacji na temat wybierania zasad klastrowania, zobacz Zasady klastra.

Jeśli używasz aktywnej replikacji geograficznej, należy ją skonfigurować podczas tworzenia. Aby uzyskać instrukcje dotyczące wykonywania tych czynności, zobacz Konfigurowanie aktywnej replikacji geograficznej dla wystąpień usługi Azure Managed Redis.

Ważne

Po utworzeniu nie można zmienić zasad klastrowania wystąpienia usługi Azure Managed Redis (wersja zapoznawcza). 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.
Wybierz pozycję Dalej: Tagi i pomiń.
Wybierz pozycję Dalej: Przeglądanie i tworzenie.
Przejrzyj ustawienia i wybierz pozycję Utwórz.

Utworzenie wystąpienia usługi Redis potrwa 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 pamięci podręcznej Azure Cache for Redis

Aby utworzyć pamięć podręczną, zaloguj się do witryny Azure Portal. W menu portalu wybierz pozycję Utwórz zasób.
W okienku Wprowadzenie wprowadź ciąg Azure Cache for Redis na pasku wyszukiwania. W wynikach wyszukiwania znajdź usługę Azure Cache for Redis, a następnie wybierz pozycję Utwórz.

W okienku Nowa pamięć podręczna Redis Cache na karcie Podstawy skonfiguruj następujące ustawienia dla pamięci podręcznej:

Ustawienie	Akcja	opis
Subskrypcja	Wybierz subskrypcję platformy Azure.	Subskrypcja do użycia w celu utworzenia nowego wystąpienia usługi Azure Cache for Redis.
Grupa zasobów:	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 DNS	Wprowadź unikatową nazwę.	Nazwa pamięci podręcznej musi być ciągiem od 1 do 63 znaków, który zawiera tylko cyfry, litery i łączniki. Nazwa musi zaczynać się i kończyć cyfrą lub literą i nie może zawierać kolejnych łączników. Nazwa hosta wystąpienia pamięci podręcznej to `\<DNS name>.redis.cache.windows.net`.
Lokalizacja	Wybierz lokalizację.	Region platformy Azure, który znajduje się w pobliżu innych usług korzystających z pamięci podręcznej.
Jednostka SKU pamięci podręcznej	Wybierz jednostkę SKU.	Jednostka SKU określa rozmiar, wydajność i parametry funkcji, które są dostępne dla pamięci podręcznej. Aby uzyskać więcej informacji, zobacz Omówienie usługi Azure Cache for Redis.
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.

Wybierz kartę Sieć lub wybierz pozycję Dalej: Sieć.
Na karcie Sieć wybierz metodę łączności do użycia dla pamięci podręcznej.
Wybierz kartę Zaawansowane lub wybierz pozycję Dalej: Zaawansowane.
W okienku Zaawansowane sprawdź lub wybierz metodę uwierzytelniania na podstawie następujących informacji:
- Domyślnie w przypadku nowej pamięci podręcznej w warstwie Podstawowa, Standardowa lub Premium jest włączone uwierzytelnianie Entra firmy Microsoft, a uwierzytelnianie kluczy dostępu jest wyłączone.
- W przypadku pamięci podręcznych w warstwie Podstawowa lub Standardowa można wybrać opcję portu innego niż TLS.
- W przypadku pamięci podręcznych w warstwie Standardowa i Premium można włą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 Premium skonfiguruj ustawienia portów innych niż TLS, klastrowanie, tożsamość zarządzana i trwałość danych.
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 przy użyciu identyfikatora Entra firmy Microsoft i tożsamości zarządzanych zapewnia doskonałe zabezpieczenia i łatwość korzystania z autoryzacji 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 Use Microsoft Entra ID for cache authentication (Używanie identyfikatora Entra firmy Microsoft do uwierzytelniania w pamięci podręcznej).
(Opcjonalnie) Wybierz kartę Tagi lub wybierz pozycję Dalej: Tagi.
(Opcjonalnie) Na karcie Tagi wprowadź nazwę i wartość tagu, jeśli chcesz podzielić zasób pamięci podręcznej.
Wybierz przycisk Przejrzyj i utwórz.

Na karcie Przeglądanie i tworzenie platforma Azure automatycznie weryfikuje konfigurację.
Po pojawieniu się zielonego komunikatu Weryfikacja przekazana wybierz pozycję Utwórz.

Nowe wdrożenie pamięci podręcznej odbywa się w ciągu kilku minut. Postęp wdrażania można monitorować w okienku Przegląd usługi Azure Cache for Redis. Gdy zostanie wyświetlony stan 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 nawiązywania połączenia z wystąpieniem usługi Azure Managed Redis (wersja zapoznawcza). Zalecamy użycie identyfikatora Entra firmy Microsoft.

Uwierzytelnianie identyfikatora Entra firmy Microsoft (zalecane)
Uwierzytelnianie za pomocą klucza dostępu

Włączanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

Jeśli masz pamięć podręczną, sprawdź, czy włączono uwierzytelnianie Firmy Microsoft Entra. Jeśli nie, włącz ją. Zalecamy używanie identyfikatora Entra firmy Microsoft dla Twoich aplikacji.

W witrynie Azure Portal wybierz wystąpienie usługi Azure Cache for Redis, w którym chcesz użyć uwierzytelniania opartego na tokenach firmy Microsoft.
Wybierz pozycję Uwierzytelnianie z menu Zasób.
Sprawdź w okienku roboczym, czy jest zaznaczone pole wyboru Włącz uwierzytelnianie firmy Microsoft Entra. Jeśli tak, możesz przejść dalej.
Wybierz pozycję Włącz uwierzytelnianie firmy Microsoft Entra 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.
Zostanie wyświetlone okno podręczne z pytaniem, czy chcesz zaktualizować konfigurację, i informuje o tym, że zajmuje to kilka minut. Wybierz opcję Tak.

Ważne

Po zakończeniu operacji włączania węzły w wystąpieniu pamięci podręcznej są ponownie uruchamiane w celu załadowania nowej konfiguracji. Zalecamy wykonanie tej operacji w oknie obsługi lub poza godzinami pracy szczytu. Operacja może potrwać do 30 minut.

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

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
```
Utwórz nowy plik skryptu o nazwie redistest.js.

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

Uruchom skrypt języka Node.js.
```
node redistest.js
```

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.

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

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

Uruchom skrypt języka Node.js.
```
node redistestreauth.js
```

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

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

Pobieranie nazwy hosta, portów i kluczy dostępu z witryny Azure Portal

Aby połączyć serwer usługi Azure Cache for Redis, klient pamięci podręcznej potrzebuje nazwy hosta, portów i klucza pamięci podręcznej. Niektórzy klienci mogą odwoływać się do tych elementów przy użyciu nieco innych nazw. Nazwę hosta, porty i klucze można uzyskać w witrynie Azure Portal.

Aby uzyskać klucze dostępu, wybierz pozycję Uwierzytelnianie z menu Zasób. Następnie wybierz kartę Klucze dostępu.
Aby uzyskać nazwę hosta i porty pamięci podręcznej, wybierz pozycję Przegląd w menu Zasób. Nazwa hosta ma formę <DNS name.redis.cache.windows.net>.

Dodaj zmienne środowiskowe dla NAZWY HOSTA i podstawowego klucza dostępu. Użyj tych zmiennych z kodu zamiast dołączać informacje poufne bezpośrednio w kodzie.

set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set AZURE_MANAGED_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Łączenie z pamięcią podręczną

Uwaga

Nie twórz nowego połączenia dla każdej operacji w kodzie. Zamiast tego należy w miarę możliwości używać połączeń ponownie.

Tworzenie nowej aplikacji na platformie Node.js

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

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

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

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życia usługi Redis z klientem node_redis, zobacz https://redis.js.org/.

Uruchom skrypt języka Node.js.
```
node redistest.js
```

Przykładowe dane wyjściowe.

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 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.

Uwierzytelnianie identyfikatora Entra firmy Microsoft (zalecane)
Uwierzytelnianie za pomocą klucza dostępu

Włączanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

W witrynie Azure Portal wybierz wystąpienie usługi Azure Cache for Redis, w którym chcesz użyć uwierzytelniania opartego na tokenach firmy Microsoft.
Wybierz pozycję Uwierzytelnianie z menu Zasób.
Sprawdź w okienku roboczym, czy jest zaznaczone pole wyboru Włącz uwierzytelnianie firmy Microsoft Entra. Jeśli tak, możesz przejść dalej.
Wybierz pozycję Włącz uwierzytelnianie firmy Microsoft Entra 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.
Zostanie wyświetlone okno podręczne z pytaniem, czy chcesz zaktualizować konfigurację, i informuje o tym, że zajmuje to kilka minut. Wybierz opcję Tak.

Ważne

Po zakończeniu operacji włączania węzły w wystąpieniu pamięci podręcznej są ponownie uruchamiane w celu załadowania nowej konfiguracji. Zalecamy wykonanie tej operacji w oknie obsługi lub poza godzinami pracy szczytu. Operacja może potrwać do 30 minut.

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

npm install @azure/identity

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

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
```
Utwórz nowy plik skryptu o nazwie redistest.js.

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

Uruchom skrypt języka Node.js.
```
node redistest.js
```

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

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

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

Uruchom skrypt języka Node.js.
```
node redistestreauth.js
```

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

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

Pobieranie nazwy hosta, portów i kluczy dostępu z witryny Azure Portal

Aby uzyskać klucze dostępu, wybierz pozycję Uwierzytelnianie z menu Zasób. Następnie wybierz kartę Klucze dostępu.
Aby uzyskać nazwę hosta i porty pamięci podręcznej, wybierz pozycję Przegląd w menu Zasób. Nazwa hosta ma formę <DNS name.redis.cache.windows.net>.

Dodaj zmienne środowiskowe dla NAZWY HOSTA i podstawowego klucza dostępu. Użyj tych zmiennych z kodu zamiast dołączać informacje poufne bezpośrednio w kodzie.

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Łączenie z pamięcią podręczną

Uwaga

Nie twórz nowego połączenia dla każdej operacji w kodzie. Zamiast tego należy w miarę możliwości używać połączeń ponownie.

Tworzenie nowej aplikacji na platformie Node.js

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

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

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

Uruchom skrypt języka Node.js.
```
node redistest.js
```

Przykładowe dane wyjściowe.

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

Czyszczenie zasobów

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

Zaloguj się do witryny Azure Portal, a następnie wybierz pozycję Grupy zasobów.
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.
Wybierz pozycję Usuń grupę zasobów.
Zobaczysz prośbę o potwierdzenie usunięcia grupy zasobów. Wpisz nazwę grupy zasobów w celu potwierdzenia, a następnie wybierz pozycję Usuń.

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.

W tym przewodniku Szybki start przedstawiono sposób używania usługi Azure Managed Redis (wersja zapoznawcza) lub usługi Azure Cache for Redis z poziomu aplikacji Node.js. Dowiedz się więcej o ofertach usługi Azure Redis:

Udostępnij za pośrednictwem

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

Wymagania wstępne

Tworzenie wystąpienia usługi Azure Managed Redis (wersja zapoznawcza)

Tworzenie wystąpienia pamięci podręcznej Azure Cache for Redis

Instalowanie biblioteki klienta node-redis

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

Włączanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

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

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

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

Pobieranie nazwy hosta, portów i kluczy dostępu z witryny Azure Portal

Łączenie z pamięcią podręczną

Tworzenie nowej aplikacji na platformie Node.js

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

Włączanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

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

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

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

Pobieranie nazwy hosta, portów i kluczy dostępu z witryny Azure Portal

Łączenie z pamięcią podręczną

Tworzenie nowej aplikacji na platformie Node.js

Czyszczenie zasobów

Aby usunąć grupę zasobów

Pobieranie przykładowego kodu

Opinia

Dodatkowe zasoby

Udostępnij za pośrednictwem

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

Wymagania wstępne

Tworzenie wystąpienia usługi Azure Managed Redis (wersja zapoznawcza)

Tworzenie wystąpienia pamięci podręcznej Azure Cache for Redis

Instalowanie biblioteki klienta node-redis

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

Włączanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

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

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

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

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

Włączanie uwierzytelniania identyfikatora Entra firmy Microsoft w pamięci podręcznej

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

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

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

Czyszczenie zasobów

Aby usunąć grupę zasobów

Pobieranie przykładowego kodu

Powiązana zawartość

Opinia

Dodatkowe zasoby