Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Autentikasi dengan IAM

Gambaran Umum

Dengan IAM Otentikasi Anda dapat mengautentikasi koneksi ElastiCache dengan Valkey atau Redis OSS menggunakan AWS IAM identitas, ketika cache Anda dikonfigurasi untuk menggunakan Valkey atau Redis versi 7 atau lebih tinggi. OSS Hal ini memungkinkan Anda memperkuat model keamanan Anda dan menyederhanakan banyak tugas keamanan administratif. Anda juga dapat menggunakan IAM Autentikasi untuk mengonfigurasi kontrol akses berbutir halus untuk setiap ElastiCache cache dan ElastiCache pengguna individual, mengikuti prinsip izin hak istimewa paling sedikit. IAMOtentikasi untuk ElastiCache dengan Valkey atau Redis OSS berfungsi dengan menyediakan token IAM otentikasi berumur pendek alih-alih kata sandi ElastiCache pengguna yang berumur panjang di Valkey atau Redis atau perintah. OSS AUTH HELLO Untuk informasi selengkapnya tentang token IAM otentikasi, lihat proses penandatanganan Signature Version 4 di Panduan Referensi AWS Umum dan contoh kode di bawah ini.

Anda dapat menggunakan IAM identitas dan kebijakan terkait untuk lebih membatasi akses Valkey atau Redis. OSS Anda juga dapat memberikan akses ke pengguna dari penyedia Identitas federasi mereka langsung ke cache Valkey atau OSS Redis.

Untuk menggunakannya AWS IAM ElastiCache, Anda harus terlebih dahulu membuat ElastiCache pengguna dengan mode otentikasi diatur keIAM. Kemudian Anda dapat membuat atau menggunakan kembali IAM identitas. IAMIdentitas memerlukan kebijakan terkait untuk memberikan elasticache:Connect tindakan ke ElastiCache cache dan ElastiCache pengguna. Setelah dikonfigurasi, Anda dapat membuat token IAM otentikasi menggunakan AWS kredensi IAM pengguna atau peran. Akhirnya Anda perlu memberikan token IAM otentikasi berumur pendek sebagai kata sandi di OSS Klien Valkey atau Redis Anda saat menghubungkan ke cache Anda. OSSKlien Valkey atau Redis dengan dukungan untuk penyedia kredensi dapat secara otomatis menghasilkan kredensi sementara secara otomatis untuk setiap koneksi baru. ElastiCache akan melakukan IAM otentikasi untuk permintaan koneksi dari ElastiCache pengguna IAM yang diaktifkan dan akan memvalidasi permintaan koneksi dengan. IAM

Batasan

Saat menggunakan IAM otentikasi, batasan berikut berlaku:

Pengaturan

Untuk mengatur IAM otentikasi:

Terhubung

Terhubung dengan token sebagai kata sandi

Pertama-tama Anda harus membuat token IAM otentikasi berumur pendek menggunakan permintaan yang telah ditandatangani sebelumnya AWS SiGv4. Setelah itu Anda memberikan token IAM otentikasi sebagai kata sandi saat menghubungkan ke OSS cache Valkey atau Redis, seperti yang ditunjukkan pada contoh di bawah ini.

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 bawah ini adalah definisi untuk 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());
    }
}

Terhubung dengan penyedia kredensial

Kode di bawah ini menunjukkan cara mengautentikasi dengan ElastiCache menggunakan penyedia kredensi IAM otentikasi.

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 bawah ini adalah contoh OSS klien Lettuce Redis yang membungkus penyedia kredensi IAMAuthTokenRequest dalam untuk menghasilkan kredensi sementara secara otomatis saat diperlukan.

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