Szybki start: nawiązywanie połączenia z usługą Azure Managed Redis w aplikacji Node.js

Dotyczy: ✅ Azure Managed Redis

Z tego przewodnika Szybki start dowiesz się, jak używać pamięci podręcznej Redis Azure Managed Redis Cache z aplikacji Node.js napisanej w języku TypeScript i uwierzytelniać połączenie usługi Redis przy użyciu identyfikatora Entra firmy Microsoft.

Wymagania wstępne

Subskrypcja platformy Azure — utwórz jedną bezpłatnie
Instalowanie Node.js LTS
Instalowanie języka TypeScript
Dodaj pakiety używane w tym przewodniku Szybki start do projektu:
```
npm install redis @redis/entraid @redis/client
```
Uwierzytelnianie na platformie Azure dla środowiska deweloperskiego przy użyciu interfejsu wiersza polecenia platformy Azure:
```
az login
```

Przykładowy kod Szybkiego startu w tym artykule jest dostępny w witrynie GitHub.

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

Najpierw utwórz pamięć podręczną Redis Azure Managed Redis Cache w witrynie Azure Portal.

Podczas tworzenia pamięci podręcznej uwierzytelnianie identyfikatora Entra firmy Microsoft jest domyślnie włączone, co sprawia, że jest ono bezpieczne od samego początku. W tym przewodniku Szybki start pamięć podręczna używa publicznego punktu końcowego. W środowisku produkcyjnym rozważ użycie prywatnych punktów końcowych i innych kontrolek sieci.

Aby utworzyć pamięć podręczną za pomocą portalu, wykonaj jedną z następujących procedur:

Azure Managed Redis

Opcjonalnie możesz utworzyć pamięć podręczną przy użyciu interfejsu wiersza polecenia platformy Azure, programu PowerShell lub niezależnie od preferowanego narzędzia.

Udziel sobie uprawnień dostępu do danych w zasobie Usługi Redis.

Kod umożliwiający nawiązanie połączenia z pamięcią podręczną Redis Cache

W pierwszej części przykładowego pliku index.tskodu TypeScript skonfiguruj połączenie z pamięcią podręczną:

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

createRedisClient() Użyj funkcji , aby utworzyć połączenie klienta node-redis z pamięcią podręczną Redis.

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

Kod do testowania połączenia

W następnej sekcji przetestuj połączenie przy użyciu polecenia Redis PING . Serwer Redis zwraca wartość PONG.

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

Kod ustawia klucz, pobierz klucz

W tej sekcji użyj SET poleceń i GET , aby rozpocząć zapisywanie i odczytywanie danych w pamięci podręcznej Redis w najprostszy sposób.

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

Uruchamianie kodu

Skompiluj i uruchom aplikację Node.js.

tsc
node index.js

Wynik wygląda następująco:

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

W tym miejscu możesz zobaczyć ten przykładowy kod w całości.

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

        }
    }
}

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

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.
Poproszono Cię 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.

Node.js klienta usługi Redis

Sprzężenie zwrotne

Czy ta strona była pomocna?

Last updated on 2025-09-02