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: Konfiguration von Lambda für den Zugriff ElastiCache in einem VPC

In diesem Tutorial erfahren Sie, wie Sie einen ElastiCache serverlosen Cache erstellen, eine Lambda-Funktion erstellen, dann die Lambda-Funktion testen und optional anschließend bereinigen.

Schritt 1: Einen serverlosen Cache erstellen ElastiCache .

Gehen Sie folgendermaßen vor, um einen serverlosen Cache zu erstellen.

Schritt 1.1: Erstellen Sie einen serverlosen Cache

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

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

Beachten Sie, dass für das Feld „Status“ der Wert CREATING festgelegt ist. Es kann eine Minute dauern ElastiCache , bis der Cache fertig erstellt ist.

Schritt 1.2: Kopieren Sie den serverlosen Cache-Endpunkt

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

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: Rolle erstellen IAM

Schritt 1.4: Erstellen Sie einen serverlosen Cache

Schritt 2: Erstellen Sie eine Lambda-Funktion für ElastiCache

Gehen Sie wie folgt vor, um eine Lambda-Funktion für den Zugriff auf den ElastiCache Cache zu erstellen.

Schritt 2.1: Erstellen Sie eine Lambda-Funktion

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

Python

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

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

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

class ElastiCacheIAMProvider(redis.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)
    redis_client = redis.Redis(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
    redis_client.set(key, uuid_in)
    result = redis_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 redis-py, um Elemente in Ihren Cache zu legen und abzurufen. Dieser Code verwendet Cachetools, um generierte IAM Auth-Token 15 Minuten lang zwischenzuspeichern. Gehen Sie wie folgt vor, um ein Bereitstellungspaket zu erstellen, das Redis-py und Cachetools enthält.

Erstellen Sie in Ihrem Projektverzeichnis, das die Quellcodedatei app.py enthält, ein Ordnerpaket, in dem Sie die Bibliotheken redis-py und cachetools installieren können.

mkdir package

Installieren Sie redis-py, cachetools mit pip.

pip install --target ./package redis
pip install --target ./package cachetools

Erstellen Sie eine ZIP-Datei, die die Bibliotheken redis-py und cachetools 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 Bibliotheken redis-py und cachetools 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-Programm, um app.py zum Stammverzeichnis Ihrer ZIP-Datei hinzuzufügen.

cd ..
zip my_deployment_package.zip app.py

Schritt 2.2: Erstellen Sie die IAM Rolle (Ausführungsrolle)

Hängen Sie die AWS verwaltete Richtlinie mit AWSLambdaVPCAccessExecutionRole dem Namen der Rolle an.

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)

In diesem Schritt erstellen Sie die Lambda-Funktion (AccessValkey) mit dem Befehl AWS CLI create-function.

Führen Sie in dem Projektverzeichnis, das die ZIP-Datei Ihres Bereitstellungspakets enthält, den folgenden Lambda-Befehl CLI create-function aus.

Verwenden Sie für die Rollenoption die ARN Ausführungsrolle, die Sie im vorherigen Schritt erstellt haben. Geben Sie für die vpc-config kommagetrennte Liste der Subnetze VPC Ihres Standardsystems und der Sicherheitsgruppen-ID VPC Ihres Standardservers ein. Sie finden diese Werte in der VPC Amazon-Konsole. Um die Subnetze Ihrer VPC Standardsubnetze zu finden, wählen Sie Ihre VPCs und dann die VPC Standardsubnetze Ihres AWS Kontos aus. Um die entsprechende Sicherheitsgruppe zu findenVPC, gehen Sie zu Sicherheit und wählen Sie Sicherheitsgruppen aus. 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

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.

Schritt 4: Aufräumen (optional)

Gehen Sie zum Aufräumen wie folgt vor.

Schritt 4.1: Lambda-Funktion löschen

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

Schritt 4.2: Löschen Sie den serverlosen Cache

Löschen Sie den Cache.

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

Benutzer und Benutzergruppen 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: IAM Rolle und Richtlinien entfernen

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"