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 einer Lambda-Funktion für den Zugriff auf MemoryDB in einem Amazon VPC

In diesem Tutorial erfahren Sie, wie Sie:

Schritt 1: Erstellen eines Clusters

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

Erstellen eines -Clusters

In diesem Schritt erstellen Sie in Ihrem Konto mithilfe von AWS Command Line Interface () CLI einen Cluster VPC im Standard-Amazon in der Region us-east-1. Informationen zum Erstellen eines Clusters mithilfe der MemoryDB-Konsole oder API finden Sie unter. Schritt 2: Erstellen eines Clusters

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

Beachten Sie, dass für das Feld „Status“ der Wert CREATING festgelegt ist. Es kann einige Minuten dauern, bis MemoryDB die Erstellung Ihres Clusters abgeschlossen hat.

Kopieren Sie den Cluster-Endpunkt

Stellen Sie mit dem Befehl sicher, dass MemoryDB die Erstellung des Clusters abgeschlossen hat. describe-clusters

aws memorydb describe-clusters \
--cluster-name cluster-01 

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

IAMRolle erstellen

Erstellen Sie eine ACL Zugriffskontrollliste ()

Schritt 2: Erstellen einer Lambda-Funktion

Gehen Sie wie folgt vor, um eine Lambda-Funktion zu erstellen.

Erstellen des Bereitstellungspakets

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 MemoryDB-Cluster. Kopieren Sie den Code in eine Datei und speichern Sie diese mit dem Namen app.py. Achten Sie darauf, den cluster_endpoint Wert im Code durch die Endpunktadresse zu ersetzen, die Sie in einem 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 MemoryDBIAMProvider(redis.CredentialProvider):
    def __init__(self, user, cluster_name, region="us-east-1"):
        self.user = user
        self.cluster_name = cluster_name
        self.region = region

        session = botocore.session.get_session()
        self.request_signer = RequestSigner(
            ServiceId("memorydb"),
            self.region,
            "memorydb",
            "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}
        
        url = urlunparse(
            ParseResult(
                scheme="https",
                netloc=self.cluster_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
        # MemoryDB 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
    cluster_name = "cluster-01" # replace with your cache name
    cluster_endpoint = "clustercfg.cluster-01.xxxxxx.memorydb.us-east-1.amazonaws.com" # replace with your cluster endpoint
    creds_provider = MemoryDBIAMProvider(user=username, cluster_name=cluster_name)
    redis_client = redis.Redis(host=cluster_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 cluster
    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 cluster and print
    # the results
    if decoded_result == uuid_in:
        print(f"Success: Inserted {uuid_in}. Fetched {decoded_result} from MemoryDB.")
    else:
        raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
        
    return "Fetched value from MemoryDB"

Dieser Code verwendet die redis-py Python-Bibliothek, um Elemente in Ihren Cluster einzufügen und abzurufen. Dieser Code dient dazucachetools, generierte IAM Auth-Token 15 Minuten lang zwischenzuspeichern. Gehen Sie wie folgt vorcachetools, um ein Bereitstellungspaket mit redis-py und zu erstellen.

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

mkdir package

Installieren redis-py und cachetools verwenden Sie 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 und macOS den folgenden Befehl aus. Verwenden Sie in Windows Ihr bevorzugtes ZIP-Hilfsprogramm, um eine .zip-Datei mit den cachetools Bibliotheken redis-py und 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

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 "memorydb-iam-auth-app" \
 --policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole"

Laden Sie das Bereitstellungspaket hoch (erstellen Sie die Lambda-Funktion)

In diesem Schritt erstellen Sie die Lambda-Funktion (AccessMemoryDB) 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 AccessMemoryDB  \
--region us-east-1 \
--zip-file fileb://my_deployment_package.zip \
--role arn:aws:iam::123456789012:role/memorydb-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 der Lambda -Funktion

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.

Lambda-Funktion löschen

aws lambda delete-function \
 --function-name AccessMemoryDB 

Löschen Sie den MemoryDB-Cluster

Löschen Sie den Cluster.

aws memorydb delete-cluster \
 --cluster-name cluster-01 

Benutzer entfernen und. ACL

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

aws memorydb delete-acl \
 --acl-name iam-acl-01

IAMRolle und Richtlinien entfernen

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