Delen via

Quickstart: Azure Managed Redis gebruiken met JavaScript

  • Van toepassing op: ✅ Azure Managed Redis

In deze quickstart leert u hoe u een Azure Managed Redis-cache gebruikt vanuit een Node.js-toepassing die is geschreven in de TypeScript-taal en hoe u de Redis-verbinding verifieert met behulp van Microsoft Entra-id.

Vereiste voorwaarden

  • Azure-abonnement: u kunt een gratis abonnement nemen

  • Node.js LTS installeren

  • TypeScript installeren

  • Voeg de pakketten die in deze quickstart worden gebruikt toe aan uw project:

    npm install redis @redis/entraid @redis/client

  • Verifiëren bij Azure voor uw ontwikkelomgeving met Azure CLI:

    az login

De quickstart-voorbeeldcode in dit artikel is beschikbaar op GitHub.

Een Azure Managed Redis-exemplaar maken

Maak eerst een Azure Managed Redis-cache in Azure Portal.

Wanneer u de cache maakt, is Verificatie via Microsoft Entra-id standaard ingeschakeld, waardoor deze vanaf het begin veilig is. Voor deze quickstart gebruikt de cache een openbaar eindpunt. Overweeg in productie om privé-eindpunten en andere netwerkbesturingselementen te gebruiken.

  1. Volg een van de volgende procedures om een cache te maken met de portal:

  • Azure Managed Redis

    U kunt eventueel een cache maken met behulp van Azure CLI, PowerShell of het hulpprogramma dat u wilt gebruiken.

  1. Verken uzelf machtigingen voor gegevenstoegang in de Redis-resource.

Code om verbinding te maken met een Redis-cache

Configureer in het eerste deel van het Voorbeeldbestand index.tsvan de TypeScript-code de verbinding met de 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;
}

Gebruik de createRedisClient() functie om een node-redis-clientverbinding met de Redis-cache te maken.

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

Code voor het testen van een verbinding

In de volgende sectie test u de verbinding met behulp van de Redis-opdracht PING . De Redis-server retourneert PONG.

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

Code een sleutel instellen, een sleutel ophalen

Gebruik en SET opdrachten in deze sectie GET om op de eenvoudigste manier gegevens te schrijven en te lezen in de Redis-cache.

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

De code uitvoeren

Bouw en voer de Node.js-toepassing uit.

tsc
node index.js

Het resultaat ziet er als volgt uit:

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

Hier ziet u dit codevoorbeeld in zijn geheel.

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

        }
    }
}

De hulpbronnen opschonen

Als u de resources wilt blijven gebruiken die u in dit artikel hebt gemaakt, moet u de resourcegroep behouden.

Als u klaar bent met de resources, kunt u de Azure-resourcegroep verwijderen die u hebt gemaakt om kosten te voorkomen.

Belangrijk

Het verwijderen van een resourcegroep kan niet ongedaan worden gemaakt. Wanneer u een resourcegroep verwijdert, worden alle resources in de groep definitief verwijderd. Zorg ervoor dat u niet per ongeluk de verkeerde bron of bronngroep verwijdert. Als u de resources in een bestaande resourcegroep hebt gemaakt die resources bevat die u wilt behouden, kunt u elke resource afzonderlijk verwijderen in plaats van de resourcegroep te verwijderen.

Een resourcegroep verwijderen

  1. Meld u aan bij Azure Portal en selecteer vervolgens Resourcegroepen.

  2. Selecteer de resourcegroep die u wilt verwijderen.

    Als er veel resourcegroepen zijn, gebruikt u het vak Filter voor een veld... en typt u de naam van de resourcegroep die u voor dit artikel hebt gemaakt. Selecteer de bronnen groep in de lijst met resultaten.

    Schermopname van een lijst met resourcegroepen die u wilt verwijderen in het werkvenster.

  3. Selecteer Resourcegroep verwijderen.

  4. U wordt gevraagd om het verwijderen van de resourcegroep te bevestigen. Typ ter bevestiging de naam van de resourcegroep. Selecteer vervolgens Verwijderen.

    Schermopname van een formulier waarvoor de resourcenaam is vereist om het verwijderen te bevestigen.

Na enkele ogenblikken worden de resourcegroep en alle bijbehorende resources verwijderd.

Verwante inhoud