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 Lambda para acceder ElastiCache en un VPC

En este tutorial, puede aprender a crear una caché ElastiCache sin servidor, crear una función Lambda, probar la función Lambda y, opcionalmente, limpiarla después.

Paso 1: Crear una ElastiCache caché sin servidor.

Para crear una caché sin servidor, sigue estos pasos.

Paso 1.1: Crea una caché sin servidor

En este paso, crearás una caché sin servidor 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 una caché sin servidor mediante la ElastiCache consola o, consulte. API Crear una caché sin servidor Valkey

aws elasticache create-serverless-cache \
  --serverless-cache-name cache-01  \
--description "ElastiCache IAM auth application" \
--engine valkey

Como puede ver, el valor del campo Estado es CREATING. Terminar de crear la caché puede tardar un minuto. ElastiCache

Paso 1.2: Copiar el punto final de la caché sin servidor

Compruebe que ElastiCache (RedisOSS) haya terminado de crear la caché con el describe-serverless-caches comando.

aws elasticache describe-serverless-caches \
--serverless-cache-name cache-01 

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

Paso 1.3: Crear un rol IAM

Paso 1.4: Crear una memoria caché sin servidor

Paso 2: Crear una función Lambda para ElastiCache

Para crear una función Lambda para acceder a la ElastiCache memoria caché, siga estos pasos.

Paso 2.1: Crear una función Lambda

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 la ElastiCache memoria caché. Copie el código y guárdelo en un archivo con el nombre app.py. Asegúrese de reemplazar el elasticache_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 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 Valkey.")
    else:
        raise Exception(f"Bad value retrieved. Expected {uuid_in}, got {decoded_result}")
        
    return "Fetched value from Valkey"

Este código usa la biblioteca redis-py de Python para colocar los elementos en la caché y recuperarlos. Este código usa cachetools para almacenar en caché los tokens de IAM 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 fuente app.py, cree un paquete de carpetas en el que instalar las bibliotecas redis-py y cachetools.

mkdir package

Instala redis-py y cachetools usando 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 zip que prefiera para crear un archivo.zip con las bibliotecas redis-py y cachetools 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

Paso 2.2: Crear el IAM rol (rol de ejecución)

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

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

Paso 2.3: cargar el paquete de despliegue (crear la función de Lambda)

En este paso, se crea la función Lambda (AccessValkey) 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, selecciona 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 AccessValkey  \
--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

Paso 3: Pruebe la función Lambda con ElastiCache

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.

Paso 4.1: Eliminar la función Lambda

aws lambda delete-function \
 --function-name AccessValkey 

Paso 4.2: Eliminar la caché sin servidor

Elimine la memoria caché.

aws elasticache delete-serverless-cache \
 --serverless-cache-name cache-01 

Elimine los usuarios y el grupo de usuarios.

aws elasticache delete-user \
 --user-id default-user-disabled

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

aws elasticache delete-user-group \
 --user-group-id iam-user-group-01

Paso 4.3: Eliminar el IAM rol y las políticas

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