Início Rápido: usar o Cache do Azure para Redis com um aplicativo Java e um cliente Redis do Redisson

Neste início rápido, você incorporará o Cache do Azure para Redis em um aplicativo Java usando o cliente Redis do Redisson e a API JCache padrão do JCP (Java Community Practice). Esses serviços fornecem acesso a um cache seguro e dedicado que pode ser acessado de qualquer aplicativo no Azure.

Este artigo descreve duas opções para selecionar a identidade do Azure a ser usada na conexão do Redis:

• Autenticação usando uma chave do Redis
• Autenticação usando o Microsoft Entra ID

Pular para o código

Este início rápido usa o recurso de arquétipo do Maven para gerar a base para um aplicativo Java. O início rápido descreve como configurar o código para criar um aplicativo funcional que se conectará ao Cache do Azure para Redis.

Se quiser pular diretamente para o código, confira a amostra de início rápido do Java no GitHub.

Pré-requisitos

• Uma assinatura do Azure. Crie um gratuitamente
• Microsoft Entra ID para autenticação de cache
• Apache Maven

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.

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 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, acesse o 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 cache:

  1. No portal do Azure, acesse o cache.
  2. No menu de serviço, selecione Visão geral.
  3. Em Itens essenciais, 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. Para obter as Portas, selecione o ícone Copiar para copiar os valores delas.

  

Configurar o ambiente de trabalho

As etapas nesta seção mostram duas opções para selecionar uma identidade do Azure a ser usada na conexão do Redis. O código de exemplo analisa o valor da variável de ambiente AUTH_TYPE e toma medidas com base nesse valor.

Autenticar-se usando uma chave do Redis

Dependendo do sistema operacional, adicione variáveis ​​de ambiente para armazenar o nome do host e a chave de acesso primária do cache. Em uma janela de prompt de comando ou de terminal, defina os seguintes valores:

export REDIS_CACHE_HOSTNAME=<your-host-name>.redis.cache.windows.net
export REDIS_CACHE_KEY=<your-primary-access-key>
export AUTH_TYPE=RedisKey

set REDIS_CACHE_HOSTNAME=<your-host-name>.redis.cache.windows.net
set REDIS_CACHE_KEY=<your-primary-access-key>
set AUTH_TYPE=RedisKey

No código anterior, substitua os espaços reservados pelos seguintes valores:

• <your-host-name>: o nome do host DNS, obtido na seção Propriedades do seu recurso do Cache do Azure para Redis no portal do Azure.
• <your-primary-access-key>: a chave de acesso primária, obtida na seção Chaves de acesso do seu recurso do Cache do Azure para Redis no portal do Azure.

Autenticar-se usando o Microsoft Entra ID

Dependendo do sistema operacional, adicione variáveis ​​de ambiente para armazenar o nome do host e o nome de usuário do cache. Em uma janela de prompt de comando ou de terminal, configure os seguintes valores:

export REDIS_CACHE_HOSTNAME=<your-host-name>.redis.cache.windows.net
export USER_NAME=<user-name>
export AUTH_TYPE=MicrosoftEntraID

set REDIS_CACHE_HOSTNAME=<your-host-name>.redis.cache.windows.net
set USER_NAME=<user-name>
set AUTH_TYPE=MicrosoftEntraID

No código anterior, substitua os espaços reservados pelos seguintes valores:

• <your-host-name>: o nome do host DNS, obtido na seção Propriedades do seu recurso do Cache do Azure para Redis no portal do Azure.

• <user-name>: o ID do objeto da identidade gerenciada ou da entidade de serviço.

  Para obter o nome de usuário:

  1. No portal do Azure, acesse a instância do Cache do Azure para Redis.

  2. No menu de serviço, selecione Configuração do acesso a dados.

  3. Na guia Usuários do Redis, localize a coluna Nome de usuário e copie o valor.

     

Criar um novo aplicativo Java

Gere um novo aplicativo de início rápido usando o Maven:

mvn archetype:generate \
    -DarchetypeGroupId=org.apache.maven.archetypes \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DarchetypeVersion=1.3 \
    -DinteractiveMode=false \
    -DgroupId=example.demo \
    -DartifactId=redis-redisson-test \
    -Dversion=1.0

mvn archetype:generate \
    -DarchetypeGroupId=org.apache.maven.archetypes \
    -DarchetypeArtifactId=maven-archetype-quickstart \
    -DarchetypeVersion=1.3 \
    -DinteractiveMode=false \
    -DgroupId=example.demo \
    -DartifactId=redis-redisson-test \
    -Dversion=1.0

Acesse o novo diretório do projeto redis-redisson-test.

Abra o arquivo pom.xml e adicione uma dependência para Redisson:

    <dependency>
        <groupId>com.azure</groupId>
        <artifactId>azure-identity</artifactId>
        <version>1.8.2</version>
    </dependency>

    <dependency>
        <groupId>org.redisson</groupId>
        <artifactId>redisson</artifactId>
        <version>3.24.3</version>
    </dependency>

Salve o arquivo pom.xml .

Abra App.java e substitua o código atual pelo seguinte:

package example.demo;

import com.azure.core.credential.TokenRequestContext;
import com.azure.identity.DefaultAzureCredential;
import com.azure.identity.DefaultAzureCredentialBuilder;
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.redisson.jcache.configuration.RedissonConfiguration;

import javax.cache.Cache;
import javax.cache.CacheManager;
import javax.cache.Caching;
import javax.cache.configuration.Configuration;
import javax.cache.configuration.MutableConfiguration;
import java.time.LocalDateTime;


/**
 * Redis test
 *
 */
public class App {
    public static void main(String[] args) {

        Config redissonconfig = getConfig();

        RedissonClient redissonClient = Redisson.create(redissonconfig);

        MutableConfiguration<String, String> jcacheConfig = new MutableConfiguration<>();
        Configuration<String, String> config = RedissonConfiguration.fromInstance(redissonClient, jcacheConfig);

        // Perform cache operations using JCache
        CacheManager manager = Caching.getCachingProvider().getCacheManager();
        Cache<String, String> map = manager.createCache("test", config);

        // Simple get and put of string data into the cache
        System.out.println("\nCache Command  : GET Message");
        System.out.println("Cache Response : " + map.get("Message"));

        System.out.println("\nCache Command  : SET Message");
        map.put("Message",
            String.format("Hello! The cache is working from Java! %s", LocalDateTime.now()));

        // Demonstrate "SET Message" executed as expected
        System.out.println("\nCache Command  : GET Message");
        System.out.println("Cache Response : " + map.get("Message"));

        redissonClient.shutdown();
    }

    private static Config getConfig(){
        if ("MicrosoftEntraID".equals(System.getenv("AUTH_TYPE"))) {
            System.out.println("Auth with Microsoft Entra ID");
            return getConfigAuthWithAAD();
        } else if ("RedisKey".equals(System.getenv("AUTH_TYPE"))) {
            System.out.println("Auth with Redis key");
            return getConfigAuthWithKey();
        }
        System.out.println("Auth with Redis key");
        return getConfigAuthWithKey();
    }

    private static Config getConfigAuthWithKey() {
        // Connect to the Azure Cache for Redis over the TLS/SSL port using the key
        Config redissonconfig = new Config();
        redissonconfig.useSingleServer().setPassword(System.getenv("REDIS_CACHE_KEY"))
            .setAddress(String.format("rediss://%s:6380", System.getenv("REDIS_CACHE_HOSTNAME")));
        return redissonconfig;
    }

    private static Config getConfigAuthWithAAD() {
        //Construct a Token Credential from Identity library, e.g. DefaultAzureCredential / ClientSecretCredential / Client CertificateCredential / ManagedIdentityCredential etc.
        DefaultAzureCredential defaultAzureCredential = new DefaultAzureCredentialBuilder().build();

        // Fetch a Microsoft Entra token to be used for authentication.
        String token = defaultAzureCredential
            .getToken(new TokenRequestContext()
                .addScopes("acca5fbb-b7e4-4009-81f1-37e38fd66d78/.default")).block().getToken();

        // Connect to the Azure Cache for Redis over the TLS/SSL port using the key
        Config redissonconfig = new Config();
        redissonconfig.useSingleServer()
            .setAddress(String.format("rediss://%s:6380", System.getenv("REDIS_CACHE_HOSTNAME")))
            .setUsername(System.getenv("USER_NAME")) // (Required) Username is Object ID of your managed identity or service principal
            .setPassword(token); // Microsoft Entra access token as password is required.
        return redissonconfig;
    }

}

Este código mostra como se conectar a uma instância do Cache do Azure para Redis usando o Microsoft Entra ID com o suporte da API JCache da biblioteca de cliente do Redisson. O código também armazena e recupera um valor de cadeia de caracteres no cache. Para saber mais, confira a especificação JCache.

Salve App.java.

Compilar e executar o aplicativo

Para criar e executar o aplicativo, execute o seguinte comando do Maven:

mvn compile exec:java -Dexec.mainClass=example.demo.App

mvn compile exec:java -Dexec.mainClass=example.demo.App

Na saída a seguir, você pode observar que a chave Message tinha anteriormente um valor armazenado em cache que foi definido na última execução. O aplicativo atualizou esse valor armazenado em cache.

Cache Command  : GET Message
Cache Response : Hello! The cache is working from Java! 2023-12-05T15:13:11.398873

Cache Command  : SET Message

Cache Command  : GET Message
Cache Response : Hello! The cache is working from Java! 2023-12-05T15:45:45.748667

Limpar os recursos

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

Para evitar custos relacionados aos recursos, se você já tiver terminado de usá-los, exclua 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 que você criou para concluir as tarefas deste 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 para confirmar e clique em Excluir.

   

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

Conteúdo relacionado

• Criar um aplicativo Web ASP.NET que usa o Cache do Azure para Redis
• Usar Java com o Cache do Azure para Redis no Serviço de Kubernetes do Azure