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 a una ElastiCache 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.

Siga estos pasos para crear una caché sin servidor.

Paso 1.1: creación de una caché sin servidor

En este paso, crea una caché sin servidor 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 una caché sin servidor mediante la ElastiCache consola o la API, consulte. Crear una caché sin servidor Redis OSS

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: copia del punto de conexión de caché sin servidor

Compruebe que ElastiCache Redis OSS 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: creación de un rol de IAM

Paso 1.4: Cree un usuario predeterminado

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: creación de una función de Lambda

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

Python

El siguiente ejemplo de código Python lee y escribe un elemento en la ElastiCache caché. Copie el código y guárdelo en un archivo con el nombre app.py. Asegúrese de reemplazar el valor elasticache_endpoint del código por la dirección del punto de conexión 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 elementos en la caché y recuperarlos. Este código usa cachetools para almacenar en caché durante 15 minutos los tokens de autenticación de IAM generados. 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 redis-py y cachetools.

mkdir package

Instale 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, cree un archivo .zip con las bibliotecas redis-py y cachetools en la raíz con la utilidad de compresión zip que prefiera.

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, añada app.py al directorio raíz del archivo .zip con la utilidad de compresión zip que prefiera.

cd ..
zip my_deployment_package.zip app.py

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

Adjunta la política AWS administrada 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 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 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, 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 limpiar, siga estos pasos.

Paso 4.1: eliminación de la función de Lambda

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

Paso 4.2: eliminación de la caché sin servidor

Elimine la caché.

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

Quite usuarios y grupos 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: eliminación de políticas y el rol de IAM

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"