Início Rápido: use o Redis do Azure no Node.js

Artigo
11/19/2024

Neste início rápido, você incorporará o Redis Gerenciado do Azure (versão prévia) ou o Cache do Azure para Redis em um aplicativo Node.js. O aplicativo tem acesso a um cache seguro e dedicado que pode ser acessado de qualquer aplicativo no Azure.

Pré-requisitos

Assinatura do Azure - criar uma gratuitamente
Node.js instalado – Para instalar o Node.js, consulte Instalar o Node.js no Windows para obter instruções sobre como instalar o Node e o npm em um computador Windows.

Criar uma instância do Redis Gerenciado do Azure (versão prévia)

Para criar uma instância do Redis Gerenciado do Azure (versão prévia), entre no portal do Azure e selecione Criar um recurso.
Na página Novo, selecione Bancos de dados e, em seguida, Cache do Azure para Redis.

Na página Novo Cache Redis, defina as configurações para o novo cache.

Configuração	Escolher um valor	Descrição
Assinatura	Clique na lista suspensa e selecione sua assinatura.	A assinatura sob a qual essa nova instância do Redis Gerenciado do Azure será criada.
Grupo de recursos	Clique na lista suspensa e selecione um grupo de recursos ou selecione Criar e insira um novo nome de grupo de recursos.	Nome do grupo de recursos no qual o cache e outros recursos serão criados. Ao colocar todos os seus recursos de aplicativos em um só grupo de recursos, você pode gerenciá-los ou excluí-los juntos com facilidade.
Nome DNS	Insira um nome que seja exclusivo na região.	O nome do cache deve conter de 1 a 63 caracteres quando combinado com o nome da região do cache que contém apenas números, letras ou hifens. (Se o nome do cache tiver menos de 45 caracteres, ele deverá funcionar em todas as regiões disponíveis no momento.) O nome precisa começar e terminar com um número ou uma letra e não pode conter hifens consecutivos. O nome do host da instância de cache é `\<DNS name\>.\<Azure region\>.redis.azure.net`.
Localidade	Clique na lista suspensa e selecione uma localização.	O Redis Gerenciado do Azure está disponível em regiões selecionadas do Azure.
Tipo de cache	Selecione o nível de desempenho e o tamanho do cache no menu suspenso.	O nível determina o desempenho da instância do Redis, enquanto o tamanho do cache determina a memória disponível para armazenar os dados. Para obter orientação sobre como escolher o nível de desempenho adequado, veja Escolher o nível correto

Captura de tela mostrando a guia Noções básicas do Redis Gerenciado do Azure.

Selecione Avançar: Rede e selecione um ponto de extremidade privado ou público.
Selecione Próximo: Avançado. Aqui, você pode configurar quaisquer módulos Redis a serem adicionados à instância.

Defina a política de clustering como Enterprise para um cache não clusterizado ou para o OSS para um cache clusterizado. Para obter mais informações sobre como escolher Política de cluster, veja Política de cluster.

Se você estiver usando a Replicação geográfica ativa, ela deverá ser configurada durante a criação. Para obter instruções sobre como fazer isso, veja Configurar replicação geográfica ativa para instâncias do Redis gerenciado do Azure.

Importante

Não é possível alterar a política de cluster de uma instância do Redis gerenciado do Azure (versão prévia) depois de criá-la. Caso esteja usando o RediSearch, a política de cluster do Enterprise será necessária e NoEviction será a única política de remoção com suporte.

Importante

Caso esteja usando essa instância de cache em um grupo de replicação geográfica, as políticas de remoção não poderão ser alteradas após a criação da instância. Lembre-se saber sobre as políticas de remoção dos nós primários antes de criar o cache. Para saber mais sobre a replicação geográfica ativa, confira Pré-requisitos da replicação geográfica ativa.

Importante

Não é possível alterar módulos depois de criar uma instância de cache. Os módulos devem ser habilitados no momento em que você criar uma instância de Cache do Azure para Redis. Não há nenhuma opção para habilitar a configuração de um módulo depois de criar um cache.
Selecione Avançar: Marcas e ignore.
Selecione Avançar: Revisar + criar.
Examine as configurações e selecione Criar.

A criação da instância do Redis levará vários minutos. Você pode monitorar o progresso na página Visão geral do Redis Gerenciado do Azure. Quando o Status for mostrado como Em execução, o cache estará pronto para uso.

Criar uma instância de Cache do Azure para Redis

Para criar um cache, entre no portal do Azure. No menu do portal, selecione Criar recurso.
Na página Introdução, insira Cache do Azure para Redis na barra de pesquisa. Nos resultados da pesquisa, localize Cache do Azure para Redis e selecione Criar.

No painel Novo Cache Redis, na guia Básico, defina as seguintes configurações para o cache:

Configuração	Ação	Descrição
Assinatura	Selecione sua assinatura do Azure.	A assinatura a ser usada para criar a instância do Cache do Azure para Redis.
Grupo de recursos	Selecione um grupo de recursos ou selecione Criar novo e insira um novo nome de grupo de recursos.	Um nome para o grupo de recursos em que você criará o cache e outros recursos. Ao colocar todos os seus recursos de aplicativos em um só grupo de recursos, você pode gerenciá-los ou excluí-los juntos com facilidade.
Nome DNS	Insira um nome exclusivo.	O nome do cache precisa ser uma cadeia de caracteres com 1 a 63 caracteres contendo somente números, letras e hifens. O nome deve começar e terminar com um número ou uma letra e não pode conter hifens consecutivos. O nome do host da instância de cache é `\<DNS name>.redis.cache.windows.net`.
Localidade	Selecione uma localização.	Uma região do Azure que esteja próxima a outros serviços que usam o cache.
Cache SKU	Selecione um SKU.	O SKU determina os parâmetros de tamanho, desempenho e recurso disponíveis para o cache. Para obter mais informações, consulte Visão geral do Cache do Azure para Redis.
Tamanho do cache	Selecione um tamanho de cache.	Para obter mais informações, consulte Visão geral do Cache do Azure para Redis.

Selecione a guia Rede ou clique em Avançar: rede.
Na guia Rede, selecione um método de conectividade a ser usado para o cache.
Selecione a guia Avançado ou clique em Avançar: avançado.
No painel Avançado, verifique ou selecione um método de autenticação com base nas seguintes informações:
- Por padrão, para um novo cache Básico, Standard ou Premium, a Autenticação do Microsoft Entra está habilitada e a Autenticação de Chaves de Acesso está desabilitada.
- Para caches Básico ou Standard, é possível escolher a seleção de uma porta não TLS.
- Para caches Standard e Premium, é possível optar por habilitar zonas de disponibilidade. Não é possível desabilitar zonas de disponibilidade após a criação do cache.
- Para um cache Premium, defina as configurações para porta não TLS, clustering, identidade gerenciada e persistência de dados.
Importante

Para otimizar a segurança, recomendamos usar o Microsoft Entra ID com identidades gerenciadas a fim de autorizar solicitações no cache, se possível. A autorização usando o Microsoft Entra ID e identidades gerenciadas oferece segurança superior e facilidade de uso em relação à autorização de chave de acesso compartilhada. Para saber como usar as identidades gerenciadas com o cache, confira Usar o Microsoft Entra ID para autenticação de cache.
(Opcional) Selecione a guia Categorias ou clique em Avançar: categorias.
(Opcional) Na guia Categorias, insira um nome e um valor de categoria se você quiser categorizar o recurso de cache.
Selecione o botão Revisar + criar.

Na guia Examinar + criar, o Azure valida a configuração automaticamente.
Depois que a mensagem em verde Validação aprovada for exibida, selecione Criar.

Uma nova implantação de cache ocorre durante diversos minutos. Você pode monitorar o progresso da implantação no painel Visão Geral do Cache do Azure para Redis. Quando o Status mostrar Em execução, o cache estará pronto para ser usado.

Instalar a biblioteca cliente node-redis

A biblioteca node-redis é o principal cliente Node.js para Redis. Você pode instalar o cliente com npm usando o seguinte comando:

npm install redis

Crie um aplicativo Node.js para acessar um cache

Crie um aplicativo do Node.js que use o Microsoft Entra ID ou chaves de acesso para se conectar à sua instância de um Redis Gerenciado do Azure (versão prévia). Recomendamos que você use o Microsoft Entra ID.

Autenticação do Microsoft Entra ID (recomendado)
Autenticação de chave de acesso

Habilitar a autenticação do Microsoft Entra no seu cache

Se você tiver um cache, verifique se a autenticação do Microsoft Entra foi habilitada. Caso contrário, habilite-a. É recomendável usar o Microsoft Entra ID para seus aplicativos.

No portal do Azure, selecione a instância do Cache do Azure para Redis onde você gostaria de usar a autenticação baseada em token do Microsoft Entra.
Selecione Autenticação no menu Recurso.
Verifique no painel de trabalho se a opção Habilitar Autenticação do Microsoft Entra está marcada. Nesse caso, você pode seguir em frente.
Selecione Habilitar Autenticação do Microsoft Entra e insira o nome de um usuário válido. O usuário inserido recebe automaticamente a Política de Acesso do Proprietário de Dados por padrão quando você seleciona Salvar. Você também pode inserir uma identidade gerenciada ou uma entidade de serviço para se conectar à instância de cache.
Uma caixa de diálogo pop-up é exibida perguntando se você deseja atualizar sua configuração e informando que leva vários minutos. Selecione Sim.

Importante

Após a operação de habilitação ter sido concluída, os nós na sua instância de cache serão reinicializados para carregar a nova configuração. Recomendamos executar essa operação durante sua janela de manutenção ou fora do seu horário comercial de pico. Essa operação pode levar até 30 minutos.

Para obter informações sobre como usar o Microsoft Entra ID com a CLI do Azure, consulte as páginas de referências para identidade.

Instalar a biblioteca de cliente JavaScript Azure Identity

A Biblioteca de Autenticação da Microsoft (MSAL) permite que você adquira tokens de segurança da identidade da Microsoft para autenticar usuários. Há uma biblioteca de cliente de identidade JavaScript do Azure disponível que usa MSAL para fornecer suporte à autenticação de token. Instale esta biblioteca usando npm:

npm install @azure/identity

Crie um novo aplicativo Node.js usando o Microsoft Entra ID

Adicione variáveis de ambiente para seu Nome do host e ID da entidade de serviço, que é a ID do objeto da entidade de serviço ou usuário do Microsoft Entra ID. No portal do Azure, procure o Nome de usuário.
```
set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Criar um novo arquivo de script chamado redistest.js.

Adicione o exemplo JavaScript a seguir ao arquivo. Este código mostra como se conectar a uma instância do Redis Gerenciado do Azure usando o nome de host de cache e as principais variáveis de ambiente. O código também armazena e recupera um valor de cadeia de caracteres no cache. Os comandos PING e CLIENT LIST também são executados. Para mais exemplos de uso do Redis com o cliente node-redis, veja https://redis.js.org/.

const { createClient } = require("redis");
const { DefaultAzureCredential } = require("@azure/identity");

async function main() {
  // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
  const credential = new DefaultAzureCredential();
  const redisScope = "https://redis.azure.com/.default";

  // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
  let accessToken = await credential.getToken(redisScope);
  console.log("access Token", accessToken);

  // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
  const cacheConnection = createClient({
    username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
    password: accessToken.token,
    url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
    pingInterval: 100000,
    socket: { 
      tls: true,
      keepAlive: 0 
    },
  });

  cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
  await cacheConnection.connect();

  // PING command
  console.log("\nCache command: PING");
  console.log("Cache response : " + await cacheConnection.ping());

  // SET
  console.log("\nCache command: SET Message");
  console.log("Cache response : " + await cacheConnection.set("Message",
      "Hello! The cache is working from Node.js!"));

  // GET
  console.log("\nCache command: GET Message");
  console.log("Cache response : " + await cacheConnection.get("Message"));

  // Client list, useful to see if connection list is growing...
  console.log("\nCache command: CLIENT LIST");
  console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

  cacheConnection.disconnect();

  return "Done"
}

main().then((result) => console.log(result)).catch(ex => console.log(ex));

Execute o script com Node.js.
```
node redistest.js
```

A saída do seu código se parece com isso.

Cache command: PING
Cache response : PONG

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: SET Message
Cache response : OK

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: CLIENT LIST
Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Done

Crie um aplicativo JavaScript simples com autenticação

Os tokens de acesso do Microsoft Entra ID têm uma vida útil limitada, em média 75 minutos. Para manter uma conexão com o seu cache, você precisa atualizar o token. Esse exemplo demonstra como fazer isso usando JavaScript.

Crie um novo arquivo de script chamado redistestreauth.js.

Adicione o exemplo JavaScript a seguir ao arquivo.

 const { createClient } = require("redis");
 const { DefaultAzureCredential } = require("@azure/identity");

 async function returnPassword(credential) {
     const redisScope = "https://redis.azure.com/.default";

     // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
     return credential.getToken(redisScope);
 }

 async function main() {
   // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
   const credential = new DefaultAzureCredential();
   let accessToken = await returnPassword(credential);

   // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
   let cacheConnection = createClient({
     username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
     password: accessToken.token,
     url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
     pingInterval: 100000,
     socket: { 
       tls: true,
       keepAlive: 0 
     },
   });

   cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
   await cacheConnection.connect();

   for (let i = 0; i < 3; i++) {
     try {
         // PING command
         console.log("\nCache command: PING");
         console.log("Cache response : " + await cacheConnection.ping());

         // SET
         console.log("\nCache command: SET Message");
         console.log("Cache response : " + await cacheConnection.set("Message",
             "Hello! The cache is working from Node.js!"));

         // GET
         console.log("\nCache command: GET Message");
         console.log("Cache response : " + await cacheConnection.get("Message"));

         // Client list, useful to see if connection list is growing...
         console.log("\nCache command: CLIENT LIST");
         console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
       break;
     } catch (e) {
       console.log("error during redis get", e.toString());
       if ((accessToken.expiresOnTimestamp <= Date.now())|| (redis.status === "end" || "close") ) {
         await redis.disconnect();
         accessToken = await returnPassword(credential);
         cacheConnection = createClient({
           username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
           password: accessToken.token,
           url: `redis://${process.env.AZURE_MANAGED_REDIS_HOST_NAME}:10000`,
           pingInterval: 100000,
           socket: {
             tls: true,
             keepAlive: 0
           },
         });
       }
     }
   }
 }

 main().then((result) => console.log(result)).catch(ex => console.log(ex));

Execute o script com Node.js.
```
node redistestreauth.js
```

A saída do seu código se parece com isso.

 Cache command: PING
 Cache response : PONG

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: SET Message
 Cache response : OK

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: CLIENT LIST
 Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Observação

Para obter exemplos adicionais de uso do Microsoft Entra ID para autenticação no Redis usando a biblioteca node-redis, veja esse repositório do GitHub

Recuperar o nome de host, as portas e as chaves de acesso do portal do Azure

Para conectar seu servidor do Cache do Azure para Redis, o cliente de cache precisa do nome do host, das portas e de uma chave para o cache. Alguns clientes podem se referir a esses itens por nomes um pouco diferentes. Você pode obter o nome do host, as portas e as chaves do portal do Azure.

Para obter as chaves de acesso, selecione Autenticação no menu Recurso. Em seguida, selecione a guia Chaves de acesso.
Para obter o nome do host e as portas do cache, selecione Visão geral no menu Recurso. O nome do host está no formato <nome DNS>.redis.cache.windows.net.

Adicionar variáveis de ambiente para o seu NOME DO HOST e a chave de acesso Primária. Use essas variáveis no seu código em vez de incluir as informações confidenciais diretamente no seu código.

set AZURE_MANAGED_REDIS_HOST_NAME=contosoCache
set AZURE_MANAGED_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Conectar-se ao cache

Observação

Não crie uma conexão para cada operação em seu código. Em vez disso, reutilize conexões sempre que possível.

Criar um novo aplicativo Node.js

Criar um novo arquivo de script chamado redistest.js.

Adicione o exemplo JavaScript a seguir ao arquivo.

const redis = require("redis");

// Environment variables for cache
const cacheHostName = process.env.AZURE_MANAGED_REDIS_HOST_NAME;
const cachePassword = process.env.AZURE_MANAGED_REDIS_ACCESS_KEY;

if(!cacheHostName) throw Error("AZURE_MANAGED_REDIS_HOST_NAME is empty")
if(!cachePassword) throw Error("AZURE_MANAGED_REDIS_ACCESS_KEY is empty")

async function testCache() {

    // Connection configuration
    const cacheConnection = redis.createClient({
        // redis for TLS
        url: `redis://${cacheHostName}:10000`,
        password: cachePassword
    });

    // Connect to Redis
    await cacheConnection.connect();

    // PING command
    console.log("\nCache command: PING");
    console.log("Cache response : " + await cacheConnection.ping());

    // GET
    console.log("\nCache command: GET Message");
    console.log("Cache response : " + await cacheConnection.get("Message"));

    // SET
    console.log("\nCache command: SET Message");
    console.log("Cache response : " + await cacheConnection.set("Message",
        "Hello! The cache is working from Node.js!"));

    // GET again
    console.log("\nCache command: GET Message");
    console.log("Cache response : " + await cacheConnection.get("Message"));

    // Client list, useful to see if connection list is growing...
    console.log("\nCache command: CLIENT LIST");
    console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

    // Disconnect
    cacheConnection.disconnect()

    return "Done"
}

testCache().then((result) => console.log(result)).catch(ex => console.log(ex));

Este código mostra como se conectar a uma instância do Cache do Azure para Redis usando o nome de host de cache e as principais variáveis de ambiente. O código também armazena e recupera um valor de cadeia de caracteres no cache. Os comandos PING e CLIENT LIST também são executados. Para obter mais exemplos de como usar Redis com o cliente node_redis, veja https://redis.js.org/.

Execute o script com Node.js.
```
node redistest.js
```

Exemplo da saída.

Cache command: PING
Cache response : PONG

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: SET Message
Cache response : OK

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: CLIENT LIST
Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Done

Crie um aplicativo Node.js para acessar um cache

Crie um aplicativo Node.js que use o Microsoft Entra ID ou chaves de acesso para se conectar a um Cache do Azure para Redis. Recomendamos que você use o Microsoft Entra ID.

Autenticação do Microsoft Entra ID (recomendado)
Autenticação de chave de acesso

Habilitar a autenticação do Microsoft Entra no seu cache

Se você tiver um cache, verifique se a autenticação do Microsoft Entra foi habilitada. Caso contrário, habilite-a. É recomendável usar o Microsoft Entra ID para seus aplicativos.

No portal do Azure, selecione a instância do Cache do Azure para Redis onde você gostaria de usar a autenticação baseada em token do Microsoft Entra.
Selecione Autenticação no menu Recurso.
Verifique no painel de trabalho se a opção Habilitar Autenticação do Microsoft Entra está marcada. Nesse caso, você pode seguir em frente.
Selecione Habilitar Autenticação do Microsoft Entra e insira o nome de um usuário válido. O usuário inserido recebe automaticamente a Política de Acesso do Proprietário de Dados por padrão quando você seleciona Salvar. Você também pode inserir uma identidade gerenciada ou uma entidade de serviço para se conectar à instância de cache.
Uma caixa de diálogo pop-up é exibida perguntando se você deseja atualizar sua configuração e informando que leva vários minutos. Selecione Sim.

Importante

Após a operação de habilitação ter sido concluída, os nós na sua instância de cache serão reinicializados para carregar a nova configuração. Recomendamos executar essa operação durante sua janela de manutenção ou fora do seu horário comercial de pico. Essa operação pode levar até 30 minutos.

Para obter informações sobre como usar o Microsoft Entra ID com a CLI do Azure, consulte as páginas de referências para identidade.

Instalar a biblioteca de cliente JavaScript Azure Identity

npm install @azure/identity

Crie um novo aplicativo Node.js usando o Microsoft Entra ID

Adicione variáveis de ambiente para seu Nome do host e ID da entidade de serviço, que é a ID do objeto da entidade de serviço ou usuário do Microsoft Entra ID. No portal do Azure, procure o Nome de usuário.
```
set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set REDIS_SERVICE_PRINCIPAL_ID=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
```
Criar um novo arquivo de script chamado redistest.js.

Adicione o exemplo JavaScript a seguir ao arquivo. Este código mostra como se conectar a uma instância do Cache do Azure para Redis usando o nome de host de cache e as principais variáveis de ambiente. O código também armazena e recupera um valor de cadeia de caracteres no cache. Os comandos PING e CLIENT LIST também são executados. Para mais exemplos de uso do Redis com o cliente node-redis, veja https://redis.js.org/.

const { createClient } = require("redis");
const { DefaultAzureCredential } = require("@azure/identity");

async function main() {
  // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
  const credential = new DefaultAzureCredential();
  const redisScope = "https://redis.azure.com/.default";

  // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
  let accessToken = await credential.getToken(redisScope);
  console.log("access Token", accessToken);

  // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
  const cacheConnection = createClient({
    username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
    password: accessToken.token,
    url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
    pingInterval: 100000,
    socket: { 
      tls: true,
      keepAlive: 0 
    },
  });

  cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
  await cacheConnection.connect();

  // PING command
  console.log("\nCache command: PING");
  console.log("Cache response : " + await cacheConnection.ping());

  // SET
  console.log("\nCache command: SET Message");
  console.log("Cache response : " + await cacheConnection.set("Message",
      "Hello! The cache is working from Node.js!"));

  // GET
  console.log("\nCache command: GET Message");
  console.log("Cache response : " + await cacheConnection.get("Message"));

  // Client list, useful to see if connection list is growing...
  console.log("\nCache command: CLIENT LIST");
  console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

  cacheConnection.disconnect();

  return "Done"
}

main().then((result) => console.log(result)).catch(ex => console.log(ex));

Execute o script com Node.js.
```
node redistest.js
```

A saída do seu código se parece com isso.

Cache command: PING
Cache response : PONG

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: SET Message
Cache response : OK

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: CLIENT LIST
Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Done

Crie um aplicativo JavaScript simples com autenticação

Crie um novo arquivo de script chamado redistestreauth.js.

Adicione o exemplo JavaScript a seguir ao arquivo.

 const { createClient } = require("redis");
 const { DefaultAzureCredential } = require("@azure/identity");

 async function returnPassword(credential) {
     const redisScope = "https://redis.azure.com/.default";

     // Fetch a Microsoft Entra token to be used for authentication. This token will be used as the password.
     return credential.getToken(redisScope);
 }

 async function main() {
   // Construct a Token Credential from Identity library, e.g. ClientSecretCredential / ClientCertificateCredential / ManagedIdentityCredential, etc.
   const credential = new DefaultAzureCredential();
   let accessToken = await returnPassword(credential);

   // Create redis client and connect to the Azure Cache for Redis over the TLS port using the access token as password.
   let cacheConnection = createClient({
     username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
     password: accessToken.token,
     url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
     pingInterval: 100000,
     socket: { 
       tls: true,
       keepAlive: 0 
     },
   });

   cacheConnection.on("error", (err) => console.log("Redis Client Error", err));
   await cacheConnection.connect();

   for (let i = 0; i < 3; i++) {
     try {
         // PING command
         console.log("\nCache command: PING");
         console.log("Cache response : " + await cacheConnection.ping());

         // SET
         console.log("\nCache command: SET Message");
         console.log("Cache response : " + await cacheConnection.set("Message",
             "Hello! The cache is working from Node.js!"));

         // GET
         console.log("\nCache command: GET Message");
         console.log("Cache response : " + await cacheConnection.get("Message"));

         // Client list, useful to see if connection list is growing...
         console.log("\nCache command: CLIENT LIST");
         console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));
       break;
     } catch (e) {
       console.log("error during redis get", e.toString());
       if ((accessToken.expiresOnTimestamp <= Date.now())|| (redis.status === "end" || "close") ) {
         await redis.disconnect();
         accessToken = await returnPassword(credential);
         cacheConnection = createClient({
           username: process.env.REDIS_SERVICE_PRINCIPAL_ID,
           password: accessToken.token,
           url: `redis://${process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME}:6380`,
           pingInterval: 100000,
           socket: {
             tls: true,
             keepAlive: 0
           },
         });
       }
     }
   }
 }

 main().then((result) => console.log(result)).catch(ex => console.log(ex));

Execute o script com Node.js.
```
node redistestreauth.js
```

A saída do seu código se parece com isso.

 Cache command: PING
 Cache response : PONG

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: SET Message
 Cache response : OK

 Cache command: GET Message
 Cache response : Hello! The cache is working from Node.js!

 Cache command: CLIENT LIST
 Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Observação

Para obter exemplos adicionais de uso do Microsoft Entra ID para autenticação no Redis usando a biblioteca node-redis, veja esse repositório do GitHub

Recuperar o nome de host, as portas e as chaves de acesso do portal do Azure

Para obter as chaves de acesso, selecione Autenticação no menu Recurso. Em seguida, selecione a guia Chaves de acesso.
Para obter o nome do host e as portas do cache, selecione Visão geral no menu Recurso. O nome do host está no formato <nome DNS>.redis.cache.windows.net.

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Conectar-se ao cache

Observação

Não crie uma conexão para cada operação em seu código. Em vez disso, reutilize conexões sempre que possível.

Criar um novo aplicativo Node.js

Criar um novo arquivo de script chamado redistest.js.

Adicione o exemplo JavaScript a seguir ao arquivo.

const redis = require("redis");

// Environment variables for cache
const cacheHostName = process.env.AZURE_CACHE_FOR_REDIS_HOST_NAME;
const cachePassword = process.env.AZURE_CACHE_FOR_REDIS_ACCESS_KEY;

if(!cacheHostName) throw Error("AZURE_CACHE_FOR_REDIS_HOST_NAME is empty")
if(!cachePassword) throw Error("AZURE_CACHE_FOR_REDIS_ACCESS_KEY is empty")

async function testCache() {

    // Connection configuration
    const cacheConnection = redis.createClient({
        // redis for TLS
        url: `redis://${cacheHostName}:6380`,
        password: cachePassword
    });

    // Connect to Redis
    await cacheConnection.connect();

    // PING command
    console.log("\nCache command: PING");
    console.log("Cache response : " + await cacheConnection.ping());

    // GET
    console.log("\nCache command: GET Message");
    console.log("Cache response : " + await cacheConnection.get("Message"));

    // SET
    console.log("\nCache command: SET Message");
    console.log("Cache response : " + await cacheConnection.set("Message",
        "Hello! The cache is working from Node.js!"));

    // GET again
    console.log("\nCache command: GET Message");
    console.log("Cache response : " + await cacheConnection.get("Message"));

    // Client list, useful to see if connection list is growing...
    console.log("\nCache command: CLIENT LIST");
    console.log("Cache response : " + await cacheConnection.sendCommand(["CLIENT", "LIST"]));

    // Disconnect
    cacheConnection.disconnect()

    return "Done"
}

testCache().then((result) => console.log(result)).catch(ex => console.log(ex));

Execute o script com Node.js.
```
node redistest.js
```

Exemplo da saída.

Cache command: PING
Cache response : PONG

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: SET Message
Cache response : OK

Cache command: GET Message
Cache response : Hello! The cache is working from Node.js!

Cache command: CLIENT LIST
Cache response : id=10017364 addr=76.22.73.183:59380 fd=221 name= age=1 idle=0 flags=N db=0 sub=0 psub=0 multi=-1 qbuf=26 qbuf-free=32742 argv-mem=10 obl=0 oll=0 omem=0 tot-mem=61466 ow=0 owmem=0 events=r cmd=client user=default numops=6

Done

Limpar os recursos

Se quiser continuar a usar os recursos que você criou neste artigo, conserve o grupo de recursos.

Caso contrário, se não pretende mais usar os recursos, você poderá excluir o grupo de recursos criado no Azure para evitar a cobrança.

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. 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ê quer manter, você pode excluir cada recurso individualmente em vez de excluir o grupo de recursos.

Para excluir um grupo de recursos

Entre no portal do Azure e selecione Grupos de recursos.
Selecione o grupo de recursos que você quer excluir.

Se existirem muitos grupos de recursos, use a caixa Filtrar para qualquer campo... e digite o nome do seu grupo de recursos que você criou para este artigo. Selecione o grupo de recursos na lista de resultados.
Selecione Excluir grupo de recursos.
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.

Após alguns instantes, o grupo de recursos, e todos os recursos nele são excluídos.

Obter o código de exemplo

Obtenha o início rápido do Node.js no GitHub.

Neste guia de início rápido, você aprendeu a usar o Redis Gerenciado do Azure (versão prévia) ou o Cache do Azure para Redis de um aplicativo Node.js. Saiba mais sobre as ofertas do Redis do Azure:

Compartilhar via

Início Rápido: use o Redis do Azure no Node.js

Pré-requisitos

Criar uma instância do Redis Gerenciado do Azure (versão prévia)

Criar uma instância de Cache do Azure para Redis

Instalar a biblioteca cliente node-redis

Crie um aplicativo Node.js para acessar um cache

Habilitar a autenticação do Microsoft Entra no seu cache

Instalar a biblioteca de cliente JavaScript Azure Identity

Crie um novo aplicativo Node.js usando o Microsoft Entra ID

Crie um aplicativo JavaScript simples com autenticação

Recuperar o nome de host, as portas e as chaves de acesso do portal do Azure

Conectar-se ao cache

Criar um novo aplicativo Node.js

Crie um aplicativo Node.js para acessar um cache

Habilitar a autenticação do Microsoft Entra no seu cache

Instalar a biblioteca de cliente JavaScript Azure Identity

Crie um novo aplicativo Node.js usando o Microsoft Entra ID

Crie um aplicativo JavaScript simples com autenticação

Recuperar o nome de host, as portas e as chaves de acesso do portal do Azure

Conectar-se ao cache

Criar um novo aplicativo Node.js

Limpar os recursos

Para excluir um grupo de recursos

Obter o código de exemplo

Comentários

Recursos adicionais

Compartilhar via

Início Rápido: use o Redis do Azure no Node.js

Pré-requisitos

Criar uma instância do Redis Gerenciado do Azure (versão prévia)

Criar uma instância de Cache do Azure para Redis

Instalar a biblioteca cliente node-redis

Crie um aplicativo Node.js para acessar um cache

Habilitar a autenticação do Microsoft Entra no seu cache

Instalar a biblioteca de cliente JavaScript Azure Identity

Crie um novo aplicativo Node.js usando o Microsoft Entra ID

Crie um aplicativo JavaScript simples com autenticação

Crie um aplicativo Node.js para acessar um cache

Habilitar a autenticação do Microsoft Entra no seu cache

Instalar a biblioteca de cliente JavaScript Azure Identity

Crie um novo aplicativo Node.js usando o Microsoft Entra ID

Crie um aplicativo JavaScript simples com autenticação

Limpar os recursos

Para excluir um grupo de recursos

Obter o código de exemplo

Conteúdo relacionado

Comentários

Recursos adicionais