

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.

# Tutorial: Lambda für den Zugriff konfigurieren ElastiCache in einer VPC

In diesem Tutorial erfahren Sie, wie Sie eine erstellen ElastiCache Serverloser Cache, erstellen Sie eine Lambda-Funktion, testen Sie dann die Lambda-Funktion und bereinigen Sie optional danach.

**Topics**
+ [Schritt 1: Erstellen eines ElastiCache Serverloser Cache.](#LambdaRedis.step1)
+ [Schritt 2: Erstellen Sie eine Lambda-Funktion für ElastiCache](#LambdaRedis.step2)
+ [Schritt 3: Testen Sie die Lambda-Funktion mit ElastiCache](#LambdaRedis.step3)
+ [Schritt 4: Aufräumen (optional)](#LambdaRedis.step4)

## Schritt 1: Erstellen eines ElastiCache Serverloser Cache.
<a name="LambdaRedis.step1"></a>

Gehen Sie wie folgt vor, um einen serverlosen Cache zu erstellen.

### Schritt 1.1: Erstellen Sie einen serverlosen Cache
<a name="LambdaRedis.step1.1"></a>

In diesem Schritt erstellen Sie einen serverlosen Cache in der standardmäßigen Amazon-VPC in der Region us-east-1 in Ihrem Konto mithilfe der AWS Command Line Interface (CLI). Informationen zum Erstellen eines serverlosen Caches mit dem ElastiCache Konsole oder API finden Sie unter [Erstellen Sie einen serverlosen Valkey-Cache](GettingStarted.serverless-valkey.step1.md).

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

Beachten Sie, dass der Wert des Felds Status auf gesetzt ist `CREATING`. ElastiCache erstellt deinen Cache in etwa einer Minute.

### Schritt 1.2: Kopieren Sie den serverlosen Cache-Endpunkt
<a name="LambdaRedis.step1.2"></a>

Stellen Sie sicher, dass ElastiCache hat die Erstellung des Caches mit dem abgeschlossen `describe-serverless-caches` Befehl.

```
aws elasticache describe-serverless-caches \
  --serverless-cache-name cache-01
```

Kopieren Sie die in der Ausgabe angezeigte Endpunktadresse. Sie benötigen diese Adresse, wenn Sie das Bereitstellungspaket für Ihre Lambda-Funktion erstellen.

### Schritt 1.3: IAM-Rolle erstellen
<a name="LambdaRedis.step1.3"></a>



1. Erstellen Sie für Ihre Rolle ein Dokument zur IAM-Vertrauensrichtlinie, wie unten dargestellt, das es dem Lambda-Service ermöglicht, die neue Rolle zu übernehmen. Speichern Sie die Richtlinie in einer Datei namens *trust-policy.json*.

   ```json
   {
       "Version": "2012-10-17",
       "Statement": [{
           "Effect": "Allow",
           "Principal": {"Service": "lambda.amazonaws.com"},
           "Action": "sts:AssumeRole"
       }]
   }
   ```

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

1. Erstellen Sie eine IAM-Rolle.

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

1. Erstellen Sie die IAM-Richtlinie.

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

1. 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"
   ```

### Schritt 1.4: Konfigurieren Sie die IAM-Authentifizierung
<a name="LambdaRedis.step1.4"></a>

**Wichtig**  
Dieser Schritt ist erforderlich. Ihre Lambda-Funktion authentifiziert sich bei ElastiCache mit IAM. Damit das funktioniert, müssen Sie eine erstellen IAM-enabled ElastiCache Benutzer, fügen Sie ihn einer Benutzergruppe hinzu und verknüpfen Sie diese Benutzergruppe mit Ihrem Cache. Ohne diese Konfiguration schlagen Verbindungsversuche von Lambda fehl.

1. Erstellen Sie eine IAM-enabled Benutzer. Dies ist die Benutzeridentität, mit der sich Ihre Lambda-Funktion authentifiziert.

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

1. Erstellen Sie eine Benutzergruppe, fügen Sie den Benutzer hinzu und verknüpfen Sie die Gruppe mit Ihrem Cache.

   ```
   aws elasticache create-user-group \
     --user-group-id iam-user-group-01 \
     --engine valkey \
     --user-ids iam-user-01
   
   aws elasticache modify-serverless-cache \
     --serverless-cache-name cache-01 \
     --user-group-id iam-user-group-01
   ```

## Schritt 2: Erstellen Sie eine Lambda-Funktion für ElastiCache
<a name="LambdaRedis.step2"></a>

Um eine Lambda-Funktion für den Zugriff auf ElastiCache Cache, gehen Sie wie folgt vor.

### Schritt 2.1: Erstellen Sie eine Lambda-Funktion
<a name="LambdaRedis.step2.1"></a>

In diesem Tutorial stellen wir Beispielcode in Python für Ihre Lambda-Funktion zur Verfügung.

**Python**

Der folgende Python-Beispielcode liest und schreibt ein Element in Ihren ElastiCache zwischenspeichern. Kopieren Sie den Code in eine Datei und speichern Sie diese mit dem Namen `app.py`. Achten Sie darauf, den zu ersetzen `elasticache_endpoint` Wert im Code mit der Endpunktadresse, die Sie im vorherigen Schritt kopiert haben. 

```
from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse

import botocore.session
import valkey
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid

class ElastiCacheIAMProvider(valkey.CredentialProvider):
    def __init__(self, user, cache_name, is_serverless=False, region="us-east-1"):
        self.user = user
        self.cache_name = cache_name
        self.is_serverless = is_serverless
        self.region = region

        session = botocore.session.get_session()
        self.request_signer = RequestSigner(
            ServiceId("elasticache"),
            self.region,
            "elasticache",
            "v4",
            session.get_credentials(),
            session.get_component("event_emitter"),
        )

    # Generated IAM tokens are valid for 15 minutes
    @cached(cache=TTLCache(maxsize=128, ttl=900))
    def get_credentials(self) -> Union[Tuple[str], Tuple[str, str]]:
        query_params = {"Action": "connect", "User": self.user}
        if self.is_serverless:
            query_params["ResourceType"] = "ServerlessCache"
        url = urlunparse(
            ParseResult(
                scheme="https",
                netloc=self.cache_name,
                path="/",
                query=urlencode(query_params),
                params="",
                fragment="",
            )
        )
        signed_url = self.request_signer.generate_presigned_url(
            {"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
            operation_name="connect",
            expires_in=900,
            region_name=self.region,
        )
        # RequestSigner only seems to work if the URL has a protocol, but
        # Elasticache only accepts the URL without a protocol
        # So strip it off the signed URL before returning
        return (self.user, signed_url.removeprefix("https://"))

def lambda_handler(event, context):
    username = "iam-user-01" # replace with your user id
    cache_name = "cache-01" # replace with your cache name
    elasticache_endpoint = "cache-01-xxxxx.serverless.use1.cache.amazonaws.com" # replace with your cache endpoint
    creds_provider = ElastiCacheIAMProvider(user=username, cache_name=cache_name, is_serverless=True)
    valkey_client = valkey.Valkey(host=elasticache_endpoint, port=6379, credential_provider=creds_provider, ssl=True, ssl_cert_reqs="none")
    
    key='uuid'
    # create a random UUID - this will be the sample element we add to the cache
    uuid_in = uuid.uuid4().hex
    valkey_client.set(key, uuid_in)
    result = valkey_client.get(key)
    decoded_result = result.decode("utf-8")
    # check the retrieved item matches the item added to the cache and print
    # the results
    if decoded_result == uuid_in:
        print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from Valkey.")
    else:
        raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
        
    return "Fetched value from Valkey"
```

Dieser Code verwendet die Python-Bibliothek valkey-py, um Elemente in Ihren Cache zu legen und abzurufen. Dieser Code verwendet Cachetools, um generierte IAM-Auth-Token für 15 Minuten zwischenzuspeichern. Führen Sie die folgenden Schritte aus, um ein Bereitstellungspaket zu erstellen, das valkey-py und cachetools enthält.

Erstellen Sie in Ihrem Projektverzeichnis, das die Quellcodedatei app.py enthält, ein Ordnerpaket, in das die Bibliotheken valkey-py und cachetools installiert werden.

```
mkdir package
```

Installieren Sie Valkey-Py und Cachetools mit Pip.

```
pip install --target ./package valkey
pip install --target ./package cachetools
```

Erstellen Sie eine ZIP-Datei, die die Valkey-Py- und Cachetools-Bibliotheken enthält. Führen Sie unter Linux oder macOS den folgenden Befehl aus: Verwenden Sie in Windows Ihr bevorzugtes ZIP-Hilfsprogramm, um eine ZIP-Datei mit den Valkey-Py- und Cachetools-Bibliotheken im Stammverzeichnis zu erstellen.

```
cd package
zip -r ../my_deployment_package.zip .
```

Fügen Sie den Funktionscode in die ZIP-Datei ein. Führen Sie unter Linux oder macOS den folgenden Befehl aus: Verwenden Sie in Windows Ihr bevorzugtes ZIP-Hilfsprogramm, um app.py zum Stammverzeichnis Ihrer ZIP-Datei hinzuzufügen.

```
cd ..
zip my_deployment_package.zip app.py
```

### Schritt 2.2: Eine IAM-Rolle erstellen (Ausführungsrolle)
<a name="LambdaRedis.step2.2"></a>

Hängen Sie das an AWS verwaltete Richtlinie mit dem Namen `AWSLambdaVPCAccessExecutionRole` zu der Rolle.

```
aws iam attach-role-policy \
 --role-name "elasticache-iam-auth-app" \
 --policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
```

### Schritt 2.3: Aktualisieren des Bereitstellungspakets (Erstellen der Lambda-Funktion)
<a name="LambdaRedis.step2.3"></a>

In diesem Schritt erstellen Sie die Lambda-Funktion (AccessValkey) mithilfe der Create-Funktion AWS CLI Befehl. 

Führen Sie im Projektverzeichnis, das die ZIP-Datei Ihres Bereitstellungspakets enthält, die folgende Lambda-CLI aus `create-function` Befehl.

Verwenden Sie für die Rollenoption den ARN der Ausführungsrolle, die Sie im vorherigen Schritt erstellt haben. Geben Sie für die vpc-config kommagetrennte Listen der Subnetze Ihrer Standard-VPC und die Sicherheitsgruppen-ID Ihrer Standard-VPC ein. Sie finden diese Werte in der Amazon-VPC-Konsole. Um die Subnetze Ihrer Standard-VPC zu finden, wählen Sie **Ihre VPCs**, dann wähle deine AWS die Standard-VPC des Kontos. Um die Sicherheitsgruppe für diese VPC zu finden, gehen Sie zu **Sicherheit** und wähle **Sicherheitsgruppen**. Stellen Sie sicher, dass die Region us-east-1 ausgewählt ist.

```
aws lambda create-function \
--function-name AccessValkey  \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/elasticache-iam-auth-app \
--handler app.lambda_handler \
--runtime python3.12  \
--timeout 30 \
--vpc-config SubnetIds=comma-separated-vpc-subnet-ids,SecurityGroupIds=default-security-group-id
```

## Schritt 3: Testen Sie die Lambda-Funktion mit ElastiCache
<a name="LambdaRedis.step3"></a>

In diesem Schritt rufen Sie die Lambda-Funktion manuell mit dem Befehl invoke auf. Wenn die Lambda-Funktion ausgeführt wird, generiert sie eine UUID und schreibt sie in den ElastiCache Cache, den Sie in Ihrem Lambda-Code angegeben haben. Die Lambda-Funktion ruft das Element dann aus dem Cache ab.

1. Rufen Sie die Lambda-Funktion auf (AccessValkey) mit dem AWS Lambda Befehl aufrufen.

   ```
   aws lambda invoke \
   --function-name AccessValkey  \
   --region us-east-1 \
   output.txt
   ```

1. Stellen Sie sicher, dass die Lambda-Funktion erfolgreich ausgeführt wurde:
   + Überprüfen Sie die Datei "output.txt".
   + Überprüfen Sie die Ergebnisse in CloudWatch Protokolliert durch Öffnen des CloudWatch Konsole und Auswahl der Protokollgruppe für Ihre Funktion (/aws/lambda/AccessValkey). Die Ausgabe dieses Protokollstreams sollte ähnlich wie folgt aussehen:

     ```
     Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
     ```
   + Überprüfen Sie die Ergebnisse in der AWS Lambda Konsole.

## Schritt 4: Aufräumen (optional)
<a name="LambdaRedis.step4"></a>

Gehen Sie zum Aufräumen wie folgt vor.

### Schritt 4.1: Löschen Sie die Lambda-Funktion
<a name="LambdaRedis.step4.1"></a>

```
aws lambda delete-function \
 --function-name AccessValkey
```

### Schritt 4.2: Serverloser Cache löschen
<a name="LambdaRedis.step4.2"></a>

Löschen Sie den Cache.

```
aws elasticache delete-serverless-cache \
 --serverless-cache-name cache-01
```

Benutzer und Benutzergruppe entfernen.

```
aws elasticache delete-user \
 --user-id default-user-disabled

aws elasticache delete-user \
 --user-id iam-user-01

aws elasticache delete-user-group \
 --user-group-id iam-user-group-01
```

### Schritt 4.3: Entfernen Sie die IAM-Rolle und die Richtlinien
<a name="LambdaRedis.step4.3"></a>

```
aws iam detach-role-policy \
 --role-name "elasticache-iam-auth-app" \
 --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
 
aws iam detach-role-policy \
--role-name "elasticache-iam-auth-app" \
--policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"
 
aws iam delete-role \
 --role-name "elasticache-iam-auth-app"
  
 aws iam delete-policy \
  --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
```