IAM을 통한 인증 - 아마존 ElastiCache (레디 스OSS)
개요제한 사항설치Connecting

기계 번역으로 제공되는 번역입니다. 제공된 번역과 원본 영어의 내용이 상충하는 경우에는 영어 버전이 우선합니다.

IAM을 통한 인증

개요

IAM 인증을 사용하면 캐시가 Redis OSS 버전 7 이상을 사용하도록 구성된 경우 AWS IAM ID를 사용하여 ElastiCache (Redis OSS) 에 대한 연결을 인증할 수 있습니다. 그러면 보안 모델이 강화되고 여러 보안 관리 작업이 단순화됩니다. 또한 IAM 인증을 사용하여 최소 권한 원칙에 따라 각 개별 캐시 및 사용자에 대한 세분화된 액세스 제어를 구성할 수 있습니다. ElastiCache ElastiCache IAM 인증 ElastiCache (Redis OSS) 은 Redis OSS 또는 명령에 수명이 긴 사용자 암호 대신 수명이 짧은 IAM 인증 토큰을 제공하여 작동합니다. ElastiCache AUTH HELLO IAM 인증 토큰에 대한 자세한 내용은 일반 참조 안내서의 서명 버전 4 서명 프로세스와 아래 코드 예제를 참조하십시오. AWS

IAM ID 및 관련 정책을 사용하여 Redis OSS 액세스를 추가로 제한할 수 있습니다. 또한 페더레이션된 ID 공급자의 사용자에게 Redis OSS 캐시에 대한 액세스 권한을 직접 부여할 수 있습니다.

ElastiCache (Redis OSS) 와 함께 AWS IAM을 사용하려면 먼저 인증 모드를 IAM으로 설정한 상태에서 ElastiCache 사용자를 생성해야 합니다. 그러면 IAM ID를 생성하거나 재사용할 수 있습니다. IAM ID에는 ElastiCache 캐시와 사용자에게 elasticache:Connect 작업을 허용하기 위한 관련 정책이 필요합니다. ElastiCache 구성한 후에는 IAM 사용자 또는 역할의 AWS 자격 증명을 사용하여 IAM 인증 토큰을 생성할 수 있습니다. 마지막으로 Redis OSS 캐시에 연결할 때 Redis OSS 클라이언트에서 수명이 짧은 IAM 인증 토큰을 암호로 제공해야 합니다. 자격 증명 공급자를 지원하는 Redis OSS 클라이언트는 새 연결마다 임시 자격 증명을 자동으로 생성할 수 있습니다. ElastiCache (Redis OSS) 는 IAM 사용 가능 ElastiCache 사용자의 연결 요청에 대해 IAM 인증을 수행하고 IAM으로 연결 요청을 검증합니다.

제한 사항

IAM 데이터베이스 인증을 사용할 때 다음 제한이 적용됩니다.

  • IAM 인증은 ElastiCache (Redis OSS) 버전 7.0 이상을 사용할 때 사용할 수 있습니다.

  • IAM 지원 ElastiCache 사용자의 경우 사용자 이름과 사용자 ID 속성이 동일해야 합니다.

  • IAM 인증 토큰은 15분간 유효합니다. 연결 수명이 긴 경우 자격 증명 공급자 인터페이스를 지원하는 Redis OSS 클라이언트를 사용하는 것이 좋습니다.

  • ElastiCache (Redis OSS) 에 대한 IAM 인증 연결은 12시간 후에 자동으로 연결이 끊어집니다. AUTH 또는 HELLO 명령과 새 IAM 인증 토큰을 전송하여 연결을 12시간 연장할 수 있습니다.

  • IAM 인증은 MULTI EXEC 명령에서 지원되지 않습니다.

  • 현재 IAM 인증은 다음의 전역 조건 컨텍스트 키를 지원합니다.

    • 서버리스 캐시와 함께 IAM 인증을 사용하는 경우 aws:VpcSourceIp, aws:SourceVpc, aws:SourceVpce, aws:CurrentTime, aws:EpochTime 및 aws:ResourceTag/%s(관련 서버리스 캐시 및 사용자 기준)가 지원됩니다.

    • 복제 그룹과 함께 IAM 인증을 사용하는 경우 aws:SourceIp, aws:ResourceTag/%s(관련 복제 그룹 및 사용자 기준)가 지원됩니다.

    전역 조건 컨텍스트 키에 대한 자세한 내용은 IAM 사용 설명서의 AWS 전역 조건 컨텍스트 키를 참조하세요.

설치

IAM 인증을 설정하려면:

  1. 캐시 생성

    aws elasticache create-serverless-cache \
  --serverless-cache-name cache-01  \
  --description "ElastiCache IAM auth application" \
  --engine redis

  2. 아래에서와 같이, 역할에 IAM 신뢰 정책 문서를 생성하여 계정이 새 역할을 수임할 수 있도록 합니다. 정책을 trust-policy.json 파일에 저장합니다.

    {
    "Version": "2012-10-17",
    "Statement": {
        "Effect": "Allow",
        "Principal": { "AWS": "arn:aws:iam::123456789012:root" },
        "Action": "sts:AssumeRole"
    }
}

  3. 아래에서와 같이, IAM 정책 문서를 생성합니다. 정책을 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. 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가 활성화된 사용자를 새로 생성합니다.

    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

Connecting

토큰을 암호로 연결

먼저 AWS SigV4 사전 서명된 요청을 사용하여 단수명 IAM 인증 토큰을 생성해야 합니다. 그런 다음 아래 예와 같이 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 = 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();

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

보안 인증 정보 공급자와 연결

아래 코드는 IAM 인증 자격 증명 공급자를 사용하여 ElastiCache (Redis OSS) 로 인증하는 방법을 보여줍니다.

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

다음은 AuthTokenRequest IAM을 자격 증명 공급자로 래핑하여 필요할 때 임시 자격 증명을 자동 생성하는 Lettuce Redis OSS 클라이언트의 예입니다.

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