Rövid útmutató: Csatlakozás az Azure Managed Redishez egy Node.js alkalmazásban

Ebben a rövid útmutatóban megtudhatja, hogyan használhat egy Azure Managed Redis-gyorsítótárat egy TypeScript nyelven írt Node.js alkalmazásból, és hogyan hitelesítheti a Redis-kapcsolatot a Microsoft Entra ID használatával.

Előfeltételek

• Azure-előfizetés – hozzon létre egyet ingyenesen

• Node.js LTS telepítése

• TypeScript telepítése

• Adja hozzá az ebben a rövid útmutatóban használt csomagokat a projekthez:

  npm install redis @redis/entraid @redis/client
  

• Hitelesítés az Azure-ban a fejlesztési környezethez az Azure CLI-vel:

  az login
  

A cikkben szereplő rövid útmutató mintakódja a GitHubon érhető el.

Azure Managed Redis-példány létrehozása

Először hozzon létre egy Azure Managed Redis-gyorsítótárat az Azure Portalon.

A gyorsítótár létrehozásakor a Microsoft Entra ID-hitelesítés alapértelmezés szerint engedélyezve van, ami kezdettől fogva biztonságossá teszi. Ebben a rövid útmutatóban a gyorsítótár nyilvános végpontot használ. Éles környezetben fontolja meg a privát végpontok és más hálózati vezérlők használatát.

1. Ha gyorsítótárat szeretne létrehozni a portállal, kövesse az alábbi eljárások egyikét:

• Azure Managed Redis

  Szükség esetén létrehozhat egy gyorsítótárat az Azure CLI, a PowerShell vagy a kívánt eszköz használatával.

1. Adjon magának adathozzáférési engedélyeket a Redis-erőforrásban.

Redis-gyorsítótárhoz való csatlakozáshoz használt kód

A TypeScript-kód mintafájljának index.tselső részében konfigurálja a gyorsítótárhoz való kapcsolatot:

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

A createRedisClient() függvény segítségével node-redis klienst hozhat létre a Redis gyorsítótárhoz.

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

Kapcsolat teszteléséhez szükséges kód

A következő szakaszban tesztelje a kapcsolatot a Redis PING paranccsal. A Redis-kiszolgáló ad vissza PONG.

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

Kulcs beállítása, kulcs lekérése

Ebben a szakaszban az adatok írását és olvasását a Legegyszerűbb módon használhatja SET és GET használhatja a Redis cache-ben.

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

A kód futtatása

Hozza létre és futtassa a Node.js alkalmazást.

tsc
node index.js

Az eredmény így néz ki:

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

Itt teljes egészében láthatja ezt a kódmintát.

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

        }
    }
}

Erőforrások tisztítása

Ha továbbra is használni szeretné a cikkben létrehozott erőforrásokat, tartsa meg az erőforráscsoportot.

Ellenkező esetben, ha végzett az erőforrásokkal, törölheti a létrehozott Azure-erőforráscsoportot a díjak elkerülése érdekében.

Fontos

Egy erőforráscsoport törlése visszafordíthatatlan. Az erőforráscsoport törlésekor a benne foglalt összes erőforrás véglegesen törlődik. Figyeljen arra, hogy ne töröljön véletlenül erőforráscsoportot vagy erőforrásokat. Ha olyan meglévő erőforráscsoportban hozta létre az erőforrásokat, amely a megtartani kívánt erőforrásokat tartalmazza, az erőforráscsoport törlése helyett egyenként törölheti az egyes erőforrásokat.

Erőforráscsoport törlése

1. Jelentkezzen be az Azure Portalra, és válassza az Erőforráscsoportok elemet.

2. Válassza ki a törölni kívánt erőforráscsoportot.

   Ha sok erőforráscsoport van, használja a Szűrő bármely mezőhöz... mezőt, írja be a cikkhez létrehozott erőforráscsoport nevét. Válassza ki az erőforráscsoportot az eredménylistában.

   

3. Válassza az Erőforráscsoport törlése lehetőséget.

4. A rendszer az erőforráscsoport törlésének megerősítését kéri. A megerősítéshez írja be az erőforráscsoport nevét, és válassza a Törlést.

   

A rendszer néhány pillanaton belül törli az erőforráscsoportot és annak erőforrásait.

Kapcsolódó tartalom

• Node.js Redis-ügyfél