Schritt 2: Erstellen einer Lambda-Funktion

Gehen Sie wie folgt vor, um eine Lambda-Funktion 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 in Schritt 1.2 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 Redis OSS.")
    else:
        raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
        
    return "Fetched value from Redis"

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: Eine IAM-Rolle erstellen (Ausführungsrolle)

Hängen Sie die AWS verwaltete Richtlinie mit dem Namen der Rolle AWSLambdaVPCAccessExecutionRole 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 (AccessRedis) mit dem Befehl AWS CLI create-function.

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

Verwenden Sie für die Rollenoption den ARN der Ausführungsrolle, die Sie in Schritt 2.2 erstellt haben. Geben Sie für die vpc-config durch Kommas getrennte 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 und dann die Standard-VPC Ihres AWS Kontos aus. Um die Sicherheitsgruppe für diese VPC zu finden, 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 AccessRedis  \
--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