Schnellstart: Verwenden von Azure Redis in Node.js

Artikel
12/20/2024

In dieser Schnellstartanleitung integrieren Sie Azure Managed Redis oder Azure Cache for Redis in eine Node.js-App. Diese App hat Zugriff auf einen sicheren, dedizierten Cache, der von jeder Anwendung in Azure aus zugänglich ist.

Voraussetzungen

Azure-Abonnement – Erstellen eines kostenlosen Kontos
Installation von Node.js: Anweisungen zur Installation von Node.js finden Sie unter Installieren von Node.js unter Windows. Dort erfahren Sie, wie Sie Node und npm auf einem Windows-Computer installieren.

Erstellen einer Azure Managed Redis-Instanz (Vorschau)

Melden Sie sich zum Erstellen einer Azure Managed Redis-Instanz (Vorschau) beim Azure-Portal an, und wählen Sie Ressource erstellen aus.
Geben Sie auf der Seite Neu im Suchfeld Azure Cache for Redis ein.

Konfigurieren Sie auf der Seite Neuer Redis Cache die Einstellungen für den neuen Cache.

Einstellung	Wert auswählen	BESCHREIBUNG
Abonnement	Öffnen Sie die Dropdownliste, und wählen Sie Ihr Abonnement aus.	Das Abonnement, unter dem diese neue Azure Managed Redis-Instanz erstellt wird.
Ressourcengruppe	Öffnen Sie die Dropdownliste, und wählen Sie eine Ressourcengruppe aus, oder wählen Sie Neu erstellen aus, und geben Sie einen Namen für eine neue Ressourcengruppe ein.	Der Name der Ressourcengruppe, in der Ihr Cache und weitere Ressourcen erstellt werden. Wenn Sie alle Ihre App-Ressourcen in einer Ressourcengruppe zusammenfassen, können Sie sie einfacher gemeinsam verwalten oder löschen.
DNS-Name	Geben Sie einen Namen ein, der in der Region eindeutig ist.	Der Cachename muss zwischen 1 und 63 Zeichen lang sein, wenn er mit dem Regionsnamen des Cache kombiniert wird, und darf nur Ziffern, Buchstaben und Bindestriche enthalten. (Wenn der Cachename weniger als 45 Zeichen lang ist, sollte er in allen derzeit verfügbaren Regionen funktionieren.) Der Name muss mit einer Zahl oder einem Buchstaben beginnen und enden und darf keine aufeinanderfolgenden Bindestriche enthalten. Der Hostname Ihrer Cache-Instanz ist `\<DNS name\>.\<Azure region\>.redis.azure.net`.
Location	Öffnen Sie die Dropdownliste, und wählen Sie einen Standort aus.	Azure Managed Redis ist in ausgewählten Azure-Regionen verfügbar.
Cachetyp	Wählen Sie in der Dropdownliste die Leistungsstufe und die Cachegröße aus.	Die Stufe bestimmt die Leistung der Redis-Instanz, während die Cachegröße den zur Datenspeicherung verfügbaren Arbeitsspeicher bestimmt. Einen Leitfaden zum Auswählen der richtigen Leistungsstufe finden Sie unter Auswählen der richtigen Dienstebene.

Screenshot: Registerkarte „Grundlagen“ in Azure Managed Redis

Wählen Sie Weiter: Netzwerk aus, um einen öffentlichen oder privaten Endpunkt auszuwählen.
Klicken Sie auf Weiter: Erweitert.

Konfigurieren Sie alle Redis-Module, die Sie der Instanz hinzufügen möchten.

Folgendes gilt standardmäßig für neue verwaltete Caches:
- Microsoft Entra ID ist aktiviert.
- Die Authentifizierung mit Zugriffsschlüsseln ist aus Sicherheitsgründen deaktiviert.
Wichtig

Für eine optimale Sicherheit empfehlen wir, Microsoft Entra ID mit verwalteten Identitäten zu verwenden, um Anforderungen nach Möglichkeit für Ihren Cache zu autorisieren. Die Autorisierung mit Microsoft Entra ID und verwalteten Identitäten bietet eine höhere Sicherheit und Benutzerfreundlichkeit als die Autorisierung mit gemeinsam verwendetem Schlüssel. Weitere Informationen zum Verwenden verwalteter Identitäten mit Ihren Caches finden Sie unter Verwenden von Microsoft Entra ID für die Cacheauthentifizierung.

Legen Sie Clusteringrichtlinie auf Enterprise für einen nicht gruppierten Cache fest oder OSS für einen gruppierten Cache. Weitere Informationen zum Auswählen einer Clusterrichtlinie finden Sie unter Clusterrichtlinie.

Bei Verwendung der aktiven Georeplikation muss diese während der Erstellung konfiguriert werden. Weitere Informationen finden Sie unter Konfigurieren der aktiven Georeplikation für Azure Managed Redis-Instanzen.

Wichtig

Sie können die Clusterrichtlinie einer Azure Managed Redis-Instanz (Vorschau) nach der Erstellung nicht mehr ändern. Wenn Sie RediSearch verwenden, ist die Enterprise-Clusterrichtlinie erforderlich, und NoEviction wird die einzige Entfernungsrichtlinie unterstützt.

Wichtig

Wenn Sie diese Cacheinstanz in einer Georeplikationsgruppe verwenden, können Entfernungsrichtlinien nach der Erstellung der Instanz nicht mehr geändert werden. Achten Sie darauf, die Entfernungsrichtlinie Ihrer primären Knoten zu kennen, bevor Sie den Cache erstellen. Weitere Informationen zur aktiven Georeplikation finden Sie unter Voraussetzungen für die aktive Georeplikation.

Wichtig

Module können nach dem Erstellen einer Cache-Instanz nicht mehr geändert werden. Module müssen zum Zeitpunkt der Erstellung einer Azure Cache for Redis-Instanz aktiviert sein. Es gibt keine Option, die Konfiguration eines Moduls zu aktivieren, nachdem Sie einen Cache erstellt haben.
Wählen Sie Weiter: Tags aus, und überspringen Sie den Schritt.
Klicken Sie auf Weiter: Überprüfen + erstellen.
Überprüfen Sie die Einstellungen, und wählen Sie Erstellen aus.

Das Erstellen der Redis-Instanz dauert einige Minuten. Sie können den Fortschritt auf der Seite Übersicht von Azure Managed Redis überwachen. Wenn Wird ausgeführt als Status angezeigt wird, ist der Cache einsatzbereit.

Erstellen einer Azure Cache for Redis-Instanz

Um einen Cache zu erstellen, melden Sie sich im Azure-Portal an. Klicken Sie im Menü des Portals auf Ressource erstellen.
Geben Sie auf der Seite Erste Schritte den Begriff Azure Cache for Redis in das Suchfeld ein. Suchen Sie in den Suchergebnissen nach Azure Cache for Redis, und wählen Sie dann Erstellen aus.

Konfigurieren Sie im Bereich Neuer Redis-Cache auf der Registerkarte Grundlagen die folgenden Einstellungen für Ihren Cache:

Einstellung	Aktion	Beschreibung
Abonnement	Wählen Sie Ihr Azure-Abonnement.	Das Abonnement, das zum Erstellen der neuen Instanz von Azure Cache for Redis verwendet werden soll.
Ressourcengruppe	Wählen Sie eine Ressourcengruppe aus, oder wählen Sie Neu erstellen aus, und geben Sie einen Namen für eine neue Ressourcengruppe ein.	Der Name der Ressourcengruppe, in der Ihr Cache und weitere Ressourcen erstellt werden. Wenn Sie alle Ihre App-Ressourcen in einer Ressourcengruppe zusammenfassen, können Sie sie einfacher gemeinsam verwalten oder löschen.
DNS-Name	Geben Sie einen eindeutigen Namen ein.	Der Cachename muss eine Zeichenfolge mit 1 bis 63 Zeichen sein, die nur Zahlen, Buchstaben und Bindestriche enthält. Der Name muss mit einer Zahl oder einem Buchstaben beginnen und enden und darf keine aufeinanderfolgenden Bindestriche enthalten. Der Hostname Ihrer Cache-Instanz ist `\<DNS name>.redis.cache.windows.net`.
Location	Wählen Sie einen Standort aus.	Eine Azure-Region, die sich in der Nähe anderer Dienste befindet, die Ihren Cache verwenden.
Cache-SKU	Wählen Sie eine SKU aus.	Die SKU bestimmt die Parameter für Größe, Leistung und Features, die für den Cache verfügbar sind. Weitere Informationen finden Sie unter Azure Cache for Redis.
Cachegröße	Wählen Sie eine Cachegröße aus.	Weitere Informationen finden Sie unter Azure Cache for Redis.

Wählen Sie die Registerkarte Netzwerk, oder wählen Sie Weiter: Netzwerk.
Wählen Sie auf der Registerkarte Netzwerk eine Konnektivitätsmethode für den Cache aus.
Wählen Sie die Registerkarte Erweitert aus, oder wählen Sie Weiter: Erweitert aus.
Überprüfen oder wählen Sie im Bereich Erweitert basierend auf den folgenden Informationen eine Authentifizierungsmethode aus:
- Standardmäßig ist für einen neuen Basic-, Standard- oder Premium-Cache die Microsoft Entra-Authentifizierung aktiviert und die Authentifizierung mit Zugriffsschlüsseln deaktiviert.
- Für Basic- oder Standard-Caches können Sie sich für die Auswahl eines Nicht-TLS-Ports entscheiden.
- Für Standard- und Premium-Caches können Sie Verfügbarkeitszonen aktivieren. Verfügbarkeitszonen können nach der Erstellung des Caches nicht deaktiviert werden.
- Konfigurieren Sie für ein Premium-Cache die Einstellungen für einen Nicht-TLS-Port, das Clustering, die verwaltete Identität und die Datenpersistenz.
Wichtig

Für eine optimale Sicherheit empfehlen wir, Microsoft Entra ID mit verwalteten Identitäten zu verwenden, um Anforderungen nach Möglichkeit für Ihren Cache zu autorisieren. Die Autorisierung mit Microsoft Entra ID und verwalteten Identitäten bietet eine höhere Sicherheit und Benutzerfreundlichkeit als die Autorisierung mit gemeinsam verwendetem Schlüssel. Weitere Informationen zum Verwenden verwalteter Identitäten mit Ihren Caches finden Sie unter Verwenden von Microsoft Entra ID für die Cacheauthentifizierung.
(Optional) Wählen Sie die Registerkarte Tags aus, oder wählen Sie Weiter: Tags aus.
Geben Sie optional auf der Registerkarte Tags den Namen und den Wert ein, wenn Sie die Cacheressource kategorisieren möchten.
Wählen Sie die Schaltfläche Überprüfen + erstellen aus.

Auf der Registerkarte Überprüfen und Erstellen überprüft Azure automatisch Ihre Konfiguration.
Wenn die grüne Meldung Validierung erfolgreich angezeigt wird, wählen Sie Erstellen aus.

Eine neue Cachebereitstellung dauert mehrere Minuten. Sie können den Fortschritt der Bereitstellung im Azure Cache for Redis -Übersichtsbereich überwachen. Wenn als Status der Wert Wird ausgeführt angezeigt wird, kann der Cache verwendet werden.

Installieren der Clientbibliothek „node-redis“

Die node-redis-Bibliothek ist der primäre Node.js-Client für Redis. Sie können den Client mit dem folgenden Befehl mit npm installieren:

npm install redis

Erstellen einer Node.js-App für den Zugriff auf einen Cache

Erstellen Sie eine Node.js-App, die entweder Microsoft Entra ID oder Zugriffsschlüssel verwendet, um eine Verbindung mit einer Azure Managed Redis-Instanz (Vorschau) herzustellen. Wir empfehlen die Verwendung von Microsoft Entra ID.

Microsoft Entra ID-Authentifizierung (empfohlen)
Zugriffsschlüsselauthentifizierung

Verwenden der Microsoft Entra ID-Authentifizierung in Ihrem Cache

Bei Azure Redis-Caches ist mit Ausnahme der Dienstebenen Enterprise und Enterprise Flash standardmäßig die Microsoft Entra-Authentifizierung aktiviert. Zugriffsschlüssel sind standardmäßig deaktiviert.

Wichtig

Microsoft empfiehlt die Verwendung der Microsoft Entra ID-Authentifizierung als sicherste Authentifizierung anstelle von Kennwörtern oder Zugriffsschlüsseln. Bei der in diesem Abschnitt des Artikels beschriebenen Authentifizierung werden Zugriffsschlüssel verwendet, die ein sehr hohes Vertrauen in die Anwendung erfordern und Risiken nach sich ziehen, die bei Verwendung von Microsoft Entra ID nicht auftreten. Verwenden Sie den Ansatz in diesem Dokument nur, wenn die Microsoft Entra ID-Authentifizierung nicht geeignet ist.

Wählen Sie im Azure-Portal den Cache aus, für den Sie die tokenbasierte Microsoft Entra-Authentifizierung verwenden möchten.
Wählen Sie im Ressourcen-Menü die Option Authentifizierung aus.
Wählen Sie Mitglied auswählen aus, und geben Sie den Namen eines gültigen Benutzenden ein. Dem eingegebenen Benutzer wird automatisch standardmäßig die Datenbesitzer-Zugriffsrichtlinie zugewiesen, wenn Sie Speichernauswählen. Sie können auch eine verwaltete Identität oder einen Dienstprinzipal eingeben, um eine Verbindung mit Ihrer Cache-Instanz herzustellen.

Weitere Informationen zur Verwendung von Microsoft Entra ID mit der Azure-Befehlszeilenschnittstelle finden Sie auf den Referenzseiten zu Identitäten.

Installieren der Azure Identity-Clientbibliothek für JavaScript

Mit der Microsoft-Authentifizierungsbibliothek können Sie Sicherheitstoken von Microsoft Identity abrufen, um Benutzer zu authentifizieren. Es ist eine Azure Identity-Clientbibliothek für JavaScript verfügbar, die die Microsoft-Authentifizierungsbibliothek verwendet, um Unterstützung bei der Tokenauthentifizierung bereitzustellen. Installieren Sie diese Bibliothek mit npm.

npm install @azure/identity

Erstellen einer neuen Node.js-App mit Microsoft Entra ID

Fügen Sie Umgebungsvariablen für Ihren Hostnamen und Ihre Dienstprinzipal-ID hinzu. Dabei handelt es sich um die Objekt-ID Ihres Microsoft Entra ID-Dienstprinzipals oder -Benutzers. Suchen Sie im Azure-Portal nach dem Benutzernamen.
```
set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Erstellen Sie eine neue Skriptdatei namens redistest.js.

Fügen Sie den folgenden JavaScript-Beispielcode in die Datei ein. Dieser Code zeigt, wie Sie unter Verwendung der Umgebungsvariablen für Cachehostname und Schlüssel eine Verbindung mit einer Azure Managed Redis-Instanz herstellen. Der Code speichert auch einen Zeichenfolgenwert im Cache und ruft ihn ab. Außerdem werden die Befehle PING und CLIENT LIST ausgeführt. Weitere Beispiele für die Verwendung von Redis mit dem node-redis-Client finden Sie unter 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));

Führen Sie das Skript mit Node.js aus.
```
node redistest.js
```

Die Ausgabe des Codes sieht wie folgt aus.

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

Erstellen einer JavaScript-Beispiel-App mit erneuter Authentifizierung

Microsoft Entra ID-Zugriffstoken haben eine begrenzte Lebensdauer, und zwar durchschnittlich 75 Minuten. Um eine Verbindung zum Cache aufrechtzuerhalten, müssen Sie das Token aktualisieren. Dies wird im folgenden Beispiel mit JavaScript veranschaulicht.

Erstellen Sie eine neue Skriptdatei namens redistestreauth.js.

Fügen Sie den folgenden JavaScript-Beispielcode in die Datei ein.

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

Führen Sie das Skript mit Node.js aus.
```
node redistestreauth.js
```

Die Ausgabe des Codes sieht wie folgt aus.

 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

Hinweis

Weitere Beispiele für die Verwendung von Microsoft Entra ID zur Authentifizierung bei Redis mithilfe der „node-redis“-Bibliothek finden Sie in diesem GitHub-Repository.

Wichtig

Abrufen von Hostname, Ports und Zugriffsschlüsseln vom Azure-Portal

Um ihren Azure Cache for Redis-Server zu verbinden, benötigt der Cacheclient den Hostnamen, die Ports und einen Schlüssel für den Cache. Von einigen Clients wird unter Umständen mit etwas anderen Namen auf diese Elemente verwiesen. Sie können den Hostnamen, Ports und Zugriffsschlüssel vom Azure-Portal abrufen.

Wählen Sie zum Abrufen der Zugriffsschlüssel im Ressourcenmenü die Option Authentifizierung aus. Wählen Sie dann die Registerkarte Zugriffsschlüssel aus.
Um den Hostnamen und die Ports für den Cache abzurufen, wählen Sie im Ressourcenmenü die Option Übersicht aus. Der Hostname hat das Format <DNS-Name>.redis.cache.windows.net.

Fügen Sie Umgebungsvariablen für Ihren HOSTNAMEN und Ihren primären Zugriffsschlüssel hinzu. Verwenden Sie diese Variablen aus Ihrem Code, damit solche vertraulichen Informationen nicht direkt in den Code eingefügt werden müssen.

set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set AZURE_MANAGED_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Herstellen einer Verbindung mit dem Cache

Hinweis

Erstellen Sie in Ihrem Code nicht für jeden Vorgang eine neue Verbindung. Verwenden Sie Verbindungen stattdessen möglichst häufig wieder.

Erstellen einer neuen Node.js-App

Erstellen Sie eine neue Skriptdatei namens redistest.js.

Fügen Sie den folgenden JavaScript-Beispielcode in die Datei ein.

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

Dieser Code zeigt, wie Sie unter Verwendung der Umgebungsvariablen für Cachehostname und Schlüssel eine Verbindung mit einer Azure Cache for Redis-Instanz herstellen. Der Code speichert auch einen Zeichenfolgenwert im Cache und ruft ihn ab. Außerdem werden die Befehle PING und CLIENT LIST ausgeführt. Weitere Beispiele für die Verwendung von Redis mit dem node_redis-Client finden Sie unter https://redis.js.org/.

Führen Sie das Skript mit Node.js aus.
```
node redistest.js
```

Beispiel für die Ausgabe.

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

Erstellen einer Node.js-App für den Zugriff auf einen Cache

Erstellen Sie eine Node.js-App, die entweder Microsoft Entra ID oder Zugriffsschlüssel verwendet, um eine Verbindung mit einer Azure Cache for Redis-Instanz herzustellen. Wir empfehlen die Verwendung von Microsoft Entra ID.

Microsoft Entra ID-Authentifizierung (empfohlen)
Zugriffsschlüsselauthentifizierung

Verwenden der Microsoft Entra ID-Authentifizierung in Ihrem Cache

Wichtig

Wählen Sie im Azure-Portal den Cache aus, für den Sie die tokenbasierte Microsoft Entra-Authentifizierung verwenden möchten.
Wählen Sie im Ressourcen-Menü die Option Authentifizierung aus.
Wählen Sie Mitglied auswählen aus, und geben Sie den Namen eines gültigen Benutzenden ein. Dem eingegebenen Benutzer wird automatisch standardmäßig die Datenbesitzer-Zugriffsrichtlinie zugewiesen, wenn Sie Speichernauswählen. Sie können auch eine verwaltete Identität oder einen Dienstprinzipal eingeben, um eine Verbindung mit Ihrer Cache-Instanz herzustellen.

Weitere Informationen zur Verwendung von Microsoft Entra ID mit der Azure-Befehlszeilenschnittstelle finden Sie auf den Referenzseiten zu Identitäten.

Installieren der Azure Identity-Clientbibliothek für JavaScript

npm install @azure/identity

Erstellen einer neuen Node.js-App mit Microsoft Entra ID

Fügen Sie Umgebungsvariablen für Ihren Hostnamen und Ihre Dienstprinzipal-ID hinzu. Dabei handelt es sich um die Objekt-ID Ihres Microsoft Entra ID-Dienstprinzipals oder -Benutzers. Suchen Sie im Azure-Portal nach dem Benutzernamen.
```
set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Erstellen Sie eine neue Skriptdatei namens redistest.js.

Fügen Sie den folgenden JavaScript-Beispielcode in die Datei ein. Dieser Code zeigt, wie Sie unter Verwendung der Umgebungsvariablen für Cachehostname und Schlüssel eine Verbindung mit einer Azure Cache for Redis-Instanz herstellen. Der Code speichert auch einen Zeichenfolgenwert im Cache und ruft ihn ab. Außerdem werden die Befehle PING und CLIENT LIST ausgeführt. Weitere Beispiele für die Verwendung von Redis mit dem node-redis-Client finden Sie unter 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));

Führen Sie das Skript mit Node.js aus.
```
node redistest.js
```

Die Ausgabe des Codes sieht wie folgt aus.

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

Erstellen einer JavaScript-Beispiel-App mit erneuter Authentifizierung

Erstellen Sie eine neue Skriptdatei namens redistestreauth.js.

Fügen Sie den folgenden JavaScript-Beispielcode in die Datei ein.

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

Führen Sie das Skript mit Node.js aus.
```
node redistestreauth.js
```

Die Ausgabe des Codes sieht wie folgt aus.

 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

Hinweis

Weitere Beispiele für die Verwendung von Microsoft Entra ID zur Authentifizierung bei Redis mithilfe der „node-redis“-Bibliothek finden Sie in diesem GitHub-Repository.

Abrufen von Hostname, Ports und Zugriffsschlüsseln vom Azure-Portal

Wählen Sie zum Abrufen der Zugriffsschlüssel im Ressourcenmenü die Option Authentifizierung aus. Wählen Sie dann die Registerkarte Zugriffsschlüssel aus.
Um den Hostnamen und die Ports für den Cache abzurufen, wählen Sie im Ressourcenmenü die Option Übersicht aus. Der Hostname hat das Format <DNS-Name>.redis.cache.windows.net.

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Herstellen einer Verbindung mit dem Cache

Hinweis

Erstellen Sie in Ihrem Code nicht für jeden Vorgang eine neue Verbindung. Verwenden Sie Verbindungen stattdessen möglichst häufig wieder.

Erstellen einer neuen Node.js-App

Erstellen Sie eine neue Skriptdatei namens redistest.js.

Fügen Sie den folgenden JavaScript-Beispielcode in die Datei ein.

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

Führen Sie das Skript mit Node.js aus.
```
node redistest.js
```

Beispiel für die Ausgabe.

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

Bereinigen von Ressourcen

Wenn Sie die in diesem Artikel erstellten Ressourcen weiterhin verwenden möchten, behalten Sie die Ressourcengruppe bei.

Wenn Sie die Ressourcen nicht mehr benötigen, können Sie die erstellte Azure-Ressourcengruppe ansonsten löschen, um Kosten zu vermeiden.

Wichtig

Das Löschen einer Ressourcengruppe kann nicht rückgängig gemacht werden. Beim Löschen einer Ressourcengruppe werden alle darin enthaltenen Ressourcen unwiderruflich gelöscht. Achten Sie daher darauf, dass Sie nicht versehentlich die falsche Ressourcengruppe oder die falschen Ressourcen löschen. Falls Sie die Ressourcen in einer vorhandenen Ressourcengruppe erstellt haben, die Ressourcen enthält, die Sie behalten wollen, können Sie jede Ressource einzeln löschen, statt die Ressourcengruppe zu löschen.

So löschen Sie eine Ressourcengruppe

Melden Sie sich beim Azure-Portal an, und wählen Sie anschließend Ressourcengruppen aus.
Wählen Sie die Ressourcengruppe aus, die Sie löschen möchten.

Wenn viele Ressourcengruppen vorhanden sind, verwenden Sie das Feld Nach einem beliebigen Feld filtern..., und geben Sie den Namen Ihrer Ressourcengruppe ein, die Sie für diesen Artikel erstellt haben. Wählen Sie die Ressourcengruppe in der Ergebnisliste aus.
Wählen Sie die Option Ressourcengruppe löschen.
Sie werden aufgefordert, das Löschen der Ressourcengruppe zu bestätigen. Geben Sie den Namen Ihrer Ressourcengruppe ein, und wählen Sie Löschen aus.

Daraufhin werden die Ressourcengruppe und alle darin enthaltenen Ressourcen gelöscht.

Beispielcode herunterladen

Rufen Sie den Node.js-Schnellstart auf GitHub ab.

In dieser Schnellstartanleitung wurde beschrieben, wie Sie entweder Azure Managed Redis oder Azure Cache for Redis über eine Node.js-Anwendung verwenden. Erfahren Sie mehr über die Angebote von Azure Redis:

Freigeben über

Schnellstart: Verwenden von Azure Redis in Node.js

Voraussetzungen

Erstellen einer Azure Managed Redis-Instanz (Vorschau)

Erstellen einer Azure Cache for Redis-Instanz

Installieren der Clientbibliothek „node-redis“

Erstellen einer Node.js-App für den Zugriff auf einen Cache

Verwenden der Microsoft Entra ID-Authentifizierung in Ihrem Cache

Installieren der Azure Identity-Clientbibliothek für JavaScript

Erstellen einer neuen Node.js-App mit Microsoft Entra ID

Erstellen einer JavaScript-Beispiel-App mit erneuter Authentifizierung

Abrufen von Hostname, Ports und Zugriffsschlüsseln vom Azure-Portal

Herstellen einer Verbindung mit dem Cache

Erstellen einer neuen Node.js-App

Erstellen einer Node.js-App für den Zugriff auf einen Cache

Verwenden der Microsoft Entra ID-Authentifizierung in Ihrem Cache

Installieren der Azure Identity-Clientbibliothek für JavaScript

Erstellen einer neuen Node.js-App mit Microsoft Entra ID

Erstellen einer JavaScript-Beispiel-App mit erneuter Authentifizierung

Abrufen von Hostname, Ports und Zugriffsschlüsseln vom Azure-Portal

Herstellen einer Verbindung mit dem Cache

Erstellen einer neuen Node.js-App

Bereinigen von Ressourcen

So löschen Sie eine Ressourcengruppe

Beispielcode herunterladen

Feedback

Zusätzliche Ressourcen

Freigeben über

Schnellstart: Verwenden von Azure Redis in Node.js

Voraussetzungen

Erstellen einer Azure Managed Redis-Instanz (Vorschau)

Erstellen einer Azure Cache for Redis-Instanz

Installieren der Clientbibliothek „node-redis“

Erstellen einer Node.js-App für den Zugriff auf einen Cache

Verwenden der Microsoft Entra ID-Authentifizierung in Ihrem Cache

Installieren der Azure Identity-Clientbibliothek für JavaScript

Erstellen einer neuen Node.js-App mit Microsoft Entra ID

Erstellen einer JavaScript-Beispiel-App mit erneuter Authentifizierung

Erstellen einer Node.js-App für den Zugriff auf einen Cache

Verwenden der Microsoft Entra ID-Authentifizierung in Ihrem Cache

Installieren der Azure Identity-Clientbibliothek für JavaScript

Erstellen einer neuen Node.js-App mit Microsoft Entra ID

Erstellen einer JavaScript-Beispiel-App mit erneuter Authentifizierung

Bereinigen von Ressourcen

So löschen Sie eine Ressourcengruppe

Beispielcode herunterladen

Zugehöriger Inhalt

Feedback

Zusätzliche Ressourcen