Início Rápido: usar o Cache do Azure para Redis com um aplicativo .NET Core

Neste início rápido, você incorporará o Cache do Azure para Redis em um aplicativo .NET Core para acessar um cache seguro e dedicado que pode ser acessado de qualquer aplicativo no Azure. Você especificamente usará o cliente StackExchange.Redis com o código C# em um aplicativo de console do .NET Core.

Ir para o código

Este artigo descreve como modificar o código de um aplicativo de exemplo para criar um aplicativo funcional que se conecta ao Cache do Azure para Redis.

Se você quiser ir direto para o código de exemplo, consulte o Exemplo de início rápido do .NET Core no GitHub.

Pré-requisitos

• Uma assinatura do Azure. Crie um gratuitamente
• SDK do .NET Core

Criar um cache

1. Para criar um cache, entre no portal do Azure. No menu do portal, selecione Criar um recurso.

   

2. Na página Introdução, insira Cache do Azure para Redis na barra de pesquisa. Nos resultados da pesquisa, localize o Cache do Azure para Redis e selecione Criar.

   

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

   Configuração	Ação	Descrição
   Assinatura	Selecione sua assinatura 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 seu 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 exclusivo.	O nome de cache precisa ser uma cadeia de caracteres de 1 a 63 caracteres que contenha 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 próxima a outros serviços que usam seu 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.

4. Selecione a guia Rede ou selecione Avançar: Rede.

5. Na guia Rede, selecione um método de conectividade a ser usado para o cache.

6. Selecione a guia Avançado ou selecione Avançar: Avançado.

7. 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 obter a segurança ideal, recomendamos que você use o Microsoft Entra ID com identidades gerenciadas para autorizar solicitações no seu cache, se possível. A autorização usando o Microsoft Entra ID e identidades gerenciadas oferece maior segurança e facilidade de uso em comparação com a autorização por chave de acesso compartilhada. Para obter mais informações sobre como usar identidades gerenciadas com seu cache, consulte Usar o Microsoft Entra ID para a autenticação de cache.

8. (Opcional) Selecione a guia Marcas ou selecione Avançar: Marcas.

9. (Opcional) Na guia Marcas, insira um nome de marca e um valor se você quiser categorizar seu recurso de cache.

10. Selecione o botão Revisar + criar.

    Na guia Revisar + criar, o Azure valida automaticamente sua configuração.

11. Depois que a mensagem em verde Validação aprovada 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 o Status mostrar Em execução, o cache estará pronto para ser usado.

Obter o nome do host, as portas e a chave de acesso

Para se conectar ao servidor do Cache do Azure para Redis, o cliente de cache precisa do nome do host, das portas e da chave de acesso do cache. Alguns clientes podem se referir a esses itens usando nomes ligeiramente diferentes. Você pode obter o nome do host, as portas e as chaves no portal do Azure.

• Para obter uma chave de acesso para seu cache:

  1. No portal do Azure, acesse seu cache.
  2. No menu de serviço, em Configurações, selecione Autenticação.
  3. No painel Autenticação, selecione a guia Chaves de acesso.
  4. Para copiar o valor de uma chave de acesso, selecione o ícone Copiar no campo de chave.

  

• Para obter o nome do host e as portas do seu cache:

  1. No portal do Azure, acesse seu cache.
  2. No menu de serviço, selecione Visão geral.
  3. Em Essentials, quanto ao Nome do host, selecione o ícone Copiar para copiar o valor do nome do host. O valor do nome do host tem o formato <DNS name>.redis.cache.windows.net.
  4. Quanti às Portas, selecione o ícone Copiar para copiar os valores da porta.

  

Anote os valores do NOME DO HOST e da chave de acesso Primária. Você usará esses valores mais tarde para construir o segredo CacheConnection.

Adicionar um segredo local para a cadeia de conexão

Na janela do Prompt de Comando, execute o comando a seguir para armazenar um novo segredo chamado CacheConnection. Substitua os espaços reservados (incluindo colchetes angulares) pelo nome do cache (<cache name>) e pela chave de acesso primária (<primary-access-key>):

dotnet user-secrets set CacheConnection "<cache name>.redis.cache.windows.net,abortConnect=false,ssl=true,allowAdmin=true,password=<primary-access-key>"

Conectar-se ao cache usando o RedisConnection

A conexão ao seu cache é gerenciada pela classe RedisConnection. Primeiro, faça a conexão nesta instrução em Program.cs:

      _redisConnection = await RedisConnection.InitializeAsync(connectionString: configuration["CacheConnection"].ToString());

No RedisConnection.cs, o namespace StackExchange.Redis é adicionado ao código. O namespace é necessário para a classe RedisConnection.

using StackExchange.Redis;

O código de classe RedisConnection garante que sempre haja uma conexão íntegra com o cache. A conexão é gerenciada pela instância de ConnectionMultiplexer do StackExchange.Redis. A classe RedisConnection recria a conexão quando uma conexão é perdida e não pode se reconectar automaticamente.

Para obter mais informações, consulte StackExchange.Redis e o código no Repositório do GitHub do StackExchange.Redis.

Executar comandos de cache

No Program.cs, você pode ver o seguinte código para o método RunRedisCommandsAsync na classe Program do aplicativo de console:

private static async Task RunRedisCommandsAsync(string prefix)
    {
        // Simple PING command
        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: PING");
        RedisResult pingResult = await _redisConnection.BasicRetryAsync(async (db) => await db.ExecuteAsync("PING"));
        Console.WriteLine($"{prefix}: Cache response: {pingResult}");

        // Simple get and put of integral data types into the cache
        string key = "Message";
        string value = "Hello! The cache is working from a .NET console app!";

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
        RedisValue getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: SET {key} \"{value}\" via StringSetAsync()");
        bool stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync(key, value));
        Console.WriteLine($"{prefix}: Cache response: {stringSetResult}");

        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache command: GET {key} via StringGetAsync()");
        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync(key));
        Console.WriteLine($"{prefix}: Cache response: {getMessageResult}");

        // Store serialized object to cache
        Employee e007 = new Employee("007", "Davide Columbo", 100);
        stringSetResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringSetAsync("e007", JsonSerializer.Serialize(e007)));
        Console.WriteLine($"{Environment.NewLine}{prefix}: Cache response from storing serialized Employee object: {stringSetResult}");

        // Retrieve serialized object from cache
        getMessageResult = await _redisConnection.BasicRetryAsync(async (db) => await db.StringGetAsync("e007"));
        Employee e007FromCache = JsonSerializer.Deserialize<Employee>(getMessageResult);
        Console.WriteLine($"{prefix}: Deserialized Employee .NET object:{Environment.NewLine}");
        Console.WriteLine($"{prefix}: Employee.Name : {e007FromCache.Name}");
        Console.WriteLine($"{prefix}: Employee.Id   : {e007FromCache.Id}");
        Console.WriteLine($"{prefix}: Employee.Age  : {e007FromCache.Age}{Environment.NewLine}");
    }

Você pode armazenar e recuperar os itens de cache usando os métodos StringSetAsync e StringGetAsync.

No exemplo, você pode ver que a chave Message está definida como um valor. O aplicativo atualizou esse valor armazenado em cache. O aplicativo também executou o PING e o comando.

Trabalhar com objetos .NET no cache

O servidor Redis armazena a maioria dos dados no formato de cadeia de caracteres. As cadeias de caracteres podem conter muitos tipos de dados, incluindo dados binários serializados. Você pode usar dados binários serializados ao armazenar objetos .NET no cache.

O Cache do Azure para Redis pode armazenar em cache objetos .NET e tipos de dados primitivos, mas antes que um objeto .NET possa ser armazenado em cache, ele deve ser serializado.

A serialização do objeto .NET é responsabilidade do desenvolvedor de aplicativos. A serialização do objeto oferece ao desenvolvedor flexibilidade na escolha do serializador.

A classe Employee a seguir foi definida em Program.cs para que o exemplo também pudesse mostrar como obter e definir um objeto serializado:

class Employee
    {
        public string Id { get; set; }
        public string Name { get; set; }
        public int Age { get; set; }

        public Employee(string id, string name, int age)
        {
            Id = id;
            Name = name;
            Age = age;
        }
    }

Execute o exemplo

Se você abriu arquivos, salve os arquivos. Em seguida, crie o aplicativo usando o seguinte comando:

dotnet build

Para testar a serialização dos objetos .NET, execute este comando:

dotnet run

Limpar os recursos

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

Caso contrário, para evitar encargos relacionados aos recursos, se você já tiver terminado de usá-los, pode excluir o grupo de recursos do Azure que você criou.

Excluir um grupo de recursos

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

2. Selecione o grupo de recursos a ser excluído.

   Se houver muitos grupos de recursos, em Filtrar para qualquer campo, insira o nome do grupo de recursos que você criou para concluir este artigo. Na lista de resultados da pesquisa, selecione o grupo de recursos.

   

3. Selecione Excluir grupo de recursos.

4. No painel Excluir um grupo de recursos, insira o nome do grupo de recursos para confirmar e selecione Excluir.

   

Em poucos instantes, o grupo de recursos e todos os seus recursos são excluídos.

Conteúdo relacionado

• Práticas recomendadas de resiliência de conexão do seu cache
• Práticas recomendadas de desenvolvimento do seu cache