Gerenciar a autenticação do IAM

Nesta página, você verá instruções sobre tarefas comuns do recurso de autenticação do IAM para o cluster do Memorystore para Redis. Para mais detalhes sobre o recurso, consulte Sobre a autenticação do IAM.

Criar uma instância com a autenticação do IAM

Para criar uma instância de cluster do Memorystore para Redis que usa a autenticação do IAM, execute o comando create:

gcloud beta redis clusters create INSTANCE_ID --region=REGION_ID --network=NETWORK --shard-count=SHARD_COUNT --auth-mode=iam-auth

Substitua:

  • INSTANCE_ID é o ID da instância do cluster do Memorystore para Redis que você está criando. O ID da instância precisa ter de 1 a 63 caracteres e usar apenas letras minúsculas, números ou hifens. Ele precisa começar com uma letra minúscula e terminar com uma letra minúscula ou um número.

  • REGION_ID é a região em que você quer colocar a instância.

  • NETWORK é a rede usada para criar a instância; Ele precisa usar o formato: projects/NETWORK_PROJECT_ID/global/networks/NETWORK_ID. O ID de rede usado aqui precisa corresponder ao usado pela política de conexão de serviço. Caso contrário, a operação create falhará. Para mais detalhes, consulte Rede.

  • SHARD_COUNT determina o número de fragmentos de 13 GB na instância. A contagem de fragmentos determina a capacidade total de memória para armazenar dados da instância. Para mais detalhes sobre as especificações de instância, consulte Especificação de cluster e fragmento.

Gerenciar permissões para autenticação do IAM

Criar um papel de administrador limitado do IAM para uma instância

Talvez você queira criar um papel que modifique as permissões do IAM de conexão da instância sem conceder acesso total de administrador do IAM. Isso pode ser feito por meio da criação de um administrador do IAM limitado para o papel "roles/redis.dbConnectionUser". Para mais detalhes, acesse Criar administradores limitados do IAM.

Conceder acesso à instância com o IAM

Por padrão, conceder um principal ao papel roles/redis.dbConnectionUser permite que ele acesse todas as instâncias do projeto. Para conceder acesso a um subconjunto de recursos no projeto, configure o acesso com base em recursos do IAM para o papel roles/redis.dbConnectionUser. Veja mais detalhes em Configurar o acesso com base em recursos.

Conectar-se a uma instância que usa autenticação do IAM

  1. Se você ainda não tiver uma VM do Compute Engine que use a mesma rede autorizada que seu cluster do Redis, crie uma e conecte-se a ela seguindo o Guia de início rápido sobre como usar uma VM do Linux.

  2. Instale o redis-cli na VM do Compute Engine executando o seguinte comando no terminal SSH do Compute Engine:

    sudo apt-get install redis-tools

  3. Execute o seguinte comando para receber um token de acesso para seu usuário do IAM:

    gcloud auth print-access-token

  4. Conecte-se ao endpoint de descoberta da instância:

    redis-cli -h NETWORK_ADDRESS -p PORT -a ACCESS_TOKEN -c

    Substitua:

  5. Execute o comando CLUSTER SHARDS para ver a topologia do cluster. Anote um dos endereços IP e números de porta do nó.

  6. Conecte-se ao nó desejado executando o seguinte comando:

    redis-cli -h NODE_IP_ADDRESS -p NODE_PORT -a ACCESS_TOKEN -c

    Substitua:

    • NODE_IP_ADDRESS é o endereço IP do nó que você encontrou na etapa anterior.
    • NODE_PORT é o número da porta do nó que você encontrou na etapa anterior;

  7. Execute os comandos SET e GET do Redis para verificar se você estabeleceu uma conexão autenticada com o nó do cluster.

  8. Quando terminar de testar a conexão com a instância do Redis, exclua a VM do Compute Engine usada para se conectar ao cluster do Redis. Isso ajuda a evitar cobranças na sua conta do Cloud Billing.

  9. Execute o seguinte comando para usar o redis-cli para autenticar e se conectar à sua instância, substituindo as variáveis pelos valores apropriados:

    redis-cli -h NETWORK_ADDRESS -p PORT -a ACCESS_TOKEN -c

    Substitua:

  10. Execute os comandos SET e GET do Redis para verificar se você estabeleceu uma conexão autenticada com a instância.

  11. Depois de terminar o teste da conexão com o cluster do Redis, exclua a VM do Compute Engine usada para se conectar ao cluster. Isso ajuda a evitar cobranças na sua conta do Cloud Billing.

Automatizar a recuperação do token de acesso

É recomendável automatizar a recuperação do token de acesso no aplicativo, já que os tokens de acesso não podem ser codificados com facilidade devido ao ciclo de vida útil deles.

  1. (Opcional) Crie uma conta de serviço para o aplicativo se ainda não tiver feito isso. Consulte Como criar e gerenciar uma conta de serviço.

    gcloud iam service-accounts create SA_NAME \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"

    Substitua:

    • SA_NAME é o nome da conta de serviço.
    • DESCRIPTION é uma descrição opcional da conta de serviço.
    • DISPLAY_NAME é um nome de conta de serviço a ser exibido no Console do Google Cloud.

  2. Conceda à sua conta de serviço a permissão redis.dbConnectionUser no seu projeto.

    gcloud projects add-iam-policy-binding PROJECT_ID \
--member="serviceAccount:SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
--role="redis.dbConnectionUser"

    Substitua:

    • PROJECT_ID é o ID do projeto.
    • SA_NAME é o nome da conta de serviço.
    • ROLE_NAME é um nome de papel, como roles/compute.osLogin.

  3. Autentique o aplicativo como a conta de serviço fornecida. Consulte as contas de serviço para mais informações.

    Para amostras de código que mostram como autenticar o aplicativo usando bibliotecas de cliente conhecidas, consulte Amostras de código de biblioteca de cliente de autenticação do IAM.

Amostras de código da biblioteca de cliente do IAM para autenticação

Nesta seção, fornecemos exemplos gerais de código de cliente para autenticação com o IAM para o cluster do Memorystore com a biblioteca de cliente Lettuce.

Alface


public void example() {
  String discoveryEndpointIp = "insert discovery endpoint ip"
  String discoveryEndpointPort = "insert discovery endpoint port"
  RedisCredentialsProvider provider =
     () ->
           Mono.just(RedisCredentials.just("default", retrieveAccessToken().toCharArray()));
  RedisURI redisUri =
     RedisURI.Builder.redis(discoveryEndpointIp, discoveryEndpointPort)
           .withAuthentication(provider)
           .build();
  ClientResources resources =
     DefaultClientResources.builder()
           .reconnectDelay(
              Delay.fullJitter(
                 Duration.ofMillis(100),
                 Duration.ofSeconds(5),
                 100,
                 TimeUnit.MILLISECONDS))
           .build();
  ClusterTopologyRefreshOptions topologyRefreshOptions = ClusterTopologyRefreshOptions.builder()
     .enablePeriodicRefresh(1, TimeUnit.MINUTES)
     .enableAllAdaptiveRefreshTriggers()
     .dynamicRefreshSources(false)
     .closeStaleConnections(true)
     .build();

  SocketOptions socketOptions = SocketOptions.builder()
     .connectTimeout(Duration.ofSeconds(5))
     .keepAlive(true)
     .build();

  // Create Redis Cluster Client
  RedisClusterClient clusterClient = RedisClusterClient.create(resources, redisUri);
  clusterClient.setOptions(
     ClusterClientOptions.builder()
           .topologyRefreshOptions(topologyRefreshOptions)
           .socketOptions(socketOptions)
           .autoReconnect(true)
           .nodeFilter(
              it ->
                 !(it.is(RedisClusterNode.NodeFlag.FAIL)
                       || it.is(RedisClusterNode.NodeFlag.EVENTUAL_FAIL)
                       || it.is(RedisClusterNode.NodeFlag.NOADDR)))
           .validateClusterNodeMembership(false)
           .build());

  // Establish connection to Redis Cluster
  StatefulRedisClusterConnection connection = clusterClient.connect();
  // Retrieve synchronous Redis Cluster commands
  RedisAdvancedClusterCommands syncCommands = connection.sync();
  // Perform Redis operations
  syncCommands.set("key1", "value1");

  // Close the connection and shutdown the client
  connection.close();
  clusterClient.shutdown();
}