Compartilhar via

Início Rápido: Conectar-se ao Redis Gerenciado do Azure em um aplicativo Node.js

  • Aplica-se a: ✅ Azure Managed Redis

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

Pré-requisitos

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

Criar uma instância do Redis Gerenciado pelo Azure

Primeiro, crie um cache do 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 este início rápido, o cache usa um ponto de extremidade público. Em 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:

  • Redis Gerenciado do Azure

    Opcionalmente, você pode criar um cache usando a CLI do Azure, o PowerShell ou qualquer ferramenta que preferir.

  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.ts, configure 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 conexão de cliente node-redis com o 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);

Definir uma chave de código, obter uma chave

Nesta seção, use os comandos SET e GET para começar a gravar e ler dados no cache do 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 tem esta aparência:

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 em sua totalidade.

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

        }
    }
}

Limpar os recursos

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

Caso contrário, se tiver terminado de usar os recursos, é possível excluir o grupo de recursos do Azure criado para evitar encargos.

Importante

A exclusão de um grupo de recursos é irreversível. Ao excluir o grupo de recursos, todos os recursos nele são excluídos permanentemente. Certifique-se de que não exclua acidentalmente o grupo de recursos ou os recursos incorretos. Se você criou os recursos dentro de um grupo de recursos existente que contém recursos que você deseja manter, é possível excluir cada recurso individualmente em vez de excluir o grupo de recursos.

Para excluir um grupo de recursos

  1. Entre no portal do Azure e selecione Grupos de recursos.

  2. Selecione o grupo de recursos que você quer excluir.

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

    Captura de tela mostrando uma lista de grupos de recursos a serem excluídos no painel de trabalho.

  3. Selecione Excluir grupo de recursos.

  4. Você receberá uma solicitação para confirmar a exclusão do grupo de recursos. Digite o nome do grupo de recursos para confirmar e selecione Excluir.

    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 recursos nele são excluídos.

Conteúdo relacionado

  • Last updated on