Übersicht Einschränkungen Aufstellen Herstellen von Verbindungen

Authentifizieren mit IAM

Themen

Übersicht
Einschränkungen
Aufstellen
Herstellen von Verbindungen

Übersicht

Mit der IAM-Authentifizierung können Sie eine Verbindung zu ElastiCache (Redis OSS) mithilfe von AWS IAM-Identitäten authentifizieren, wenn Ihr Cache für die Verwendung von Redis OSS Version 7 oder höher konfiguriert ist. Auf diese Weise können Sie Ihr Sicherheitsmodell stärken und viele administrative Sicherheitsaufgaben vereinfachen. Sie können die IAM-Authentifizierung auch verwenden, um eine detaillierte Zugriffskontrolle für jeden einzelnen Cache und jeden einzelnen ElastiCache Benutzer zu konfigurieren, wobei die Prinzipien der geringsten Zugriffsrechte eingehalten werden. ElastiCache Die IAM-Authentifizierung für ElastiCache (Redis OSS) funktioniert durch die Bereitstellung eines kurzlebigen IAM-Authentifizierungstoken anstelle eines langlebigen Benutzerkennworts im Redis-OSS oder -Befehl. ElastiCache AUTH HELLO Weitere Informationen zum IAM-Authentifizierungstoken finden Sie im Signaturprozess für Signature Version 4 im AWS Allgemeinen Referenzhandbuch und im folgenden Codebeispiel.

Sie können IAM-Identitäten und die zugehörigen Richtlinien verwenden, um den Zugriff auf Redis OSS weiter einzuschränken. Sie können Benutzern von ihren Federated Identity-Anbietern auch direkten Zugriff auf Redis OSS-Caches gewähren.

Um AWS IAM mit ElastiCache (Redis OSS) zu verwenden, müssen Sie zunächst einen ElastiCache Benutzer erstellen, dessen Authentifizierungsmodus auf IAM eingestellt ist. Anschließend können Sie eine IAM-Identität erstellen oder wiederverwenden. Für die IAM-Identität ist eine zugehörige Richtlinie erforderlich, um dem ElastiCache Cache und ElastiCache dem elasticache:Connect Benutzer die Aktion zu gewähren. Nach der Konfiguration können Sie ein IAM-Authentifizierungstoken mit den AWS Anmeldeinformationen des IAM-Benutzers oder der IAM-Rolle erstellen. Schließlich müssen Sie das kurzlebige IAM-Authentifizierungstoken als Passwort in Ihrem Redis OSS-Client angeben, wenn Sie eine Verbindung zu Ihrem Redis OSS-Cache herstellen. Ein Redis OSS-Client mit Unterstützung für den Anbieter von Anmeldeinformationen kann die temporären Anmeldeinformationen für jede neue Verbindung automatisch generieren. ElastiCache (Redis OSS) führt die IAM-Authentifizierung für Verbindungsanfragen von IAM-fähigen ElastiCache Benutzern durch und validiert die Verbindungsanfragen mit IAM.

Einschränkungen

Bei der Verwendung der IAM-Authentifizierung gelten die folgenden Einschränkungen:

Die IAM-Authentifizierung ist verfügbar, wenn Sie ElastiCache (Redis OSS) Version 7.0 oder höher verwenden.
Für IAM-fähige ElastiCache Benutzer müssen die Eigenschaften Benutzername und Benutzer-ID identisch sein.
Das IAM-Authentifizierungstoken ist für 15 Minuten gültig. Für langlebige Verbindungen empfehlen wir die Verwendung eines Redis OSS-Clients, der eine Schnittstelle zum Anbieter von Anmeldeinformationen unterstützt.
Eine IAM-authentifizierte Verbindung zu ElastiCache (Redis OSS) wird nach 12 Stunden automatisch getrennt. Die Verbindung kann um 12 Stunden verlängert werden, indem ein AUTH- oder HELLO-Befehl mit einem neuen IAM-Authentifizierungstoken gesendet wird.
Die IAM-Authentifizierung wird in MULTI EXEC-Befehlen nicht unterstützt.
Derzeit unterstützt die IAM-Authentifizierung die folgenden globalen Bedingungskontextschlüssel:
- Bei Verwendung der IAM-Authentifizierung mit Serverless-Caches werden aws:VpcSourceIp, aws:SourceVpc, aws:SourceVpce, aws:CurrentTime, aws:EpochTime und aws:ResourceTag/%s (von zugehörigen Serverless-Caches und Benutzern) unterstützt.
- Bei Verwendung der IAM-Authentifizierung mit Replikationsgruppen werden aws:SourceIp und aws:ResourceTag/%s (von zugehörigen Replikationsgruppen und Benutzern) unterstützt.
Weitere Informationen über globale Bedingungskontextschlüssel finden Sie unter Globale AWS -Bedingungskontextschlüssel im IAM-Benutzerhandbuch.

Aufstellen

So richten Sie die IAM-Authentifizierung ein:

Erstellen eines Caches


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

Erstellen Sie, wie unten dargestellt, ein Dokument mit den IAM-Vertrauensrichtlinien für Ihre Rolle, sodass Ihr Konto die neue Rolle übernehmen kann. Speichern Sie die Richtlinie in einer Datei namens trust-policy.json.
```
{
    "Version": "2012-10-17",
    "Statement": {
        "Effect": "Allow",
        "Principal": { "AWS": "arn:aws:iam::123456789012:root" },
        "Action": "sts:AssumeRole"
    }
}
```

Erstellen Sie ein IAM-Richtliniendokument wie im Folgenden dargestellt. Speichern Sie die Richtlinie in einer Datei namens 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"
      ]
    }
  ]
}

Erstellen Sie eine IAM-Rolle.


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

Erstellen Sie die IAM-Richtlinie.


aws iam create-policy \
  --policy-name "elasticache-allow-all" \
  --policy-document file://policy.json

Fügen Sie die IAM-Richtlinie an die Rolle an.


aws iam attach-role-policy \
 --role-name "elasticache-iam-auth-app" \
 --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"

Erstellen Sie einen neuen IAM-fähigen Benutzer.


aws elasticache create-user \
  --user-name iam-user-01 \
  --user-id iam-user-01 \
  --authentication-mode Type=iam \
  --engine redis \
  --access-string "on ~* +@all"

Erstellen Sie eine Benutzergruppe und fügen Sie einen Benutzer an.


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

Herstellen von Verbindungen

Verbinden mit Token als Passwort

Sie müssen zuerst das kurzlebige IAM-Authentifizierungstoken mithilfe einer vorab signierten AWS -SigV4-Anfrage generieren. Danach geben Sie das IAM-Authentifizierungstoken als Passwort an, wenn Sie eine Verbindung zu einem Redis OSS-Cache herstellen, wie im folgenden Beispiel gezeigt.


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

Im Folgenden finden Sie die Definition für 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());
    }
}

Verbinden mit Anbieter von Anmeldeinformationen

Der folgende Code zeigt, wie Sie sich mit ElastiCache (Redis OSS) mithilfe des IAM-Anbieters für Authentifizierungsdaten authentifizieren.


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

Im Folgenden finden Sie ein Beispiel für einen Lettuce Redis OSS-Client, der das IAM AuthTokenRequest in einen Anbieter für Anmeldeinformationen einbindet, um bei Bedarf automatisch temporäre Anmeldeinformationen zu generieren.


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

Warnung JavaScript ist in Ihrem Browser nicht verfügbar oder deaktiviert.

Zur Nutzung der AWS-Dokumentation muss JavaScript aktiviert sein. Weitere Informationen finden auf den Hilfe-Seiten Ihres Browsers.

Dokumentkonventionen

Automatisches Rotieren von Passwörtern für Benutzer

Authentifizierung mit Redis OSS AUTH