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.
# 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 IAM-enabled ElastiCache los usuarios y las validará 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.
+ La autenticación de IAM requiere que el cifrado en tránsito (TLS) esté habilitado en la memoria caché. Para obtener más información, consulte [ElastiCache cifrado en tránsito (TLS)](in-transit-encryption.md).
+ En el caso de IAM-enabled ElastiCache los usuarios, las propiedades del nombre de usuario y del 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 por IAM ElastiCache para 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.
+ La autenticación de IAM no se admite dentro de los bloques/. `MULTI` `EXEC`
+ 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.
**nota**
Los nombres de la caché se convierten a minúsculas en el momento de la creación de la caché. Asegúrese de que el código de autenticación proporcione el nombre de la caché en minúsculas para evitar errores de autenticación.
## 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 usuario nuevo. IAM-enabled
```
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 ElastiCache credenciales de autenticación de 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. IAMAuthTokenRequest
```
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());
}
}
```