Autenticación con IAM

Descripción general

Con la autenticación de IAM, puede autenticar una conexión a ElastiCache para Valkey o Redis OSS mediante identidades de AWS IAM cuando la caché esté configurada para usar la versión 7 o una posterior de Valkey o Redis OSS. Esto le permite reforzar el modelo de seguridad y simplificar muchas tareas de seguridad administrativa. También puede usar la autenticación de IAM a fin de configurar un control de acceso detallado para cada caché y usuario de ElastiCache, con base en los principios de permisos de privilegio mínimo. La autenticación de IAM para ElastiCache se realiza proporcionando un token de autenticación de IAM de corta duración, en lugar de una contraseña de usuario de ElastiCache de larga duración en el comando AUTH o HELLO de Valkey o Redis OSS. 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 en la guía de referencia general de AWS y el ejemplo de código que se muestra 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 usuario de ElastiCache con el modo de autenticación establecido 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 acción elasticache:Connect a la caché y el usuario de ElastiCache. Una vez configurado, puede crear un token de autenticación de IAM con las credenciales de AWS 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 de Valkey o Redis OSS compatible con 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 usuarios de ElastiCache 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:

Configuración

Para configurar la autenticación de IAM:

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. 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<Void> request = getSignableRequest();
        sign(request, credentials);
        return new URIBuilder(request.getEndpoint())
            .addParameters(toNamedValuePair(request.getParameters()))
            .build()
            .toString()
            .replace(REQUEST_PROTOCOL, "");
    }

    private <T> Request<T> getSignableRequest() {
        Request<T> 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 <T> void sign(SignableRequest<T> 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<NameValuePair> toNamedValuePair(Map<String, List<String>> in) {
        return in.entrySet().stream()
            .map(e -> new BasicNameValuePair(e.getKey(), e.getValue().get(0)))
            .collect(Collectors.toList());
    }
}

Conectar con el proveedor de credenciales

En el siguiente código, se muestra cómo autenticarse con ElastiCache mediante el proveedor de 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();

Más abajo, vemos un ejemplo de un cliente de Lettuce Redis OSS que incluye IAMAuthTokenRequest en 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 userId;
    private final IAMAuthTokenRequest iamAuthTokenRequest;
    private final Supplier<String> 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<RedisCredentials> resolveCredentials() {
        return Mono.just(RedisCredentials.just(userId, iamAuthTokenSupplier.get()));
    }

    private String getIamAuthToken() {
        return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
    }
}