Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Tutorial: Configuración de una función Lambda para acceder a MemoryDB en Amazon VPC

En este tutorial, puede aprender a:

Paso 1: creación de un clúster

Para crear un clúster, siga estos pasos.

Creación de un clúster

En este paso, creas un clúster en el Amazon VPC predeterminado de la región us-east-1 de tu cuenta mediante AWS Command Line Interface (). CLI Para obtener información sobre cómo crear un clúster mediante la consola MemoryDB oAPI, consulte. Paso 2: crear un clúster

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

Como puede ver, el valor del campo Estado es CREATING. MemoryDB puede tardar unos minutos en terminar de crear el clúster.

Copie el punto final del clúster

Compruebe que MemoryDB haya terminado de crear el clúster con el describe-clusters comando.

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

Copie la dirección del punto final del clúster que se muestra en el resultado. Necesitará esta dirección cuando cree el paquete de implementación para la función de Lambda.

Crear IAM rol

Crea una lista de control ACL de acceso ()

Paso 2: Crear una función de Lambda

Para crear una función Lambda, siga estos pasos.

Crear el paquete de implementación

En este tutorial, proporcionamos código de ejemplo en Python para su función Lambda.

Python

El siguiente ejemplo de código Python lee y escribe un elemento en el clúster de MemoryDB. Copie el código y guárdelo en un archivo con el nombre app.py. Asegúrese de reemplazar el cluster_endpoint valor del código por la dirección de punto final que copió en el paso anterior.

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"

Este código usa la redis-py biblioteca de Python para colocar elementos en el clúster y recuperarlos. Este código se utiliza cachetools para almacenar en caché los tokens IAM de autenticación generados durante 15 minutos. Para crear un paquete de despliegue que contenga redis-py y cachetools lleve a cabo los siguientes pasos.

En el directorio del proyecto que contiene el archivo de código app.py fuente, cree un paquete de carpetas en el que instalar cachetools las bibliotecas redis-py y.

mkdir package

Instala redis-py y cachetools usa pip.

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

Cree un archivo.zip que contenga las bibliotecas redis-py ycachetools. En Linux y macOS, ejecuta el siguiente comando. En Windows, usa la utilidad zip que prefieras para crear un archivo.zip con las cachetools bibliotecas redis-py y en la raíz.

cd package
zip -r ../my_deployment_package.zip 

Añada el código de función al archivo .zip. En Linux y macOS, ejecute el siguiente comando. En Windows, usa la utilidad zip que prefieras para agregar app.py a la raíz del archivo.zip.

cd ..
zip my_deployment_package.zip app.py

Cree el IAM rol (rol de ejecución)

Adjunte la política AWS gestionada nombrada AWSLambdaVPCAccessExecutionRole al rol.

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

Cargue el paquete de despliegue (cree la función Lambda)

En este paso, se crea la función Lambda (AccessMemoryDB) mediante el comando AWS CLI create-function.

Desde el directorio del proyecto que contiene el archivo.zip del paquete de despliegue, ejecute el siguiente comando de CLI create-function Lambda.

Para la opción de rol, utilice el rol ARN de ejecución que creó en el paso anterior. Para el vpc-config, introduzca listas separadas por comas de las subredes predeterminadas y VPC el ID del grupo de seguridad VPC de su configuración predeterminada. Puedes encontrar estos valores en la VPC consola de Amazon. Para encontrar las subredes predeterminadasVPC, selecciona Tu y, a continuaciónVPCs, elige la predeterminada VPC de tu AWS cuenta. Para buscar el grupo de seguridad correspondienteVPC, ve a Seguridad y selecciona Grupos de seguridad. Compruebe que ha seleccionado la región 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

Paso 3: comprobación de la función de Lambda

En este paso, se invoca la función Lambda manualmente mediante el comando invoke. Cuando se ejecuta la función Lambda, genera un UUID y lo escribe en la ElastiCache caché que especificó en el código Lambda. A continuación, la función de Lambda recupera el elemento de la caché.

Paso 4: Limpiar (opcional)

Para limpiar, sigue estos pasos.

Eliminar función Lambda

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

Eliminar el clúster de MemoryDB

Eliminar el clúster.

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

Eliminar usuario y. ACL

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

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

Eliminar IAM rol y políticas

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"