Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Control de acceso basado en roles (RBAC)
Con el comando AUTH de Valkey y Redis OSS, tal como se describe en [Autenticación con el comando AUTH de Valkey o Redis OSS](auth.md), puede utilizar el control de acceso basado en roles (RBAC). El RBAC también es la única forma de controlar el acceso a las cachés sin servidor. Está disponible para Valkey 7.2 en adelante y Redis OSS 6.0 a 7.2.
RBAC le permite:
+ Controlar el acceso a la caché a través de grupos de usuarios. Estos grupos de usuarios se han diseñado como una forma de organizar el acceso a las cachés.
+ Con *authN*, puede utilizar contraseñas por usuario en lugar de tokens de autenticación por clúster.
+ Con *authZ*, tiene permisos de usuario detallados.
+ Base su acceso al clúster en. ACLs
A diferencia de AUTH de Valkey y Redis OSS, donde todos los clientes autenticados tienen acceso completo a la caché si su token está autenticado, RBAC le permite asignar usuarios a conjuntos en función de los roles deseados de los usuarios. Estos conjuntos se han diseñado para organizar el acceso a las cachés.
Con el RBAC, puede crear usuarios y asignarles permisos específicos mediante una cadena de acceso, como se describe a continuación. Los usuarios se asignan a conjuntos alineados con una función específica (administradores, recursos humanos) que, a continuación, se despliegan en una o más ElastiCache cachés. Al hacerlo, puede establecer límites de seguridad entre clientes que utilicen las mismas cachés de Valkey o Redis OSS e impedir que los clientes accedan a los datos de los demás.
RBAC se ha diseñado para facilitar la introducción de [ACL](https://valkey.io/topics/acl/) en Redis OSS 6. Al utilizar RBAC con la caché de OSS de ElastiCache Valkey o Redis, existen algunas limitaciones:
+ Un grupo de usuarios configurado para el motor VALKEY solo puede contener usuarios que utilicen un mecanismo de autenticación (contraseña o IAM). Esto significa que todos los usuarios con el motor VALKEY y cualquier otro usuario con el motor Redis que tenga su configuración configurada para autenticarse con contraseña o IAM, pueden estar en este grupo de usuarios.
+ Cuando se utiliza RBAC con clústeres de Valkey, se pueden utilizar tanto los grupos de usuarios con el motor VALKEY como con el motor REDIS.
+ Cuando se utiliza RBAC con clústeres de Redis OSS, solo se pueden utilizar grupos de usuarios con el motor REDIS.
+ No puede especificar contraseñas en una cadena de acceso. Las contraseñas se configuran con nuestras llamadas. [CreateUser[ModifyUser](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_ModifyUser.html)](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_CreateUser.html)
+ Para los derechos de usuarios, debe activar o desactivar usuarios con `on` y `off` como parte de la cadena de acceso. Si no se especifica ninguno en la cadena de acceso, se le asigna `off` al usuario y no tiene derechos de acceso a la caché.
+ No puede utilizar comandos prohibidos o renombrados en una cadena de acceso. Si especifica un comando prohibido o renombrado, se generará una excepción. Si desea utilizar listas de control de acceso (ACLs) para un comando cuyo nombre ha cambiado, especifique el nombre original del comando, es decir, el nombre del comando antes de cambiarle el nombre.
+ No puede utilizar el comando `reset` como parte de una cadena de acceso. Las contraseñas se especifican con parámetros de API y, en el caso ElastiCache de Valkey y Redis, OSS administra las contraseñas. Por lo tanto, no puede utilizar `reset` porque eliminará todas las contraseñas de un usuario.
+ Redis OSS 6 introduce el comando [ACL LIST](https://valkey.io/commands/acl-list). Este comando devuelve una lista de usuarios junto con las reglas de ACL aplicadas a cada usuario. ElastiCache admite el `ACL LIST` comando, pero no incluye soporte para hashes de contraseñas como lo hace Redis OSS. Con ElastiCache, puede utilizar la [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)operación para obtener información similar, incluidas las reglas contenidas en la cadena de acceso. Sin embargo, [DescribeUsers](https://docs.aws.amazon.com/AmazonElastiCache/latest/APIReference/API_DescribeUsers.html)no recupera la contraseña de un usuario.
+ [Otros comandos de solo lectura compatibles ElastiCache con Valkey y Redis OSS son [ACL WHOAMI, ACL USERS](https://valkey.io/commands/acl-whoami) y [ACL CAT](https://valkey.io/commands/acl-users).](https://valkey.io/commands/acl-cat) ElastiCache para Valkey y Redis, el OSS no admite ningún otro comando de ACL basado en la escritura.
+ Se aplican los siguientes límites:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonElastiCache/latest/dg/Clusters.RBAC.html)
**RBAC con Valkey**
Cuando se utiliza el control de acceso basado en roles con Valkey, los usuarios y los grupos de usuarios se crean con el tipo de motor VALKEY. Se recomienda esta opción, ya que, de forma predeterminada, Valkey con RBAC proporciona mayor seguridad en comparación con Redis OSS. Tanto los clústeres de Valkey aprovisionados como sin servidor admiten las asociaciones de usuarios y grupos de usuarios VALKEY.
Las principales características del control de acceso a Valkey son:
+ Los usuarios de Valkey están restringidos únicamente a las asociaciones de grupos de usuarios de Valkey.
+ Los grupos de usuarios de Valkey pueden incluir usuarios de Valkey y usuarios de Redis OSS protegidos con contraseña o habilitados para la autenticación de IAM.
+ Los usuarios de Valkey deben utilizar la protección por contraseña o la autenticación de IAM.
+ Los grupos de usuarios VALKEY solo se pueden asociar con los clústeres VALKEY.
+ No hay ningún requisito de usuario predeterminado. Cuando el grupo de usuarios de Valkey está asociado con clústeres, el requisito de usuario predeterminado se desactiva automáticamente. Los clientes verán que el usuario predeterminado está desactivado al usar el comando ACL LIST.
A continuación encontrará más información sobre el uso de RBAC con Valkey y Redis ElastiCache OSS.
**Topics**
+ [Especificación de permisos mediante una cadena de acceso](#Access-string)
+ [Aplicar RBAC a una caché para Valkey o Redis ElastiCache OSS](#rbac-using)
+ [Migración de AUTH a RBAC](#Migrate-From-RBAC-to-Auth)
+ [Migración de RBAC a AUTH](#Migrate-From-RBAC-to-AUTH-1)
+ [Rotación automática de contraseñas para usuarios](User-Secrets-Manager.md)
+ [Autenticación con IAM](auth-iam.md)
## Especificación de permisos mediante una cadena de acceso
Para especificar los permisos para una caché de OSS de ElastiCache Valkey o Redis, debe crear una cadena de acceso y asignarla a un usuario mediante la tecla o.AWS CLIConsola de administración de AWS
Las cadenas de acceso se definen como una lista de reglas delimitadas por espacios que se aplican al usuario. Definen qué comandos puede ejecutar un usuario y qué claves puede operar. Para ejecutar un comando, un usuario debe tener acceso al comando que se ejecuta y a todas las claves a las que accede el comando. Las reglas se aplican de izquierda a derecha de forma acumulativa y se puede utilizar una cadena más simple en lugar de la proporcionada si hay redundancias en la cadena proporcionada.
Para obtener más información sobre la sintaxis de las reglas de ACL, consulte [ACL](https://valkey.io/topics/acl/).
En el siguiente ejemplo, la cadena de acceso representa un usuario activo con acceso a todas las claves y comandos disponibles.
`on ~* +@all`
La sintaxis de la cadena de acceso se desglosa de la siguiente manera:
+ `on`: el usuario es un usuario activo.
+ `~*`: se brinda acceso a todas las claves disponibles.
+ `+@all`: se brinda acceso a todos los comandos disponibles.
La configuración anterior es la menos restrictiva. Puede modificar esta configuración para hacerla más segura.
En el siguiente ejemplo, la cadena de acceso representa a un usuario con acceso restringido al acceso de lectura en claves que comienzan por el espacio de claves “app::”
`on ~app::* -@all +@read`
Puede refinar aún más estos permisos al enumerar comandos a los que el usuario tiene acceso:
`+command1`: el acceso del usuario a los comandos se encuentra limitado a *`command1`*.
`+@category`: el acceso del usuario a los comandos se encuentra limitado a la categoría de comandos.
Para obtener información sobre cómo asignar una cadena de acceso a un usuario, consulte [Creación de usuarios y grupos de usuarios con la consola y la CLI](#Users-management).
Si va a migrar una carga de trabajo existente a ElastiCache, puede recuperar la cadena de acceso mediante una llamada`ACL LIST`, excluyendo los hashes de usuario y de contraseña.
Para la versión 6.2 y posteriores de Redis OSS, también se admite la siguiente sintaxis de cadena de acceso:
+ `&*`: se brinda acceso a todos los canales disponibles.
Para la versión 7.0 y posteriores de Redis OSS, también se admite la siguiente sintaxis de cadena de acceso:
+ `|`: se puede usar para bloquear subcomandos (por ejemplo, “-config\$1set”).
+ `%R~`: agregue el patrón de claves de lectura especificado. Esto se comporta de forma similar al patrón de claves normal, pero solo permite leer las claves que coinciden con el patrón dado. Consulte [key permissions](https://valkey.io/topics/acl/) (permisos de clave) para obtener más información.
+ `%W~`: agregue el patrón de claves de escritura especificado. Esto se comporta de forma similar al patrón de claves normal, pero solo concede permiso de escritura a las claves que coinciden con el patrón dado. Consulte [ACL key permissions](https://valkey.io/topics/acl/) para obtener más información.
+ `%RW~`: alias para `~`.
+ `()`: cree un nuevo selector con el que comparar las reglas. Los selectores se evalúan después de los permisos del usuario y según el orden en que se definen. Si un comando coincide con los permisos del usuario o con algún selector, está permitido. Consulte la página sobre [selectores de ACL](https://valkey.io/topics/acl/) para obtener más información.
+ `clearselectors`: elimine todos los selectores asociados al usuario.
## Aplicar RBAC a una caché para Valkey o Redis ElastiCache OSS
Para usarlo ElastiCache para Valkey o Redis OSS RBAC, siga los siguientes pasos:
1. Cree uno o más usuarios.
1. Cree un grupo de usuarios y agregue usuarios al grupo.
1. Asigne el grupo de usuarios a una caché que tenga el cifrado en tránsito habilitado.
Estos pasos se describen con detalle a continuación.
**Topics**
+ [Creación de usuarios y grupos de usuarios con la consola y la CLI](#Users-management)
+ [Administración de grupos de usuarios con la consola y la CLI](#User-Groups)
+ [Asignación de grupos de usuarios a cachés sin servidor](#Users-groups-to-serverless-caches)
+ [Asignación de grupos de usuarios a grupos de reproducción](#Users-groups-to-RGs)
### Creación de usuarios y grupos de usuarios con la consola y la CLI
La información de usuario para los usuarios de RBAC es un ID de usuario, nombre de usuario y, opcionalmente, una contraseña y una cadena de acceso. La cadena de acceso proporciona el nivel de permisos en las claves y comandos. El ID de usuario es exclusivo del usuario y el nombre de usuario es lo que se pasa al motor.
Asegúrese de que los permisos de usuario que proporcione tengan sentido con el propósito previsto del grupo de usuarios. Por ejemplo, si crea un grupo de usuarios denominado `Administrators`, cualquier usuario que agregue a ese grupo debe tener su cadena de acceso establecida en el acceso completo a las claves y comandos. Para los usuarios de un grupo de usuarios `e-commerce`, puede establecer las cadenas de acceso en acceso de solo lectura.
ElastiCache configura automáticamente un usuario predeterminado con un ID de usuario y un nombre de usuario y lo añade a todos `"default"` los grupos de usuarios. No puede modificar ni eliminar este usuario. Este usuario se ha diseñado para ser compatible con el comportamiento predeterminado de las versiones anteriores de Redis OSS y tiene una cadena de acceso que permite llamar a todos los comandos y acceder a todas las claves.
Para agregar un control de acceso adecuado a una caché, reemplace este usuario predeterminado por uno nuevo que no se encuentre habilitado o utilice una contraseña segura. Para cambiar el usuario predeterminado, cree un usuario nuevo con el nombre de usuario establecido en `default`. A continuación, puede intercambiarlo con el usuario predeterminado original.
En los siguientes procedimientos se muestra cómo intercambiar el usuario `default` original con otro usuario `default` que tiene una cadena de acceso modificada.
**Para modificar el usuario predeterminado de la consola**
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. Seleccione **Administración de grupos de usuarios** en el panel de navegación.
1. En **ID de grupo de usuarios**, elija el ID que desea modificar. Asegúrese de elegir el enlace y no la casilla de verificación.
1. Elija **Modificar**.
1. En la ventana **Modificar**, seleccione **Administrar**. En Seleccione el usuario que desee, elija el usuario con el **Nombre de usuario** predeterminado.
1. Seleccione **Elegir**.
1. Elija **Modificar**. Al hacerlo, se terminan todas las conexiones existentes que el usuario predeterminado tenga a una caché.
**Para modificar el usuario predeterminado con el AWS CLI**
1. Cree un usuario nuevo con el nombre de usuario `default` mediante los siguientes comandos.
Para Linux, macOS o Unix:
```
aws elasticache create-user \
--user-id "new-default-user" \
--user-name "default" \
--engine "VALKEY" \
--passwords "a-str0ng-pa))word" \
--access-string "off +get ~keys*"
```
Para Windows:
```
aws elasticache create-user ^
--user-id "new-default-user" ^
--user-name "default" ^
--engine "VALKEY" ^
--passwords "a-str0ng-pa))word" ^
--access-string "off +get ~keys*"
```
1. Cree un grupo de usuarios y agregue el usuario que creó anteriormente.
Para Linux, macOS o Unix:
```
aws elasticache create-user-group \
--user-group-id "new-group-2" \
--engine "VALKEY" \
--user-ids "new-default-user"
```
Para Windows:
```
aws elasticache create-user-group ^
--user-group-id "new-group-2" ^
--engine "VALKEY" ^
--user-ids "new-default-user"
```
Al crear un usuario, puede configurar hasta dos contraseñas. Al modificar una contraseña, se mantienen todas las conexiones existentes a las cachés.
En concreto, tenga en cuenta estas restricciones de contraseña de usuario cuando utilice RBAC ElastiCache para Valkey y Redis OSS:
+ Las contraseñas deben tener entre 16 y 128 caracteres imprimibles.
+ No se admiten los siguientes caracteres no alfanuméricos: `,` `""` `/` `@`.
#### Administración de usuarios con la consola y la CLI
Utilice el siguiente procedimiento para administrar usuarios en la consola.
**Para administrar usuarios con la consola**
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el ElastiCache panel de Amazon, selecciona **Gestión de usuarios**. Están disponibles las siguientes opciones:
+ **Crear usuario**: al crear un usuario, introduce un ID de usuario, un nombre de usuario, un modo de autenticación y una cadena de acceso. La cadena de acceso establece el nivel de permisos para qué claves y comandos se permite al usuario.
Al crear un usuario, puede configurar hasta dos contraseñas. Al modificar una contraseña, se mantienen todas las conexiones existentes a las cachés.
+ **Modificar usuario**: permite actualizar la configuración de autenticación de un usuario o cambiar su cadena de acceso.
+ **Eliminar usuario**: la cuenta se eliminará de cualquier grupo de usuarios al que pertenezca.
Utilice los siguientes procedimientos para administrar usuarios con la AWS CLI.
**Para modificar un usuario mediante la CLI**
+ Utilice el comando `modify-user` para actualizar la contraseña o contraseñas de un usuario o cambiar los permisos de acceso de un usuario.
Cuando se modifica un usuario, se actualizan los grupos de usuarios asociados al usuario, junto con las cachés asociadas al grupo de usuarios. Se mantienen todas las conexiones existentes. A continuación se muestran algunos ejemplos.
Para Linux, macOS o Unix:
```
aws elasticache modify-user \
--user-id user-id-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode Type=iam
```
Para Windows:
```
aws elasticache modify-user ^
--user-id user-id-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode Type=iam
```
**nota**
No recomendamos utilizar la opción `nopass`. Si lo hace, recomendamos que configure los permisos del usuario en solo lectura con acceso a un conjunto limitado de claves.
**Para eliminar un usuario mediante la CLI**
+ Ejecute el comando `delete-user` para eliminar un usuario. La cuenta se borra y elimina de todos los grupos de usuarios a los que pertenezca. A continuación se muestra un ejemplo.
Para Linux, macOS o Unix:
```
aws elasticache delete-user \
--user-id user-id-2
```
Para Windows:
```
aws elasticache delete-user ^
--user-id user-id-2
```
Para ver una lista de usuarios, llame a la operación [describe-users](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-users.html).
```
aws elasticache describe-users
```
### Administración de grupos de usuarios con la consola y la CLI
Puede crear grupos de usuarios para organizar y controlar el acceso de los usuarios a una o más cachés, como se muestra a continuación.
Utilice el siguiente procedimiento para administrar grupos de usuarios en la consola.
**Para administrar grupos de usuarios mediante la consola**
1. Inicia sesión en la ElastiCache consola de Amazon Consola de administración de AWS y ábrela en [https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/).
1. En el ElastiCache panel de Amazon, selecciona **Administración de grupos de usuarios**.
A continuación, se muestran las operaciones disponibles para crear grupos de usuarios nuevos:
+ **Crear**: al crear un grupo de usuarios, se agregan usuarios y, a continuación, se asignan los grupos de usuarios a las cachés. Por ejemplo, puede crear un grupo de usuarios `Admin` para los usuarios que tienen roles administrativos en una caché.
**importante**
Si no utiliza ningún grupo de usuarios de Valkey o Redis OSS, debe incluir un usuario predeterminado al crear un grupo de usuarios.
+ **Agregar usuarios**: agregue usuarios al grupo de usuarios.
+ **Eliminar usuarios**: elimine usuarios del grupo de usuarios. Cuando se quitan usuarios de un grupo de usuarios, se terminan todas las conexiones existentes que tengan a una caché.
+ **Eliminar**: utilice esta opción para eliminar un grupo de usuarios. Tenga en cuenta que se eliminará el grupo de usuarios en sí, no los usuarios que pertenecen al grupo.
Para los grupos de usuarios existentes, puede realizar lo siguiente:
+ **Agregar usuarios**: agregue usuarios existentes al grupo de usuarios.
+ **Eliminar usuarios**: elimine los usuarios existentes del grupo de usuarios.
**nota**
Los usuarios se eliminan del grupo de usuarios, pero no se eliminan del sistema.
Utilice el siguiente procedimiento para administrar grupos de usuarios en la CLI.
**Para crear un grupo de usuarios nuevo y agregar un usuario mediante la CLI**
+ Utilice el comando `create-user-group`, tal y como se muestra a continuación:
Para Linux, macOS o Unix:
```
aws elasticache create-user-group \
--user-group-id "new-group-1" \
--engine "VALKEY" \
--user-ids user-id-1, user-id-2
```
Para Windows:
```
aws elasticache create-user-group ^
--user-group-id "new-group-1" ^
--engine "VALKEY" ^
--user-ids user-id-1, user-id-2
```
**Para modificar un grupo de usuarios al agregar usuarios nuevos o eliminar miembros actuales mediante la CLI**
+ Utilice el comando `modify-user-group`, tal y como se muestra a continuación:
Para Linux, macOS o Unix:
```
aws elasticache modify-user-group --user-group-id new-group-1 \
--user-ids-to-add user-id-3 \
--user-ids-to-remove user-id-2
```
Para Windows:
```
aws elasticache modify-user-group --user-group-id new-group-1 ^
--user-ids-to-add user-id-3 ^
--user-ids-to-removere user-id-2
```
**nota**
Cualquier conexión abierta que pertenezca a un usuario eliminado de un grupo de usuarios finaliza con este comando.
**Para eliminar un grupo de usuarios mediante la CLI**
+ Utilice el comando `delete-user-group`, tal y como se muestra a continuación: Se elimina el grupo de usuarios en sí, no los usuarios que pertenecen al grupo.
Para Linux, macOS o Unix:
```
aws elasticache delete-user-group /
--user-group-id
```
Para Windows:
```
aws elasticache delete-user-group ^
--user-group-id
```
Para ver una lista de grupos de usuarios, puedes llamar a la [describe-user-groups](https://docs.aws.amazon.com/cli/latest/reference/elasticache/describe-user-groups.html)operación.
```
aws elasticache describe-user-groups \
--user-group-id test-group
```
### Asignación de grupos de usuarios a cachés sin servidor
Después de crear un grupo de usuarios y agregar usuarios, el paso final para implementar el RBAC es asignar el grupo de usuarios a una caché sin servidor.
#### Asignación de grupos de usuarios a cachés sin servidor mediante la consola
Para añadir un grupo de usuarios a una caché sin servidor mediante el Consola de administración de AWS, haga lo siguiente:
+ Para el modo de clúster deshabilitado, consulte [Creación de un clúster de Valkey (modo de clúster deshabilitado) (consola)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ Para el modo de clúster habilitado, consulte [Creación de un clúster de Valkey o Redis OSS (modo de clúster habilitado) (consola)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
#### Asignación de grupos de usuarios a cachés sin servidor mediante el AWS CLI
La siguiente AWS CLI operación crea una caché sin servidor mediante el **user-group-id** parámetro con el valor. `my-user-group-id` Reemplace el grupo de subredes `sng-test` por otro existente.
**Parámetros clave**
+ **--engine**: debe ser `VALKEY` o `REDIS`.
+ **--user-group-id**: este valor proporciona el ID del grupo de usuarios, compuesto por usuarios con permisos de acceso especificados para la caché.
Para Linux, macOS o Unix:
```
aws elasticache create-serverless-cache \
--serverless-cache-name "new-serverless-cache" \
--description "new-serverless-cache" \
--engine "VALKEY" \
--user-group-id "new-group-1"
```
Para Windows:
```
aws elasticache create-serverless-cache ^
--serverless-cache-name "new-serverless-cache" ^
--description "new-serverless-cache" ^
--engine "VALKEY" ^
--user-group-id "new-group-1"
```
La siguiente AWS CLI operación modifica una caché sin servidor con el **user-group-id** parámetro con el valor. `my-user-group-id`
Para Linux, macOS o Unix:
```
aws elasticache modify-serverless-cache \
--serverless-cache-name serverless-cache-1 \
--user-group-id "new-group-2"
```
Para Windows:
```
aws elasticache modify-serverless-cache ^
--serverless-cache-name serverless-cache-1 ^
--user-group-id "new-group-2"
```
Tenga en cuenta que cualquier modificación que se haga en una caché se actualizará de forma asíncrona. Puede monitorear el progreso al visualizar los eventos. Para obtener más información, consulte [Visualización de ElastiCache eventos](ECEvents.Viewing.md).
### Asignación de grupos de usuarios a grupos de reproducción
Después de crear un grupo de usuarios y agregar usuarios, el paso final para implementar el RBAC es asignar el grupo de usuarios a un grupo de reproducción.
#### Asignación de grupos de usuarios a grupos de reproducción mediante la consola
Para añadir un grupo de usuarios a una replicación mediante el Consola de administración de AWS, haga lo siguiente:
+ Para el modo de clúster deshabilitado, consulte [Creación de un clúster de Valkey (modo de clúster deshabilitado) (consola)](SubnetGroups.designing-cluster-pre.valkey.md#Clusters.Create.CON.valkey-gs)
+ Para el modo de clúster habilitado, consulte [Creación de un clúster de Valkey o Redis OSS (modo de clúster habilitado) (consola)](Clusters.Create.md#Clusters.Create.CON.RedisCluster)
#### Asignación de grupos de usuarios a grupos de replicación mediante el AWS CLI
La siguiente AWS CLI operación crea un grupo de replicación con el cifrado en tránsito (TLS) activado y el **user-group-ids** parámetro con el valor. `my-user-group-id` Reemplace el grupo de subredes `sng-test` por otro existente.
**Parámetros clave**
+ **--engine**: debe ser `valkey` o `redis`.
+ **--engine-version**: debe ser 6.0 o posterior.
+ **--transit-encryption-enabled**: obligatorio para la autenticación y a fin de asociar un grupo de usuarios.
+ **--user-group-ids**: este valor proporciona el ID del grupo de usuarios, compuesto por usuarios con permisos de acceso especificados para la caché.
+ **--cache-subnet-group**: obligatorio para asociar un grupo de usuarios.
Para Linux, macOS o Unix:
```
aws elasticache create-replication-group \
--replication-group-id "new-replication-group" \
--replication-group-description "new-replication-group" \
--engine "VALKEY" \
--cache-node-type cache.m5.large \
--transit-encryption-enabled \
--user-group-ids "new-group-1" \
--cache-subnet-group "cache-subnet-group"
```
Para Windows:
```
aws elasticache create-replication-group ^
--replication-group-id "new-replication-group" ^
--replication-group-description "new-replication-group" ^
--engine "VALKEY" ^
--cache-node-type cache.m5.large ^
--transit-encryption-enabled ^
--user-group-ids "new-group-1" ^
--cache-subnet-group "cache-subnet-group"
```
La siguiente AWS CLI operación modifica un grupo de replicación con el cifrado en tránsito (TLS) habilitado y el **user-group-ids** parámetro con el valor. `my-user-group-id`
Para Linux, macOS o Unix:
```
aws elasticache modify-replication-group \
--replication-group-id replication-group-1 \
--user-group-ids-to-remove "new-group-1" \
--user-group-ids-to-add "new-group-2"
```
Para Windows:
```
aws elasticache modify-replication-group ^
--replication-group-id replication-group-1 ^
--user-group-ids-to-remove "new-group-1" ^
--user-group-ids-to-add "new-group-2"
```
Tenga en cuenta los `PendingChanges` en la respuesta. Las modificaciones que se hagan en una caché se actualizarán de forma asíncrona. Puede monitorear el progreso al visualizar los eventos. Para obtener más información, consulte [Visualización de ElastiCache eventos](ECEvents.Viewing.md).
## Migración de AUTH a RBAC
Si se encuentra utilizando AUTH como se describe en [Autenticación con el comando AUTH de Valkey o Redis OSS](auth.md) y desea migrar a RBAC, utilice los siguientes procedimientos.
Utilice el siguiente procedimiento para migrar de AUTH a RBAC con la consola.
**Migración de AUTH de Valkey o Redis OSS a RBAC mediante la consola**
1. Inicie sesión en Consola de administración de AWS y abra la ElastiCache consola en. [ https://console.aws.amazon.com/elasticache/](https://console.aws.amazon.com/elasticache/)
1. En la lista de la esquina superior derecha, selecciona la AWS región en la que se encuentra la memoria caché que deseas modificar.
1. En el panel de navegación, elija el motor que se ejecuta en la caché que desea modificar.
Aparecerá una lista de las cachés del motor elegido.
1. En la lista de cachés, elija el nombre de la caché que desea modificar.
1. Para **Actions (Acciones)**, elija **Modify (Modificar)**.
Aparecerá la ventana **Modificar**.
1. En **Opción de control de acceso**, elija **Lista de control de acceso de grupos de usuarios**.
1. En **Lista de control de acceso de grupos de usuarios**, elija un grupo de usuarios.
1. Seleccione **Vista previa de los cambios** y seleccione **Modificar** en la siguiente pantalla.
Utilice el siguiente procedimiento para migrar de AUTH de Valkey o Redis OSS a RBAC con la CLI.
**Migración de AUTH a RBAC mediante la CLI**
+ Utilice el comando `modify-replication-group`, tal y como se muestra a continuación:
Para Linux, macOS o Unix:
```
aws elasticache modify-replication-group --replication-group-id test \
--auth-token-update-strategy DELETE \
--user-group-ids-to-add user-group-1
```
Para Windows:
```
aws elasticache modify-replication-group --replication-group-id test ^
--auth-token-update-strategy DELETE ^
--user-group-ids-to-add user-group-1
```
## Migración de RBAC a AUTH
Si utiliza RBAC y desea migrar a AUTH de Redis OSS, consulte [Migración de RBAC a AUTH](auth.md#Migrate-From-RBAC-to-AUTH).
**nota**
Si necesitas deshabilitar el control de acceso a una ElastiCache caché, tendrás que hacerlo a través del.AWS CLI Para obtener más información, consulte [Deshabilitación del control de acceso en una caché de ElastiCache Valkey o Redis OSS](in-transit-encryption-disable.md).
# Rotación automática de contraseñas para usuarios
Con AWS Secrets Manager, puedes reemplazar las credenciales codificadas de tu código (incluidas las contraseñas) por una llamada a la API a Secrets Manager para recuperar el secreto mediante programación. Esto ayuda a garantizar la integridad del secreto si alguien examina el código, dado que el secreto sencillamente no está allí. Asimismo, puede configurar Secrets Manager para rotar el secreto automáticamente de acuerdo con la programación que especifique. Esto le permite reemplazar secretos a largo plazo con secretos a corto plazo, lo que contribuye a reducir significativamente el riesgo de peligro.
Con Secrets Manager, puede rotar automáticamente sus contraseñas de OSS ElastiCache para Redis (es decir, secretas) mediante una AWS Lambda función que proporciona Secrets Manager.
Para obtener más información al respecto AWS Secrets Manager, consulte [¿Qué es?AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/intro.html)
## ¿Cómo ElastiCache usa los secretos
Valkey 7.2 y versiones posteriores tiene un conjunto de características equivalente al de Redis OSS 7.0. En Redis OSS 6, ElastiCache introducido [Control de acceso basado en roles (RBAC)](Clusters.RBAC.md) para proteger el clúster OSS de Valkey o Redis. Esta característica permite limitar determinadas conexiones en términos de los comandos que se pueden ejecutar y las claves a las que se puede acceder. Con RBAC, mientras el cliente crea un usuario con contraseñas, los valores de la contraseña se deben ingresar manualmente en texto no cifrado y estar visibles para el operador.
Con Secrets Manager, las aplicaciones obtienen la contraseña de Secrets Manager en lugar de ingresarla manualmente y almacenarla en la configuración de la aplicación. Para obtener información sobre cómo hacerlo, consulte [Cómo se asocian ElastiCache los usuarios al secreto](#How-User-Secrets-Manager-Associate).
El uso de secretos conlleva un coste. Para obtener información sobre precios, consulte [Precios de AWS Secrets Manager](https://aws.amazon.com/secrets-manager/pricing/).
## Cómo se asocian ElastiCache los usuarios al secreto
Secrets Manager guardará una referencia del usuario asociado en el campo `SecretString` del secreto. No habrá ninguna referencia al secreto desde ElastiCache un lado.
```
{
"password": "strongpassword",
"username": "user1",
"user_arn": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1" //this is the bond between the secret and the user
}
```
## Función de rotación de Lambda
Para habilitar la rotación automática de contraseñas de Secrets Manager, se creará una función de Lambda que interactuará con la API [modificar-usuario](https://docs.aws.amazon.com/cli/latest/reference/elasticache/modify-user.html) para actualizar las contraseñas del usuario.
Para obtener información sobre cómo funciona esto, consulte [Cómo funciona la rotación](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotating-secrets.html#rotate-secrets_how).
**nota**
En el caso de algunos AWS servicios, para evitar el confuso escenario de los suplentes, se AWS recomienda utilizar tanto la `aws:SourceArn` clave de condición como la clave de condición `aws:SourceAccount` global. No obstante, si se incluye la condición `aws:SourceArn` en la política de la función de rotación, la función de rotación solo se puede utilizar para rotar el secreto especificado por ese ARN. Se recomienda incluir solo la clave de contexto `aws:SourceAccount`, para poder utilizar la función de rotación para varios secretos.
Para cualquier problema que puedas encontrar, consulta [Solucionar problemas de rotación de AWS Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/troubleshoot_rotation.html).
## Cómo crear un ElastiCache usuario y asociarlo a Secrets Manager
Los siguientes pasos muestran cómo crear un usuario y asociarlo con Secrets Manager:
1. **Crear un usuario inactivo**
Para Linux, macOS o Unix:
```
aws elasticache create-user \
--user-id user1 \
--user-name user1 \
--engine "REDIS" \
--no-password \ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
Para Windows:
```
aws elasticache create-user ^
--user-id user1 ^
--user-name user1 ^
--engine "REDIS" ^
--no-password ^ // no authentication is required
--access-string "*off* +get ~keys*" // this disables the user
```
Verá una respuesta similar a la siguiente:
```
{
"UserId": "user1",
"UserName": "user1",
"Status": "active",
"Engine": "redis",
"AccessString": "off ~keys* -@all +get",
"UserGroupIds": [],
"Authentication": {
"Type": "no_password"
},
"ARN": "arn:aws:elasticache:us-east-1:xxxxxxxxxx918:user:user1"
}
```
1. **Crear un secreto**
Para Linux, macOS o Unix:
```
aws secretsmanager create-secret \
--name production/ec/user1 \
--secret-string \
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
Para Windows:
```
aws secretsmanager create-secret ^
--name production/ec/user1 ^
--secret-string ^
'{
"user_arn": "arn:aws:elasticache:us-east-1:123456xxxx:user:user1",
"username":"user1"
}'
```
Verá una respuesta similar a la siguiente:
```
{
"ARN": "arn:aws:secretsmanager:us-east-1:123456xxxx:secret:production/ec/user1-eaFois",
"Name": "production/ec/user1",
"VersionId": "aae5b963-1e6b-4250-91c6-ebd6c47d0d95"
}
```
1. **Configurar una función de Lambda para rotar la contraseña**
1. Inicie sesión en la consola Lambda Consola de administración de AWS y ábrala en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/elasticache/)
1. Elija **Functions** (Funciones) en el panel de navegación y, a continuación, elija la función que ha creado. Elija el nombre de la función, no la casilla de verificación situada a la izquierda.
1. Elija la pestaña **Configuración**.
1. En **General configuration** (Configuración general), elija **Edit** (Editar) y, a continuación, establezca **Timeout** (Tiempo de espera) en al menos 12 minutos.
1. Seleccione **Save**.
1. Elija **Environment variables** (Variables de entorno) y, a continuación, establezca lo siguiente:
1. SECRETS\$1MANAGER\$1ENDPOINT: https://secretsmanager.**REGION**.amazonaws.com
1. SECRET\$1ARN: el nombre de recurso de Amazon (ARN) del secreto que creó en el paso 2.
1. USER\$1NAME: nombre de usuario del usuario, ElastiCache
1. Seleccione **Save**.
1. Elegir **Permissions** (Permisos)
1. En **Execution role** (Rol de ejecución), elija el nombre del rol de la función de Lambda para verla en la consola de IAM.
1. La función de Lambda necesitará el siguiente permiso para modificar los usuarios y establecer la contraseña:
ElastiCache
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"elasticache:DescribeUsers",
"elasticache:ModifyUser"
],
"Resource": "arn:aws:elasticache:us-east-1:123456789012:user:user1"
}
]
}
```
------
Secrets Manager
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"secretsmanager:GetSecretValue",
"secretsmanager:DescribeSecret",
"secretsmanager:PutSecretValue",
"secretsmanager:UpdateSecretVersionStage"
],
"Resource": "arn:aws:secretsmanager:us-east-1:123456789012:secret:XXXX"
},
{
"Effect": "Allow",
"Action": "secretsmanager:GetRandomPassword",
"Resource": "*"
}
]
}
```
------
1. Configurar la rotación de secretos de Secrets Manager
1. **Uso de Consola de administración de AWS, consulte [Configurar la rotación automática de los AWS secretos de Secrets Manager mediante la consola](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_turn-on-for-other.html)**
Para obtener más información sobre la configuración de un programa de rotación, consulte [Programación de expresiones en la rotación de Secrets Manager](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets_schedule.html).
1. **Con el AWS CLI, consulte [Configurar la rotación automática para AWS Secrets Manager usar el AWS Command Line Interface](https://docs.aws.amazon.com/secretsmanager/latest/userguide/rotate-secrets-cli.html)**
# Autenticación con IAM
**Topics**
+ [Descripción general de](#auth-iam-overview)
+ [Limitaciones](#auth-iam-limits)
+ [Configuración](#auth-iam-setup)
+ [Conexión](#auth-iam-Connecting)
## Descripción general de
Con la autenticación de IAM, puede autenticar una conexión ElastiCache para Valkey o Redis OSS mediante identidades de AWS IAM, si su caché está configurada para usar Valkey o Redis OSS versión 7 o superior. Esto le permite reforzar el modelo de seguridad y simplificar muchas tareas de seguridad administrativa. También puede utilizar la autenticación de IAM para configurar un control de acceso detallado para cada caché y usuario individual, siguiendo los principios de permisos con privilegios mínimos. ElastiCache ElastiCache La autenticación de IAM ElastiCache funciona proporcionando un token de autenticación de IAM de corta duración en lugar de una contraseña de usuario de larga duración ElastiCache en el OSS o comando de Valkey o Redis. `AUTH` `HELLO` Para obtener más información sobre el token de autenticación de IAM, consulte el [proceso de firma de la versión 4](https://docs.aws.amazon.com//general/latest/gr/signature-version-4.html) en la Guía de referencia AWS general y el ejemplo de código que aparece a continuación.
Puede utilizar las identidades de IAM y sus políticas asociadas para restringir aún más el acceso a Valkey o Redis OSS. También puede conceder acceso a los usuarios desde sus proveedores de identidades federados directamente a las cachés de Valkey o Redis OSS.
Para usar AWS IAM con ElastiCache, primero debe crear un ElastiCache usuario con el modo de autenticación configurado en IAM. A continuación, puede crear o reutilizar una identidad de IAM. La identidad de IAM necesita una política asociada para conceder la `elasticache:Connect` acción a la ElastiCache memoria caché y al usuario. ElastiCache Una vez configurado, puede crear un token de autenticación de IAM con AWS las credenciales del usuario o rol de IAM. Por último, debe proporcionar el token de autenticación de IAM de corta duración como contraseña en el cliente de Valkey o Redis OSS cuando se conecte a la caché. Un cliente OSS de Valkey o Redis con soporte para el proveedor de credenciales puede generar automáticamente las credenciales temporales para cada nueva conexión. ElastiCache realizará la autenticación de IAM para las solicitudes de conexión de los ElastiCache usuarios habilitados para IAM y validará las solicitudes de conexión con IAM.
## Limitaciones
Si utiliza la autenticación de IAM, se aplicarán las siguientes limitaciones:
+ La autenticación de IAM está disponible cuando se utiliza ElastiCache para Valkey 7.2 y versiones posteriores o para Redis OSS, versión 7.0 y versiones posteriores.
+ En el caso de ElastiCache los usuarios con IAM, las propiedades del nombre de usuario y el identificador de usuario deben ser idénticas.
+ El token de autenticación de IAM es válido durante 15 minutos. Para conexiones de larga duración, recomendamos utilizar un cliente de Valkey o Redis OSS que admita la interfaz de un proveedor de credenciales.
+ Una conexión autenticada ElastiCache por IAM a Valkey o Redis OSS se desconectará automáticamente después de 12 horas. La conexión se puede prolongar durante 12 horas enviando un comando `AUTH` o `HELLO` con un nuevo token de autenticación de IAM.
+ Los comandos `MULTI EXEC` no admiten la autenticación de IAM.
+ Actualmente, la autenticación de IAM admite las siguientes claves de contexto de condición global:
+ Cuando se utiliza la autenticación de IAM con cachés sin servidor, se admiten `aws:VpcSourceIp`, `aws:SourceVpc`, `aws:SourceVpce`, `aws:CurrentTime`, `aws:EpochTime` y `aws:ResourceTag/%s` (desde usuarios y cachés sin servidor asociados).
+ Cuando se utiliza la autenticación de IAM con grupos de réplica, se admiten `aws:SourceIp` y `aws:ResourceTag/%s` (desde los usuarios y grupos de réplica asociados).
Para obtener más información sobre las claves de contexto de condición globales, consulte [Claves de contexto de condición globales de AWS](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_condition-keys.html) en la Guía del usuario de IAM.
## Configuración
Para configurar la autenticación de IAM:
1. Creación de una caché
```
aws elasticache create-serverless-cache \
--serverless-cache-name cache-01 \
--description "ElastiCache IAM auth application" \
--engine redis
```
1. Cree un documento de política de confianza de IAM, como se muestra a continuación, para el rol que permita a la cuenta asumir el nuevo rol. Guarde la política en un archivo denominado *trust-policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": { "AWS": "arn:aws:iam::123456789012:root" },
"Action": "sts:AssumeRole"
}
}
```
------
1. Cree un documento de política de IAM, como se muestra a continuación. Guarde la política en un archivo denominado *policy.json*.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect" : "Allow",
"Action" : [
"elasticache:Connect"
],
"Resource" : [
"arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01",
"arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01"
]
}
]
}
```
------
1. Crear un rol de IAM.
```
aws iam create-role \
--role-name "elasticache-iam-auth-app" \
--assume-role-policy-document file://trust-policy.json
```
1. Creación de la política de IAM.
```
aws iam create-policy \
--policy-name "elasticache-allow-all" \
--policy-document file://policy.json
```
1. Adjunte la política de IAM al rol.
```
aws iam attach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```
1. Cree un nuevo usuario habilitado para IAM.
```
aws elasticache create-user \
--user-name iam-user-01 \
--user-id iam-user-01 \
--authentication-mode Type=iam \
--engine redis \
--access-string "on ~* +@all"
```
1. Cree un grupo de usuarios y asocie al usuario.
```
aws elasticache create-user-group \
--user-group-id iam-user-group-01 \
--engine redis \
--user-ids default iam-user-01
aws elasticache modify-serverless-cache \
--serverless-cache-name cache-01 \
--user-group-id iam-user-group-01
```
## Conexión
**Conectar con el token como contraseña**
Primero debe generar el token de autenticación de IAM de corta duración mediante una [solicitud prefirmada SigV4 de AWS](https://docs.aws.amazon.com//general/latest/gr/sigv4-signed-request-examples.html). A continuación, debe proporcionar el token de autenticación de IAM como contraseña al conectarse a una caché de Valkey o Redis OSS, como se muestra en el ejemplo siguiente.
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request and signed it using the AWS credentials.
// The pre-signed request URL is used as an IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userId, iamAuthToken)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
A continuación, se muestra la definición de `IAMAuthTokenRequest`.
```
public class IAMAuthTokenRequest {
private static final HttpMethodName REQUEST_METHOD = HttpMethodName.GET;
private static final String REQUEST_PROTOCOL = "http://";
private static final String PARAM_ACTION = "Action";
private static final String PARAM_USER = "User";
private static final String PARAM_RESOURCE_TYPE = "ResourceType";
private static final String RESOURCE_TYPE_SERVERLESS_CACHE = "ServerlessCache";
private static final String ACTION_NAME = "connect";
private static final String SERVICE_NAME = "elasticache";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userId;
private final String cacheName;
private final String region;
private final boolean isServerless;
public IAMAuthTokenRequest(String userId, String cacheName, String region, boolean isServerless) {
this.userId = userId;
this.cacheName = cacheName;
this.region = region;
this.isServerless = isServerless;
}
public String toSignedRequestUri(AWSCredentials credentials) throws URISyntaxException {
Request request = getSignableRequest();
sign(request, credentials);
return new URIBuilder(request.getEndpoint())
.addParameters(toNamedValuePair(request.getParameters()))
.build()
.toString()
.replace(REQUEST_PROTOCOL, "");
}
private Request getSignableRequest() {
Request request = new DefaultRequest<>(SERVICE_NAME);
request.setHttpMethod(REQUEST_METHOD);
request.setEndpoint(getRequestUri());
request.addParameters(PARAM_ACTION, Collections.singletonList(ACTION_NAME));
request.addParameters(PARAM_USER, Collections.singletonList(userId));
if (isServerless) {
request.addParameters(PARAM_RESOURCE_TYPE, Collections.singletonList(RESOURCE_TYPE_SERVERLESS_CACHE));
}
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, cacheName));
}
private void sign(SignableRequest request, AWSCredentials credentials) {
AWS4Signer signer = new AWS4Signer();
signer.setRegionName(region);
signer.setServiceName(SERVICE_NAME);
DateTime dateTime = DateTime.now();
dateTime = dateTime.plus(Duration.standardSeconds(TOKEN_EXPIRY_SECONDS));
signer.presignRequest(request, credentials, dateTime.toDate());
}
private static List toNamedValuePair(Map> in) {
return in.entrySet().stream()
.map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0)))
.collect(Collectors.toList());
}
}
```
**Conectar con el proveedor de credenciales**
El siguiente código muestra cómo autenticarse con el proveedor de credenciales de autenticación de ElastiCache IAM.
```
String userId = "insert user id";
String cacheName = "insert cache name";
boolean isServerless = true;
String region = "insert region";
// Create a default AWS Credentials provider.
// This will look for AWS credentials defined in environment variables or system properties.
AWSCredentialsProvider awsCredentialsProvider = new DefaultAWSCredentialsProviderChain();
// Create an IAM authentication token request. Once this request is signed it can be used as an
// IAM authentication token for ElastiCache with Redis OSS.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless);
// Create a Redis OSS credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userId, iamAuthTokenRequest, awsCredentialsProvider);
// Construct Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce Redis OSS client
RedisClient client = RedisClient.create(redisURI);
client.connect();
```
A continuación se muestra un ejemplo de un cliente OSS de Lettuce Redis que incluye un proveedor de credenciales para generar automáticamente credenciales temporales cuando sea necesario. IAMAuth TokenRequest
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userId;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userId,
IAMAuthTokenRequest iamAuthTokenRequest,
AWSCredentialsProvider awsCredentialsProvider) {
this.userName = userName;
this.awsCredentialsProvider = awsCredentialsProvider;
this.iamAuthTokenRequest = iamAuthTokenRequest;
this.iamAuthTokenSupplier = Suppliers.memoizeWithExpiration(this::getIamAuthToken, TOKEN_EXPIRY_SECONDS, TimeUnit.SECONDS);
}
@Override
public Mono resolveCredentials() {
return Mono.just(RedisCredentials.just(userId, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
}
```