Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Authentification avec IAM

Présentation

Avec IAM Authentication, vous pouvez authentifier une connexion à MemoryDB à l'aide d' AWS IAMidentités, lorsque votre cluster est configuré pour utiliser Valkey ou Redis version 7 ou supérieureOSS. Cela vous permet de renforcer votre modèle de sécurité et de simplifier de nombreuses tâches administratives de sécurité. Avec IAM Authentication, vous pouvez configurer un contrôle d'accès précis pour chaque cluster MemoryDB individuel et chaque utilisateur de MemoryDB et suivre les principes d'autorisation du moindre privilège. IAML'authentification pour MemoryDB fonctionne en fournissant un jeton d'IAMauthentification de courte durée au lieu d'un mot de passe utilisateur MemoryDB de longue durée dans la commande or. AUTH HELLO Pour plus d'informations sur le jeton IAM d'authentification, reportez-vous au processus de signature de la version 4 de Signature dans le Guide de référence AWS général et à l'exemple de code ci-dessous.

Vous pouvez utiliser les IAM identités et leurs politiques associées pour restreindre davantage l'accès à Valkey ou RedisOSS. Vous pouvez également accorder l'accès aux utilisateurs depuis leurs fournisseurs d'identité fédérés directement aux clusters MemoryDB.

Pour utiliser AWS IAM MemoryDB, vous devez d'abord créer un utilisateur MemoryDB avec le mode d'authentification défini surIAM, puis vous pouvez créer ou réutiliser une identité. IAM L'IAMidentité a besoin d'une politique associée pour accorder l'memorydb:Connectaction au cluster MemoryDB et à l'utilisateur MemoryDB. Une fois configuré, vous pouvez créer un jeton IAM d'authentification à l'aide des AWS informations d'identification de l'IAMutilisateur ou du rôle. Enfin, vous devez fournir le jeton IAM d'authentification de courte durée sous forme de mot de passe dans votre OSS client Valkey ou Redis lorsque vous vous connectez à votre nœud de cluster MemoryDB. Un client prenant en charge le fournisseur d'informations d'identification peut générer automatiquement les informations d'identification temporaires pour chaque nouvelle connexion. MemoryDB effectuera IAM l'authentification pour les demandes de IAM connexion des utilisateurs de MemoryDB activés et validera les demandes de connexion avec. IAM

Limites

Lorsque vous utilisez IAM l'authentification, les limites suivantes s'appliquent :

Configuration

Pour configurer IAM l'authentification :

Connexion

Se connecter avec un jeton comme mot de passe

Vous devez d'abord générer le jeton IAM d'authentification de courte durée à l'aide d'une demande AWS SigV4 pré-signée. Ensuite, vous fournissez le jeton IAM d'authentification sous forme de mot de passe lors de la connexion à un cluster MemoryDB, comme indiqué dans l'exemple ci-dessous.

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();

Vous trouverez ci-dessous la définition 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());
    }
}

Se connecter avec un fournisseur d'informations d'identification

Le code ci-dessous montre comment s'authentifier auprès de MemoryDB à l'aide du fournisseur d'identifiants d'IAMauthentification.

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();

Vous trouverez ci-dessous un exemple de client de cluster Lettuce qui intègre un fournisseur d'informations d'identification pour générer automatiquement des informations d'identification temporaires IAMAuthTokenRequest en cas de besoin.

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());
    }