Authenticating with IAM - Amazon ElastiCache untuk Redis
Gambaran UmumKeterbatasan:PengaturanTerhubung

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

Authenticating with IAM

Gambaran Umum

Dengan IAM Authentication Anda dapat mengautentikasi sambungan ke ElastiCache untuk Redis menggunakan identitas AWS IAM, ketika klaster Anda dikonfigurasi untuk menggunakan Redis versi 7 atau di atas. Ini memungkinkan Anda untuk memperkuat model keamanan Anda dan menyederhanakan banyak tugas keamanan administratif. Dengan IAM Authentication Anda dapat mengonfigurasi kontrol akses berbutir halus untuk setiap grup ElastiCache replikasi individu dan ElastiCache pengguna dan mengikuti prinsip izin paling sedikit hak istimewa. Otentikasi IAM untuk ElastiCache Redis bekerja dengan menyediakan token otentikasi IAM berumur pendek, bukan kata sandi ElastiCache pengguna berumur panjang di Redis atau perintah. AUTH HELLO

Dengan IAM Authentication Anda dapat mengautentikasi sambungan ke ElastiCache untuk Redis menggunakan identitas AWS IAM, ketika klaster Anda dikonfigurasi untuk menggunakan Redis versi 7 atau di atas. Ini memungkinkan Anda untuk memperkuat model keamanan Anda dan menyederhanakan banyak tugas keamanan administratif. Dengan IAM Authentication Anda dapat mengonfigurasi kontrol akses berbutir halus untuk setiap grup ElastiCache replikasi individu dan ElastiCache pengguna dan mengikuti prinsip izin paling sedikit hak istimewa. Otentikasi IAM untuk ElastiCache Redis bekerja dengan menyediakan token otentikasi IAM berumur pendek, bukan kata sandi ElastiCache pengguna berumur panjang di Redis atau perintah. AUTH HELLO Untuk informasi lebih lanjut tentang token otentikasi 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 membatasi akses Redis lebih lanjut. Anda juga dapat memberikan akses ke pengguna dari penyedia Identitas federasi mereka langsung ke klaster Redis.

Untuk menggunakan AWS IAM dengan ElastiCache untuk Redis, Anda harus terlebih dahulu membuat ElastiCache pengguna dengan mode otentikasi diatur ke IAM, kemudian Anda dapat membuat atau menggunakan kembali identitas IAM. Identitas IAM membutuhkan kebijakan terkait untuk memberikan elasticache:Connect tindakan kepada grup ElastiCache replikasi dan ElastiCache pengguna. Setelah dikonfigurasi, Anda dapat membuat token otentikasi IAM menggunakan AWS kredensi pengguna atau peran IAM. Akhirnya Anda perlu memberikan token otentikasi IAM berumur pendek sebagai kata sandi di Klien Redis Anda saat menghubungkan ke simpul grup replikasi Redis Anda. Klien Redis dengan dukungan untuk penyedia kredenial dapat secara otomatis menghasilkan kredensi sementara secara otomatis untuk setiap koneksi baru. ElastiCacheuntuk Redis akan melakukan otentikasi IAM untuk permintaan koneksi ElastiCache pengguna berkemampuan IAM dan akan memvalidasi permintaan koneksi dengan IAM.

Keterbatasan:

Saat menggunakan otentikasi, batasan berikut berlaku pada:

  • Autentikasi IAM ElastiCache

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

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

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

  • Otentikasi IAM tidak didukung dalam MULTI EXEC perintah.

  • Saat ini, autentikasi global tidak mendukung kunci konteks syarat global. Untuk informasi lebih lanjut tentang kunci konteks syarat AWSglobal, lihat Kunci konteks syarat global dalam Panduan Pengguna IAM.

Pengaturan

Untuk mengatur otentikasi IAM:

  1. Buat klaster

    aws elasticache create-replication-group \
  --replication-group-id replication-group-01  \
  --replication-group-description "ElastiCache IAM auth application" \
  --engine redis \
  --engine-version 7.0 \
  --cache-node-type cache.m5.large \
  --transit-encryption-enabled \
  --cache-subnet-group insert cache security group

  2. Buat dokumen kebijakan kepercayaan IAM, seperti yang ditunjukkan di bawah ini, untuk peran Anda yang memungkinkan akun Anda untuk 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:replicationgroup:replication-group-01",
        "arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01"
      ]
    }
  ]
}

  4. Buatlah IAM role.

    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 pada 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.

    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-replication-group \
  --replication-group-id replication-group-01  \
  --user-group-ids-to-add iam-user-group-01

Terhubung

Connect dengan token sebagai kata sandi

Anda harus terlebih dahulu membuat token otentikasi IAM berumur pendek menggunakan permintaan AWSSigv4 yang telah ditandatangani sebelumnya. Setelah itu Anda memberikan token otentikasi IAM sebagai kata sandi saat menghubungkan ke cluster Redis, seperti yang ditunjukkan pada contoh di bawah ini. 

String userId = "insert user id"
String replicationGroupId = "insert replication group id"
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, replicationGroupId, region);
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 untukIAMAuthTokenRequest.

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 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 replicationGroupId;
    private final String region;

    public IAMAuthTokenRequest(String userId, String replicationGroupId, String region) {
        this.userId = userId;
        this.replicationGroupId = replicationGroupId;
        this.region = region;
    }

    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));
        return request;
    }

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

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

Connect dengan penyedia kredensi

Kode di bawah ini menunjukkan cara mengotentikasi dengan ElastiCache for Redis menggunakan penyedia kredensi otentikasi IAM.

String userId = "insert user id"
String replicationGroupId = "insert replication group id"
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, replicationGroupId, region);

// 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 IAM AuthTokenRequest di penyedia kredensi untuk menghasilkan kredensi sementara secara otomatis bila 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());
    }
}