Autentikasi dengan IAM - Amazon ElastiCache untuk Redis

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 Autentikasi IAM, Anda dapat mengautentikasi koneksi ke ElastiCache for Redis menggunakan identitas IAM AWS, ketika cache Anda dikonfigurasi untuk menggunakan Redis versi 7 atau yang lebih baru. Hal ini memungkinkan Anda memperkuat model keamanan Anda dan menyederhanakan banyak tugas keamanan administratif. Anda juga dapat menggunakan Autentikasi IAM untuk mengonfigurasi kontrol akses ketat untuk setiap cache ElastiCache dan pengguna ElastiCache, dengan mengikuti prinsip izin hak akses paling rendah. Autentikasi IAM untuk ElastiCache for Redis bekerja dengan menyediakan token autentikasi IAM berumur pendek alih-alih kata sandi pengguna ElastiCache berumur panjang di AUTH Redis atau perintah HELLO. Untuk informasi selengkapnya tentang token autentikasi IAM, lihat proses penandatanganan Signature Version 4 di Panduan Referensi AWS Umum dan contoh kode di bawah ini.

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

Untuk menggunakan AWS IAM dengan ElastiCache for Redis, Anda harus terlebih dahulu membuat pengguna ElastiCache dengan mode autentikasi diatur ke IAM, kemudian Anda dapat membuat atau menggunakan kembali identitas IAM. Identitas IAM memerlukan kebijakan terkait untuk memberikan tindakan elasticache:Connect ke cache ElastiCache dan pengguna ElastiCache. Setelah dikonfigurasi, Anda dapat membuat token autentiksai IAM menggunakan kredensial AWS peran atau pengguna IAM. Terakhir, Anda perlu memberikan token otentikasi IAM berumur pendek sebagai kata sandi di Klien Redis Anda saat menghubungkan ke cache Redis Anda. Klien Redis dengan dukungan untuk penyedia kredensi dapat secara otomatis menghasilkan kredensi sementara secara otomatis untuk setiap koneksi baru. ElastiCache for Redis akan melakukan autentikasi IAM untuk permintaan koneksi pengguna ElastiCache yang mendukung IAM dan akan memvalidasi permintaan koneksi dengan IAM.

Batasan

Saat menggunakan autentikasi IAM, batasan berikut berlaku:

  • Autentikasi IAM tersedia saat menggunakan ElastiCache for Redis versi 7.0 atau yang lebih baru.

  • Untuk pengguna ElastiCache yang mendukung IAM, properti nama pengguna dan id pengguna harus identik.

  • Token autentikasi IAM berlaku selama 15 menit. Untuk koneksi yang berumur panjang, sebaiknya gunakan klien Redis yang mendukung antarmuka penyedia kredensial.

  • Koneksi yang diautentikasi IAM ke ElastiCache for Redis akan secara otomatis terputus setelah 12 jam. Koneksi dapat diperpanjang selama 12 jam dengan mengirim perintah AUTH atau HELLO dengan token autentikasi IAM baru.

  • Autentikasi IAM tidak didukung dalam perintah MULTI EXEC.

  • Saat ini, autentikasi IAM mendukung kunci konteks kondisi global berikut ini:

    • Saat menggunakan autentikasi IAM dengan cache nirserver, aws:VpcSourceIp, aws:SourceVpc, aws:SourceVpce, aws:CurrentTime, aws:EpochTime, dan aws:ResourceTag/%s (dari cache dan pengguna tanpa server terkait) didukung.

    • Saat menggunakan autentikasi IAM dengan grup replikasi, aws:SourceIp dan aws:ResourceTag/%s (dari grup replikasi terkait dan pengguna) didukung.

    Untuk informasi lebih lanjut tentang kunci konteks kondisi global, lihat kunci konteks kondisi global AWS dalam Panduan Pengguna IAM.

Pengaturan

Untuk mengatur autentikasi IAM:

  1. Buat cache

    aws elasticache create-serverless-cache \ --serverless-cache-name cache-01 \ --description "ElastiCache IAM auth application" \ --engine redis
  2. Buat dokumen kebijakan kepercayaan IAM, seperti yang ditunjukkan di bawah ini, untuk peran Anda yang memungkinkan akun Anda mengambil peran baru. Simpan kebijakan ini ke file bernama trust-policy.json.

    { "Version": "2012-10-17", "Statement": { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789012:root" }, "Action": "sts:AssumeRole" } }
  3. Buat dokumen kebijakan IAM, seperti yang ditunjukkan di bawah ini. Simpan kebijakan ke file bernama policy.json.

    { "Version": "2012-10-17", "Statement": [ { "Effect" : "Allow", "Action" : [ "elasticache:Connect" ], "Resource" : [ "arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01", "arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01" ] } ] }
  4. Buat peran IAM.

    aws iam create-role \ --role-name "elasticache-iam-auth-app" \ --assume-role-policy-document file://trust-policy.json
  5. Buat kebijakan IAM.

    aws iam create-policy \ --policy-name "elasticache-allow-all" \ --policy-document file://policy.json
  6. Lampirkan kebijakan IAM di peran tersebut.

    aws iam attach-role-policy \ --role-name "elasticache-iam-auth-app" \ --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
  7. Buat pengguna baru yang mendukung IAM.

    aws elasticache create-user \ --user-name iam-user-01 \ --user-id iam-user-01 \ --authentication-mode Type=iam \ --engine redis \ --access-string "on ~* +@all"
  8. Buat grup pengguna dan lampirkan pengguna.

    aws elasticache create-user-group \ --user-group-id iam-user-group-01 \ --engine redis \ --user-ids default iam-user-01 aws elasticache modify-serverless-cache \ --serverless-cache-name cache-01 \ --user-group-id iam-user-group-01

Terhubung

Terhubung dengan token sebagai kata sandi

Pertama-tama, Anda harus membuat token autentikasi IAM berumur pendek menggunakan permintaan AWS SigV4 yang telah ditandatangani sebelumnya. Setelah itu, Anda memberikan token autentikasi IAM sebagai kata sandi saat menghubungkan ke cache 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. IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless); String iamAuthToken = iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials()); // Construct Redis 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 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 for Redis menggunakan penyedia kredensi autentikasi 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 = 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. IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userId, cacheName, region, isServerless); // Create a Redis credentials provider using IAM credentials. RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider( userId, iamAuthTokenRequest, awsCredentialsProvider); // Construct Redis URL with IAM Auth credentials provider RedisURI redisURI = RedisURI.builder() .withHost(host) .withPort(port) .withSsl(ssl) .withAuthentication(redisCredentialsProvider) .build(); // Create a new Lettuce Redis client RedisClient client = RedisClient.create(redisURI); client.connect();

Di bawah ini adalah contoh klien Lettuce Redis yang membungkus IAMAuthTokenRequest dalam penyedia kredensial untuk menghasilkan kredensial sementara secara otomatis jika 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()); } }