Início Rápido: Usar o Cache do Azure para Redis no .NET Framework

Neste guia de início rápido, você incorporará o Cache do Azure para Redis a um aplicativo .NET Framework para ter acesso a 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.

Pular para o código no GitHub

Clone o repositório de Azure-Samples/azure-cache-redis-samples no GitHub.

Pré-requisitos

• Assinatura do Azure - criar uma gratuitamente
• Visual Studio 2019
• .NET Framework 4 ou superior, que é exigido pelo cliente StackExchange.Redis.

Criar um cache

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

   

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

   

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

4. Selecione a guia Rede ou clique em 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 clique em 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 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.

8. (Opcional) Selecione a guia Categorias ou clique em Avançar: categorias.

9. (Opcional) Na guia Categorias, insira um nome e um valor de categoria se você quiser categorizar o recurso de cache.

10. Selecione o botão Revisar + criar.

    Na guia Examinar + criar, o Azure valida a configuração automaticamente.

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

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

Os caches do Azure Redis, exceto para os níveis Enterprise e Enterprise Flash, têm a autenticação do Microsoft Entra habilitada por padrão. As chaves de acesso estão desabilitadas por padrão.

Importante

A Microsoft recomenda o uso da autenticação do 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 apresentam riscos que não estão presentes ao usar o Microsoft Entra ID. Use a abordagem desse documento somente quando a autenticação do Microsoft Entra ID não for viável.

1. No portal do Azure, selecione o cache em que você deseja usar a autenticação baseada em token do Microsoft Entra.

2. Selecione Autenticação no menu Recurso.

3. Selecione Selecionar membro 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.

   

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

1. Edite o arquivo App.config e adicione o seguinte conteúdo:

   <appSettings>
   
   <add key="RedisHostName" value="your_redis_cache_hostname"/>
   

```

1. Substitua "your_Azure_Redis_hostname" pelo nome do host e números de porta do Azure Redis. Por exemplo: cache-name.eastus.redis.azure.net:10000 para o Cache do Azure para Redis Enterprise e cache-name.redis.cache.windows.net:6380 para os serviços do Cache do Azure para Redis.

2. Salve o arquivo.

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>Gerenciador de Pacotes NuGet>Console do Gerenciador de Pacotes e execute o comando a seguir na janela do Console do Gerenciador de Pacotes.

   Install-Package Microsoft.Azure.StackExchangeRedis
   

2. Depois que a instalação for concluída, o cliente de cache StackExchange.Redis está disponível para uso com o seu projeto.

Conexão ao cache com RedisConnection

A conexão ao seu cache é gerenciada pela classe RedisConnection. A conexão é feita pela primeira vez nesta instrução a partir de Program.cs:

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

O valor do appSetting CacheConnection é usado para referenciar a cadeia de conexão do cache do portal do Azure como o parâmetro de senha.

Em RedisConnection.cs, você verá o namespace StackExchange.Redis com a palavra-chave using. Isto é necessário para a classe RedisConnection.

using StackExchange.Redis;

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

Para obter mais informações, confira StackExchange.Redis e o código em um repositório GitHub.

Executar comandos de cache

Em program.cs, você pode ver o seguinte código para o método RunRedisCommandsAsync na classe Program 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 armazenados e recuperados usando os métodos StringSetAsync e StringGetAsync.

No exemplo, você pode ver que a chave Message está definida como 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 mais 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 do .NET no cache.

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

Essa serialização de objetos .NET é de responsabilidade do desenvolvedor do aplicativo e proporciona ao desenvolvedor a flexibilidade na escolha do serializador.

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

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

1. Selecione Ferramentas>Gerenciador de Pacotes NuGet>Console do Gerenciador de Pacotes.

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

   Install-Package system.text.json
   

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 employeeId, string name, int age)
    {
        Id = employeeId;
        Name = name;
        Age = age;
    }
}

Execute o exemplo

Pressione Ctrl + F5 para compilar e executar o aplicativo de console para testar a serialização de objetos .NET.

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

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

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

   

3. Selecione Excluir grupo de recursos.

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

   

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

Próximas etapas

• Resiliência da conexão
• Desenvolvimento de melhores práticas