View a markdown version of this page

使用 IAM 进行身份验证 ElastiCache - 亚马逊 ElastiCache
Amazon Web Services 文档中描述的 Amazon Web Services 服务或功能可能因区域而异。要查看适用于中国区域的差异,请参阅 中国的 Amazon Web Services 服务入门 (PDF)。

本文属于机器翻译版本。若本译文内容与英语原文存在差异,则一律以英文原文为准。

使用 IAM 进行身份验证 ElastiCache

概述

使用 IAM 身份验证,您可以对连接进行身份验证 ElastiCache 对于 Valkey 或 Redis OSS 使用 Amazon IAM 身份,前提是您的缓存配置为使用 Valkey 或 Redis OSS 版本 7 或更高版本。这使您可以增强安全模型并简化许多管理安全任务。您还可以使用 IAM 身份验证为每个人配置精细的访问控制 ElastiCache 缓存和 ElastiCache 用户,遵循最低权限原则。的 IAM 身份验证 ElastiCache 通过提供短期的 IAM 身份验证令牌而不是长期有效的 IAM 身份验证令牌来工作 ElastiCache Valkey 或 Redis OSS 中的用户密码 AUTH 要么 HELLO 命令。有关 IAM 身份验证令牌的更多信息,请参阅 签名版本 4 签名流程 在 Amazon 一般参考指南和下面的代码示例。

您可以使用 IAM 身份及其关联策略进一步限制 Valkey 或 Redis OSS 访问权限。您还可以直接从联合身份提供商向用户授予对 Valkey 或 Redis OSS 缓存的访问权限。

要使用 Amazon IAM 和 ElastiCache,你首先需要创建一个 ElastiCache 身份验证模式设置为 IAM 的用户。然后,您可以创建或重复使用 IAM 身份。IAM 身份需要关联的策略才能授予 elasticache:Connect 对... 采取行动 ElastiCache 缓存和 ElastiCache 用户。配置完成后,您可以使用创建 IAM 身份验证令牌 Amazon IAM 用户或角色的证书。最后,在连接到您的缓存时,您需要在 Valkey 或 Redis OSS 客户端中提供有效期较短的 IAM 身份验证令牌作为密码。支持凭证提供商的 Valkey 或 Redis OSS 客户端可以为每个新连接自动生成临时证书。 ElastiCache 将对的连接请求执行 IAM 身份验证 IAM-enabled ElastiCache 用户,并将验证与 IAM 的连接请求。

限制

使用 IAM 身份验证时,以下限制适用:

  • 使用时可用 IAM 身份验证 ElastiCache 适用于 Valkey 7.2 及更高版本或 Redis OSS 7.0 及更高版本。

  • IAM 身份验证需要在缓存上启用传输加密 (TLS)。有关更多信息,请参阅 ElastiCache 传输中加密 (TLS)。

  • 对于 IAM-enabled ElastiCache 用户的用户名和用户 ID 的属性必须相同。

  • IAM 身份验证令牌的有效期为 15 分钟。如果使用过期令牌对连接进行重新身份验证,则身份验证请求将被拒绝。对于长期连接,我们建议使用支持凭证提供者接口的 Valkey 或 Redis OSS 客户端,在到期前自动生成新令牌。

  • 经过 IAM 身份验证的连接到 ElastiCache for Valkey 或 Redis OSS 将在 12 小时后自动断开连接。通过使用新 IAM 身份验证令牌发送 AUTH 或 HELLO 命令,可以将连接延长 12 小时。

  • IAM 重新认证 (AUTH 要么 HELLO 内部不支持命令) MULTI/EXEC 或 Lua 脚本块。但是,你可以在里面运行常规的数据命令 MULTI/EXEC 积木上的 IAM-authenticated 连接。

  • 目前,IAM 身份验证支持以下全局条件上下文键:

    • 使用 IAM 身份验证和带有 VPC 终端节点的无服务器缓存时, aws:VpcSourceIp, aws:SourceVpc, aws:SourceVpce, aws:CurrentTime, aws:EpochTime,以及 aws:ResourceTag/%s 支持(来自关联的无服务器缓存和用户)。

    • 对复制组使用 IAM 身份验证时,支持 aws:SourceIp 和 aws:ResourceTag/%s(从关联的复制组和用户)。

    有关全局条件上下文键的更多信息,请参阅《IAM 用户指南》中的 Amazon 全局条件上下文键。

注意

缓存名称在缓存创建时转换为小写。确保身份验证代码以小写形式提供缓存名称,以避免身份验证错误。

设置

要设置 IAM 身份验证,请执行以下操作:

  1. 创建缓存

    aws elasticache create-serverless-cache \ --serverless-cache-name cache-01 \ --description "ElastiCache IAM auth application" \ --engine redis
  2. 为您的角色创建 IAM 信任政策文档,如下所示,允许您的账户承担新角色。将策略保存到名为 trust-policy.json 的文件中。

    JSON
    { "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789012:role/my-application-role" }, "Action": "sts:AssumeRole" } ] }
    注意

    替换 my-application-role 使用需要连接到您的缓存的 IAM 角色或用户。使用最低权限委托人而不是账户根来限制哪些身份可以代入此角色。

  3. 创建 IAM 策略文档,如下所示。将策略保存到名为 policy.json 的文件中。

    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. 创建 IAM 角色。

    aws iam create-role \ --role-name "elasticache-iam-auth-app" \ --assume-role-policy-document file://trust-policy.json
  5. 创建 IAM 策略。

    aws iam create-policy \ --policy-name "elasticache-allow-all" \ --policy-document file://policy.json
  6. 向角色附加 IAM 策略。

    aws iam attach-role-policy \ --role-name "elasticache-iam-auth-app" \ --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
  7. 创建一个新的 IAM-enabled 用户。

    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. 创建用户组并附加用户。

    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
注意

带有公有终端节点的缓存需要一个所有用户都使用 IAM 身份验证的用户组。 ElastiCache 提供默认用户 (default.iam-user) 和用户组 (default.iam-user-group) 你可以用它来开始。

连接

与 GLIDE 连接

GLIDE 2.2 及更高版本包括内置的 IAM 身份验证支持。你配置你的 Amazon 凭证,GLIDE 会自动处理令牌生成、缓存和刷新。有关安装说明,请参阅 GLIDE 文档 在 GLIDE 网站上。

Python

from glide import ( GlideClusterClient, GlideClusterClientConfiguration, NodeAddress, ServerCredentials, IamAuthConfig, ServiceType, ) config = GlideClusterClientConfiguration( addresses=[NodeAddress("my-cache-x2e9hv.serverless.use1.cache.amazonaws.com", 6379)], credentials=ServerCredentials( username="my-iam-user", iam_config=IamAuthConfig( cluster_name="my-cache", service=ServiceType.ELASTICACHE, region="us-east-1", ), ), use_tls=True, ) client = await GlideClusterClient.create(config) await client.set("key", "value") result = await client.get("key") print(result) # b"value"

Java

import glide.api.GlideClusterClient; import glide.api.models.configuration.IamAuthConfig; import glide.api.models.configuration.ServiceType; import glide.api.models.configuration.ServerCredentials; import glide.api.models.configuration.GlideClusterClientConfiguration; import glide.api.models.configuration.NodeAddress; import java.util.List; import java.util.Collections; List<NodeAddress> nodes = Collections.singletonList( NodeAddress.builder() .host("my-cache-x2e9hv.serverless.use1.cache.amazonaws.com") .port(6379) .build() ); IamAuthConfig iamConfig = IamAuthConfig.builder() .clusterName("my-cache") .service(ServiceType.ELASTICACHE) .region("us-east-1") .build(); GlideClusterClientConfiguration config = GlideClusterClientConfiguration.builder() .addresses(nodes) .credentials(ServerCredentials.builder() .username("my-iam-user") .iamConfig(iamConfig) .build()) .useTLS(true) .build(); GlideClusterClient client = GlideClusterClient.createClient(config).get(); client.set("key", "value").get(); String result = client.get("key").get(); System.out.println(result); // "value"

连接开发者工具包 ElastiCache

开发者工具包 ElastiCache (developer-toolkit-elasticache) 是一个独立的 Python 库和 CLI,用于生成 IAM 身份验证令牌。将其与 Python Valkey 或 Redis OSS 客户端库(例如 valkey-py)一起使用。

pip install developer-toolkit-elasticache

带有 valkey-py 的 Py

import valkey from valkey.credentials import CredentialProvider from developer_toolkit_elasticache import ElastiCacheIAMAuthTokenProvider class ElastiCacheCredentialProvider(CredentialProvider): def __init__(self, auth): self._auth = auth def get_credentials(self): return self._auth.user_id, self._auth.get_token() auth = ElastiCacheIAMAuthTokenProvider( serverless_cache_name="my-cache", user_id="my-iam-user", region="us-east-1", ) # For a node-based cluster, use replication_group_id instead: # auth = ElastiCacheIAMAuthTokenProvider( # replication_group_id="my-cluster", # user_id="my-iam-user", # region="us-east-1", # ) client = valkey.ValkeyCluster( host="my-cache-x2e9hv.serverless.use1.cache.amazonaws.com", port=6379, ssl=True, credential_provider=ElastiCacheCredentialProvider(auth), ) client.set("key", "value") result = client.get("key") print(result) # b"value"

开发者工具包不会自动刷新令牌。IAM 身份验证令牌的有效期为 15 分钟,因此您的应用程序必须在当前令牌到期之前生成新令牌。

带有开发者工具包的 CLI

要从命令行生成令牌,请执行以下操作:

developer-toolkit-elasticache generate_iam_auth_token \ --serverless-cache-name my-cache \ --user-id my-iam-user \ --region us-east-1

要连接 valkey-cli 或 redis-cli,请设置身份验证环境变量并进行连接:

export VALKEYCLI_AUTH=$(developer-toolkit-elasticache generate_iam_auth_token \ --serverless-cache-name my-cache \ --user-id my-iam-user \ --region us-east-1) valkey-cli -c -h my-cache-x2e9hv.serverless.use1.cache.amazonaws.com \ -p 6379 \ --tls \ --user my-iam-user

VALKEYCLI_AUTH 需要 valkey-cli 9.0 或更高版本。对于 redis-cli,请使用 REDISCLI_AUTH 而不是 VALKEYCLI_AUTH。

有关源代码和其他示例,请参阅 开发者工具包 ElastiCache 存储库在 GitHub。

使用令牌作为密码进行连接

您首先需要使用 Amazon SigV4 预签名请求生成有效期较短的 IAM 身份验证令牌。之后,您需要在连接到 Valkey 或 Redis OSS 缓存时提供 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 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();

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

使用凭证提供程序进行连接

以下代码显示了如何使用进行身份验证 ElastiCache 使用 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();

以下是封装了 Lettuce Redis OSS 客户端的示例 IAMAuthTokenRequest 在证书提供商中,在需要时自动生成临时证书。

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