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 di

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

Puoi utilizzare le identità IAM e le politiche associate per limitare ulteriormente l'accesso a Valkey o Redis OSS. Puoi anche concedere l'accesso agli utenti dai 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 puoi creare o riutilizzare un'identità IAM. L'identità IAM richiede una policy associata per concedere l'elasticache:Connectazione alla ElastiCache cache e ElastiCache all'utente. Una volta configurato, puoi creare un token di autenticazione IAM utilizzando le AWS credenziali dell'utente o del ruolo IAM. Infine, devi fornire il token di autenticazione IAM di breve durata come password nel tuo Valkey o Redis OSS Client quando ti connetti alla tua cache. Un client Valkey o Redis OSS con supporto per il fornitore di credenziali può generare automaticamente le credenziali temporanee automaticamente per ogni nuova connessione. ElastiCache eseguirà l'autenticazione IAM per le richieste di connessione degli IAM-enabled ElastiCache utenti e convaliderà le richieste di connessione con IAM.

Limitazioni

Durante l'utilizzo dell'autenticazione IAM, valgono le seguenti limitazioni:

Configurazione

Per impostare l'autenticazione IAM:

Connessione

Connetti con token come password

È innanzitutto necessario generare il token di autenticazione IAM di breve durata utilizzando una richiesta prefirmata AWS SigV4. Dopodiché fornisci il token di autenticazione IAM come password quando ti connetti a una cache OSS 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 = DefaultCredentialsProvider.create();

// 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.resolveCredentials());

// 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 SdkHttpMethod REQUEST_METHOD = SdkHttpMethod.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 Duration TOKEN_EXPIRY_DURATION = Duration.ofSeconds(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) {
        SdkHttpFullRequest request = getSignableRequest();
        SdkHttpFullRequest signedRequest = sign(request, credentials);
        return signedRequest.getUri().toString().replace(REQUEST_PROTOCOL, "");
    }

    private SdkHttpFullRequest getSignableRequest() {
        SdkHttpFullRequest.Builder builder = SdkHttpFullRequest.builder()
            .method(REQUEST_METHOD)
            .uri(getRequestUri())
            .appendRawQueryParameter(PARAM_ACTION, ACTION_NAME)
            .appendRawQueryParameter(PARAM_USER, userId);
        if (isServerless) {
            builder.appendRawQueryParameter(PARAM_RESOURCE_TYPE, RESOURCE_TYPE_SERVERLESS_CACHE);
        }
        return builder.build();
    }

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

    private SdkHttpFullRequest sign(SdkHttpFullRequest request, AwsCredentials credentials) {
        AwsV4HttpSigner signer = AwsV4HttpSigner.create();
        SignedRequest signedRequest = signer.sign(r -> r.identity(credentials)
            .request(request)
            .putProperty(AwsV4HttpSigner.SERVICE_SIGNING_NAME, SERVICE_NAME)
            .putProperty(AwsV4HttpSigner.REGION_NAME, region)
            .putProperty(AwsV4HttpSigner.AUTH_LOCATION, AwsV4HttpSigner.AuthLocation.QUERY_STRING)
            .putProperty(AwsV4HttpSigner.EXPIRATION_DURATION, TOKEN_EXPIRY_DURATION)
            .build()
        );
        return (SdkHttpFullRequest) signedRequest.request();
    }
}

Connetti con provider di credenziali

Il codice seguente mostra come autenticarsi ElastiCache utilizzando il provider di credenziali di autenticazione 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 = DefaultCredentialsProvider.create();

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

Di seguito è riportato un esempio di client Lettuce Redis OSS che integra un provider di credenziali per generare automaticamente le IAMAuthTokenRequest 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.userId = userId;
        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.resolveCredentials());
    }
}