Autenticación con IAM

Información general

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 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 OSS o el comando de 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 en la Guía de referencia general y el ejemplo de código que aparece a continuación. AWS

Puede utilizar las identidades de IAM y sus políticas asociadas para restringir aún más el acceso a Redis OSS. También puede conceder acceso a los usuarios de los proveedores de identidades federados directamente a los clústeres de MemoryDB.

Para utilizar 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 su cliente OSS de Redis cuando se conecte al nodo de clúster de MemoryDB. Un cliente OSS de Redis con soporte para el proveedor de credenciales puede generar automáticamente las credenciales temporales automáticamente 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 la versión 7.0 o superior del motor OSS de Redis.

• El token de autenticación de IAM es válido durante 15 minutos. Para conexiones de larga duración, recomendamos utilizar un cliente OSS de Redis 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 en la Guía del usuario de IAM.

Configuración

Para configurar la autenticación de IAM:

1. Crear 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

2. 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.

   {
       "Version": "2012-10-17",
       "Statement": {
           "Effect": "Allow",
           "Principal": { "AWS": "arn:aws:iam::123456789012:root" },
           "Action": "sts:AssumeRole"
       }
   }

3. Cree un documento de política de IAM, como se muestra a continuación. Guarde la política en un archivo denominado policy.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"
         ]
       }
     ]
   }

4. Crear un rol de IAM.

   aws iam create-role \
     --role-name "memorydb-iam-auth-app" \
     --assume-role-policy-document file://trust-policy.json

5. Cree la política de IAM.

   aws iam create-policy \
     --policy-name "memorydb-allow-all" \
     --policy-document file://policy.json

6. 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"

7. Cree un nuevo usuario habilitado para IAM.

   aws memorydb create-user \
     --user-name iam-user-01 \
     --authentication-mode Type=iam \
     --access-string "on ~* +@all"

8. 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. 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 Redis OSS URL with IAM Auth credentials provider
RedisURI redisURI = RedisURI.builder()
    .withHost(host)
    .withPort(port)
    .withSsl(ssl)
    .withAuthentication(userName, iamAuthToken)
    .build();

// Create a new Lettuce Redis OSS 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<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(userName));
        return request;
    }

    private URI getRequestUri() {
        return URI.create(String.format("%s%s/", REQUEST_PROTOCOL, clusterName));
    }

    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

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 Redis OSS credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
    userName, 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 cluster client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();

A continuación, se muestra un ejemplo de un cliente de clúster OSS de Lettuce Redis que incluye el IAM AuthTokenRequest en un proveedor de credenciales para generar automáticamente credenciales temporales cuando es 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<String> 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<RedisCredentials> resolveCredentials() {
        return Mono.just(RedisCredentials.just(userName, iamAuthTokenSupplier.get()));
    }

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