Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tutorial: configurazione di una funzione Lambda per accedere a MemoryDB in Amazon VPC

In questo tutorial puoi imparare a:

Fase 1: creazione di un cluster

Per creare un cluster, segui questi passaggi.

Creazione di un cluster

In questo passaggio, crei un cluster nell'Amazon predefinito VPC nella regione us-east-1 del tuo account utilizzando AWS Command Line Interface (). CLI Per informazioni sulla creazione di cluster utilizzando la console MemoryDB oppureAPI, consulta. Fase 2: creazione di un cluster

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

Il valore del campo Stato è impostato su CREATING. MemoryDB può impiegare alcuni minuti per completare la creazione del cluster.

Copia l'endpoint del cluster

Verifica che MemoryDB abbia terminato la creazione del cluster con il describe-clusters comando.

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

Copia l'indirizzo dell'endpoint del cluster mostrato nell'output. Avrai bisogno di questo indirizzo quando crei il pacchetto di implementazione per la funzione Lambda.

Crea ruolo IAM

Crea una lista di controllo degli ACL accessi ()

Passaggio 2: creazione di una funzione Lambda

Per creare una funzione Lambda, procedi nel seguente modo.

Creazione del pacchetto di implementazione

In questo tutorial, forniamo codice di esempio in Python per la tua funzione Lambda.

Python

L'esempio seguente di codice Python legge e scrive un elemento nel cluster MemoryDB. Copia il codice e salvalo in un file denominato app.py. Assicurati di sostituire il cluster_endpoint valore nel codice con l'indirizzo dell'endpoint che hai copiato nel passaggio precedente.

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"

Questo codice utilizza la redis-py libreria Python per inserire elementi nel cluster e recuperarli. Questo codice viene utilizzato cachetools per memorizzare nella cache i token di IAM autenticazione generati per 15 minuti. Per creare un pacchetto di distribuzione contenente redis-py ecachetools, effettuate le seguenti operazioni.

Nella directory del progetto contenente il file del codice app.py sorgente, create un pacchetto di cartelle in cui installare le cachetools librerie redis-py and.

mkdir package

Installa redis-py e cachetools usa pip.

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

Crea un file.zip contenente le librerie redis-py andcachetools. In Linux e macOS, esegui il seguente comando. In Windows, utilizzate l'utilità zip preferita per creare un file.zip con le cachetools librerie redis-py and alla radice.

cd package
zip -r ../my_deployment_package.zip 

Aggiungi il codice della funzione al file .zip. Su Linux e macOS, esegui il comando seguente. In Windows, utilizzate l'utilità zip preferita per aggiungere app.py alla radice del file.zip.

cd ..
zip my_deployment_package.zip app.py

Crea il IAM ruolo (ruolo di esecuzione)

Allega la politica AWS gestita denominata AWSLambdaVPCAccessExecutionRole al ruolo.

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

Carica il pacchetto di distribuzione (crea la funzione Lambda)

In questo passaggio, si crea la funzione Lambda (AccessMemoryDB) utilizzando il comando AWS CLI create-function.

Dalla directory del progetto che contiene il file.zip del pacchetto di distribuzione, esegui il seguente comando CLI create-function Lambda.

Per l'opzione role, utilizzate il ruolo ARN di esecuzione creato nel passaggio precedente. Per vpc-config inserisci gli elenchi separati da virgole delle sottoreti predefinite e VPC dell'ID del gruppo di sicurezza predefinito. VPC Puoi trovare questi valori nella VPC console Amazon. Per trovare le sottoreti predefinite, scegli VPC YourVPCs, quindi scegli le impostazioni predefinite del tuo AWS account. VPC Per trovare il gruppo di sicurezza adattoVPC, vai su Sicurezza e scegli Gruppi di sicurezza. Assicurati di aver selezionato la regione us-east-1.

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

Fase 3: esecuzione del test della funzione Lambda

In questo passaggio, si richiama la funzione Lambda manualmente utilizzando il comando invoke. Quando la funzione Lambda viene eseguita, genera un file UUID e lo scrive ElastiCache nella cache specificata nel codice Lambda. Successivamente la funzione Lambda recupera la voce dalla cache.

Fase 4: Pulizia (opzionale)

Per eseguire la pulizia, procedi nel seguente modo.

Elimina la funzione Lambda

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

Elimina il cluster MemoryDB

Elimina il cluster.

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

Rimuovi utente e. ACL

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

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

Rimuovi IAM ruolo e politiche

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"