Tutorial: Configuración de una función de Lambda para obtener acceso a MemoryDB una Amazon VPC.

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.

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.

En este tutorial, podrá 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, crea un clúster en la Amazon VPC predeterminada de la región us-east-1 de su cuenta mediante la (CLI). AWS Command Line Interface Para obtener información sobre cómo crear un clúster mediante la consola o la API de MemoryDB, 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. Este proceso puede tardar unos minutos, hasta que MemoryDB termine de crear el clúster.

Copiar el punto de conexión de clúster

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

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

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

Creación de un rol de IAM

Crear una lista de control de acceso (ACL)

Paso 2: creación de una función de Lambda

Para crear una función de Lambda, realice los pasos que se indican a continuación.

Crear el paquete de implementación

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

Python

El siguiente ejemplo de código de 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 valor cluster_endpoint del código con la dirección del punto de conexión que copió en un 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 biblioteca redis-py de Python para colocar elementos en el clúster y recuperarlos. Este código usa cachetools para almacenar en caché los tokens de autenticación de IAM generados durante 15 minutos. Para crear un paquete de implementación que contenga redis-py y cachetools, siga estos pasos.

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

mkdir package

Instale redis-py y cachetools con pip.

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

Cree un archivo .zip que contenga las bibliotecas redis-py y cachetools. En Linux y MacOS, ejecute el siguiente comando. En Windows, utilice la utilidad de compresión que prefiera para crear un archivo .zip con las bibliotecas de redis-py y cachetools en el directorio 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, utilice la utilidad de compresión que prefiera para añadir app.py al directorio raíz del archivo .zip.

cd ..
zip my_deployment_package.zip app.py

Crear el rol de IAM (rol de ejecución)

Adjunte la política AWS administrada 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"

Cargar el paquete de implementación (crear la función de 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 implementación, ejecute el siguiente comando create-function de la CLI de Lambda.

Para la opción del rol, utilice el ARN del rol de ejecución que creó en el paso anterior. Para vpc-config, introduzca listas separadas por comas de las subredes de la VPC predeterminada y el ID del grupo de seguridad de la VPC predeterminada. Puede encontrar estos valores en la Consola de Amazon VPC. Para buscar las subredes de su VPC predeterminada, elija Su VPC y, a continuación VPCs, elija la VPC predeterminada de su AWS cuenta. Para buscar el grupo de seguridad de esta VPC, vaya a Seguridad y elija 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, invocará la función de Lambda manualmente utilizando el comando de invocación. 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: limpieza (opcional)

Para la limpieza, siga estos pasos.

Eliminar la función de 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 

Elimine el usuario y la ACL.

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

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

Eliminar el rol de IAM y las 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"