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 una funzione Lambda per accedere a MemoryDB in un Amazon VPC In questo tutorial puoi imparare a: + Crea un cluster MemoryDB nel tuo Amazon Virtual Private Cloud (Amazon VPC) predefinito nella regione us-east-1. + Crea una funzione Lambda per accedere al cluster. Quando crei la funzione Lambda, fornisci una sottorete nel IDs tuo Amazon VPC e un gruppo di sicurezza VPC per consentire alla funzione Lambda di accedere alle risorse nel tuo VPC. A titolo illustrativo in questo tutorial, la funzione Lambda genera un UUID, lo scrive nel cluster e lo recupera dal cluster. + Richiama la funzione Lambda manualmente e verifica che abbia avuto accesso al cluster nel tuo VPC. + Pulisci la funzione Lambda, il cluster e il ruolo IAM configurati per questo tutorial. **Topics** + [Fase 1: creazione di un cluster](#LambdaMemoryDB.step1) + [Passaggio 2: creazione di una funzione Lambda](#LambdaMemoryDB.step2) + [Fase 3: esecuzione del test della funzione Lambda](#LambdaMemoryDB.step3) + [Fase 4: Pulizia (opzionale)](#LambdaMemoryDB.step4) ## Fase 1: creazione di un cluster Per creare un cluster, segui questi passaggi. ### Creazione di un cluster In questa fase, crei un cluster nel VPC Amazon predefinito nella regione us-east-1 del tuo account utilizzando (CLI). AWS Command Line Interface Per informazioni sulla creazione di cluster utilizzando la console o l'API di MemoryDB, consulta. [Fase 2: creazione di un cluster](getting-started.md#getting-started.createcluster) ``` 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 ``` Il valore del campo Stato è impostato su `CREATING`. MemoryDB può impiegare alcuni minuti per completare la creazione del cluster. ### Copia l'endpoint del cluster Verifica che MemoryDB abbia terminato la creazione del cluster con il comando. ` describe-clusters` ``` aws memorydb describe-clusters \ --cluster-name cluster-01 ``` Copia l'indirizzo dell'endpoint del cluster mostrato nell'output. Avrai bisogno di questo indirizzo quando crei il pacchetto di implementazione per la funzione Lambda. ### Crea un ruolo IAM 1. Crea un documento della policy di attendibilità IAM per il ruolo, come mostrato di seguito, che consenta all'account di assumere il nuovo ruolo. Salva la policy in un file denominato *trust-policy.json*. Assicurati di sostituire account\_id 123456789012 in questa politica con il tuo account\_id. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [{ "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::123456789012:root" }, "Action": "sts:AssumeRole" }, { "Effect": "Allow", "Principal": { "Service": "lambda.amazonaws.com" }, "Action": "sts:AssumeRole" }] } ``` ------ 1. Crea un documento della policy IAM, come mostrato di seguito. Salva la policy in un file denominato *policy.json*. Assicurati di sostituire account\_id 123456789012 in questa politica con il tuo account\_id. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect" : "Allow", "Action" : [ "memorydb:Connect" ], "Resource" : [ "arn:aws:memorydb:us-east-1:123456789012:cluster/cluster-01", "arn:aws:memorydb:us-east-1:123456789012:user/iam-user-01" ] } ] } ``` ------ 1. Crea un ruolo IAM. ``` aws iam create-role \ --role-name "memorydb-iam-auth-app" \ --assume-role-policy-document file://trust-policy.json ``` 1. Creare la policy IAM. ``` aws iam create-policy \ --policy-name "memorydb-allow-all" \ --policy-document file://policy.json ``` 1. Allega la policy IAM al ruolo. Assicurati di sostituire account\_id 123456789012 in questo policy-arn con il tuo account\_id. ``` aws iam attach-role-policy \ --role-name "memorydb-iam-auth-app" \ --policy-arn "arn:aws:iam::123456789012:policy/memorydb-allow-all" ``` ### Crea una lista di controllo degli accessi (ACL) 1. Crea un nuovo utente attivato da IAM. ``` aws memorydb create-user \ --user-name iam-user-01 \ --authentication-mode Type=iam \ --access-string "on ~* +@all" ``` 1. Crea un ACL e collegalo al cluster. ``` aws memorydb create-acl \ --acl-name iam-acl-01 \ --user-names iam-user-01 aws memorydb update-cluster \ --cluster-name cluster-01 \ --acl-name iam-acl-01 ``` ## Passaggio 2: creazione di una funzione Lambda Per creare una funzione Lambda, procedi nel seguente modo. ### Creazione del pacchetto di implementazione 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 nel cluster MemoryDB. Copia il codice e salvalo in un file denominato `app.py`. Assicurati di sostituire il `cluster_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 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" ``` Questo codice utilizza la `redis-py` libreria Python per inserire elementi nel cluster e recuperarli. Questo codice viene utilizzato `cachetools` per memorizzare nella cache i token di autenticazione IAM generati per 15 minuti. Per creare un pacchetto di distribuzione contenente `redis-py` e`cachetools`, procedi nel seguente modo. Nella directory del progetto contenente il file del codice `app.py` sorgente, create un pacchetto di cartelle in cui installare le `cachetools` librerie `redis-py` and. ``` mkdir package ``` Installa `redis-py` e `cachetools` usa pip. ``` pip install --target ./package redis pip install --target ./package cachetools ``` Crea un file.zip contenente le librerie `redis-py` and`cachetools`. In Linux e macOS, esegui il seguente comando. In Windows, utilizzate l'utilità zip preferita per creare un file.zip con le `cachetools` librerie `redis-py` and 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 con estensione zip. ``` cd .. zip my_deployment_package.zip app.py ``` ### Crea il ruolo IAM (ruolo di esecuzione) Allega la policy AWS gestita denominata `AWSLambdaVPCAccessExecutionRole` al ruolo. ``` aws iam attach-role-policy \ --role-name "memorydb-iam-auth-app" \ --policy-arn "arn:aws:iam::aws:policy/service-role/AWSLambdaVPCAccessExecutionRole" ``` ### Carica il pacchetto di distribuzione (crea la funzione Lambda) In questo passaggio, si crea la funzione Lambda (AccessMemoryDB) utilizzando il comando AWS CLI create-function. Dalla directory del progetto che contiene il file.zip del pacchetto di distribuzione, esegui il seguente comando Lambda `create-function` CLI. Per l'opzione role, utilizzate l'ARN del ruolo di esecuzione creato nel passaggio precedente. Per vpc-config inserisci gli elenchi separati da virgole delle sottoreti del tuo VPC predefinito e dell'ID del gruppo di sicurezza del tuo VPC predefinito. Questi valori sono disponibili nella console Amazon VPC. Per trovare le sottoreti del tuo VPC predefinito, scegli **Your VPCs, quindi scegli il** VPC predefinito AWS del tuo account. Per trovare il gruppo di sicurezza per questo VPC, vai su **Sicurezza** e scegli Gruppi di **sicurezza**. Assicurati di aver selezionato la regione 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 ``` ## Fase 3: esecuzione del test della funzione Lambda In questo passaggio, si richiama la funzione Lambda manualmente utilizzando il comando invoke. Quando la funzione Lambda viene eseguita, genera un UUID e lo scrive nella ElastiCache cache specificata nel codice Lambda. Successivamente la funzione Lambda recupera la voce dalla cache. 1. Invoca la funzione Lambda AccessMemory (DB) utilizzando AWS Lambda il comando invoke. ``` aws lambda invoke \ --function-name AccessMemoryDB \ --region us-east-1 \ output.txt ``` 1. Eseguire le operazioni seguenti per verificare che la funzione Lambda sia stata eseguita nel modo corretto: + Esaminare il file output.txt. + Verifica i risultati in CloudWatch Logs aprendo la CloudWatch console e scegliendo il gruppo di log per la tua funzione (/). aws/lambda/AccessRedis Il flusso di log genera un output simile al seguente: ``` Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from MemoryDB. ``` + Controlla i risultati nella AWS Lambda console. ## Fase 4: Pulizia (opzionale) Per eseguire la pulizia, procedi nel seguente modo. ### Elimina la funzione Lambda ``` aws lambda delete-function \ --function-name AccessMemoryDB ``` ### Elimina il cluster MemoryDB Elimina il cluster. ``` aws memorydb delete-cluster \ --cluster-name cluster-01 ``` Rimuovi utente e ACL. ``` aws memorydb delete-user \ --user-id iam-user-01 aws memorydb delete-acl \ --acl-name iam-acl-01 ``` ### Rimuovi il ruolo e le politiche IAM ``` 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" ```