As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Tutorial: Configurando o Lambda para acessar em um ElastiCache VPC

Neste tutorial, você pode aprender como criar um cache ElastiCache sem servidor, criar uma função Lambda, testar a função Lambda e, opcionalmente, limpá-la depois.

Etapa 1: Criar um cache ElastiCache sem servidor.

Para criar um cache sem servidor, siga estas etapas.

Etapa 1.1: Criar um cache sem servidor

Nesta etapa, você cria um cache sem servidor na Amazon padrão na região us-east-1 VPC em sua conta usando o (). AWS Command Line Interface CLI Para obter informações sobre como criar cache sem servidor usando o ElastiCache console ouAPI, consulte. Crie um cache sem servidor Valkey

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

O valor do campo Status está definido como CREATING. Pode levar um minuto para concluir ElastiCache a criação do cache.

Etapa 1.2: Copiar o endpoint de cache sem servidor

Verifique se ElastiCache (RedisOSS) terminou de criar o cache com o describe-serverless-caches comando.

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

Copie o endereço do endpoint mostrado na saída. Você precisará desse endereço ao criar o pacote de implantação da função do Lambda.

Etapa 1.3: Criar IAM função

Etapa 1.4: Criar um cache sem servidor

Etapa 2: criar uma função Lambda para ElastiCache

Para criar uma função Lambda para acessar o ElastiCache cache, siga estas etapas.

Etapa 2.1: Criar uma função Lambda

Neste tutorial, fornecemos um exemplo de código em Python para sua função Lambda.

Python

O exemplo a seguir, o código Python lê e grava um item no seu ElastiCache cache. Copie o código e o salve em um arquivo chamado app.py. Certifique-se de substituir o elasticache_endpoint valor no código pelo endereço do endpoint que você copiou na etapa 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"

Esse código usa a biblioteca Python redis-py para colocar itens em seu cache e recuperá-los. Esse código usa ferramentas de cache para armazenar em cache os tokens de IAM autenticação gerados por 15 minutos. Para criar um pacote de implantação contendo redis-py e cachetools, execute as etapas a seguir.

No diretório do projeto contendo o arquivo de código-fonte app.py, crie um pacote de pastas para instalar as bibliotecas redis-py e cachetools.

mkdir package

Instale redis-py, cacheetools usando pip.

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

Crie um arquivo.zip contendo as bibliotecas redis-py e cachetools. No Linux e no MacOS, execute o comando a seguir. No Windows, use seu utilitário zip preferido para criar um arquivo.zip com as bibliotecas redis-py e cachetools na raiz.

cd package
zip -r ../my_deployment_package.zip .

Adicione o código de função ao arquivo .zip. No Linux e no MacOS, execute o comando a seguir. No Windows, use seu utilitário zip preferido para adicionar app.py à raiz do seu arquivo.zip.

cd ..
zip my_deployment_package.zip app.py

Etapa 2.2: Criar a IAM função (função de execução)

Anexe a política AWS gerenciada nomeada AWSLambdaVPCAccessExecutionRole à função.

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

Etapa 2.3: fazer upload do pacote de implantação (criar função do Lambda)

Nesta etapa, você cria a função Lambda (AccessValkey) usando o comando AWS CLI create-function.

No diretório do projeto que contém o arquivo.zip do pacote de implantação, execute o seguinte comando CLI create-function Lambda.

Para a opção de função, use a função ARN de execução que você criou na etapa anterior. Para o vpc-config, insira listas separadas por vírgulas das sub-redes padrão e VPC o ID do grupo de segurança padrão. VPC Você pode encontrar esses valores no VPC console da Amazon. Para encontrar as sub-redes padrãoVPC, escolha Seu e, em seguidaVPCs, escolha o padrão da sua AWS conta. VPC Para encontrar o grupo de segurança para issoVPC, vá para Segurança e escolha Grupos de segurança. Não se esqueça de selecionar a região 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

Etapa 3: Teste a função Lambda com ElastiCache

Nesta etapa, você invoca a função Lambda manualmente usando o comando invoke. Quando a função Lambda é executada, ela gera um UUID e o grava no ElastiCache cache que você especificou no seu código Lambda. Depois, a função do Lambda recupera o item do cache.

Etapa 4: limpar (opcional)

Para limpar, siga estas etapas.

Etapa 4.1: Excluir a função Lambda

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

Etapa 4.2: Excluir o cache sem servidor

Exclua o cache.

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

Remova usuários e grupos de usuários.

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

Etapa 4.3: Remover IAM função e 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"