Partilhar via

Início Rápido: Ligue-se ao Azure Managed Redis numa aplicação Node.js

  • Aplica-se a: ✅ Azure Managed Redis

Neste guia de início rápido, você aprenderá a usar um cache Redis gerenciado do Azure de um aplicativo Node.js escrito na linguagem TypeScript e autenticar a conexão Redis usando a ID do Microsoft Entra.

Pré-requisitos

O código de exemplo de início rápido neste artigo está disponível no GitHub.

Criar uma instância do Azure Managed Redis

Primeiro, crie um cache Redis gerenciado do Azure no portal do Azure.

Quando você cria o cache, a autenticação do Microsoft Entra ID é habilitada por padrão, o que a torna segura desde o início. Para esse início rápido, o cache usa um ponto de extremidade público. Na produção, considere o uso de pontos de extremidade privados e outros controles de rede.

  1. Para criar um cache com o portal, siga um destes procedimentos:

  • Azure Managed Redis

    Opcionalmente, você pode criar um cache usando a CLI do Azure, o PowerShell ou qualquer ferramenta de sua preferência.

  1. Conceda a si mesmo permissões de acesso a dados no recurso Redis.

Código para se conectar a um cache Redis

Na primeira parte do arquivo de exemplo de código TypeScript, index.tsconfigure sua conexão com o 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;
}

Use a createRedisClient() função para criar uma ligação cliente node-redis à cache Redis.

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

Código para testar uma conexão

Na próxima seção, teste a conexão usando o comando Redis PING . O servidor Redis retorna PONG.

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

Código definir uma chave, obter uma chave

Nesta seção, use SET e GET comandos para começar a escrever e ler dados no cache Redis da maneira mais simples.

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

Executar o código

Crie e execute o aplicativo Node.js.

tsc
node index.js

O resultado é assim:

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

Aqui, você pode ver este exemplo de código na íntegra.

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

        }
    }
}

Limpeza de recursos

Se quiser continuar a usar os recursos criados neste artigo, mantenha o grupo de recursos.

Caso contrário, se tiver terminado os recursos, pode eliminar o grupo de recursos do Azure que criou para evitar cobranças.

Importante

A eliminação de um grupo de recursos é irreversível. Quando elimina um grupo de recursos, todos os recursos nele contidos são eliminados permanentemente. Certifique-se de que não elimina acidentalmente grupos de recursos ou recursos errados. Se você criou os recursos dentro de um grupo de recursos existente que contém recursos que deseja manter, poderá excluir cada recurso individualmente em vez de excluir o grupo de recursos.

Para eliminar um grupo de recursos

  1. Inicie sessão no Portal do Azure e selecione Grupos de recursos.

  2. Selecione o grupo de recursos que pretende eliminar.

    Se houver muitos grupos de recursos, use a caixa Filtrar para qualquer campo... , digite o nome do grupo de recursos criado para este artigo. Selecione o grupo de recursos na lista de resultados.

    Captura de ecrã a mostrar uma lista de grupos de recursos a eliminar no painel de trabalho.

  3. Selecione Eliminar grupo de recursos.

  4. É-lhe pedido que confirme a eliminação do grupo de recursos. Escreva o nome do grupo de recursos para confirmar e, em seguida, selecione Eliminar.

    Captura de tela mostrando um formulário que requer o nome do recurso para confirmar a exclusão.

Após alguns instantes, o grupo de recursos e todos os respetivos recursos são eliminados.

Conteúdo relacionado

  • Last updated on