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: uso di Lambda con Amazon API Gateway In questo tutorial, viene creata una REST API tramite la quale viene richiamata una funzione Lambda utilizzando una richiesta HTTP. La funzione Lambda eseguirà operazioni di creazione, aggiornamento ed eliminazione (CRUD) su una tabella DynamoDB. Questa funzione viene fornita qui a scopo dimostrativo, ma imparerai a configurare una REST API di Gateway API in grado di richiamare qualsiasi funzione Lambda. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/APIG_tut_resources.png) L'utilizzo di Gateway API fornisce agli utenti un endpoint HTTP sicuro per richiamare la funzione Lambda e può aiutare a gestire grandi volumi di chiamate alla funzione limitando il traffico e convalidando e autorizzando automaticamente le chiamate API. API Gateway fornisce anche controlli di sicurezza flessibili utilizzando AWS Identity and Access Management (IAM) e Amazon Cognito. Ciò è utile nei casi d'uso in cui è richiesta un'autorizzazione preventiva per le chiamate all'applicazione. **Suggerimento** Lambda offre due modi per richiamare una funzione tramite un endpoint HTTP: API Gateway e funzione Lambda. URLs In caso di dubbi su quale sia il metodo migliore per il tuo caso d'uso, consulta [Selezionare un metodo per richiamare la funzione Lambda tramite una richiesta HTTP](apig-http-invoke-decision.md). Per completare questo tutorial, saranno completate le seguenti fasi: 1. Crea e configura una funzione Lambda in Python o Node.js per eseguire operazioni su una tabella DynamoDB. 1. Crea una REST API in Gateway API per connetterti alla funzione Lambda. 1. Crea una tabella DynamoDB e testala con la funzione Lambda nella console. 1. Implementa la tua API e testa la configurazione completa usando curl in un terminale. Completando queste fasi, imparerai come utilizzare Gateway API per creare un endpoint HTTP in grado di richiamare in modo sicuro una funzione Lambda su qualsiasi scala. Imparerai anche come distribuire la tua API e come testarla nella console e inviando una richiesta HTTP tramite un terminale. ## Creazione di una policy di autorizzazione Prima di poter creare un [ruolo di esecuzione](lambda-intro-execution-role.md) per la tua funzione Lambda, devi prima creare una politica di autorizzazioni per concedere alla funzione il permesso di accedere alle risorse richieste. AWS Per questo tutorial, la policy consente a Lambda di eseguire operazioni CRUD su una tabella DynamoDB e scrivere su Amazon Logs. CloudWatch **Come creare la policy** 1. Apri la pagina [Policies (Policy)](https://console.aws.amazon.com/iam/home#/policies) nella console IAM. 1. Scegli **Crea policy**. 1. Scegliere la scheda **JSON** e quindi incollare la seguente policy personalizzata nell'editor JSON. ------ #### [ JSON ] **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "Stmt1428341300017", "Action": [ "dynamodb:DeleteItem", "dynamodb:GetItem", "dynamodb:PutItem", "dynamodb:Query", "dynamodb:Scan", "dynamodb:UpdateItem" ], "Effect": "Allow", "Resource": "*" }, { "Sid": "", "Resource": "*", "Action": [ "logs:CreateLogGroup", "logs:CreateLogStream", "logs:PutLogEvents" ], "Effect": "Allow" } ] } ``` ------ 1. Scegliere **Next: Tags (Successivo: Tag)**. 1. Scegliere **Next:Review (Successivo: Rivedi)**. 1. In **Rivedi policy**, per **Nome** della policy inserisci **lambda-apigateway-policy**. 1. Scegli **Crea policy**. ## Creazione di un ruolo di esecuzione Un [ruolo di esecuzione](lambda-intro-execution-role.md) è un ruolo AWS Identity and Access Management (IAM) che concede a una funzione Lambda l'autorizzazione all' Servizi AWS accesso e alle risorse. Per consentire alla funzione di eseguire operazioni su una tabella DynamoDB, collega la policy di autorizzazione che hai creato nella fase precedente. **Creazione di un ruolo di esecuzione e collegamento di una policy di autorizzazione personalizzata** 1. Aprire la [pagina Roles (Ruoli)](https://console.aws.amazon.com/iam/home#/roles) della console IAM. 1. Scegli **Crea ruolo**. 1. Per il tipo di entità attendibile, scegli **Servizio AWS **, quindi per il caso d'uso seleziona **Lambda**. 1. Scegli **Next (Successivo)**. 1. Nella casella di ricerca delle policy, immettere **lambda-apigateway-policy**. 1. Nei risultati della ricerca, seleziona la policy creata (`lambda-apigateway-policy`), quindi scegli **Next** (Successivo). 1. In **Role details** (Dettagli del ruolo), per **Role name** (Nome del ruolo), specifica **lambda-apigateway-role**, quindi scegli **Create role** (Crea ruolo). ## Creazione della funzione Lambda 1. Apri la [pagina Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda e scegli **Crea funzione**. 1. Scegli **Crea da zero**. 1. Nel campo **Function name (Nome funzione)**, immettere `LambdaFunctionOverHttps`. 1. Per **Runtime**, scegli l'ultimo runtime di Node.js o di Python. 1. In **Autorizzazioni** espandere **Modifica ruolo di esecuzione predefinito**. 1. Scegli **Utilizza un ruolo esistente**, quindi seleziona il ruolo **lambda-apigateway-role** creato in precedenza. 1. Scegli **Crea funzione**. 1. Nel riquadro **Fonte codice**, sostituisci il codice predefinito con il seguente codice Node.js o Python. ------ #### [ Node.js ] L'`region`impostazione deve corrispondere al Regione AWS luogo in cui si distribuisce la funzione e si [crea la tabella DynamoDB](#services-apigateway-tutorial-table). **Example index.mjs** ``` import { DynamoDBDocumentClient, PutCommand, GetCommand, UpdateCommand, DeleteCommand} from "@aws-sdk/lib-dynamodb"; import { DynamoDBClient } from "@aws-sdk/client-dynamodb"; const ddbClient = new DynamoDBClient({ region: "us-east-2" }); const ddbDocClient = DynamoDBDocumentClient.from(ddbClient); // Define the name of the DDB table to perform the CRUD operations on const tablename = "lambda-apigateway"; /** * Provide an event that contains the following keys: * * - operation: one of 'create,' 'read,' 'update,' 'delete,' or 'echo' * - payload: a JSON object containing the parameters for the table item * to perform the operation on */ export const handler = async (event, context) => { const operation = event.operation; if (operation == 'echo'){ return(event.payload); } else { event.payload.TableName = tablename; let response; switch (operation) { case 'create': response = await ddbDocClient.send(new PutCommand(event.payload)); break; case 'read': response = await ddbDocClient.send(new GetCommand(event.payload)); break; case 'update': response = ddbDocClient.send(new UpdateCommand(event.payload)); break; case 'delete': response = ddbDocClient.send(new DeleteCommand(event.payload)); break; default: response = 'Unknown operation: ${operation}'; } console.log(response); return response; } }; ``` ------ #### [ Python ] **Example lambda\$1function.py** ``` import boto3 # Define the DynamoDB table that Lambda will connect to table_name = "lambda-apigateway" # Create the DynamoDB resource dynamo = boto3.resource('dynamodb').Table(table_name) # Define some functions to perform the CRUD operations def create(payload): return dynamo.put_item(Item=payload['Item']) def read(payload): return dynamo.get_item(Key=payload['Key']) def update(payload): return dynamo.update_item(**{k: payload[k] for k in ['Key', 'UpdateExpression', 'ExpressionAttributeNames', 'ExpressionAttributeValues'] if k in payload}) def delete(payload): return dynamo.delete_item(Key=payload['Key']) def echo(payload): return payload operations = { 'create': create, 'read': read, 'update': update, 'delete': delete, 'echo': echo, } def lambda_handler(event, context): '''Provide an event that contains the following keys: - operation: one of the operations in the operations dict below - payload: a JSON object containing parameters to pass to the operation being performed ''' operation = event['operation'] payload = event['payload'] if operation in operations: return operations[operation](payload) else: raise ValueError(f'Unrecognized operation "{operation}"') ``` ------ **Nota** In questo esempio, il nome della tabella DynamoDB è definito come variabile nel codice della funzione. In un'applicazione reale, la best practice consiste nell'inviare questo parametro come variabile d'ambiente ed evitare di codificare il nome della tabella. Per ulteriori informazioni, consulta [Uso AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html) delle variabili di ambiente. 1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione: ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/getting-started-tutorial/deploy-console.png) ## Test della funzione Prima di integrare la tua funzione con Gateway API, verifica di aver implementato correttamente la funzione. Utilizza la console Lambda per inviare un evento di test alla tua funzione. 1. Nella pagina della console Lambda della funzione, scegli la scheda **Test**. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/test-tab.png) 1. Scorri alla sezione **JSON dell'evento** e sostituisci l’evento predefinito con il seguente. Questo evento corrisponde alla struttura prevista dalla funzione Lambda. ``` { "operation": "echo", "payload": { "somekey1": "somevalue1", "somekey2": "somevalue2" } } ``` 1. Scegli **Test (Esegui test)**. 1. In **Esecuzione funzione: riuscita**, espandi **Dettagli**. Dovrebbe essere visualizzata la seguente risposta: ``` { "somekey1": "somevalue1", "somekey2": "somevalue2" } ``` ## Creazione di una REST API utilizzando API Gateway In questa fase, viene creata la REST API di Gateway API che sarà utilizzata per richiamare la funzione Lambda. **Per creare l'API** 1. Apri la [console API Gateway](https://console.aws.amazon.com/apigateway). 1. Seleziona **Create API** (Crea API). 1. Nella casella **REST API**, scegliere **Build**. 1. In **Dettagli API**, lasciare selezionata **Nuova API** e per **Nome API**, inserire **DynamoDBOperations**. 1. Seleziona **Create API** (Crea API). ## Creazione di una risorsa sulla REST API Per aggiungere un metodo HTTP all'API, è necessario prima creare una risorsa su cui quel metodo possa operare. Qui viene creata la risorsa per gestire la tabella DynamoDB. **Per creare la risorsa** 1. Nella [console API Gateway](https://console.aws.amazon.com/apigateway), nella pagina **Risorse** dell'API, scegliere **Crea risorsa**. 1. In **Dettagli risorsa**, per **Nome risorsa**, inserire **DynamoDBManager**. 1. Scegliere **Create Resource (Crea risorsa)**. ## Creazione di un metodo HTTP POST In questa fase, viene creato un metodo (`POST`) per la risorsa `DynamoDBManager`. Il metodo `POST` viene collegato alla funzione Lambda in modo che quando il metodo riceve una richiesta HTTP, Gateway API richiama la funzione Lambda. **Nota** Ai fini di questo tutorial, viene utilizzato un metodo HTTP (`POST`) per richiamare una singola funzione Lambda che esegue tutte le operazioni sulla tabella DynamoDB. In un'applicazione reale, la best practice consiste nell'utilizzare una funzione Lambda e un metodo HTTP diversi per ogni operazione. Per ulteriori informazioni, consulta [Il monolite Lambda](https://serverlessland.com/content/service/lambda/guides/aws-lambda-operator-guide/monolith) in Serverless Land. **Creazione del metodo POST** 1. Nella pagina **Risorse** dell'API, assicurarsi che la risorsa `/DynamoDBManager` sia evidenziata. Quindi, nel riquadro **Metodi**, scegliere **Crea metodo**. 1. Per **Metodo HTTP** scegliere **POST**. 1. Per **Tipo di integrazione** lasciare selezionato **Funzione Lambda**. 1. Per la **funzione Lambda**, scegliere nome della risorsa Amazon (ARN) per la funzione (`LambdaFunctionOverHttps`). 1. Scegli **Crea metodo**. ## Creazione di una tabella DynamoDB Crea una tabella DynamoDB vuota su cui la funzione Lambda eseguirà le operazioni CRUD. **Creare la tabella DynamoDB** 1. Aprire la pagina [Tables (Tabelle)](https://console.aws.amazon.com/dynamodbv2#tables) della console DynamoDB. 1. Scegliere **Create table (Crea tabella)**. 1. In **Table details (Dettagli tabella)**, effettuare le seguenti operazioni: 1. Nel campo **Table name (Nome tabella)** immetti **lambda-apigateway**. 1. Per **Partition key (Chiave di partizione)**, immettere **id** e mantenere il tipo di dati impostato come **String (Stringa)**. 1. In **Table settings** (Impostazioni tabella), mantieni le **impostazioni predefinite**. 1. Scegliere **Create table (Crea tabella)**. ## Test dell'integrazione di Gateway API, Lambda e DynamoDB A questo punto sei pronto per testare l'integrazione del metodo API di Gateway API con la funzione Lambda e la tabella DynamoDB. Utilizzando la console di Gateway API, invii le richieste direttamente al metodo `POST` utilizzando la funzione di test della console. In questo passaggio, viene utilizzata prima un'operazione `create` per aggiungere un nuovo elemento alla tabella DynamoDB, quindi viene utilizzata un'operazione `update` per modificare l'elemento. **Test 1: creazione di un nuovo elemento nella tabella DynamoDB** 1. Nella [console di Gateway API](https://console.aws.amazon.com/apigateway), scegli l'API (`DynamoDBOperations`). 1. Scegli il metodo **POST** sotto la risorsa `DynamoDBManager`. 1. Seleziona la scheda **Test**. Potrebbe essere necessario scegliere il pulsante freccia destra per visualizzare la scheda. 1. In **Metodo di prova**, lasciare vuote le **stringhe di query** e le **intestazioni**. Per **Corpo della richiesta**, incollare il file JSON seguente: ``` { "operation": "create", "payload": { "Item": { "id": "1234ABCD", "number": 5 } } } ``` 1. Scegli **Test (Esegui test)**. I risultati visualizzati al termine del test devono mostrare lo stato `200`. Questo codice di stato indica che l'operazione `create` è riuscita. Come verifica, controlla che la tabella DynamoDB contenga il nuovo elemento. 1. Apri la pagina [Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tabelle) della console DynamoDB e scegli la tabella `lambda-apigateway`. 1. Scegli **Explore table items** (Esplora elementi della tabella). Nel riquadro **Items returned** (Elementi restituiti), dovresti vedere un elemento con l'**id** `1234ABCD` e il **numero** `5`. Esempio: ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/items-returned.png) **Test 2: aggiornamento dell'elemento nella tabella DynamoDB** 1. Nella [Console API Gateway](https://console.aws.amazon.com/apigateway), tornare alla scheda **Test** del metodo POST. 1. In **Metodo di prova**, lasciare vuote le **stringhe di query** e le **intestazioni**. Per **Corpo della richiesta**, incollare il file JSON seguente: ``` { "operation": "update", "payload": { "Key": { "id": "1234ABCD" }, "UpdateExpression": "SET #num = :newNum", "ExpressionAttributeNames": { "#num": "number" }, "ExpressionAttributeValues": { ":newNum": 10 } } } ``` 1. Scegli **Test (Esegui test)**. I risultati visualizzati al termine del test devono mostrare lo stato `200`. Questo codice di stato indica che l'operazione `update` è riuscita. Per confermare, controlla che l'elemento nella tua tabella DynamoDB sia stato modificato. 1. Apri la pagina [Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tabelle) della console DynamoDB e scegli la tabella `lambda-apigateway`. 1. Scegli **Explore table items** (Esplora elementi della tabella). Nel riquadro **Items returned** (Elementi restituiti), dovresti vedere un elemento con l'**id** `1234ABCD` e il **numero** `10`. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/items-returned-2.png) ## Distribuzione dell'API Per consentire al client di chiamare l'API, è necessario creare una implementazione e una fase associata. Una fase rappresenta un'istantanea dell'API, inclusi i suoi metodi e le sue integrazioni. **Per distribuire l'API** 1. Apri la **APIs**pagina della [console API Gateway](https://console.aws.amazon.com/apigateway) e scegli l'`DynamoDBOperations`API. 1. Nella pagina **Risorse** per la tua API, scegliere **Distribuzione dell'API**. 1. Per **Fase**, scegliere **\$1Nuova fase\$1** quindi per **Nome fase** specificare **test**. 1. Seleziona **Implementa**. 1. Nel riquadro **Editor fase** (Editor fasi) del test, copia l'**URL di richiamo**. Questo verrà utilizzato nella fase successiva per richiamare la tua funzione utilizzando una richiesta HTTP. ## Uso di curl per richiamare la funzione tramite le richieste HTTP A questo punto è possibile richiamare la funzione Lambda inviando una richiesta HTTP all'API. In questo passaggio, verrà creato un nuovo elemento nella tabella DynamoDB e quindi verranno eseguite le operazioni di lettura, aggiornamento ed eliminazione su tale elemento. **Per creare un elemento nella tabella DynamoDB utilizzando curl** 1. Apri un terminale o un prompt dei comandi sul computer locale ed esegui il comando `curl` seguente utilizzando l'URL di invocazione che hai copiato nel passaggio precedente. Questo comando utilizza le seguenti opzioni: + `-H`: aggiunge un'intestazione personalizzata alla richiesta. Qui specifica il tipo di contenuto come JSON. + `-d`: invia i dati nel corpo della richiesta. Per impostazione predefinita, questa opzione utilizza un metodo HTTP POST. ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "create", "payload": {"Item": {"id": "5678EFGH", "number": 15}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"create\", \"payload\": {\"Item\": {\"id\": \"5678EFGH\", \"number\": 15}}}' ``` ------ Se l'operazione ha avuto esito positivo, dovrebbe essere restituita una risposta con un codice di stato HTTP di 200. 1. È inoltre possibile utilizzare la console DynamoDB per verificare che il nuovo elemento sia nella tabella effettuando le operazioni seguenti: 1. Apri la pagina [Tables](https://console.aws.amazon.com/dynamodbv2#tables) (Tabelle) della console DynamoDB e scegli la tabella `lambda-apigateway`. 1. Scegli **Explore table items** (Esplora elementi della tabella). Nel riquadro **Items returned** (Elementi restituiti), dovresti vedere un elemento con l'**id** `5678EFGH` e il **numero** `15`. **Per leggere l'elemento nella tabella DynamoDB utilizzando curl** + Nel terminale o nel prompt dei comandi, esegui il comando `curl` seguente per leggere il valore dell'elemento appena creato. Utilizzo dei propri URL di richiamo ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ Dovresti vedere un output simile a uno dei seguenti a seconda che tu abbia scelto il codice della funzione Node.js o Python: ------ #### [ Node.js ] ``` {"$metadata":{"httpStatusCode":200,"requestId":"7BP3G5Q0C0O1E50FBQI9NS099JVV4KQNSO5AEMVJF66Q9ASUAAJG", "attempts":1,"totalRetryDelay":0},"Item":{"id":"5678EFGH","number":15}} ``` ------ #### [ Python ] ``` {"Item":{"id":"5678EFGH","number":15},"ResponseMetadata":{"RequestId":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG", "HTTPStatusCode":200,"HTTPHeaders":{"server":"Server","date":"Wed, 31 Jul 2024 00:37:01 GMT","content-type":"application/x-amz-json-1.0", "content-length":"52","connection":"keep-alive","x-amzn-requestid":"QNDJICE52E86B82VETR6RKBE5BVV4KQNSO5AEMVJF66Q9ASUAAJG","x-amz-crc32":"2589610852"}, "RetryAttempts":0}} ``` ------ **Per aggiornare l'elemento nella tabella DynamoDB utilizzando curl** 1. Nel terminale o nel prompt dei comanti, esegui il comando `curl` seguente per aggiornare l'elemento appena creato modificando il valore `number`. Utilizzo dei propri URL di richiamo ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "update", "payload": {"Key": {"id": "5678EFGH"}, "UpdateExpression": "SET #num = :new_value", "ExpressionAttributeNames": {"#num": "number"}, "ExpressionAttributeValues": {":new_value": 42}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"update\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}, \"UpdateExpression\": \"SET #num = :new_value\", \"ExpressionAttributeNames\": {\"#num\": \"number\"}, \"ExpressionAttributeValues\": {\":new_value\": 42}}}' ``` ------ 1. Per verificare che il valore di `number` per l'elemento sia stato aggiornato, esegui un altro comando di lettura: ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "read", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"read\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ **Per eliminare l'elemento nella tabella DynamoDB utilizzando curl** 1. Nel terminale o nel prompt dei comandi, esegui il comando `curl` seguente per eliminare l'elemento appena creato. Utilizzo dei propri URL di richiamo ------ #### [ Linux/macOS ] ``` curl https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager \ -H "Content-Type: application/json" \ -d '{"operation": "delete", "payload": {"Key": {"id": "5678EFGH"}}}' ``` ------ #### [ PowerShell ] ``` curl.exe 'https://l8togsqxd8.execute-api.us-east-2.amazonaws.com/test/DynamoDBManager' -H 'Content-Type: application/json' -d '{\"operation\": \"delete\", \"payload\": {\"Key\": {\"id\": \"5678EFGH\"}}}' ``` ------ 1. Verifica che l'operazione di eliminazione è andata a buon fine. Nel riquadro **Elementi restituiti** della pagina **Esplora elementi** della console DynamoDB, verifica che l'elemento con **id** `5678EFGH` non sia più presente nella tabella. ## Pulizia delle risorse (facoltativo) Ora è possibile eliminare le risorse create per questo tutorial, a meno che non si voglia conservarle. Eliminando AWS le risorse che non utilizzi più, eviti addebiti inutili a tuo Account AWS carico. **Per eliminare la funzione Lambda** 1. Aprire la pagina [Functions (Funzioni)](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Selezionare la funzione creata. 1. Scegliere **Operazioni**, **Elimina**. 1. Inserisci **confirm** nel campo di immissione del testo, quindi scegli **Elimina**. **Come eliminare il ruolo di esecuzione** 1. Aprire la pagina [Ruoli](https://console.aws.amazon.com/iam/home#/roles) della console IAM. 1. Selezionare il ruolo di esecuzione creato. 1. Scegliere **Elimina**. 1. Inserisci il nome del ruolo nel campo di immissione testo e seleziona **Delete** (Elimina). **Per eliminare l'API** 1. Apri la [APIs pagina](https://console.aws.amazon.com/apigateway/main/apis) della console API Gateway. 1. Selezionare l'API creata. 1. Scegliere **Actions (Operazioni)**, **Delete (Elimina)**. 1. Scegliere **Delete (Elimina)**. **Per eliminare la tabella DynamoDB** 1. Aprire la pagina [Tables (Tabelle)](https://console.aws.amazon.com//dynamodb/home#tables:) della console DynamoDB. 1. Selezionare la tabella creata. 1. Scegliere **Delete (Elimina)**. 1. Immettere **delete** nella casella di testo. 1. Seleziona **Delete Table (Elimina tabella)**.