Authentifizieren mit IAM - Amazon MemoryDB
ÜbersichtEinschränkungenAufstellenHerstellen von Verbindungen

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Authentifizieren mit IAM

Übersicht

Mit der IAM-Authentifizierung können Sie eine Verbindung zu MemoryDB mithilfe von AWS IAM-Identitäten authentifizieren, wenn Ihr Cluster 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. Mit der IAM-Authentifizierung können Sie eine differenzierte Zugriffskontrolle für jeden einzelnen MemoryDB-Cluster und jeden einzelnen MemoryDB-Benutzer konfigurieren und dabei die Prinzipien der geringsten Zugriffsrechte befolgen. Die IAM-Authentifizierung für MemoryDB funktioniert durch die Bereitstellung eines kurzlebigen IAM-Authentifizierungstoken anstelle eines langlebigen MemoryDB-Benutzerkennworts im Redis-OSS oder -Befehl. AUTH HELLO Weitere Informationen zum IAM-Authentifizierungstoken finden Sie im Signaturprozess für Signature Version 4 im Allgemeinen Referenzhandbuch und im Codebeispiel unten. AWS

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 Providern auch direkt Zugriff auf MemoryDB-Cluster gewähren.

Um AWS IAM mit MemoryDB zu verwenden, müssen Sie zunächst einen MemoryDB-Benutzer erstellen, dessen Authentifizierungsmodus auf IAM eingestellt ist. Anschließend können Sie eine IAM-Identität erstellen oder wiederverwenden. Die IAM-Identität benötigt eine zugehörige Richtlinie, um die memorydb:Connect Aktion dem MemoryDB-Cluster und dem MemoryDB-Benutzer 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 MemoryDB-Clusterknoten 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. MemoryDB führt die IAM-Authentifizierung für Verbindungsanfragen von IAM-fähigen MemoryDB-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 die Redis OSS-Engine Version 7.0 oder höher verwenden.

  • 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 MemoryDB 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 nicht alle globalen Bedingungskontextschlüssel. Weitere Informationen über globale Bedingungskontextschlüssel finden Sie unter Globale AWS -Bedingungskontextschlüssel im IAM-Benutzerhandbuch.

Aufstellen

So richten Sie die IAM-Authentifizierung ein:

  1. Erstellen eines -Clusters

    aws memorydb create-cluster \
    --cluster-name cluster-01 \
    --description "MemoryDB IAM auth application"
    --node-type db.r6g.large \
    --engine-version 7.0 \
    --acl-name open-access

  2. 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"
    }
}

  3. 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" : [
        "memorydb:connect"
      ],
      "Resource" : [
        "arn:aws:memorydb:us-east-1:123456789012:cluster/cluster-01",
        "arn:aws:memorydb:us-east-1:123456789012:user/iam-user-01"
      ]
    }
  ]
}

  4. Erstellen Sie eine IAM-Rolle.

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

  5. Erstellen Sie die IAM-Richtlinie.

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

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

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

  7. Erstellen Sie einen neuen IAM-fähigen Benutzer.

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

  8. Erstellen Sie eine ACL und fügen Sie den Benutzer hinzu.

    aws memorydb create-acl \
  --acl-name iam-acl-01 \
  --user-names iam-user-01

aws memorydb update-cluster \
  --cluster-name cluster-01 \
  --acl-name iam-acl-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 MemoryDB-Cluster herstellen, wie im folgenden Beispiel gezeigt. 

String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);
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(userName, iamAuthToken)
    .build();

// Create a new Lettuce Redis OSS client
RedisClusterClient client = RedisClusterClient.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 ACTION_NAME = "connect";
    private static final String SERVICE_NAME = "memorydb";
    private static final long TOKEN_EXPIRY_SECONDS = 900;

    private final String userName;
    private final String clusterName;
    private final String region;

    public IAMAuthTokenRequest(String userName, String clusterName, String region) {
        this.userName = userName;
        this.clusterName = clusterName;
        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(userName));
        return request;
    }

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

    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 MemoryDB mithilfe des Anbieters für IAM-Authentifizierungsdaten authentifizieren.

String userName = "insert user name"
String clusterName = "insert cluster name"
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 MemoryDB.
IAMAuthTokenRequest iamAuthTokenRequest = new IAMAuthTokenRequest(userName, clusterName, region);

// Create a Redis OSS credentials provider using IAM credentials.
RedisCredentialsProvider redisCredentialsProvider = new RedisIAMAuthCredentialsProvider(
    userName, 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 cluster client
RedisClusterClient client = RedisClusterClient.create(redisURI);
client.connect();

Im Folgenden finden Sie ein Beispiel für einen Lettuce Redis OSS-Cluster-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 userName;
    private final IAMAuthTokenRequest iamAuthTokenRequest;
    private final Supplier<String> iamAuthTokenSupplier;

    public RedisIAMAuthCredentialsProvider(String userName,
        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(userName, iamAuthTokenSupplier.get()));
    }

    private String getIamAuthToken() {
        return iamAuthTokenRequest.toSignedRequestUri(awsCredentialsProvider.getCredentials());
    }