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 l'authentification, vous pouvez authentifier une connexion ElastiCache avec Valkey ou Redis à OSS l'aide d' AWS IAMidentités, lorsque votre cache 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é. Vous pouvez également utiliser l'IAMauthentification pour configurer un contrôle d'accès précis pour chaque ElastiCache cache et chaque ElastiCache utilisateur, conformément aux principes d'autorisation du moindre privilège. IAML'authentification ElastiCache avec Valkey ou Redis OSS fonctionne en fournissant un jeton d'IAMauthentification de courte durée au lieu d'un mot de passe ElastiCache utilisateur de longue durée dans la commande Valkey ou Redis or. OSS 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 caches Valkey ou RedisOSS.

Pour l'utiliser AWS IAM avec ElastiCache, vous devez d'abord créer un ElastiCache utilisateur dont le mode d'authentification est défini surIAM. Vous pouvez ensuite créer ou réutiliser une IAM identité. L'IAMidentité a besoin d'une politique associée pour accorder l'elasticache:Connectaction au ElastiCache cache et à ElastiCache l'utilisateur. 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 cache. Un OSS client Valkey ou Redis prenant en charge le fournisseur d'informations d'identification peut générer automatiquement les informations d'identification temporaires pour chaque nouvelle connexion. ElastiCache effectuera une IAM authentification pour les demandes de IAM connexion des ElastiCache utilisateurs autorisés et validera les demandes de connexion avecIAM.

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 comme mot de passe lorsque vous vous connectez à un OSS cache Valkey ou Redis, comme indiqué dans l'exemple ci-dessous.

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

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

Se connecter avec un fournisseur d'informations d'identification

Le code ci-dessous montre comment s'authentifier à ElastiCache l'aide du fournisseur IAM d'identifiants d'authentification.

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

Vous trouverez ci-dessous un exemple de OSS client Lettuce Redis 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 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());
    }
}