Administrar la autenticación de IAM

En esta página, se proporcionan instrucciones sobre las tareas comunes de la función de autenticación de IAM para el clúster de Memorystore para Redis. Para obtener más detalles sobre la función, consulta Acerca de la autenticación de IAM.

Crear una instancia con autenticación de IAM

Para crear una instancia de clúster de Memorystore para Redis que use la autenticación de IAM, ejecuta el comando create:

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

Reemplaza lo siguiente:

INSTANCE_ID es el ID de la instancia del clúster de Memorystore para Redis que estás creando. El ID de la instancia debe tener entre 1 y 63 caracteres y solo contener letras minúsculas, números o guiones. Debe comenzar con una letra minúscula y terminar con una letra minúscula o un número.
REGION_ID es la región en la que deseas colocar la instancia.

Nota: Solo puedes crear instancias en las regiones compatibles con el clúster de Memorystore para Redis. No todas las regiones que admiten Memorystore para Redis están disponibles en clústeres de Memorystore para Redis. El comando gcloud redis regions list muestra regiones compatibles con Memorystore para Redis, no con el clúster de Memorystore para Redis.
NETWORK es la red que se usa para crear tu instancia. Debe usar el siguiente formato: projects/NETWORK_PROJECT_ID/global/networks/NETWORK_ID. El ID de red que se usa aquí debe coincidir con el ID de red que usa la política de conexión de servicios. De lo contrario, la operación create falla. Para obtener más detalles, consulta Herramientas de redes.
SHARD_COUNT determina la cantidad de fragmentos de 13 GB en la instancia. El recuento de fragmentos determina la capacidad de memoria total para almacenar datos de la instancia. Para obtener más detalles sobre las especificaciones de las instancias, consulta Especificación de clústeres y fragmentos.

Administrar los permisos para la autenticación de IAM

Crea un rol de administrador de IAM limitado para una instancia

Se recomienda crear una función que pueda modificar los permisos de IAM de conexión de instancias sin otorgar acceso de administrador de IAM completo. Esto se puede hacer mediante la creación de un administrador de IAM limitado para la función “roles/redis.dbConnectionUser”. Para obtener más información, consulta Crea administradores de IAM limitados.

Otorga acceso a tu instancia con IAM

De forma predeterminada, si otorgas a una principal la función roles/redis.dbConnectionUser, la principal podrá acceder a todas las instancias del proyecto. Para otorgar acceso a un subconjunto de recursos en tu proyecto, configura el acceso basado en recursos de IAM para la función roles/redis.dbConnectionUser. Para obtener más información, consulta Configura el acceso basado en recursos.

Conéctate a una instancia que use la autenticación de IAM

Si aún no tienes una VM de Compute Engine que use la misma red autorizada que tu clúster de Redis, crea una y conéctate a ella siguiendo la Guía de inicio rápido sobre el uso de una VM de Linux.
Ejecuta el siguiente comando desde la terminal SSH de Compute Engine para instalar redis-cli en la VM de Compute Engine:
```
sudo apt-get install redis-tools
```
Ejecuta el siguiente comando a fin de obtener un token de acceso para tu usuario de IAM:
```
gcloud auth print-access-token
```
Nota: Los tokens de acceso vencerán en una hora. Para obtener más información, consulta Período de tiempo del token de acceso de IAM.
Conéctate al extremo de descubrimiento de tu instancia:
```
redis-cli -h NETWORK_ADDRESS -p PORT -a ACCESS_TOKEN -c
```
Reemplaza lo siguiente:
- NETWORK_ADDRESS es la dirección de red de la instancia. Para ver la dirección de red, consulta Ver información de la instancia.
- PORT es el número de puerto de las instancias. Para ver el número de puerto, consulta Ver información de la instancia.
- ACCESS_TOKEN es el token de acceso de IAM recuperado en los pasos anteriores.
Nota: Las conexiones autenticadas son válidas durante 12 horas. Para obtener más información, consulta el Período de tiempo de autenticación.
Ejecuta el comando CLUSTER SHARDS para ver la topología de tu clúster. Anota una de las direcciones IP y los números de puerto del nodo.
Conéctate al nodo que quieras ejecutando el siguiente comando:
```
redis-cli -h NODE_IP_ADDRESS -p NODE_PORT -a ACCESS_TOKEN -c
```
Reemplaza lo siguiente:
- NODE_IP_ADDRESS es la dirección IP del nodo que encontraste en el paso anterior.
- NODE_PORT es el número de puerto del nodo que encontraste en el paso anterior.
Ejecuta un comando SET y GET de Redis para verificar que estableciste una conexión autenticada al nodo del clúster.
Una vez que termines de probar tu conexión a la instancia de Redis, debes considerar borrar la VM de Compute Engine que usaste para conectarte al clúster de Redis. Esto te ayuda a evitar que se apliquen cargos a tu cuenta de Facturación de Cloud.
Ejecuta el siguiente comando para usar redis-cli a fin de autenticar y conectarte a tu instancia, y reemplaza las variables con valores adecuados:
```
redis-cli -h NETWORK_ADDRESS -p PORT -a ACCESS_TOKEN -c
```
Reemplaza lo siguiente:
- NETWORK_ADDRESS es la dirección de red de la instancia. Para ver la dirección de red, consulta Ver información de la instancia.
- PORT es el número de puerto de las instancias. Para ver el número de puerto, consulta Ver información de la instancia.
- ACCESS_TOKEN es el token de acceso de IAM recuperado en los pasos anteriores.
Nota: Las conexiones autenticadas son válidas durante 12 horas. Para obtener más información, consulta el Período de tiempo de autenticación.
Ejecuta un comando SET y GET de Redis para verificar que estableciste una conexión autenticada a tu instancia.
Una vez que termines de probar tu conexión al clúster de Redis, debes considerar borrar la VM de Compute Engine que usaste para conectarte al clúster de Redis. Esto te ayuda a evitar que se apliquen cargos a tu cuenta de Facturación de Cloud.

Automatiza la recuperación de tokens de acceso

Se recomienda que automatices la recuperación de tokens de acceso en tu aplicación, ya que no es fácil codificar los tokens de acceso debido a su corta duración.

(Opcional) Si aún no lo hiciste, crea una cuenta de servicio para tu aplicación (consulta Crea y administra una cuenta de servicio).
```
gcloud iam service-accounts create SA_NAME \
    --description="DESCRIPTION" \
    --display-name="DISPLAY_NAME"
```
Reemplaza lo siguiente:
- SA_NAME es el nombre de la cuenta de servicio.
- DESCRIPTION es una descripción opcional de la cuenta de servicio.
- DISPLAY_NAME es un nombre de cuenta de servicio que se mostrará en Google Cloud Console.
Otorga a tu cuenta de servicio el permiso redis.dbConnectionUser en tu proyecto.
```
gcloud projects add-iam-policy-binding PROJECT_ID \
--member="serviceAccount:SA_NAME@PROJECT_ID.iam.gserviceaccount.com" \
--role="redis.dbConnectionUser"
```
Reemplaza lo siguiente:
- PROJECT_ID es el ID del proyecto.
- SA_NAME es el nombre de la cuenta de servicio.
- ROLE_NAME es un nombre de función, como roles/compute.osLogin.
Autentica tu aplicación como la cuenta de servicio determinada. Consulta las cuentas de servicio para obtener más información.

Para ver muestras de código que muestran cómo puedes autenticar tu aplicación con bibliotecas cliente populares, consulta las muestras de código de biblioteca cliente de autenticación de IAM.

Muestras de código de la biblioteca cliente de autenticación de IAM

En esta sección, se proporcionan ejemplos generales de código de cliente para la autenticación con la autenticación de IAM para tu clúster de Memorystore con la biblioteca cliente de Lettuce.

Lechuga


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();
}