Freigeben über

Schnellstart: Herstellen einer Verbindung mit azure Managed Redis in einer Node.js-App

  • Gilt für:: ✅ Azure Managed Redis

In dieser Schnellstartanleitung erfahren Sie, wie Sie einen Azure Managed Redis-Cache aus einer in der TypeScript-Sprache geschriebenen Node.js-Anwendung verwenden und die Redis-Verbindung mithilfe der Microsoft Entra-ID authentifizieren.

Voraussetzungen

  • Azure-Abonnement – Erstellen eines kostenlosen Kontos

  • Installieren Sie Node.js LTS

  • Installieren von TypeScript

  • Fügen Sie die in dieser Schnellstartanleitung verwendeten Pakete zu Ihrem Projekt hinzu:

    npm install redis @redis/entraid @redis/client

  • Authentifizieren sie sich bei Azure für Ihre Entwicklungsumgebung mit Azure CLI:

    az login

Der Schnellstartbeispielcode in diesem Artikel ist auf GitHub verfügbar.

Erstellen einer Azure Managed Redis-Instanz

Erstellen Sie zunächst einen Azure Managed Redis-Cache im Azure-Portal.

Wenn Sie den Cache erstellen, ist die Microsoft Entra-ID-Authentifizierung standardmäßig aktiviert, wodurch sie von Anfang an sicher ist. Für diese Schnellstartanleitung verwendet der Cache einen öffentlichen Endpunkt. In der Produktion sollten Sie private Endpunkte und andere Netzwerksteuerelemente verwenden.

  1. Führen Sie zum Erstellen eines Caches mit dem Portal eine der folgenden Verfahren aus:

  • Azure Managed Redis

    Optional können Sie einen Cache mithilfe von Azure CLI, PowerShell oder dem von Ihnen gewünschten Tool erstellen.

  1. Gewähren Sie sich datenzugriffsberechtigungen in der Redis-Ressource.

Code zum Herstellen einer Verbindung mit einem Redis-Cache

Konfigurieren Sie im ersten Teil der TypeScript-Codebeispieldatei index.tsIhre Verbindung mit dem Cache:

import { DefaultAzureCredential } from '@azure/identity';
import { EntraIdCredentialsProviderFactory, REDIS_SCOPE_DEFAULT } from '@redis/entraid';
import { createCluster, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } from '@redis/client';
import * as net from 'node:net';

const redisEndpoint = process.env.REDIS_ENDPOINT!;
if (!redisEndpoint) {
    console.error('REDIS_ENDPOINT is not set. It should look like: `cache-name.region-name.redis.azure.net:<PORT>`. Find the endpoint in the Azure portal.');
    process.exit(1);
}

const [redisHostName, _] = redisEndpoint.split(":");

let client;

function createRedisClient(): RedisClusterType<RedisModules, RedisFunctions, RedisScripts>  {

    const credential = new DefaultAzureCredential();

    const provider = EntraIdCredentialsProviderFactory.createForDefaultAzureCredential({
        credential,
        scopes: REDIS_SCOPE_DEFAULT,
        options: {},
        tokenManagerConfig: {
            expirationRefreshRatio: 0.8
        }
    });

    const client = createCluster<RedisModules, RedisFunctions, RedisScripts>({
        rootNodes: [{ url: `rediss://${redisEndpoint}` }],
        defaults: {
            credentialsProvider: provider,
            socket: {
                connectTimeout: 15000,
                tls: true,

                // This quickstart code uses a fail fast `reconnectStrategy` which
                // is suitable only in sample code. The purpose is to quickly
                // demonstrate the functionality without getting stuck in
                // reconnection loops if your endpoint or authentication is not
                // correctly configured. In production code, a more robust
                // `reconnectStrategy` should be implemented.
                reconnectStrategy: () => new Error('Failure to connect')
            }

        },
        nodeAddressMap(incomingAddress) {
            const [hostNameOrIP, port] = incomingAddress.split(":");

            const address =
                net.isIP(hostNameOrIP) !== 0
                    ? redisHostName
                    : hostNameOrIP;

            return {
                host: address,
                port: Number(port),
            };
        }

    });

    client.on('error', (err) => console.error('Redis cluster error:', err));

    return client;
}

Verwenden Sie die createRedisClient() Funktion, um eine Node-redis-Clientverbindung mit dem Redis-Cache zu erstellen.

client = createRedisClient();
await client.connect();

Code zum Testen einer Verbindung

Testen Sie die Verbindung im nächsten Abschnitt mithilfe des Befehls "Redis PING ". Der Redis-Server gibt zurück PONG.

const pingResult = await client.ping();
console.log('Ping result:', pingResult);

Code legt einen Schlüssel fest, ruft einen Schlüssel ab

In diesem Abschnitt verwenden Sie die SET und GET Befehle, um auf einfachste Weise mit dem Schreiben und Lesen von Daten im Redis-Cache zu beginnen.

const setResult = await client.set("Message", "Hello! The cache is working from Node.js!");
console.log('Set result:', setResult);

const getResult = await client.get("Message");
console.log('Get result:', getResult);

Ausführen des Codes

Erstellen Sie die Node.js Anwendung, und führen Sie sie aus.

tsc
node index.js

Das Ergebnis sieht wie folgt aus:

Ping result: PONG
Set result: OK
Get result: Hello! The cache is working from Node.js!

Hier sehen Sie dieses Codebeispiel vollständig.

import { DefaultAzureCredential } from '@azure/identity';
import { EntraIdCredentialsProviderFactory, REDIS_SCOPE_DEFAULT } from '@redis/entraid';
import { createCluster, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } from '@redis/client';
import * as net from 'node:net';

const redisEndpoint = process.env.REDIS_ENDPOINT!;
if (!redisEndpoint) {
    console.error('REDIS_ENDPOINT is not set. It should look like: `cache-name.region-name.redis.azure.net:<PORT>`. Find the endpoint in the Azure portal.');
    process.exit(1);
}

const [redisHostName, _] = redisEndpoint.split(":");

let client;

function createRedisClient(): RedisClusterType<RedisModules, RedisFunctions, RedisScripts>  {

    const credential = new DefaultAzureCredential();

    const provider = EntraIdCredentialsProviderFactory.createForDefaultAzureCredential({
        credential,
        scopes: REDIS_SCOPE_DEFAULT,
        options: {},
        tokenManagerConfig: {
            expirationRefreshRatio: 0.8
        }
    });

    const client = createCluster<RedisModules, RedisFunctions, RedisScripts>({
        rootNodes: [{ url: `rediss://${redisEndpoint}` }],
        defaults: {
            credentialsProvider: provider,
            socket: {
                connectTimeout: 15000,
                tls: true,

                // This quickstart code uses a fail fast `reconnectStrategy` which
                // is suitable only in sample code. The purpose is to quickly
                // demonstrate the functionality without getting stuck in
                // reconnection loops if your endpoint or authentication is not
                // correctly configured. In production code, a more robust
                // `reconnectStrategy` should be implemented.
                reconnectStrategy: () => new Error('Failure to connect')
            }

        },
        nodeAddressMap(incomingAddress) {
            const [hostNameOrIP, port] = incomingAddress.split(":");

            const address =
                net.isIP(hostNameOrIP) !== 0
                    ? redisHostName
                    : hostNameOrIP;

            return {
                host: address,
                port: Number(port),
            };
        }

    });

    client.on('error', (err) => console.error('Redis cluster error:', err));

    return client;
}

try {

    client = createRedisClient();

    await client.connect();

    const pingResult = await client.ping();
    console.log('Ping result:', pingResult);

    const setResult = await client.set("Message", "Hello! The cache is working from Node.js!");
    console.log('Set result:', setResult);

    const getResult = await client.get("Message");
    console.log('Get result:', getResult);

} catch (err) {
    console.error('Error:', err);
} finally {
    if (client) {
        try {
            await client.quit();
        } catch (quitErr) {
            console.error('Error occurred while quitting Redis client:', quitErr);

        }
    }
}

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.

Von Bedeutung

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

  1. Melden Sie sich beim Azure-Portal an, und wählen Sie anschließend Ressourcengruppen aus.

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

    Screenshot: Liste mit zu löschenden Ressourcengruppen im Arbeitsbereich.

  3. Wählen Sie die Option Ressourcengruppe löschen.

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

    Screenshot: Formular, in das der Ressourcenname eingegeben werden muss, um den Löschvorgang zu bestätigen.

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

Verwandte Inhalte

  • Last updated on