Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

Tutorial: Configurazione di Lambda per ElastiCache l'accesso in un VPC

In questo tutorial puoi imparare a creare una cache ElastiCache serverless, creare una funzione Lambda, quindi testare la funzione Lambda e, facoltativamente, ripulirla dopo.

Passaggio 1: creazione di una cache serverless. ElastiCache

Per creare una cache serverless, segui questi passaggi.

Passaggio 1.1: Creare una cache serverless

In questo passaggio, crei una cache serverless nell'Amazon predefinito VPC nella regione us-east-1 del tuo account utilizzando (). AWS Command Line Interface CLI Per informazioni sulla creazione di cache serverless utilizzando la ElastiCache console oppure, consulta. API Crea una cache serverless Valkey

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

Il valore del campo Stato è impostato su CREATING. Il completamento della creazione della cache può richiedere un minuto. ElastiCache

Passaggio 1.2: Copia l'endpoint della cache serverless

Verifica che ElastiCache (RedisOSS) abbia terminato la creazione della cache con il comando. describe-serverless-caches

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

Copia l'indirizzo dell'endpoint presente nell'output. Avrai bisogno di questo indirizzo quando crei il pacchetto di implementazione per la funzione Lambda.

Passaggio 1.3: Crea ruolo IAM

Fase 1.4: Creare una cache serverless

Fase 2: Creare una funzione Lambda per ElastiCache

Per creare una funzione Lambda per accedere alla ElastiCache cache, procedi nel seguente modo.

Fase 2.1: Creare una funzione Lambda

In questo tutorial, forniamo codice di esempio in Python per la tua funzione Lambda.

Python

L'esempio seguente di codice Python legge e scrive un elemento nella cache. ElastiCache Copia il codice e salvalo in un file denominato app.py. Assicurati di sostituire il elasticache_endpoint valore nel codice con l'indirizzo dell'endpoint che hai copiato nel passaggio precedente.

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"

Questo codice utilizza la libreria Python redis-py per inserire elementi nella cache e recuperarli. Questo codice utilizza cachetools per memorizzare nella cache i token di autenticazione generati per 15 minuti. IAM Per creare un pacchetto di distribuzione contenente redis-py e cachetools, procedi nel seguente modo.

Nella directory del progetto contenente il file di codice sorgente app.py, create un pacchetto di cartelle in cui installare le librerie redis-py e cachetools.

mkdir package

Installa redis-py, cachetools usando pip.

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

Crea un file.zip contenente le librerie redis-py e cachetools. Su Linux e macOS, esegui il comando seguente. In Windows, utilizzate l'utilità zip preferita per creare un file.zip con le librerie redis-py e cachetools alla radice.

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

Aggiungi il codice della funzione al file .zip. Su Linux e macOS, esegui il comando seguente. In Windows, utilizzate l'utilità zip preferita per aggiungere app.py alla radice del file .zip.

cd ..
zip my_deployment_package.zip app.py

Fase 2.2: Creare il IAM ruolo (ruolo di esecuzione)

Allega la politica AWS gestita denominata AWSLambdaVPCAccessExecutionRole al ruolo.

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

Fase 2.3: caricamento del pacchetto di implementazione (creazione della funzione Lambda)

In questo passaggio, crei la funzione Lambda (AccessValkey) utilizzando il comando AWS CLI create-function.

Dalla directory del progetto che contiene il file.zip del pacchetto di distribuzione, esegui il seguente comando CLI create-function Lambda.

Per l'opzione role, utilizzate il ruolo ARN di esecuzione creato nel passaggio precedente. Per vpc-config inserisci gli elenchi separati da virgole delle sottoreti predefinite e VPC dell'ID del gruppo di sicurezza predefinito. VPC Puoi trovare questi valori nella VPC console Amazon. Per trovare le sottoreti predefinite, scegli VPC YourVPCs, quindi scegli le impostazioni predefinite del tuo AWS account. VPC Per trovare il gruppo di sicurezza adattoVPC, vai su Sicurezza e scegli Gruppi di sicurezza. Assicurati di aver selezionato la regione 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

Fase 3: testare la funzione Lambda con ElastiCache

In questo passaggio, si richiama la funzione Lambda manualmente utilizzando il comando invoke. Quando la funzione Lambda viene eseguita, genera un file UUID e lo scrive ElastiCache nella cache specificata nel codice Lambda. Successivamente la funzione Lambda recupera la voce dalla cache.

Fase 4: Pulizia (opzionale)

Per eseguire la pulizia, procedi nel seguente modo.

Fase 4.1: Eliminare la funzione Lambda

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

Fase 4.2: Eliminare la cache serverless

Eliminare la cache.

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

Rimuovi utenti e gruppi di utenti.

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

Fase 4.3: Rimuovi IAM ruolo e politiche

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"