Guia de início rápido: usar o Cache Redis do Azure com um aplicativo .NET

Neste início rápido, você incorpora o Cache Redis do Azure em um aplicativo .NET para acessar um cache seguro e dedicado acessível a partir de qualquer aplicativo no Azure. Você usa especificamente o cliente StackExchange.Redis com código C# em um aplicativo de console .NET.

Saltar para o código no GitHub

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

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

Pré-requisitos

• Uma subscrição do Azure. Crie um gratuitamente
• Visual Studio 2019
• .NET Framework 4 ou posterior, conforme exigido pelo cliente StackExchange.Redis

Criar uma cache

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

   

2. 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.

   

3. 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.

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

8. (Opcional) Selecione a guia Tags ou selecione Next: Tags.

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

10. Selecione o botão Rever + criar.

    Na guia Revisão + criação, o Azure valida automaticamente sua configuração.

11. 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.

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

Para se conectar ao seu servidor Cache do Azure para Redis, o cliente de cache precisa do nome do host, das portas e de uma 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 o cache:

  1. No portal do Azure, vá para o cache.
  2. No menu de serviço, em Configurações, selecione Autenticação.
  3. No painel Autenticação, selecione a guia Teclas 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 para seu cache:

  1. No portal do Azure, vá para o cache.
  2. No menu de serviço, selecione Visão geral.
  3. Em Essentials, para 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. Em Portas, selecione o ícone Copiar para copiar os valores da porta.

  

1. Crie um arquivo no seu computador chamado CacheSecrets.config. Coloque-o na pasta *C:\AppSecrets*.

2. Edite o ficheiro CacheSecrets.config e adicione os seguintes conteúdos:

   <appSettings>
       <add key="CacheConnection" value="<host-name>,abortConnect=false,ssl=true,allowAdmin=true,password=<access-key>"/>
   </appSettings>
   

   • Substitua <host-name> pelo nome do anfitrião da cache.

   • Substitua <access-key> pela chave primária da sua cache.

3. Guarde o ficheiro.

Configurar o cliente de cache

Nesta seção, você prepara o aplicativo de console para usar o cliente StackExchange.Redis para .NET.

1. No Visual Studio, selecione Ferramentas>Gestor de pacote NuGet>Consola do Gestor de Pacotes. Execute o seguinte comando na janela Console do Gerenciador de Pacotes:

   Install-Package StackExchange.Redis
   

2. Quando a instalação estiver concluída, o cliente de cache StackExchange.Redis estará disponível para uso com seu projeto.

Conectar-se ao cache de Segredos

No Visual Studio, abra o arquivo App.config para verificar se ele contém um appSettings file atributo que faz referência ao arquivo CacheSecrets.config :

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <startup> 
        <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.7.2" />
    </startup>

    <appSettings file="C:\AppSecrets\CacheSecrets.config"></appSettings>
</configuration>

Nunca armazene credenciais no seu código-fonte. Para manter este exemplo simples, usamos um arquivo de configuração de segredos externos. Uma melhor abordagem seria utilizar o Azure Key Vault com certificados.

Conectar-se ao cache usando RedisConnection

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

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

O valor da configuração do aplicativo CacheConnection é usado para fazer referência à cadeia de conexão de cache do portal do Azure como o parâmetro de senha.

No RedisConnection.cs, o namespace StackExchange.Redis aparece como uma using instrução que a RedisConnection classe requer:

using StackExchange.Redis;

O RedisConnection código de classe garante que haja sempre uma conexão íntegra com o cache. A conexão é gerenciada ConnectionMultiplexer pela instância de StackExchange.Redis. A RedisConnection classe 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 GitHub StackExchange.Redis.

Executar comandos de cache

No Program.cs, você pode ver o seguinte código para o RunRedisCommandsAsync método na Program classe para o 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}");
    }

Os itens de cache podem ser obtidos com os métodos StringSetAsync e StringGetAsync.

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

Trabalhar com objetos .NET na cache

O servidor Redis armazena a maioria dos dados como cadeias de caracteres, mas essas cadeias de caracteres podem conter muitos tipos de dados, incluindo dados binários serializados, que podem ser usados ao armazenar objetos .NET no cache.

O Cache Redis do Azure 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.

Essa serialização de objeto .NET é de responsabilidade do desenvolvedor do aplicativo. Você tem alguma flexibilidade na escolha do serializador.

Uma maneira simples de serializar objetos é usar os JsonConvert métodos de serialização em System.text.Json.

Adicione o namespace System.text.Json no Visual Studio:

1. Selecione Ferramentas>NuGet Package Manager Package Manager>Console*.

2. Em seguida, execute o seguinte comando na janela Console do Gerenciador de Pacotes:

   Install-Package system.text.json
   

A seguinte Employee classe foi definida em Program.cs para que o exemplo possa 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 employeeId, string name, int age)
    {
        Id = employeeId;
        Name = name;
        Age = age;
    }
}

Executar o exemplo

Para criar e executar o aplicativo de console para testar a serialização de objetos .NET, selecione Ctrl+F5.

Clean up resources (Limpar recursos)

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

Caso contrário, para evitar cobranças relacionadas aos recursos, se você terminar de usá-los, poderá excluir o grupo de recursos do Azure que você criou.

Eliminar um grupo de recursos

1. Inicie sessão 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 criado para concluir este artigo. Na lista de resultados da pesquisa, selecione o grupo de recursos.

   

3. Selecione Eliminar grupo de recursos.

4. No painel Eliminar um grupo de recursos, introduza o nome do grupo de recursos a confirmar e, em seguida, selecione Eliminar.

   

Dentro de alguns momentos, o grupo de recursos e todos os seus recursos são excluídos.

Conteúdos relacionados

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