Partager via

Démarrage rapide : Se connecter à Azure Managed Redis dans une application Node.js

  • S’applique à: ✅ Azure Managed Redis

Dans ce guide de démarrage rapide, vous allez apprendre à utiliser un cache Redis managé Azure à partir d’une application Node.js écrite dans le langage TypeScript et authentifier la connexion Redis à l’aide de l’ID Microsoft Entra.

Conditions préalables

  • Abonnement Azure : créez-en un gratuitement

  • Installer Node.js LTS

  • Installer TypeScript

  • Ajoutez les packages utilisés dans ce guide de démarrage rapide à votre projet :

    npm install redis @redis/entraid @redis/client

  • Authentifiez-vous auprès d’Azure pour votre environnement de développement avec Azure CLI :

    az login

L’exemple de code de démarrage rapide de cet article est disponible sur GitHub.

Créer une instance Azure Managed Redis

Tout d’abord, créez un cache Redis managé Azure dans le portail Azure.

Lorsque vous créez le cache, l’authentification Microsoft Entra ID est activée par défaut, ce qui le rend sécurisé à partir du démarrage. Pour ce guide de démarrage rapide, le cache utilise un point de terminaison public. En production, envisagez d’utiliser des points de terminaison privés et d’autres contrôles réseau.

  1. Pour créer un cache avec le portail, suivez l’une des procédures suivantes :

  • Redis managé Azure

    Si vous le souhaitez, vous pouvez créer un cache à l’aide d’Azure CLI, de PowerShell ou de l’outil que vous préférez.

  1. Accordez-vous des autorisations d’accès aux données dans la ressource Redis.

Code permettant de se connecter à un cache Redis

Dans la première partie de l’exemple de fichier de code TypeScript, index.tsconfigurez votre connexion au 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;
}

Utilisez la createRedisClient() fonction pour créer une connexion cliente node-redis au cache Redis.

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

Code pour tester une connexion

Dans la section suivante, testez la connexion à l’aide de la commande Redis PING . Le serveur Redis retourne PONG.

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

Définir une clé, obtenir une clé

Dans cette section, utilisez SET et GET commandes pour commencer à écrire et lire des données dans le cache Redis de la manière la plus simple.

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

Exécuter le code

Générez et exécutez l’application Node.js.

tsc
node index.js

Le résultat ressemble à ceci :

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

Ici, vous pouvez voir cet exemple de code dans son intégralité.

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

        }
    }
}

Nettoyer les ressources

Si vous souhaitez continuer à utiliser les ressources que vous avez créées dans cet article, conservez le groupe de ressources.

Sinon, si vous avez terminé avec les ressources, vous pouvez supprimer le groupe de ressources Azure que vous avez créé pour éviter les frais.

Important

La suppression d’un groupe de ressources est irréversible. Quand vous supprimez un groupe de ressources, toutes les ressources qu’il contient sont supprimées définitivement. Veillez à ne pas supprimer accidentellement des ressources ou un groupe de ressources incorrects. Si vous avez créé les ressources dans un groupe de ressources existant contenant des ressources que vous souhaitez conserver, vous pouvez supprimer chaque ressource individuellement, au lieu de supprimer l’intégralité du groupe de ressources.

Pour supprimer un groupe de ressources

  1. Connectez-vous au Portail Azure, puis sélectionnez Groupes de ressources.

  2. Recherchez le groupe de ressources à supprimer.

    S’il existe de nombreux groupes de ressources, utilisez la zone Filtrer pour n’importe quel champ..., saisissez le nom du groupe de ressources que vous avez créé pour cet article. Sélectionnez le groupe de ressources dans la liste des résultats.

    Capture d’écran présentant une liste de groupes de ressources à supprimer dans le volet de travail.

  3. Sélectionnez Supprimer le groupe de ressources.

  4. Vous êtes invité à confirmer la suppression du groupe de ressources. Saisissez le nom de votre groupe de ressources pour confirmer, puis sélectionnez Supprimer.

    Capture d’écran présentant un formulaire qui demande le nom de la ressource pour confirmer la suppression.

Après quelques instants, le groupe de ressources et toutes ses ressources sont supprimés.

Contenu connexe

  • Last updated on