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.
# Protección de datos en MemoryDB
El modelo de [responsabilidad AWS compartida modelo](https://aws.amazon.com/compliance/shared-responsibility-model/) se aplica a la protección de datos en. Como se describe en este modelo, AWS es responsable de proteger la infraestructura global que ejecuta todos los Nube de AWS. Eres responsable de mantener el control sobre el contenido alojado en esta infraestructura. También eres responsable de las tareas de administración y configuración de seguridad para los Servicios de AWS que utiliza. Para obtener más información sobre la privacidad de los datos, consulte las [Preguntas frecuentes sobre la privacidad de datos](https://aws.amazon.com/compliance/data-privacy-faq/). Para obtener información sobre la protección de datos en Europa, consulte la publicación de blog sobre el [Modelo de responsabilidad compartida de AWS y GDPR](https://aws.amazon.com/blogs/security/the-aws-shared-responsibility-model-and-gdpr/) en el * Blog de seguridad de AWS *.
Con fines de protección de datos, le recomendamos que proteja Cuenta de AWS las credenciales y configure los usuarios individuales con AWS IAM Identity Center o AWS Identity and Access Management (IAM). De esta manera, solo se otorgan a cada usuario los permisos necesarios para cumplir sus obligaciones laborales. También recomendamos proteger sus datos de la siguiente manera:
+ Utiliza la autenticación multifactor (MFA) en cada cuenta.
+ Se utiliza SSL/TLS para comunicarse con AWS los recursos. Exigimos TLS 1.2 y recomendamos TLS 1.3.
+ Configure la API y el registro de actividad de los usuarios con AWS CloudTrail. Para obtener información sobre el uso de CloudTrail senderos para capturar AWS actividades, consulte [Cómo trabajar con CloudTrail senderos](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-trails.html) en la *Guía del AWS CloudTrail usuario*.
+ Utilice soluciones de AWS cifrado, junto con todos los controles de seguridad predeterminados Servicios de AWS.
+ Utiliza servicios de seguridad administrados avanzados, como Amazon Macie, que lo ayuden a detectar y proteger la información confidencial almacenada en Amazon S3.
+ Si necesita módulos criptográficos validados por FIPS 140-3 para acceder a AWS través de una interfaz de línea de comandos o una API, utilice un punto final FIPS. Para obtener más información sobre los puntos de conexión de FIPS disponibles, consulte [Estándar de procesamiento de la información federal (FIPS) 140-3](https://aws.amazon.com/compliance/fips/).
Se recomienda encarecidamente no introducir nunca información confidencial o sensible, como por ejemplo, direcciones de correo electrónico de clientes, en etiquetas o campos de formato libre, tales como el campo **Nombre**. Esto incluye cuando trabaja con o Servicios de AWS utiliza la consola, la API o. AWS CLI AWS SDKs Cualquier dato que introduzca en etiquetas o campos de formato libre utilizados para los nombres se pueden emplear para los registros de facturación o diagnóstico. Si proporciona una URL a un servidor externo, recomendamos encarecidamente que no incluya información de credenciales en la URL a fin de validar la solicitud para ese servidor.
# Seguridad de los datos en MemoryDB
Para ayudar a proteger los datos, MemoryDB y Amazon EC2 incluyen mecanismos que impiden el acceso no autorizado a los datos del servidor.
MemoryDB también proporciona funciones de cifrado para datos en clústeres:
+ El cifrado en tránsito cifra los datos mientras se mueven de un lugar a otro; por ejemplo, entre los nodos del clúster o entre el clúster y la aplicación.
+ El cifrado en reposo cifra el registro de transacciones y los datos en el disco durante las operaciones de instantáneas.
También puede usar [Autenticación de usuarios con listas de control de acceso () ACLs](clusters.acls.md) para controlar el acceso de los usuarios al clúster.
**Topics**
+ [Seguridad de los datos en MemoryDB](encryption.md)
+ [Cifrado en reposo en MemoryDB](at-rest-encryption.md)
+ [Cifrado en tránsito (TLS) de MemoryDB](in-transit-encryption.md)
+ [Autenticación de usuarios con listas de control de acceso () ACLs](clusters.acls.md)
+ [Autenticación con IAM](auth-iam.md)
# Cifrado en reposo en MemoryDB
Para ayudarle a mantener los datos protegidos, MemoryDB y Amazon S3 cuentan con diferentes formas que permiten restringir el acceso a los datos de sus clústeres. Para obtener más información, consulte [MemoryDB y Amazon VPC](vpcs.md) y [Administración de identidades y accesos en MemoryDB](iam.md).
El cifrado en reposo de MemoryDB siempre está activado para aumentar la seguridad de la información al cifrar los datos persistentes. Encripta los siguientes aspectos:
+ Datos del registro de transacciones
+ Disco durante las operaciones de sincronización, instantáneas o intercambio
+ Instantáneas almacenadas en Amazon S3
MemoryDB ofrece cifrado en reposo predeterminado (servicio administrado), así como capacidad para usar sus propias claves maestras simétricas del cliente administradas por el cliente en [AWS Key Management Service (KMS)](https://docs.aws.amazon.com/kms/latest/developerguide/overview.html).
Los datos almacenados en los SSD (unidades de estado sólido) en clústeres habilitados para la organización de datos en niveles siempre se cifran de forma predeterminada.
Para obtener más información sobre el cifrado en tránsito, consulte . [Cifrado en tránsito (TLS) de MemoryDB](in-transit-encryption.md)
**Topics**
+ [Uso de claves administradas por el cliente desde AWS KMS](#using-customer-managed-keys-for-memorydb-security)
+ [Véase también](#at-rest-encryption-see-also)
## Uso de claves administradas por el cliente desde AWS KMS
MemoryDB admite las claves maestras simétricas administradas por el cliente (clave de KMS) para el cifrado en reposo. Las claves de KMS administradas por el cliente son claves de cifrado que crea, posee y administra en la cuenta de AWS. Para obtener más información, consulte [Claves raíz del cliente](https://docs.aws.amazon.com/kms/latest/developerguide/concepts.html#root_keys) en la *Guía para desarrolladores de AWS Key Management Service*. Las claves deben crearse en AWS KMS para poder utilizarlas con MemoryDB.
Para obtener más información sobre la creación de claves maestras de AWS KMS, consulte [Creación de claves](https://docs.aws.amazon.com/kms/latest/developerguide/create-keys.html) en la *Guía para desarrolladores de AWS Key Management Service*.
MemoryDB permite la integración con AWS KMS. Para obtener más información, consulte [Uso de concesiones](https://docs.aws.amazon.com/kms/latest/developerguide/grants.html) en la *Guía para desarrolladores de AWS Key Management Service*. No se requieren acciones del cliente para habilitar la integración de MemoryDB con AWS KMS.
La clave de condición `kms:ViaService` limita el uso de una clave de AWS KMS a determinadas solicitudes de servicios de AWS. Para utilizar `kms:ViaService` con MemoryDB, incluya ambos nombres de ViaService en el valor de clave de condición: `memorydb.amazon_region.amazonaws.com`. Para obtener más información, consulte [kms:ViaService](https://docs.aws.amazon.com/kms/latest/developerguide/policy-conditions.html#conditions-kms-via-service).
Puede utilizar [AWS CloudTrail](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/cloudtrail-user-guide.html) para realizar un seguimiento de las solicitudes que MemoryDB envía a AWS Key Management Service en su nombre. Todas las llamadas a la API a AWS Key Management Service relacionadas con claves administradas por el cliente tienen los registros de CloudTrail correspondientes. También puede ver las concesiones que crea MemoryDB llamando a la API de KMS [ListGrants](https://docs.aws.amazon.com/kms/latest/APIReference/API_ListGrants.html).
Una vez que se cifra un clúster mediante la clave administrada por el cliente, todas las instantáneas para el clúster se cifran de la siguiente manera:
+ Las instantáneas diarias automáticas se cifran mediante la clave administrada por el cliente asociada con el clúster.
+ La instantánea final creada cuando se elimina el clúster también se cifra mediante la clave administrada por el cliente asociada con el clúster.
+ Las instantáneas creadas de forma manual se cifran de manera predeterminada para utilizar la clave de KMS asociada con el clúster. Puede anular esto al elegir otra clave administrada por el cliente.
+ Al copiar una instantánea se utiliza de forma predeterminada una clave administrada por el cliente asociada a la instantánea de origen. Puede anular esto al elegir otra clave administrada por el cliente.
**nota**
Las claves administradas por el cliente no se pueden utilizar cuando se exportan instantáneas al bucket de Amazon S3 seleccionado. Sin embargo, todas las instantáneas exportadas a Amazon S3 se cifran mediante el [cifrado del lado del servidor](https://docs.aws.amazon.com/AmazonS3/latest/dev/UsingServerSideEncryption.html). Puede optar por copiar el archivo de instantánea en un objeto de S3 nuevo y cifrarlo mediante una clave de KMS administrada por el cliente, copiar el archivo a otro bucket de S3 que se haya configurado con el cifrado predeterminado mediante una clave de KMS o cambiar una opción de cifrado en el propio archivo.
También puede utilizar claves administradas por el cliente a fin de cifrar instantáneas creadas de forma manual que no utilicen claves administradas por el cliente para el cifrado. Con esta opción, el archivo de instantánea almacenado en Amazon S3 se cifra mediante una clave de KMS, aunque los datos no se cifren en el clúster original.
La restauración desde una instantánea le permite elegir entre las opciones de cifrado disponibles, similares a las opciones de cifrado disponibles cuando se crea un nuevo clúster.
+ Si elimina la clave o [deshabilita](https://docs.aws.amazon.com/kms/latest/developerguide/enabling-keys.html) la clave y [revoca las concesiones](https://docs.aws.amazon.com/kms/latest/APIReference/API_RevokeGrant.html) para la clave que utilizó para cifrar un clúster, el clúster se vuelve irrecuperable. En otras palabras, no se puede modificar ni recuperar después de un error de hardware. AWS KMS solo elimina las claves maestras después de un periodo de espera de al menos siete días. Después de eliminar la clave, puede utilizar una clave administrada por el cliente diferente para crear una instantánea con fines de archivo.
+ La rotación automática de claves conserva las propiedades de las claves maestras de AWS KMS, por lo que la rotación no tiene efecto sobre la capacidad de acceder a los datos de MemoryDB. Los clústeres de MemoryDB no admiten la rotación de claves manual, lo que implica la creación de una nueva clave maestra y la actualización de cualquier referencia a la antigua clave. Para obtener más información, consulte [Rotación de claves del cliente](https://docs.aws.amazon.com/kms/latest/developerguide/rotate-keys.html) en la *Guía para desarrolladores de AWS Key Management Service*.
+ El cifrado de un clúster de MemoryDB mediante la clave de KMS requiere una concesión por clúster. Esa concesión se utiliza a lo largo de la vida útil del clúster. Además, se utiliza una concesión por instantánea durante la creación de la instantánea. Dicha concesión se retira una vez que se crea la instantánea.
+ Para obtener más información sobre las cuotas y las concesiones de AWS KMS, consulte [Cuotas](https://docs.aws.amazon.com/kms/latest/developerguide/limits.html) en la *Guía para desarrolladores de AWS Key Management Service*.
## Véase también
+ [Cifrado en tránsito (TLS) de MemoryDB](in-transit-encryption.md)
+ [MemoryDB y Amazon VPC](vpcs.md)
+ [Administración de identidades y accesos en MemoryDB](iam.md)
# Cifrado en tránsito (TLS) de MemoryDB
Para ayudar a proteger los datos, MemoryDB y Amazon EC2 incluyen mecanismos que impiden el acceso no autorizado a los datos del servidor. Al contar con una funcionalidad de cifrado en tránsito, MemoryDB le brinda una herramienta que puede utilizar para ayudar a proteger los datos cuando se trasladan de una ubicación a otra. Por ejemplo, puede mover datos de un nodo principal a un nodo de réplica de lectura de un clúster o entre el clúster y la aplicación.
**Topics**
+ [Información general sobre el cifrado en tránsito](#in-transit-encryption-overview)
+ [Véase también](#in-transit-encryption-see-also)
## Información general sobre el cifrado en tránsito
El cifrado en tránsito de MemoryDB es una característica que permite reforzar la seguridad de los datos en sus momentos más vulnerables: cuando se trasladan de una ubicación a otra.
El cifrado en tránsito de MemoryDB implementa las siguientes características:
+ **Conexiones cifradas**: las conexiones del servidor y el cliente se cifran con la seguridad de la capa de transporte (TLS).
+ **Replicación cifrada**: se cifran los datos que se trasladan entre un nodo principal y los nodos de réplica.
+ **Autenticación de servidores**: los clientes pueden autenticar que se encuentran conectados al servidor correcto.
A partir del 20 de julio de 2023, TLS 1.2 es la versión mínima admitida para los clústeres nuevos y existentes. Utilice este [enlace](https://aws.amazon.com/blogs/security/tls-1-2-required-for-aws-endpoints/) para obtener más información sobre TLS 1.2 en AWS.
Para obtener más información acerca de la conexión a los clústeres de MemoryDB, consulte [Conexión a los nodos de MemoryDB mediante redis-cli](getting-started.md#connect-tls).
## Véase también
+ [Cifrado en reposo en MemoryDB](at-rest-encryption.md)
+ [Autenticación de usuarios con listas de control de acceso (ACL)](https://docs.aws.amazon.com/memorydb/latest/devguide/clusters.acls.html)
+ [MemoryDB y Amazon VPC](vpcs.md)
+ [Administración de identidades y accesos en MemoryDB](iam.md)
# Autenticación de usuarios con listas de control de acceso () ACLs
Puede autenticar a los usuarios con listas de control de acceso (). ACLs
ACLs le permiten controlar el acceso al clúster agrupando los usuarios. Estas listas de control de acceso se han diseñado como una forma de organizar el acceso a los clústeres.
Con ACLs, puede crear usuarios y asignarles permisos específicos mediante una cadena de acceso, tal y como se describe en la siguiente sección. Asigne los usuarios a listas de control de acceso alineadas con un rol específico (administradores, recursos humanos) que luego se implementan en uno o más clústeres de MemoryDB. De esta manera, puede establecer límites de seguridad entre clientes que utilicen el mismo clúster o clústeres de MemoryDB e impedir que los clientes obtengan acceso a los datos de los demás.
ACLs están diseñados para respaldar la introducción de [ACL](https://valkey.io/docs/topics/acl/) en Redis OSS 6. Cuando se utiliza ACLs con un clúster de MemoryDB, existen algunas limitaciones:
+ No puede especificar contraseñas en una cadena de acceso. Las contraseñas se configuran con [CreateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_CreateUser.html)o [UpdateUser](https://docs.aws.amazon.com/memorydb/latest/APIReference/API_UpdateUser.html)con las llamadas.
+ Para los derechos de usuario, pasa `on` y `off` como parte de la cadena de acceso. Si no se especifica ninguno en la cadena de acceso, se asigna `off` al usuario y no tiene derechos de acceso al clúster.
+ No se pueden utilizar comandos prohibidos. Si especifica un comando prohibido, se generará una excepción. Para ver una lista de dichos comandos, consulte [Comandos restringidos](restrictedcommands.md).
+ No puede utilizar el comando `reset` como parte de una cadena de acceso. Las contraseñas se especifican con parámetros de la API y MemoryDB 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. MemoryDB admite el comando `ACL LIST`, pero no incluye soporte para hash de contraseña como lo hace Redis OSS. Con MemoryDB, puede utilizar la [DescribeUsers](https://docs.aws.amazon.com/memorydb/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/memorydb/latest/APIReference/API_DescribeUsers.html)no recupera la contraseña de un usuario.
Otros comandos de solo lectura admitidos por MemoryDB incluyen [ACL WHOAMI](https://valkey.io/commands/acl-whoami), [ACL USERS](https://valkey.io/commands/acl-users) y [ACL CAT](https://valkey.io/commands/acl-cat). MemoryDB no admite otros comandos ACL basados en escritura.
El uso ACLs con MemoryDB se describe con más detalle a continuación.
**Topics**
+ [Especificación de permisos mediante una cadena de acceso](#access-string)
+ [Capacidades de la búsqueda vectorial](#access-vss)
+ [Se aplica ACLs a un clúster para MemoryDB](#rbac-using)
## Especificación de permisos mediante una cadena de acceso
Para especificar los permisos de un clúster de MemoryDB, debe crear una cadena de acceso y asignarla a un usuario mediante la tecla o. AWS CLI Consola 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.
+ `&*`: se brinda acceso a todos los canales pubsub 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 listas de control de acceso con la consola y la CLI](#users-management).
Si va a migrar una carga de trabajo existente a MemoryDB, puede recuperar la cadena de acceso mediante una llamada a `ACL LIST`, que excluya el usuario y cualquier hash de contraseña.
## Capacidades de la búsqueda vectorial
En [Búsqueda vectorial](vector-search.md), todos los comandos de la búsqueda pertenecen a la categoría `@search`, y las categorías existentes `@read`, `@write`, `@fast` y `@slow` se actualizan para incluir los comandos de la búsqueda. Si un usuario no tiene acceso a una categoría, entonces no tiene acceso a ningún comando de la categoría. Por ejemplo, si el usuario no tiene acceso a `@search`, entonces no puede ejecutar ningún comando relacionado con la búsqueda.
En la siguiente tabla se indica la asignación de los comandos JSON a las categorías apropiadas.
| Comandos de VSS | @read | @write | @fast | @slow |
| --- | --- | --- | --- | --- |
| FT.CREATE | | Y | Y | |
| FT.DROPINDEX | | Y | Y | |
| FT.LIST | Y | | | Y |
| FT.INFO | Y | | Y | |
| FT.SEARCH | Y | | | Y |
| FT.AGGREGATE | Y | | | Y |
| FT.PROFILE | Y | | | Y |
| FT.ALIASADD | | Y | Y | |
| FT.ALIASDEL | | Y | Y | |
| FT.ALIASUPDATE | | Y | Y | |
| FT.\$1ALIASLIST | Y | | | Y |
| FT.EXPLAIN | Y | | Y | |
| FT.EXPLAINCLI | Y | | Y | |
| FT.CONFIG | Y | | Y | |
## Se aplica ACLs a un clúster para MemoryDB
Para usar MemoryDB ACLs, siga los siguientes pasos:
1. Cree uno o más usuarios.
1. Cree una ACL y agregue usuarios a la lista.
1. Asigne la ACL a un clúster.
Estos pasos se describen en la siguiente tabla.
**Topics**
+ [Creación de usuarios y listas de control de acceso con la consola y la CLI](#users-management)
+ [Administración de listas de control de acceso con la consola y la CLI](#user-groups)
+ [Asignación de listas de control de acceso a clústeres](#users-groups-to-clusterss)
### Creación de usuarios y listas de control de acceso con la consola y la CLI
La información de usuario para ACLs los usuarios es un 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 nombre de usuario es exclusivo del usuario y es lo que se pasa al motor.
Asegúrese de que los permisos de usuario que proporcione tengan sentido con el propósito previsto de la ACL. Por ejemplo, si crea una ACL denominada `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 una ACL de `e-commerce`, puede establecer las cadenas de acceso en acceso de solo lectura.
MemoryDB configura automáticamente un usuario predeterminado por cuenta con un nombre de usuario `"default"`. No se asociará a ningún clúster a menos que se añada explícitamente a una ACL. 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.
Se creará una ACL inmutable de “acceso abierto” para cada cuenta que contenga el usuario predeterminado. Esta es la única ACL a la que el usuario predeterminado puede pertenecer. Al crear un clúster, es preciso asociarlo con una ACL. Si bien tiene la opción de aplicar la ACL de “acceso abierto” con el usuario predeterminado, le recomendamos encarecidamente que cree una ACL con usuarios que tengan permisos restringidos a sus necesidades empresariales.
Los clústeres que no tienen habilitada la TLS deben usar la ACL de “acceso abierto” para proporcionar una autenticación abierta.
ACLs se puede crear sin ningún usuario. Una ACL vacía no tendría acceso a un clúster y solo se puede asociar a clústeres habilitados para TLS.
Al crear un usuario, puede configurar hasta dos contraseñas. Al modificar una contraseña, se mantienen todas las conexiones existentes a los clústeres.
En particular, tenga en cuenta estas restricciones de contraseña de usuario cuando utilice ACLs MemoryDB:
+ 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
##### Creación de usuarios (consola)
**Para crear usuarios con la consola**
1. Inicie sesión en la consola de Consola de administración de AWS MemoryDB y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Usuarios**.
1. Elija **Crear usuario**
1. En la página **Crear usuario**, introduzca un **nombre**.
Las restricciones para la asignación de nombres de clúster son las siguientes:
+ Deben contener entre 1 y 40 caracteres alfanuméricos o guiones.
+ Deben comenzar por una letra.
+ No pueden contener dos guiones consecutivos.
+ No pueden terminar con un guion.
1. En **Contraseñas**, puede introducir hasta dos contraseñas.
1. En **Cadena de acceso**, introduzca una cadena de acceso. La cadena de acceso establece el nivel de permisos para qué claves y comandos se permite al usuario.
1. En el **caso de las etiquetas**, si lo desea, puede aplicar etiquetas para buscar y filtrar a sus usuarios o realizar un seguimiento de sus AWS costes.
1. Seleccione **Crear**.
##### Crear un usuario mediante AWS CLI
**Para crear un usuario mediante la CLI**
+ Utilice el comando [create-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-user.html) para crear un usuario.
Para Linux, macOS o Unix:
```
aws memorydb create-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*" \
--authentication-mode \
Passwords="abc",Type=password
```
Para Windows:
```
aws memorydb create-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*" ^
--authentication-mode \
Passwords="abc",Type=password
```
##### Modificación de un usuario (consola)
**Para modificar usuarios con la consola**
1. Inicie sesión en la consola de MemoryDB Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Usuarios**.
1. Elija el botón de opción situado junto al usuario que desea modificar y luego elija **Acciones** -> **Modificar**
1. Si desea modificar una contraseña, pulse el botón de opción **Modificar contraseñas**. Tenga en cuenta que si tiene dos contraseñas, debe introducir ambas al modificar una de ellas.
1. Si va a actualizar la cadena de acceso, introduzca la nueva.
1. Elija **Modificar**.
##### Modificar un usuario mediante AWS CLI
**Para modificar un usuario mediante la CLI**
1. Utilice el comando [update-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-user.html) para modificar un usuario.
1. Cuando se modifica un usuario, se actualizan las listas de control de acceso asociadas al usuario, junto con los clústeres asociados a la ACL. Se mantienen todas las conexiones existentes. A continuación se muestran algunos ejemplos.
Para Linux, macOS o Unix:
```
aws memorydb update-user \
--user-name user-name-1 \
--access-string "~objects:* ~items:* ~public:*"
```
Para Windows:
```
aws memorydb update-user ^
--user-name user-name-1 ^
--access-string "~objects:* ~items:* ~public:*"
```
##### Visualización de detalles de los usuarios (consola)
**Para ver los detalles del usuario en la consola**
1. Inicie sesión en la consola de MemoryDB Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Usuarios**.
1. Elija el usuario en **Nombre de usuario** o utilice el cuadro de búsqueda para encontrarlo.
1. En **Configuración de usuario**, puede revisar la cadena de acceso del usuario, el recuento de contraseñas, el estado y el nombre del recurso de Amazon (ARN).
1. En **las listas de control de acceso (ACL)**, puede revisar la ACL a la que pertenece el usuario.
1. En **Etiquetas**, puede revisar cualquier etiqueta asociada al usuario.
##### Visualización de los detalles del usuario mediante el AWS CLI
Utilice el comando [describe-users](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-users.html) para ver los detalles de un usuario.
```
aws memorydb describe-users \
--user-name my-user-name
```
##### Eliminación de un usuario (consola)
**Para eliminar usuarios con la consola**
1. Inicie sesión en la consola de MemoryDB Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Usuarios**.
1. Elija el botón de opción situado junto al usuario que desea modificar y luego elija **Acciones** -> **Eliminar**
1. Para confirmar, en el cuadro de texto de confirmación, introduzca `delete` y, a continuación, elija **Eliminar**.
1. Para cancelar, elija **Cancelar**.
##### Eliminar un usuario mediante el AWS CLI
**Para eliminar un usuario mediante la CLI**
+ Utilice el comando [delete-user](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-user.html) para eliminar un usuario.
La cuenta se borra y elimina de todas las listas de control de acceso a las que pertenezca. A continuación se muestra un ejemplo.
Para Linux, macOS o Unix:
```
aws memorydb delete-user \
--user-name user-name-2
```
Para Windows:
```
aws memorydb delete-user ^
--user-name user-name-2
```
### Administración de listas de control de acceso con la consola y la CLI
Puede crear listas de control de acceso para organizar y controlar el acceso de los usuarios a uno o más clústeres, como se muestra a continuación.
Use el siguiente procedimiento para administrar las listas de control de acceso mediante la consola.
#### Creación de una lista de control de acceso (ACL) (consola)
**Para crear una lista de control de acceso mediante la consola**
1. Inicie sesión en la consola de MemoryDB Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Listas de control de acceso (ACL)**.
1. Seleccione **Crear ACL**.
1. En la página **Crear lista de control de acceso (ACL)**, introduzca un nombre ACL.
Las restricciones para la asignación de nombres de clúster son las siguientes:
+ Deben contener entre 1 y 40 caracteres alfanuméricos o guiones.
+ Deben comenzar por una letra.
+ No pueden contener dos guiones consecutivos.
+ No pueden terminar con un guion.
1. En **Usuarios seleccionados**, realice una de las siguientes acciones:
1. Para crear un nuevo usuario, seleccione **Crear usuario**
1. Para agregar usuarios, elija **Administrar** y, a continuación, seleccione los usuarios en el cuadro de diálogo **Administrar usuarios** y, a continuación, seleccione **Elegir**.
1. En el **caso de las etiquetas**, si lo desea, puede aplicar etiquetas para buscar y filtrar sus costes ACLs o realizar un seguimiento de los mismos. AWS
1. Seleccione **Crear**.
#### Creación de una lista de control de acceso (ACL) mediante AWS CLI
Utilice el siguiente procedimiento para crear una lista de control de acceso mediante la CLI.
**Para crear una nueva ACL y agregar un usuario mediante la CLI**
+ Utilice el comando [create-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/create-acl.html) para crear una ACL.
Para Linux, macOS o Unix:
```
aws memorydb create-acl \
--acl-name "new-acl-1" \
--user-names "user-name-1" "user-name-2"
```
Para Windows:
```
aws memorydb create-acl ^
--acl-name "new-acl-1" ^
--user-names "user-name-1" "user-name-2"
```
#### Modificación de una lista de control de acceso (ACL) (consola)
**Para modificar una lista de control de acceso mediante la consola**
1. Inicie sesión en la consola de MemoryDB Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Listas de control de acceso (ACL)**.
1. Elija la ACL que desea modificar y elija **Modificar**
1. En la página **Modificar**, en **Usuarios seleccionados**, realice una de las siguientes acciones:
1. Cree un nuevo usuario seleccionando **Crear usuario** para agregarlo a la ACL.
1. Agregue o elimine usuarios seleccionando **Administrar** y, a continuación, seleccionando o deseleccionando los usuarios en el cuadro de diálogo **Administrar usuarios** y, a continuación, seleccionando **Elegir**.
1. En la página **Crear lista de control de acceso (ACL)**, introduzca un nombre ACL.
Las restricciones para la asignación de nombres de clúster son las siguientes:
+ Deben contener entre 1 y 40 caracteres alfanuméricos o guiones.
+ Deben comenzar por una letra.
+ No pueden contener dos guiones consecutivos.
+ No pueden terminar con un guion.
1. En **Usuarios seleccionados**, realice una de las siguientes acciones:
1. Para crear un nuevo usuario, seleccione **Crear usuario**
1. Para agregar usuarios, elija **Administrar** y, a continuación, seleccione los usuarios en el cuadro de diálogo **Administrar usuarios** y, a continuación, seleccione **Elegir**.
1. Seleccione **Modificar** para guardar los cambios o **Cancelar** para descartarlos.
#### Modificación de una lista de control de acceso (ACL) mediante AWS CLI
**Para modificar una ACL agregando usuarios nuevos o eliminando miembros actuales mediante la CLI**
+ Utilice el comando [update-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/update-acl.html) para modificar una ACL.
Para Linux, macOS o Unix:
```
aws memorydb update-acl --acl-name new-acl-1 \
--user-names-to-add user-name-3 \
--user-names-to-remove user-name-2
```
Para Windows:
```
aws memorydb update-acl --acl-name new-acl-1 ^
--user-names-to-add user-name-3 ^
--user-names-to-remove user-name-2
```
**nota**
Cualquier conexión abierta que pertenezca a un usuario eliminado de una ACL finalizará con este comando.
#### Información de las listas de control de acceso (ACL) (consola)
**Para ver los detalles de la ACL en la consola**
1. Inicie sesión en la consola de MemoryDB Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Listas de control de acceso (ACL)**.
1. Elija la ACL en el **nombre de la ACL** o utilice el cuadro de búsqueda para buscar la ACL.
1. En **Usuarios**, puede revisar la lista de usuarios asociados a la ACL.
1. En **Clústeres asociados**, puede revisar el clúster al que pertenece la ACL.
1. En **Etiquetas**, puede revisar cualquier etiqueta asociada a la ACL.
#### Visualización de las listas de control de acceso (ACL) mediante AWS CLI
Utilice el comando [describe-acls](https://docs.aws.amazon.com/cli/latest/reference/memorydb/describe-acls.html) para ver los detalles de una ACL.
```
aws memorydb describe-acls \
--acl-name test-group
```
#### Eliminación de una lista de control de acceso (ACL) (consola)
**Para eliminar las listas de control de acceso mediante la consola**
1. Inicie sesión en la consola de MemoryDB Consola de administración de AWS y ábrala en. [https://console.aws.amazon.com/memorydb/](https://console.aws.amazon.com/memorydb/)
1. En el panel de navegación izquierdo, elija **Listas de control de acceso (ACL)**.
1. Elija la ACL que desee modificar y, a continuación, elija **Eliminar**
1. En la página de **eliminación**, ingrese `delete` en el cuadro de confirmación y elija **Eliminar** o **Cancelar** para evitar que se elimine la ACL.
Se elimina la ACL en sí, no los usuarios que pertenecen al grupo.
#### Eliminar una lista de control de acceso (ACL) mediante el AWS CLI
**Para eliminar una ACL mediante la CLI**
+ Ejecute el comando [delete-acl](https://docs.aws.amazon.com/cli/latest/reference/memorydb/delete-acl.html) para eliminar una ACL.
Para Linux, macOS o Unix:
```
aws memorydb delete-acl /
--acl-name
```
Para Windows:
```
aws memorydb delete-acl ^
--acl-name
```
Los ejemplos anteriores devuelven la siguiente respuesta.
```
aws memorydb delete-acl --acl-name "new-acl-1"
{
"ACLName": "new-acl-1",
"Status": "deleting",
"EngineVersion": "6.2",
"UserNames": [
"user-name-1",
"user-name-3"
],
"clusters": [],
"ARN":"arn:aws:memorydb:us-east-1:493071037918:acl/new-acl-1"
}
```
### Asignación de listas de control de acceso a clústeres
Tras crear una ACL y añadir usuarios, el último paso de la implementación ACLs consiste en asignar la ACL a un clúster.
#### Asignación de listas de control de acceso a los clústeres mediante la consola
Para agregar una ACL a un clúster mediante el Consola de administración de AWS, consulte[Creación de un clúster de MemoryDB](getting-started.md#clusters.create).
#### Asignación de listas de control de acceso a clústeres mediante AWS CLI
La siguiente AWS CLI operación crea un clúster con el cifrado en tránsito (TLS) activado y el **acl-name** parámetro con el valor. `my-acl-name` Reemplace el grupo de subredes `subnet-group` por otro existente.
**Parámetros clave**
+ **--engine-version**: debe ser 6.2.
+ **--tls-enabled**: se utiliza para la autenticación y para asociar una ACL.
+ **--acl-name**: este valor proporciona listas de control de acceso compuestas por usuarios con permisos de acceso especificados para el clúster.
Para Linux, macOS o Unix:
```
aws memorydb create-cluster \
--cluster-name "new-cluster" \
--description "new-cluster" \
--engine-version "6.2" \
--node-type db.r6g.large \
--tls-enabled \
--acl-name "new-acl-1" \
--subnet-group-name "subnet-group"
```
Para Windows:
```
aws memorydb create-cluster ^
--cluster-name "new-cluster" ^
--cluster-description "new-cluster" ^
--engine-version "6.2" ^
--node-type db.r6g.large ^
--tls-enabled ^
--acl-name "new-acl-1" ^
--subnet-group-name "subnet-group"
```
La siguiente AWS CLI operación modifica un clúster con el cifrado en tránsito (TLS) habilitado y el **acl-name** parámetro con el valor. `new-acl-2`
Para Linux, macOS o Unix:
```
aws memorydb update-cluster \
--cluster-name cluster-1 \
--acl-name "new-acl-2"
```
Para Windows:
```
aws memorydb update-cluster ^
--cluster-name cluster-1 ^
--acl-name "new-acl-2"
```
# 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 a MemoryDB mediante identidades de AWS IAM cuando su clúster esté configurado 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. Con la autenticación de IAM puede configurar un control de acceso detallado para cada clúster de MemoryDB y usuario de MemoryDB y seguir los principios de permisos de privilegio mínimo. La autenticación de IAM para MemoryDB funciona proporcionando un token de autenticación de IAM de corta duración en lugar de una contraseña de usuario de MemoryDB de larga duración en el comando `AUTH` o `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 de Signature](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 de los proveedores de identidades federados directamente a los clústeres de MemoryDB.
Para usar AWS IAM con MemoryDB, primero debe crear un usuario de MemoryDB con el modo de autenticación establecido en IAM y, a continuación, puede crear o reutilizar una identidad de IAM. La identidad de IAM necesita una política asociada para conceder la acción `memorydb:Connect` al clúster de MemoryDB y al usuario de MemoryDB. Una vez configurado, puede crear un token de autenticación de IAM con las credenciales del usuario o rol de IAM. AWS Por último, debe proporcionar el token de autenticación de IAM de corta duración como contraseña en el cliente de Valkey o de Redis OSS cuando se conecte al nodo del clúster de MemoryDB. Un cliente compatible con el proveedor de credenciales puede generar automáticamente las credenciales temporales para cada nueva conexión. MemoryDB realizará la autenticación de IAM para las solicitudes de conexión de los usuarios de MemoryDB 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 Valkey o la versión 7.0 o superior del motor de Redis OSS.
+ El token de autenticación de IAM es válido durante 15 minutos. Para conexiones de larga duración, recomendamos utilizar un cliente de Redis OSS que admita una interfaz de proveedor de credenciales.
+ Una conexión autenticada de IAM a MemoryDB 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 no admite todas las claves de contexto de condición global. 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 un clúster
```
aws memorydb create-cluster \
--cluster-name cluster-01 \
--description "MemoryDB IAM auth application"
--node-type db.r6g.large \
--engine-version 7.0 \
--acl-name open-access
```
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" : [
"memorydb:connect"
],
"Resource" : [
"arn:aws:memorydb:us-east-1:123456789012:cluster/cluster-01",
"arn:aws:memorydb:us-east-1:123456789012:user/iam-user-01"
]
}
]
}
```
------
1. Crear un rol de IAM.
```
aws iam create-role \
--role-name "memorydb-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 "memorydb-allow-all" \
--policy-document file://policy.json
```
1. Adjunte la política de IAM al rol.
```
aws iam attach-role-policy \
--role-name "memorydb-iam-auth-app" \
--policy-arn "arn:aws:iam::123456789012:policy/memorydb-allow-all"
```
1. Cree un nuevo usuario habilitado para IAM.
```
aws memorydb create-user \
--user-name iam-user-01 \
--authentication-mode Type=iam \
--access-string "on ~* +@all"
```
1. Cree una ACL y asocie al usuario.
```
aws memorydb create-acl \
--acl-name iam-acl-01 \
--user-names iam-user-01
aws memorydb update-cluster \
--cluster-name cluster-01 \
--acl-name iam-acl-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). Después de eso, debe proporcionar el token de autenticación de IAM como contraseña al conectarse a un clúster de MemoryDB, como se muestra en el ejemplo siguiente.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(userName, iamAuthToken)
.build();
// Create a new Lettuce client
RedisClusterClient client = RedisClusterClient.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 ACTION_NAME = "connect";
private static final String SERVICE_NAME = "memorydb";
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final String userName;
private final String clusterName;
private final String region;
public IAMAuthTokenRequest(String userName, String clusterName, String region) {
this.userName = userName;
this.clusterName = clusterName;
this.region = region;
}
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(userName));
return request;
}
private URI getRequestUri() {
return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, clusterName));
}
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 MemoryDB mediante el proveedor de credenciales de autenticación de IAM.
```
String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
// Create a credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
userName, iamAuthTokenRequest, awsCredentialsProvider);
// Construct URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
.withHost(host)
.withPort(port)
.withSsl(ssl)
.withAuthentication(redisCredentialsProvider)
.build();
// Create a new Lettuce cluster client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();
```
A continuación, se muestra un ejemplo de un cliente de clúster de Lettuce que incluye IAMAuth TokenRequest un proveedor de credenciales para generar automáticamente credenciales temporales cuando sea necesario.
```
public class RedisIAMAuthCredentialsProvider implements RedisCredentialsProvider {
private static final long TOKEN_EXPIRY_SECONDS = 900;
private final AWSCredentialsProvider awsCredentialsProvider;
private final String userName;
private final IAMAuthTokenRequest iamAuthTokenRequest;
private final Supplier iamAuthTokenSupplier;
public RedisIAMAuthCredentialsProvider(String userName,
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(userName, iamAuthTokenSupplier.get()));
}
private String getIamAuthToken() {
return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
}
```