Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Autenticazione con IAM

Panoramica

Con IAM Authentication è possibile autenticare una connessione ElastiCache con Valkey o Redis OSS utilizzando AWS IAM identità, quando la cache è configurata per utilizzare Valkey o Redis versione 7 o successiva. OSS Ciò consente di consolidare il modello di sicurezza e semplificare molte attività di sicurezza amministrative. Puoi anche utilizzare l'IAMautenticazione per configurare un controllo granulare degli accessi per ogni singolo ElastiCache utente e cache, seguendo i principi delle autorizzazioni con privilegi minimi. ElastiCache IAML'autenticazione ElastiCache con Valkey o Redis OSS funziona fornendo un token di IAM autenticazione di breve durata anziché una password utente di lunga durata nel comando Valkey o Redis or. ElastiCache OSS AUTH HELLO Per ulteriori informazioni sul token di IAM autenticazione, consulta il processo di firma di Signature Version 4 nella Guida di riferimento AWS generale e l'esempio di codice riportato di seguito.

È possibile utilizzare IAM le identità e le politiche associate per limitare ulteriormente l'accesso a Valkey o RedisOSS. Puoi anche concedere l'accesso agli utenti dei loro provider di identità federati direttamente alle cache Valkey o Redis. OSS

Per utilizzare AWS IAM con ElastiCache, devi prima creare un ElastiCache utente con la modalità di autenticazione impostata su. IAM È quindi possibile creare o riutilizzare un'IAMidentità. L'IAMidentità necessita di una policy associata per concedere l'elasticache:Connectazione alla ElastiCache cache e ElastiCache all'utente. Una volta configurato, è possibile creare un token di IAM autenticazione utilizzando AWS le credenziali dell'IAMutente o del ruolo. Infine, è necessario fornire il token di IAM autenticazione di breve durata come password nel OSS client Valkey o Redis durante la connessione alla cache. Un OSS client Valkey o Redis con supporto per il provider di credenziali può generare automaticamente le credenziali temporanee per ogni nuova connessione. ElastiCache eseguirà IAM l'autenticazione per le richieste di connessione degli ElastiCache utenti IAM abilitati e convaliderà le richieste di connessione con. IAM

Limitazioni

Quando si utilizza IAM l'autenticazione, si applicano le seguenti limitazioni:

Installazione

Per configurare IAM l'autenticazione:

Connessione

Connetti con token come password

È innanzitutto necessario generare il token di IAM autenticazione di breve durata utilizzando una richiesta AWS SigV4 prefirmata. Dopodiché fornisci il token di IAM autenticazione come password quando ti connetti a una OSS cache Valkey o Redis, come mostrato nell'esempio seguente.

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

Di seguito è riportata la definizione per 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());
    }
}

Connetti con provider di credenziali

Il codice seguente mostra come eseguire l'autenticazione ElastiCache utilizzando il provider di credenziali di IAM autenticazione.

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

Di seguito è riportato un esempio di OSS client Lettuce Redis che inserisce un provider di credenziali per IAMAuthTokenRequest generare automaticamente credenziali temporanee quando necessario.

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