

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 l'accesso ElastiCache in un VPC

In questo tutorial puoi imparare a creare un ElastiCache cache serverless, crea una funzione Lambda, quindi prova la funzione Lambda e, facoltativamente, pulisci dopo.

**Topics**
+ [Fase 1: Creazione di un ElastiCache cache serverless.](#LambdaRedis.step1)
+ [Passaggio 2: creare una funzione Lambda per ElastiCache](#LambdaRedis.step2)
+ [Fase 3: Testare la funzione Lambda con ElastiCache](#LambdaRedis.step3)
+ [Fase 4: Pulizia (opzionale)](#LambdaRedis.step4)

## Fase 1: Creazione di un ElastiCache cache serverless.
<a name="LambdaRedis.step1"></a>

Per creare una cache serverless, segui questi passaggi.

### Passaggio 1.1: Creare una cache serverless
<a name="LambdaRedis.step1.1"></a>

In questo passaggio, crei una cache serverless nell'Amazon VPC predefinito nella regione us-east-1 del tuo account utilizzando AWS Command Line Interface (CLI). Per informazioni sulla creazione di una cache serverless utilizzando ElastiCache console o API, vedi [Crea una cache serverless Valkey](GettingStarted.serverless-valkey.step1.md).

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

Si noti che il valore del campo Stato è impostato su `CREATING`. ElastiCache crea la tua cache in circa un minuto.

### Fase 1.2: Copia l'endpoint della cache serverless
<a name="LambdaRedis.step1.2"></a>

Verificalo ElastiCache ha terminato la creazione della cache con `describe-serverless-caches` comando.

```
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.

### Fase 1.3: Creare un ruolo IAM
<a name="LambdaRedis.step1.3"></a>



1. Crea un documento sulla policy di fiducia IAM, come mostrato di seguito, per il tuo ruolo che consenta al servizio Lambda di assumere il nuovo ruolo. Salva la policy in un file denominato *trust-policy.json*.

   ```json
   {
       "Version": "2012-10-17",
       "Statement": [{
           "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*.

   ```json
   {
       "Version": "2012-10-17",
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "elasticache:Connect"
               ],
               "Resource": [
                   "arn:aws:elasticache:us-east-1:123456789012:serverlesscache:cache-01",
                   "arn:aws:elasticache:us-east-1:123456789012:user:iam-user-01"
               ]
           }
       ]
   }
   ```

1. Crea un ruolo IAM.

   ```
   aws iam create-role \
   --role-name "elasticache-iam-auth-app" \
   --assume-role-policy-document file://trust-policy.json
   ```

1. Creare la policy IAM.

   ```
   aws iam create-policy \
     --policy-name "elasticache-allow-all" \
     --policy-document file://policy.json
   ```

1. Allega la policy IAM al ruolo.

   ```
   aws iam attach-role-policy \
    --role-name "elasticache-iam-auth-app" \
    --policy-arn "arn:aws:iam::123456789012:policy/elasticache-allow-all"
   ```

### Fase 1.4: Configurare l'autenticazione IAM
<a name="LambdaRedis.step1.4"></a>

**Importante**  
Questo passaggio è obbligatorio. La tua funzione Lambda si autentica su ElastiCache usando IAM. Affinché funzioni, è necessario creare un IAM-enabled ElastiCache utente, aggiungilo a un gruppo di utenti e associalo alla tua cache. Senza questa configurazione, i tentativi di connessione da parte di Lambda falliranno.

1. Crea un IAM-enabled utente. Questa è l'identità utente con cui la funzione Lambda si autenticherà.

   ```
   aws elasticache create-user \
     --user-name iam-user-01 \
     --user-id iam-user-01 \
     --authentication-mode Type=iam \
     --engine valkey \
     --access-string "on ~* +@all"
   ```

1. Crea un gruppo di utenti, aggiungici l'utente e associa il gruppo alla tua cache.

   ```
   aws elasticache create-user-group \
     --user-group-id iam-user-group-01 \
     --engine valkey \
     --user-ids iam-user-01
   
   aws elasticache modify-serverless-cache \
     --serverless-cache-name cache-01 \
     --user-group-id iam-user-group-01
   ```

## Passaggio 2: creare una funzione Lambda per ElastiCache
<a name="LambdaRedis.step2"></a>

Per creare una funzione Lambda per accedere a ElastiCache cache, segui questi passaggi.

### Fase 2.1: Creare una funzione Lambda
<a name="LambdaRedis.step2.1"></a>

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

**Python**

Il seguente esempio di codice Python legge e scrive un elemento nel tuo ElastiCache cache. Copia il codice e salvalo in un file denominato `app.py`. Assicurarsi di sostituire il `elasticache_endpoint` valore nel codice con l'indirizzo dell'endpoint copiato nel passaggio precedente. 

```
from typing import Tuple, Union
from urllib.parse import ParseResult, urlencode, urlunparse

import botocore.session
import valkey
from botocore.model import ServiceId
from botocore.signers import RequestSigner
from cachetools import TTLCache, cached
import uuid

class ElastiCacheIAMProvider(valkey.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)
    valkey_client = valkey.Valkey(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
    valkey_client.set(key, uuid_in)
    result = valkey_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 valkey-py per inserire elementi nella cache e recuperarli. Questo codice utilizza cachetools per memorizzare nella cache i token di autenticazione IAM generati per 15 minuti. Per creare un pacchetto di distribuzione contenente valkey-py e cachetools, esegui i seguenti passaggi.

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

```
mkdir package
```

Installa valkey-py, cachetools usando pip.

```
pip install --target ./package valkey
pip install --target ./package cachetools
```

Crea un file .zip contenente le librerie valkey-py e cachetools. Su Linux e macOS, esegui il comando seguente. In Windows, usate la vostra utilità zip preferita per creare un file .zip con le librerie valkey-py e cachetools come root.

```
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, usa la tua utilità zip preferita per aggiungere app.py alla radice del tuo file .zip.

```
cd ..
zip my_deployment_package.zip app.py
```

### Fase 2.2: creazione del ruolo IAM (ruolo di esecuzione)
<a name="LambdaRedis.step2.2"></a>

Allega il AWS politica 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)
<a name="LambdaRedis.step2.3"></a>

In questo passaggio, crei la funzione Lambda (AccessValkey) utilizzando la funzione di creazione AWS CLI comando. 

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

Per l'opzione role, usa l'ARN del ruolo di esecuzione che hai creato nel passaggio precedente. Per vpc-config, inserisci gli elenchi separati da virgole delle sottoreti del tuo VPC predefinito e l'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 **I tuoi VPC**, quindi scegli il tuo AWS VPC predefinito dell'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 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
<a name="LambdaRedis.step3"></a>

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 nel ElastiCache cache specificata nel codice Lambda. Successivamente la funzione Lambda recupera la voce dalla cache.

1. Richiama la funzione Lambda (AccessValkey) utilizzando AWS Lambda invoca il comando.

   ```
   aws lambda invoke \
   --function-name AccessValkey  \
   --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 Registra aprendo il CloudWatch console e scegliendo il gruppo di log per la tua funzione (/aws/lambda/AccessValkey). Il flusso di log genera un output simile al seguente:

     ```
     Success: Inserted 826e70c5f4d2478c8c18027125a3e01e. Fetched 826e70c5f4d2478c8c18027125a3e01e from Valkey.
     ```
   + Rivedi i risultati nel AWS Lambda console.

## Fase 4: Pulizia (opzionale)
<a name="LambdaRedis.step4"></a>

Per pulire, procedi nel seguente modo.

### Passaggio 4.1: Elimina la funzione Lambda
<a name="LambdaRedis.step4.1"></a>

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

### Passaggio 4.2: eliminare la cache Serverless
<a name="LambdaRedis.step4.2"></a>

Elimina 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
```

### Passaggio 4.3: rimuovere il ruolo e le politiche IAM
<a name="LambdaRedis.step4.3"></a>

```
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"
```