Guia de início rápido: usar o Azure Redis no Node.js

Artigo
12/19/2024

Neste início rápido, você incorpora o Azure Managed Redis (visualização) ou o Cache Redis do Azure 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

Subscrição do Azure - crie uma gratuitamente
Node.js instalado - Para instalar o Node.js, consulte Instalar 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 Azure Managed Redis (visualização)

Para criar uma instância do Azure Managed Redis (visualização), entre no portal do Azure e selecione Criar um recurso.
Na página Novo, na caixa de pesquisa, digite Cache do Azure para Redis.

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

Definição	Escolher um valor	Description
Subscrição	Drop-down e selecione sua assinatura.	A assinatura sob a qual criar essa nova instância do Azure Managed Redis.
Grupo de recursos	Drop-down e selecione um grupo de recursos, ou selecione Criar novo e insira um novo nome de grupo de recursos.	Nome do grupo de recursos no qual criar o cache e outros recursos. Ao colocar todos os recursos do seu aplicativo em um grupo de recursos, você pode facilmente gerenciá-los ou excluí-los juntos.
Nome DNS	Insira um nome exclusivo na região.	O nome do cache deve ser uma cadeia de caracteres entre 1 e 63 caracteres quando combinado com o nome da região do cache que contém apenas números, letras ou hífenes. (Se o nome do cache tiver menos de 45 caracteres, ele deverá funcionar em todas as regiões atualmente disponíveis.) O nome deve começar e terminar com um número ou letra e não pode conter hífenes consecutivos. O nome de host da instância de cache é `\<DNS name\>.\<Azure region\>.redis.azure.net`.
Location	Drop-down e selecione um local.	O Azure Managed Redis está disponível em regiões selecionadas do Azure.
Tipo de cache	Faça uma lista suspensa e selecione a camada de desempenho e o tamanho do cache.	A camada determina o desempenho da instância do Redis, enquanto o tamanho do cache determina a memória disponível para armazenar dados. Para obter orientação sobre como escolher a camada de desempenho correta, consulte Escolhendo a camada certa

Captura de ecrã a mostrar o separador Noções básicas do Azure Managed Redis.

Selecione Next: Networking e selecione um ponto de extremidade público ou privado.
Selecione Next: Avançado.

Configure todos os módulos Redis que você deseja adicionar à instância.

Por padrão, para um novo cache gerenciado:
- O Microsoft Entra ID está habilitado.
- A Autenticação de Chaves de Acesso está desativada por motivos de segurança.
Importante

Para uma segurança ideal, recomendamos que você use o Microsoft Entra ID com identidades gerenciadas para autorizar solicitações em seu cache, se possível. A autorização usando o ID do Microsoft Entra e identidades gerenciadas oferece segurança superior e facilidade de uso em relação à autorização de chave de acesso compartilhado. Para obter mais informações sobre como usar identidades gerenciadas com seu cache, consulte Usar a ID do Microsoft Entra para autenticação de cache.

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

Se você estiver usando a replicação geográfica ativa, ela deverá ser configurada durante a criação. Para obter mais informações, consulte Configurar a replicação geográfica ativa para instâncias do Azure Managed Redis.

Importante

Não é possível alterar a política de clustering de uma instância do Azure Managed Redis (visualização) depois de criá-la. Se você estiver usando o RediSearch, a política de cluster Enterprise será necessária e NoEviction será a única política de remoção suportada.

Importante

Se você estiver 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. Certifique-se de conhecer as políticas de remoção de seus nós principais antes de criar o cache. Para obter mais informações sobre replicação geográfica ativa, consulte Pré-requisitos de 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ê cria uma instância do 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 Next: Tags e skip.
Selecione Seguinte: Rever + criar.
Revise as configurações e selecione Criar.

Leva vários minutos para a instância do Redis ser criada. Você pode monitorar o progresso na página Visão Geral do Redis Gerenciado do Azure. Quando Status é exibido como Em execução, o cache está pronto para uso.

Criar uma instância do Cache do Azure para Redis

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

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

Definição	Ação	Descrição
Subscrição	Selecione a subscrição do Azure.	A assinatura a ser usada para criar a nova 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 no qual criar seu cache e outros recursos. Ao colocar todos os recursos do seu aplicativo em um grupo de recursos, você pode facilmente gerenciá-los ou excluí-los juntos.
Nome DNS	Introduza um nome exclusivo.	O nome do cache deve ser uma cadeia de caracteres de 1 a 63 caracteres que contenha apenas números, letras e hífenes. O nome deve começar e terminar com um número ou letra, e não pode conter hífenes consecutivas. O nome de host da instância de cache é `\<DNS name>.redis.cache.windows.net`.
Location	Selecione uma localização.	Uma região do Azure que está perto de outros serviços que usam seu cache.
Cache SKU	Selecione uma SKU.	A SKU determina o tamanho, o desempenho e os parâmetros de 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 selecione Avançar: Rede.
Na guia Rede, selecione um método de conectividade a ser usado para o cache.
Selecione a guia Avançado ou selecione 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 Basic ou Standard, você pode escolher a seleção para uma porta não-TLS.
- Para caches Standard e Premium, você pode optar por habilitar zonas de disponibilidade. Não é possível desativar as 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 uma segurança ideal, recomendamos que você use o Microsoft Entra ID com identidades gerenciadas para autorizar solicitações em seu cache, se possível. A autorização usando o ID do Microsoft Entra e identidades gerenciadas oferece segurança superior e facilidade de uso em relação à autorização de chave de acesso compartilhado. Para obter mais informações sobre como usar identidades gerenciadas com seu cache, consulte Usar a ID do Microsoft Entra para autenticação de cache.
(Opcional) Selecione a guia Tags ou selecione Next: Tags.
(Opcional) Na guia Marcas , insira um nome e um valor de tag se quiser categorizar seu recurso de cache.
Selecione o botão Rever + criar.

Na guia Revisão + criação, o Azure valida automaticamente sua configuração.
Depois que a mensagem verde Validação passada for exibida, selecione Criar.

Uma nova implantação de cache ocorre ao longo de vários minutos. Você pode monitorar o progresso da implantação no painel Visão Geral do Cache do Azure para Redis. Quando Status exibe Em execução, o cache está pronto para uso.

Instalar a biblioteca de 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

Criar um aplicativo Node.js para acessar um cache

Crie um aplicativo Node.js que use a ID do Microsoft Entra ou chaves de acesso para se conectar a uma instância do Azure Managed Redis (visualização). Recomendamos que você use o Microsoft Entra ID.

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

Usar a autenticação do Microsoft Entra ID no cache

Os caches Redis do Azure, exceto para as camadas Enterprise e Enterprise Flash, têm a Autenticação Microsoft Entra habilitada por padrão. As chaves de acesso estão desativadas por padrão.

Importante

A Microsoft recomenda o uso da autenticação Microsoft Entra ID para a experiência de autenticação mais segura em vez de usar senhas ou chaves de acesso. A autenticação descrita nesta seção do artigo usa chaves de acesso, que exigem um grau muito alto de confiança no aplicativo e acarreta riscos não presentes ao usar o Microsoft Entra ID. Use a abordagem neste documento somente quando a autenticação do Microsoft Entra ID não for viável.

No portal do Azure, selecione o cache onde você gostaria de usar a autenticação baseada em token do Microsoft Entra.
Selecione Autenticação no menu Recurso.
Selecione Selecionar membro e digite 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 à sua instância de cache.

Para obter informações sobre como usar a ID do Microsoft Entra com a CLI do Azure, consulte as páginas de referência 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 o MSAL para fornecer suporte à autenticação de token. Instale esta biblioteca usando npm:

npm install @azure/identity

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

Adicione variáveis de ambiente para o nome do host e a ID da entidade de serviço, que é a ID do objeto da entidade de serviço ou do 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
```
Crie um novo ficheiro de script com o nome redistest.js.

Adicione o seguinte exemplo de JavaScript ao ficheiro. Este código mostra como se conectar a uma instância do Azure Managed Redis usando o nome do host de cache e as principais variáveis de ambiente. O código também armazena e obtém um valor de cadeia na cache. Os comandos PING e CLIENT LIST também são executados. Para obter mais exemplos de como usar o Redis com o cliente node-redis , consulte 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 o Node.js.
```
node redistest.js
```

A saída do seu código tem esta aparência.

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

Criar um aplicativo JavaScript de exemplo com reautenticação

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

Crie um novo arquivo de script chamado redistestreauth.js.

Adicione o seguinte exemplo de JavaScript ao ficheiro.

 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 o Node.js.
```
node redistestreauth.js
```

A saída do seu código tem esta aparência.

 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

Nota

Para obter exemplos adicionais de como usar o Microsoft Entra ID para autenticar no Redis usando a biblioteca node-redis, consulte este repositório GitHub

Importante

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

Para conectar seu servidor 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 mencionar esses itens com nomes ligeiramente diferentes. Você pode obter o nome do host, as portas e as chaves no portal do Azure.

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

Adicione variáveis de ambiente ao NOME DO ANFITRIÃO e à chave de acesso Primária. Use essas variáveis do 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

Ligar-se à cache

Nota

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

Criar uma aplicação nova em Node.js

Crie um novo ficheiro de script com o nome redistest.js.

Adicione o seguinte exemplo de JavaScript ao ficheiro.

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 Redis do Azure usando o nome do host do cache e as principais variáveis de ambiente. O código também armazena e obtém um valor de cadeia na cache. Os comandos PING e CLIENT LIST também são executados. Para obter mais exemplos de utilização de Redis com o cliente node_redis, veja https://redis.js.org/.

Execute o script com o 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

Criar um aplicativo Node.js para acessar um cache

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

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

Usar a autenticação do Microsoft Entra ID no cache

Os caches Redis do Azure, exceto para as camadas Enterprise e Enterprise Flash, têm a Autenticação Microsoft Entra habilitada por padrão. As chaves de acesso estão desativadas por padrão.

Importante

No portal do Azure, selecione o cache onde você gostaria de usar a autenticação baseada em token do Microsoft Entra.
Selecione Autenticação no menu Recurso.
Selecione Selecionar membro e digite 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 à sua instância de cache.

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

Instalar a biblioteca de cliente JavaScript Azure Identity

npm install @azure/identity

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

Adicione variáveis de ambiente para o nome do host e a ID da entidade de serviço, que é a ID do objeto da entidade de serviço ou do 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
```
Crie um novo ficheiro de script com o nome redistest.js.

Adicione o seguinte exemplo de JavaScript ao ficheiro. Este código mostra como se conectar a uma instância do Cache Redis do Azure usando o nome do host do cache e as principais variáveis de ambiente. O código também armazena e obtém um valor de cadeia na cache. Os comandos PING e CLIENT LIST também são executados. Para obter mais exemplos de como usar o Redis com o cliente node-redis , consulte 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 o Node.js.
```
node redistest.js
```

A saída do seu código tem esta aparência.

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

Criar um aplicativo JavaScript de exemplo com reautenticação

Crie um novo arquivo de script chamado redistestreauth.js.

Adicione o seguinte exemplo de JavaScript ao ficheiro.

 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 o Node.js.
```
node redistestreauth.js
```

A saída do seu código tem esta aparência.

 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

Nota

Para obter exemplos adicionais de como usar o Microsoft Entra ID para autenticar no Redis usando a biblioteca node-redis, consulte este repositório GitHub

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

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

set AZURE_CACHE_FOR_REDIS_HOST_NAME=contosoCache
set AZURE_CACHE_FOR_REDIS_ACCESS_KEY=XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Ligar-se à cache

Nota

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

Criar uma aplicação nova em Node.js

Crie um novo ficheiro de script com o nome redistest.js.

Adicione o seguinte exemplo de JavaScript ao ficheiro.

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 o 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

Clean up resources (Limpar 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. Confirme que não elimina acidentalmente o grupo 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

Inicie sessão no Portal do Azure e selecione Grupos de recursos.
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.
Selecione Eliminar grupo de recursos.
É-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.

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

Obter o código de exemplo

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

Neste início rápido, você aprendeu a usar o Azure Managed Redis (visualização) ou o Cache Redis do Azure a partir de um aplicativo Node.js. Saiba mais sobre as ofertas do Azure Redis:

Partilhar via

Guia de início rápido: usar o Azure Redis no Node.js

Pré-requisitos

Criar uma instância do Azure Managed Redis (visualização)

Criar uma instância do Cache do Azure para Redis

Instalar a biblioteca de cliente node-redis

Criar um aplicativo Node.js para acessar um cache

Usar a autenticação do Microsoft Entra ID no cache

Instalar a biblioteca de cliente JavaScript Azure Identity

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

Criar um aplicativo JavaScript de exemplo com reautenticação

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

Ligar-se à cache

Criar uma aplicação nova em Node.js

Criar um aplicativo Node.js para acessar um cache

Usar a autenticação do Microsoft Entra ID no cache

Instalar a biblioteca de cliente JavaScript Azure Identity

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

Criar um aplicativo JavaScript de exemplo com reautenticação

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

Ligar-se à cache

Criar uma aplicação nova em Node.js

Clean up resources (Limpar recursos)

Para eliminar um grupo de recursos

Obter o código de exemplo

Comentários

Recursos adicionais

Partilhar via

Guia de início rápido: usar o Azure Redis no Node.js

Pré-requisitos

Criar uma instância do Azure Managed Redis (visualização)

Criar uma instância do Cache do Azure para Redis

Instalar a biblioteca de cliente node-redis

Criar um aplicativo Node.js para acessar um cache

Usar a autenticação do Microsoft Entra ID no cache

Instalar a biblioteca de cliente JavaScript Azure Identity

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

Criar um aplicativo JavaScript de exemplo com reautenticação

Criar um aplicativo Node.js para acessar um cache

Usar a autenticação do Microsoft Entra ID no cache

Instalar a biblioteca de cliente JavaScript Azure Identity

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

Criar um aplicativo JavaScript de exemplo com reautenticação

Clean up resources (Limpar recursos)

Para eliminar um grupo de recursos

Obter o código de exemplo

Conteúdos relacionados

Comentários

Recursos adicionais