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à. # Richiamo di funzione Lambda utilizzando un endpoint Gateway Amazon API È possibile creare un'API web con un endpoint HTTP per la funzione Lambda utilizzando Amazon API Gateway. API Gateway fornisce strumenti per creare e documentare siti Web APIs che instradano le richieste HTTP verso le funzioni Lambda. È possibile proteggere l'accesso all'API con controlli di autenticazione e autorizzazione. APIs Puoi servire il traffico su Internet o essere accessibile solo all'interno del tuo VPC. **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). Le risorse nell'API definiscono uno o più metodi, ad esempio GET o POST. I metodi hanno un'integrazione che instrada le richieste a una funzione Lambda o a un altro tipo di integrazione. È possibile definire ogni risorsa e metodo singolarmente oppure utilizzare tipi di risorse e metodi speciali per soddisfare tutte le richieste che si adattano a un modello. Una [risorsa proxy](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html) cattura tutti i percorsi sottostanti una risorsa. Il metodo `ANY` cattura tutti i metodi HTTP. **Topics** + [Scelta di un tipo di API](#services-apigateway-apitypes) + [Aggiunta di un endpoint alla funzione Lambda](#apigateway-add) + [Integrazione proxy](#apigateway-proxy) + [Formato dell'evento](#apigateway-example-event) + [Formato della risposta](#apigateway-types-transforms) + [Permissions](#apigateway-permissions) + [Applicazione di esempio](#services-apigateway-samples) + [Il gestore di eventi di Powertools for Lambda AWS](#services-apigateway-powertools) + [Tutorial: uso di Lambda con Amazon API Gateway](services-apigateway-tutorial.md) + [Gestione degli errori con un'API di API Gateway](services-apigateway-errors.md) + [Selezionare un metodo per richiamare la funzione Lambda tramite una richiesta HTTP](apig-http-invoke-decision.md) ## Scelta di un tipo di API API Gateway supporta tre tipi di funzioni APIs che richiamano funzioni Lambda: + [API HTTP: un'API](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) leggera e a bassa RESTful latenza. + [API REST: un'API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html) personalizzabile e ricca di funzionalità RESTful . + [WebSocket API](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html): un'API Web che mantiene connessioni persistenti con i client per comunicazioni full-duplex. HTTP APIs e REST APIs elaborano entrambe RESTful APIs le richieste HTTP e restituiscono risposte. APIs Gli HTTP sono più recenti e sono creati con l'API API Gateway versione 2. Le seguenti funzionalità sono nuove per HTTP: APIs **Funzionalità API HTTP** + **Distribuzioni automatiche**: quando si modificano routing o integrazioni, le modifiche vengono distribuite automaticamente alle fasi in cui è abilitata la distribuzione automatica. + **Fase predefinita**: è possibile creare una fase predefinita (`$default`) che invii le richieste nel percorso root dell'URL dell'API. Per le fasi denominate, è necessario includere il nome dello stage all'inizio del percorso. + **Configurazione CORS:** è possibile configurare l'API in modo da aggiungere intestazioni CORS alle risposte in uscita, invece di aggiungerle manualmente nel codice della funzione. APIs I REST sono i classici RESTful APIs che API Gateway ha supportato sin dal lancio. APIs Attualmente REST offre più funzionalità di personalizzazione, integrazione e gestione. **Funzionalità REST API** + **Tipi di integrazione**: REST APIs supporta integrazioni Lambda personalizzate. Con un'integrazione personalizzata, è possibile inviare solo il corpo della richiesta alla funzione, o applicare un modello di trasformazione al corpo della richiesta prima di inviarlo alla funzione. + **Controllo degli accessi**: REST APIs supporta più opzioni per l'autenticazione e l'autorizzazione. + **Monitoraggio e tracciamento**: REST APIs supporta il AWS X-Ray tracciamento e opzioni di registrazione aggiuntive. Per un confronto dettagliato, consulta [Choose between HTTP APIs and REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-vs-rest.html) nella *API Gateway Developer Guide*. WebSocket APIs utilizza anche l'API API Gateway versione 2 e supporta un set di funzionalità simile. Utilizza un' WebSocket API per le applicazioni che traggono vantaggio da una connessione persistente tra il client e l'API. WebSocket APIs forniscono una comunicazione full-duplex, il che significa che sia il client che l'API possono inviare messaggi in modo continuo senza attendere una risposta. HTTP APIs supporta un formato di eventi semplificato (versione 2.0). Per un esempio di evento da un'API HTTP, consulta [Creare integrazioni AWS Lambda proxy per HTTP APIs in API Gateway](https://docs.aws.amazon.com//apigateway/latest/developerguide/http-api-develop-integrations-lambda.html). Per ulteriori informazioni, consulta [Creare integrazioni AWS Lambda proxy per HTTP APIs in API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html). ## Aggiunta di un endpoint alla funzione Lambda **Per aggiungere un endpoint pubblico alla funzione Lambda** 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegliere una funzione. 1. In **Function overview (Panoramica delle funzioni)**, scegliere **Add trigger (Aggiungi trigger)**. 1. Selezionare **API Gateway**. 1. Scegliere **Create an API** (Crea una nuova API) o **Use an existing API** (Usa un'API esistente). 1. **Nuova API:** per **API type** (Tipo di API), scegliere **HTTP API** (API HTTP). Per ulteriori informazioni, consulta [Scelta di un tipo di API](#services-apigateway-apitypes). 1. **API esistente:** seleziona l'API dal menu a discesa o inserisci l'ID API (ad esempio, r3pmxmplak). 1. Per **Security (Sicurezza)**, scegliere **Open (Apri)**. 1. Scegliere **Add (Aggiungi)**. ## Integrazione proxy Gli API Gateway APIs sono composti da fasi, risorse, metodi e integrazioni. La fase e la risorsa determinano il percorso dell'endpoint: **Formato del percorso API** + `/prod/`: la fase e la risorsa radice di `prod`. + `/prod/user`: la fase di `prod` e la risorsa di `user`. + `/dev/{proxy+}` – Qualunque routing della fase `dev`. + `/`— (HTTP APIs) La fase e la risorsa principale predefinite. Un'integrazione Lambda mappa una combinazione di percorso e metodo HTTP a una funzione Lambda. È possibile configurare API Gateway in modo da passare il corpo della richiesta HTTP così com'è (integrazione personalizzata), o da incapsulare il corpo della richiesta in un documento che include tutte le informazioni sulla richiesta, incluse intestazioni, risorsa, percorso e metodo. Per ulteriori informazioni, consulta [Integrazioni del proxy Lambda di API Gateway](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html). ## Formato dell'evento Amazon API Gateway richiama la funzione [in modo sincrono](invocation-sync.md) con un evento che contiene una rappresentazione JSON della richiesta HTTP. Per un'integrazione personalizzata, l'evento è il corpo della richiesta. Per un'integrazione proxy, l'evento ha una struttura definita. Per un esempio di evento proxy proveniente da una REST API di API Gateway, consulta [Formato di input di una funzione Lambda per l'integrazione del proxy](https://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-input-format) nella *Guida per gli sviluppatori di API Gateway*. ## Formato della risposta API Gateway attende una risposta dalla funzione e inoltra il risultato al chiamante. Per un'integrazione personalizzata, è possibile definire una risposta di integrazione e una risposta al metodo per convertire l'output dalla funzione a una risposta HTTP. Per un'integrazione proxy, la funzione deve rispondere con una rappresentazione della risposta in un formato specifico. L'esempio seguente mostra un oggetto risposta da una funzione Node.js. L'oggetto risposta rappresenta una risposta HTTP riuscita che contiene un documento JSON. **Example index.mjs: oggetto risposta di integrazione proxy (Node.js)** ``` var response = { "statusCode": 200, "headers": { "Content-Type": "application/json" }, "isBase64Encoded": false, "multiValueHeaders": { "X-Custom-Header": ["My value", "My other value"], }, "body": "{\n \"TotalCodeSize\": 104330022,\n \"FunctionCount\": 26\n}" } ``` Il runtime Lambda serializza l'oggetto di risposta in JSON e lo invia all'API. L'API analizza la risposta e la utilizza per creare una risposta HTTP, che quindi la invia al client che ha effettuato la richiesta originale. **Example Risposta HTTP** ``` < HTTP/1.1 200 OK < Content-Type: application/json < Content-Length: 55 < Connection: keep-alive < x-amzn-RequestId: 32998fea-xmpl-4268-8c72-16138d629356 < X-Custom-Header: My value < X-Custom-Header: My other value < X-Amzn-Trace-Id: Root=1-5e6aa925-ccecxmplbae116148e52f036 < { "TotalCodeSize": 104330022, "FunctionCount": 26 } ``` ## Permissions Amazon API Gateway ottiene l'autorizzazione a richiamare la funzione dalla [policy basata su risorse](access-control-resource-based.md) della funzione. È possibile concedere l'autorizzazione a un'intera API o concedere un accesso limitato a una fase, una risorsa o un metodo. Quando aggiungi un'API alla funzione utilizzando la console Lambda, la console API Gateway o in un modello AWS SAM , la policy basata su risorse della funzione viene aggiornata automaticamente. Di seguito è riportata una policy di funzioni di esempio. **Example Policy di funzione** **** ``` { "Version":"2012-10-17", "Id": "default", "Statement": [ { "Sid": "nodejs-apig-functiongetEndpointPermissionProd-BWDBXMPLXE2F", "Effect": "Allow", "Principal": { "Service": "apigateway.amazonaws.com" }, "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-2:111122223333:function:nodejs-apig-function-1G3MXMPLXVXYI", "Condition": { "StringEquals": { "aws:SourceAccount": "111122223333" }, "ArnLike": { "aws:SourceArn": "arn:aws:execute-api:us-east-2:111122223333:ktyvxmpls1/*/GET/" } } } ] } ``` È possibile gestire manualmente le autorizzazioni delle policy di funzione con le seguenti operazioni API: + [AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html) + [RemovePermission](https://docs.aws.amazon.com/lambda/latest/api/API_RemovePermission.html) + [GetPolicy](https://docs.aws.amazon.com/lambda/latest/api/API_GetPolicy.html) Per concedere l'autorizzazione di chiamata a un'API esistente, utilizzare il comando `add-permission`. Esempio: ``` aws lambda add-permission \ --function-name my-function \ --statement-id apigateway-get --action lambda:InvokeFunction \ --principal apigateway.amazonaws.com \ --source-arn "arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET/" ``` Verrà visualizzato l’output seguente: ``` { "Statement": "{\"Sid\":\"apigateway-test-2\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"apigateway.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:us-east-2:123456789012:function:my-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:execute-api:us-east-2:123456789012:mnh1xmpli7/default/GET\"}}}" } ``` **Nota** Se la funzione e l'API sono diverse Regioni AWS, l'identificatore di regione nell'ARN di origine deve corrispondere alla regione della funzione, non alla regione dell'API. Quando API Gateway richiama una funzione, utilizza un ARN di risorsa basato sull'ARN dell'API, ma modificato per corrispondere alla regione della funzione. L'ARN di origine in questo esempio concede l'autorizzazione a un'integrazione nel metodo GET della risorsa root nella fase predefinita di un'API, con ID `mnh1xmpli7`. È possibile utilizzare un asterisco nell'ARN di origine per concedere autorizzazioni a più fasi, metodi o risorse. **Modelli di risorse** + `mnh1xmpli7/*/GET/*`: metodo GET su tutte le risorse in tutte le fasi. + `mnh1xmpli7/prod/ANY/user`: metodo ANY sulla risorsa `user` nella fase `prod`. + `mnh1xmpli7/*/*/*`: qualsiasi metodo su tutte le risorse in tutte le fasi. Per informazioni dettagliate sulla visualizzazione delle policy e sulla rimozione delle istruzioni, vedere [Visualizzazione delle policy IAM basate sulle risorse in Lambda](access-control-resource-based.md). ## Applicazione di esempio L'app di esempio [API Gateway with Node.js](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig) include una funzione con un AWS SAM modello che crea un'API REST con AWS X-Ray tracciamento abilitato. Include anche script per l'implementazione, il richiamo della funzione, il test dell'API e la pulizia. ## Il gestore di eventi di Powertools for Lambda AWS Il gestore di eventi del toolkit Powertools for AWS Lambda fornisce routing, middleware, configurazione CORS, generazione di specifiche OpenAPI, convalida delle richieste, gestione degli errori e altre funzioni utili durante la scrittura di funzioni Lambda richiamate da un endpoint API Gateway (HTTP o REST). L'utilità Event Handler è disponibile per Python TypeScript e/. JavaScript Per ulteriori informazioni, vedete l'[API REST di Event Handler](https://docs.powertools.aws.dev/lambda/python/latest/core/event_handler/api_gateway/) nella documentazione di *Powertools for AWS Lambda (Python)* [e l'API HTTP Event Handler](https://docs.aws.amazon.com/powertools/typescript/latest/features/event-handler/http/) nella documentazione di *Powertools* for Lambda (). AWS TypeScript ### Python ``` from aws_lambda_powertools import Logger from aws_lambda_powertools.event_handler import APIGatewayRestResolver from aws_lambda_powertools.logging import correlation_paths from aws_lambda_powertools.utilities.typing.lambda_context import LambdaContext app = APIGatewayRestResolver() logger = Logger() @app.get("/healthz") def ping(): return {"message": "health status ok"} @logger.inject_lambda_context(correlation_id_path=correlation_paths.API_GATEWAY_REST) def lambda_handler(event: dict, context: LambdaContext) -> dict: return app.resolve(event, context) ``` ### Typescript ``` import { Router } from '@aws-lambda-powertools/event-handler/experimental-rest'; import { Logger } from '@aws-lambda-powertools/logger'; import { correlationPaths, search, } from '@aws-lambda-powertools/logger/correlationId'; import type { Context } from 'aws-lambda/handler'; const logger = new Logger({ correlationIdSearchFn: search, }); const app = new Router({ logger }); app.get("/healthz", async () => { return { message: "health status ok" }; }); export const handler = async (event: unknown, context: Context) => { // You can continue using other utilities just as before logger.addContext(context); logger.setCorrelationId(event, correlationPaths.API_GATEWAY_REST); return app.resolve(event, context); }; ``` # 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)**. # Gestione degli errori con un'API di API Gateway API Gateway considera tutti gli errori di invocazione e di funzione come errori interni. Se l'API Lambda rifiuta la richiesta di invocazione, API Gateway restituisce un codice di errore 500. Se la funzione viene eseguita ma restituisce un errore o una risposta nel formato errato, API Gateway restituisce il codice 502. In entrambi i casi, il corpo della risposta da API Gateway è `{"message": "Internal server error"}`. **Nota** API Gateway non riprova le invocazioni Lambda. Se Lambda restituisce un errore, API Gateway restituisce una risposta di errore al client. Nell'esempio seguente viene illustrata una mappa di tracciamento X-Ray per una richiesta che ha generato un errore di funzione e un codice 502 da API Gateway. Il client riceve il messaggio di errore generico. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/tracemap-apig-502.png) Per personalizzare la risposta di errore, è necessario rilevare gli errori nel codice e formattare una risposta nel formato richiesto. **Example [index.mjs](https://github.com/awsdocs/aws-lambda-developer-guide/tree/main/sample-apps/nodejs-apig/function/index.mjs): errore di formattazione** ``` var formatError = function(error){ var response = { "statusCode": error.statusCode, "headers": { "Content-Type": "text/plain", "x-amzn-ErrorType": error.code }, "isBase64Encoded": false, "body": error.code + ": " + error.message } return response } ``` API Gateway converte questa risposta in un errore HTTP con un codice di stato personalizzato e un corpo. Nella mappa di tracciamento, il nodo della funzione è verde perché ha gestito l'errore. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/tracemap-apig-404.png) # Selezionare un metodo per richiamare la funzione Lambda tramite una richiesta HTTP Numerosi casi d'uso comuni per Lambda implicano l'invocazione della funzione tramite una richiesta HTTP. Ad esempio, potrebbe essere preferibile che un'applicazione Web invochi la funzione tramite una richiesta del browser. Le funzioni Lambda possono essere utilizzate anche per creare REST completo APIs, gestire le interazioni degli utenti da app mobili, elaborare dati da servizi esterni tramite chiamate HTTP o creare webhook personalizzati. Le sezioni seguenti spiegano quali sono le tue scelte per richiamare Lambda tramite HTTP e forniscono informazioni per aiutarti a prendere la decisione giusta per il tuo caso d'uso particolare. ## Quali sono le tue scelte quando selezioni un metodo di invocazione HTTP? [[Lambda offre due metodi principali per richiamare una funzione utilizzando una richiesta HTTP: funzione e API URLs Gateway.](services-apigateway.md)](urls-configuration.md) Le differenze tra queste due opzioni sono le seguenti: + **La funzione Lambda URLs** fornisce un endpoint HTTP semplice e diretto per una funzione Lambda. Sono ottimizzati per semplicità ed economicità e forniscono il percorso più veloce per esporre una funzione Lambda tramite HTTP. + **API Gateway** è un servizio più avanzato per la creazione di funzionalità complete APIs. API Gateway è ottimizzato per la creazione e la gestione di produzioni APIs su larga scala e fornisce strumenti completi per la sicurezza, il monitoraggio e la gestione del traffico. ## Suggerimenti se conosci già le tue esigenze Se hai già le idee chiare sulle tue esigenze, ecco i nostri suggerimenti di base: Consigliamo **[la funzionalità URLs](urls-configuration.md)** per applicazioni semplici o per la prototipazione in cui sono necessari solo metodi di autenticazione e request/response gestione di base e dove si desidera ridurre al minimo costi e complessità. **[API Gateway](services-apigateway.md)** è la scelta migliore per le applicazioni di produzione su larga scala o per i casi in cui sono necessarie funzionalità più avanzate come il supporto [OpenAPI Description](https://www.openapis.org/), una scelta di opzioni di autenticazione, nomi di dominio personalizzati o una request/response gestione avanzata che include throttling, caching e trasformazione. request/response ## Cosa considerare quando si seleziona un metodo per richiamare la funzione Lambda Nella scelta tra funzione URLs e API Gateway, è necessario considerare i seguenti fattori: + Le tue esigenze di autenticazione, ad esempio se richiedi OAuth o Amazon Cognito per autenticare gli utenti + I tuoi requisiti di scalabilità e la complessità dell'API che desideri implementare + Se hai bisogno di funzionalità avanzate come la convalida e la formattazione delle richieste request/response + I tuoi requisiti di monitoraggio + I tuoi obiettivi di costo Comprendendo questi fattori, è possibile selezionare l'opzione che meglio bilancia i requisiti di sicurezza, complessità e costi. Le informazioni seguente riepilogano le differenze principali tra le due opzioni. ### Autenticazione + **La funzione URLs** fornisce opzioni di autenticazione di base tramite AWS Identity and Access Management (IAM). Puoi configurare gli endpoint in modo che siano pubblici (senza autenticazione) o che richiedano l'autenticazione IAM. Con l'autenticazione IAM, puoi utilizzare AWS credenziali standard o ruoli IAM per controllare l'accesso. Sebbene sia semplice da configurare, questo approccio offre opzioni limitate rispetto ad altri metodi di autenticazione. + **API Gateway** fornisce l'accesso a una gamma più completa di opzioni di autenticazione. Oltre all'autenticazione IAM, puoi utilizzare gli [autorizzatori Lambda](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-use-lambda-authorizer.html) (logica di autenticazione personalizzata), i pool di utenti di [Amazon Cognito e i flussi](https://docs.aws.amazon.com/cognito/latest/developerguide/what-is-amazon-cognito.html) .0. OAuth2 Questa flessibilità consente di implementare schemi di autenticazione complessi, inclusi provider di autenticazione di terze parti, autenticazione basata su token e autenticazione a più fattori. ### Gestione di richieste/risposte + **La funzione URLs fornisce la** gestione di base delle richieste e delle risposte HTTP. Supportano i metodi HTTP standard e includono il supporto integrato per CORS (cross-origin resource sharing). Sebbene siano in grado di gestire i payload JSON e i parametri di query in modo naturale, non offrono funzionalità di trasformazione o convalida delle richieste. La gestione delle risposte è altrettanto semplice: il client riceve la risposta dalla funzione Lambda esattamente come la restituisce Lambda. + **API Gateway** offre sofisticate funzionalità di gestione delle richieste e delle risposte. È possibile definire validatori di richiesta, trasformare richieste e risposte utilizzando modelli di mappatura, impostare request/response intestazioni e implementare la memorizzazione nella cache delle risposte. API Gateway supporta anche payload binari e nomi di dominio personalizzati e può modificare le risposte prima che raggiungano il client. È possibile configurare modelli per la request/response convalida e la trasformazione utilizzando JSON Schema. ### Dimensionamento + Le **funzioni** si URLs adattano direttamente ai limiti di concorrenza della funzione Lambda e gestisci i picchi di traffico scalando la funzione fino al limite di concorrenza massimo configurato. Una volta raggiunto tale limite, Lambda risponde alle richieste aggiuntive con risposte HTTP 429. Non esiste un meccanismo di accodamento integrato, pertanto la gestione della scalabilità dipende interamente dalla configurazione della funzione Lambda. Per impostazione predefinita, le funzioni Lambda hanno un limite di 1.000 esecuzioni simultanee per. Regione AWS + **API Gateway** offre funzionalità di scalabilità aggiuntive oltre alla scalabilità propria di Lambda. Include controlli integrati per l'accodamento e la limitazione delle richieste che consentono di gestire i picchi di traffico con maggiore efficienza. Per impostazione predefinita, API Gateway è in grado di gestire fino a 10.000 richieste al secondo per regione, con una capacità di espansione di 5.000 richieste al secondo. Fornisce inoltre strumenti per limitare le richieste a diversi livelli (API, fase o metodo) per proteggere il backend. ### Monitoraggio + **La funzione URLs** offre un monitoraggio di base tramite i CloudWatch parametri di Amazon, tra cui il conteggio delle richieste, la latenza e i tassi di errore. Puoi accedere a parametri e log Lambda standard, che mostrano le richieste non elaborate che arrivano alla tua funzione. Sebbene ciò fornisca una visibilità operativa essenziale, i parametri si concentrano principalmente sull'esecuzione delle funzioni. + **API Gateway** offre funzionalità di monitoraggio complete, tra cui parametri dettagliati, opzioni di registrazione e tracciamento. Puoi monitorare le chiamate API, la latenza, i tassi di errore e i tassi di cache hit/miss tramite. CloudWatch API Gateway si integra anche con AWS X-Ray il tracciamento distribuito e fornisce formati di registrazione personalizzabili. ### Costo + Le **funzioni URLs** seguono il modello di prezzo standard Lambda: paghi solo per le chiamate di funzione e il tempo di calcolo. Non sono previsti costi aggiuntivi per l'endpoint URL stesso. Ciò lo rende una scelta conveniente per applicazioni semplici APIs o a basso traffico se non sono necessarie le funzionalità aggiuntive di API Gateway. + **API Gateway** offre un [piano gratuito](https://aws.amazon.com/api-gateway/pricing/#Free_Tier) che include un milione di chiamate API ricevute per REST APIs e un milione di chiamate API ricevute per HTTP APIs. Successivamente, API Gateway addebita i costi per le chiamate API, il trasferimento dei dati e la memorizzazione nella cache (se abilitata). Consulta la [pagina dei prezzi](https://aws.amazon.com/api-gateway/pricing/) di API Gateway per conoscere i costi relativi al tuo caso d'uso. ### Altre funzionalità + URLsLe **funzioni** sono progettate per la semplicità e l'integrazione diretta con Lambda. Supportano endpoint HTTP e HTTPS, offrono supporto CORS integrato e forniscono endpoint dual-stack (e). IPv4 IPv6 Sebbene non dispongano di funzionalità avanzate, eccellono negli scenari in cui è necessario un modo rapido e diretto per esporre le funzioni Lambda tramite HTTP. + **API Gateway** include numerose funzionalità aggiuntive come il controllo delle versioni delle API, la gestione delle fasi, le chiavi API per i piani di utilizzo, la documentazione delle API tramite Swagger/OpenAPI, l'accesso WebSocket APIs privato all'interno di APIs un VPC e l'integrazione WAF per una maggiore sicurezza. Supporta anche implementazioni Canary, integrazioni fittizie per i test e l'integrazione con altri sistemi oltre a Lambda. Servizi AWS ## Selezionare un metodo per richiamare la funzione Lambda Ora che hai letto i criteri per la selezione tra la funzione Lambda URLs e l'API Gateway e le principali differenze tra di essi, puoi selezionare l'opzione più adatta alle tue esigenze e utilizzare le seguenti risorse per iniziare a utilizzarla. ------ #### [ Function URLs ] **Inizia a usare la funzione URLs con le seguenti risorse** + Segui il tutorial [Creazione di una funzione Lambda con la funzione URL](urls-webhook-tutorial.md) + Scopri di più sulla funzione URLs nel [Creazione e gestione della funzione Lambda URLs](urls-configuration.md) capitolo di questa guida + Prova il tutorial guidato dalla console **Creare una semplice app Web** effettuando le seguenti operazioni: 1. Apri la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Apri il pannello di aiuto scegliendo l'icona nell'angolo in alto a destra della schermata. ![\[\]](http://docs.aws.amazon.com/it_it/lambda/latest/dg/images/console_help_screenshot.png) 1. Seleziona **Tutorial**. 1. In **Crea una semplice app Web**, scegli **Avvia tutorial**. ------ #### [ API Gateway ] **Iniziare a usare Lambda e API Gateway con le seguenti risorse** + Segui il tutorial [Utilizzo di Lambda con API Gateway](services-apigateway-tutorial.md) per creare una REST API integrata con una funzione Lambda di backend. + Scopri di più sui diversi tipi di API offerti da API Gateway nelle seguenti sezioni della *Guida per gli sviluppatori di Gateway Amazon API*: + [API Gateway REST APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-rest-api.html) + [Gateway API HTTP APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api.html) + [API Gateway WebSocket APIs](https://docs.aws.amazon.com/apigateway/latest/developerguide/apigateway-websocket-api.html) + Prova uno o più esempi nella sezione [Tutorial e workshop](https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-tutorials.html) della *Guida per gli sviluppatori di Gateway Amazon API*. ------