"` |
| `requestContext.http` | Un oggetto contenente i dettagli sulla richiesta HTTP. | |
| `requestContext.http.method` | Il metodo HTTP utilizzato nella richiesta. I valori validi includono `GET`, `POST`, `PUT`, `HEAD`, `OPTIONS`, `PATCH` e `DELETE`. | `GET` |
| `requestContext.http.path` | Percorso della richiesta. Ad esempio, se l'URL della richiesta è `https://{url-id}.lambda-url.{region}.on.aws/example/test/demo`, il valore del percorso è `/example/test/demo`. | `/example/test/demo` |
| `requestContext.http.protocol` | Il protocollo della richiesta. | `HTTP/1.1` |
| `requestContext.http.sourceIp` | L'indirizzo IP di origine della connessione TCP immediata da cui proviene la richiesta. | `123.123.123.123` |
| `requestContext.http.userAgent` | Il valore dell'intestazione della richiesta User-Agent. | `Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Gecko/20100101 Firefox/42.0` |
| `requestContext.requestId` | L'l'ID della richiesta di richiamo. È possibile utilizzare questo ID per tenere traccia dei registri dei richiami correlati alla funzione. | `e1506fd5-9e7b-434f-bd42-4f8fa224b599` |
| `requestContext.routeKey` | Gli URL della funzione non utilizzano questo parametro. Lambda lo imposta su `$default` come segnaposto. | `$default` |
| `requestContext.stage` | Gli URL della funzione non utilizzano questo parametro. Lambda lo imposta su `$default` come segnaposto. | `$default` |
| `requestContext.time` | Il timestamp della richiesta. | `"07/Sep/2021:22:50:22 +0000"` |
| `requestContext.timeEpoch` | Il timestamp della richiesta, in formato temporale Unix epoch. | `"1631055022677"` |
| `body` | Il corpo della richiesta. Se il tipo di contenuto della richiesta è binario, il corpo è con codifica base64. | `{"key1": "value1", "key2": "value2"}` |
| `pathParameters` | Gli URL della funzione non utilizzano questo parametro. Lambda lo imposta su `null` o lo esclude dal JSON. | `null` |
| `isBase64Encoded` | `TRUE` se il corpo è un payload binario e con codifica base64. `FALSE` in caso contrario. | `FALSE` |
| `stageVariables` | Gli URL della funzione non utilizzano questo parametro. Lambda lo imposta su `null` o lo esclude dal JSON. | `null` |
### Formato del payload di risposta
Quando la funzione restituisce una risposta, Lambda analizza la risposta e la converte in una risposta HTTP. I payload di risposta della funzione hanno il formato seguente:
```
{
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": "{ \"message\": \"Hello, world!\" }",
"cookies": [
"Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT",
"Cookie_2=Value2; Max-Age=78000"
],
"isBase64Encoded": false
}
```
Lambda deduce il formato di risposta per l'utente. Se la funzione Lambda restituisce un JSON valido e non restituisce un `statusCode`, Lambda presuppone quanto segue:
+ `statusCode` is `200`.
**Nota**
I valori validi `statusCode` sono compresi tra 100 e 599.
+ `content-type` is `application/json`.
+ `body` è la risposta della funzione.
+ `isBase64Encoded` is `false`.
Gli esempi seguenti mostrano come l'output della funzione Lambda viene mappato al payload della risposta e come il payload della risposta viene mappato alla risposta HTTP finale. Quando il client richiama l'URL della funzione, viene visualizzata la risposta HTTP.
**Esempio di output per una risposta stringa**
| Risultato della funzione Lambda | Output di risposta interpretata | Risposta HTTP (cosa vede il client) |
| --- | --- | --- |
| "Hello, world!"
| {
"statusCode": 200,
"body": "Hello, world!",
"headers": {
"content-type": "application/json"
},
"isBase64Encoded": false
} | HTTP/2 200
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 15
"Hello, world!"
|
**Esempio di output per una risposta JSON**
| Risultato della funzione Lambda | Output di risposta interpretata | Risposta HTTP (cosa vede il client) |
| --- | --- | --- |
| {
"message": "Hello, world!"
} | {
"statusCode": 200,
"body": {
"message": "Hello, world!"
},
"headers": {
"content-type": "application/json"
},
"isBase64Encoded": false
} | HTTP/2 200
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 34
{
"message": "Hello, world!"
}
|
**Esempio di output per una risposta personalizzata**
| Risultato della funzione Lambda | Output di risposta interpretata | Risposta HTTP (cosa vede il client) |
| --- | --- | --- |
| {
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": JSON.stringify({
"message": "Hello, world!"
}),
"isBase64Encoded": false
} | {
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": JSON.stringify({
"message": "Hello, world!"
}),
"isBase64Encoded": false
} | HTTP/2 201
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 27
my-custom-header: Custom Value
{
"message": "Hello, world!"
}
|
### Cookie
Per restituire i cookie della funzione, non aggiungere manualmente intestazioni `set-cookie`. Al contrario, includi i cookie nell'oggetto payload di risposta. Lambda li interpreta automaticamente e li aggiunge come intestazioni `set-cookie` nella risposta HTTP, come nell'esempio seguente.
| Risultato della funzione Lambda | Risposta HTTP (cosa vede il client) |
| --- | --- |
| {
"statusCode": 201,
"headers": {
"Content-Type": "application/json",
"My-Custom-Header": "Custom Value"
},
"body": JSON.stringify({
"message": "Hello, world!"
}),
"cookies": [
"Cookie_1=Value1; Expires=21 Oct 2021 07:48 GMT",
"Cookie_2=Value2; Max-Age=78000"
],
"isBase64Encoded": false
} | HTTP/2 201
date: Wed, 08 Sep 2021 18:02:24 GMT
content-type: application/json
content-length: 27
my-custom-header: Custom Value
set-cookie: Cookie_1=Value2; Expires=21 Oct 2021 07:48 GMT
set-cookie: Cookie_2=Value2; Max-Age=78000
{
"message": "Hello, world!"
}
|
# Monitoraggio degli URL della funzione Lambda
Puoi utilizzare AWS CloudTrail e Amazon CloudWatch per monitorare gli URL della funzione.
**Topics**
+ [
## Monitoraggio degli URL della funzione con CloudTrail
](#urls-cloudtrail)
+ [
## Parametri CloudWatch per gli URL della funzione
](#urls-cloudwatch)
## Monitoraggio degli URL della funzione con CloudTrail
Per gli URL della funzione, Lambda supporta automaticamente la registrazione delle seguenti operazioni API come eventi nei file di log di CloudTrail:
+ [CreateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html)
+ [UpdateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_UpdateFunctionUrlConfig.html)
+ [DeleteFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_DeleteFunctionUrlConfig.html)
+ [GetFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_GetFunctionUrlConfig.html)
+ [ListFunctionUrlConfigs](https://docs.aws.amazon.com/lambda/latest/api/API_ListFunctionUrlConfigs.html)
Ogni voce di registro contiene informazioni sull'identità del chiamante, sul momento in cui è stata effettuata la richiesta e altri dettagli. Puoi vedere tutti gli eventi degli ultimi 90 giorni visualizzando la **cronologia eventi** di CloudTrail. Per conservare i record degli ultimi 90 giorni, puoi creare un percorso.
Per impostazione predefinita, CloudTrail non registra le richieste `InvokeFunctionUrl`, che sono considerate eventi di dati. È comunque possibile attivare la registrazione degli eventi di dati in CloudTrail. Per ulteriori informazioni, consulta [Registrazione di eventi di dati per i percorsi](https://docs.aws.amazon.com/awscloudtrail/latest/userguide/logging-data-events-with-cloudtrail.html) nella *Guida per l'utente di AWS CloudTrail*.
## Parametri CloudWatch per gli URL della funzione
Lambda invia parametri aggregati relativi alle richieste degli URL della funzione a CloudWatch. Con questi parametri, puoi monitorare gli URL della funzione, creare dashboard e configurare allarmi nella console di CloudWatch.
Gli URL della funzione supportano i seguenti parametri di richiamo. È consigliabile visualizzare questi parametri con le statistiche di `Sum`.
+ `UrlRequestCount`: il numero di richieste inviate all'URL della funzione.
+ `Url4xxCount`: il numero di richieste che hanno restituito un codice di stato HTTP 4XX. I codici della serie 4XX indicano errori lato client, ad esempio richieste non valide.
+ `Url5xxCount`: il numero di richieste che hanno restituito un codice di stato HTTP 5XX. I codici della serie 5XX indicano errori lato server, ad esempio errori di funzione e timeout.
Gli URL della funzione supportano anche il seguente parametro di prestazioni. È consigliabile visualizzare questo parametro con le statistiche di `Average` o `Max`.
+ `UrlRequestLatency`: il periodo di tempo che intercorre tra il momento in cui l'URL della funzione riceve una richiesta e il momento in cui l'URL della funzione restituisce una risposta.
Ciascuno di questi parametri di richiamo e prestazioni supporta le seguenti dimensioni:
+ `FunctionName`: visualizza i parametri aggregati per gli URL della funzione assegnati a una versione `$LATEST` non pubblicata di una funzione o a uno degli alias della funzione. Ad esempio, `hello-world-function`.
+ `Resource`: visualizza i parametri relativi a un URL della funzione specifico. Questo URL è definito dal nome di una funzione, insieme alla versione `$LATEST` non pubblicata della funzione o a uno degli alias della funzione. Ad esempio, `hello-world-function:$LATEST`.
+ `ExecutedVersion`: visualizza i parametri per un URL di funzione specifico, in base alla versione eseguita. Puoi utilizzare questa dimensione principalmente per tenere traccia dell'URL della funzione assegnato alla versione `$LATEST` non pubblicata.
# 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*.
------
# Tutorial: creazione di un endpoint webhook utilizzando l'URL di una funzione Lambda
In questo tutorial, crei l'URL di una funzione Lambda per implementare un endpoint webhook. Un webhook è una comunicazione leggera basata sugli eventi che invia automaticamente i dati tra le applicazioni tramite HTTP. È possibile utilizzare un webhook per ricevere aggiornamenti immediati sugli eventi che si verificano in un altro sistema, ad esempio quando un nuovo cliente si registra su un sito Web, viene elaborato un pagamento o viene caricato un file.
Con Lambda, i webhook possono essere implementati utilizzando la funzione Lambda o l'API Gateway. URLs URLs Le funzioni sono un'ottima scelta per webhook semplici che non richiedono funzionalità come l'autorizzazione avanzata o la convalida delle richieste.
**Suggerimento**
Se non sei sicuro di quale sia la soluzione migliore per il tuo caso d'uso particolare, consulta. [Selezionare un metodo per richiamare la funzione Lambda tramite una richiesta HTTP](furls-http-invoke-decision.md)
## Prerequisiti
Per completare questo tutorial, devi avere Python (versione 3.8 o successiva) o Node.js (versione 18 o successiva) installato sul tuo computer locale.
Per testare l'endpoint utilizzando una richiesta HTTP, il tutorial utilizza [curl](https://curl.se/), uno strumento a riga di comando che è possibile utilizzare per trasferire dati utilizzando vari protocolli di rete. Fai riferimento alla [documentazione di curl](https://curl.se/docs/install.html) per scoprire come installare lo strumento se non lo possiedi già.
## Creazione della funzione Lambda
Per prima cosa crea la funzione Lambda che viene eseguita quando una richiesta HTTP viene inviata al tuo endpoint webhook. In questo esempio, l'applicazione di invio invia un aggiornamento ogni volta che viene inviato un pagamento e indica nel corpo della richiesta HTTP se il pagamento è andato a buon fine. La funzione Lambda analizza la richiesta e interviene in base allo stato del pagamento. In questo esempio, il codice stampa solo l'ID dell'ordine per il pagamento, ma in un'applicazione reale è possibile aggiungere l'ordine a un database o inviare una notifica.
La funzione implementa anche il metodo di autenticazione più comune utilizzato per i webhook, l'autenticazione dei messaggi basata su hash (HMAC). Con questo metodo, sia l'applicazione di invio che quella di ricezione condividono una chiave segreta. L'applicazione di invio utilizza un algoritmo di hashing per generare una firma univoca utilizzando questa chiave insieme al contenuto del messaggio e include la firma nella richiesta del webhook come intestazione HTTP. L'applicazione ricevente ripete quindi questo passaggio, generando la firma utilizzando la chiave segreta e confronta il valore risultante con la firma inviata nell'intestazione della richiesta. Se il risultato corrisponde, la richiesta viene considerata legittima.
Crea la funzione utilizzando la console Lambda con il runtime Python o Node.js.
------
#### [ Python ]
**Creazione della funzione Lambda**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Crea una funzione di base «Hello world» effettuando le seguenti operazioni:
1. Scegli **Crea funzione**.
1. Scegli **Crea da zero**.
1. Nel campo **Function name (Nome funzione)**, immettere **myLambdaWebhook**.
1. **Per **Runtime**, seleziona python3.14.**
1. Scegli **Crea funzione**.
1. Nel riquadro **Codice sorgente**, sostituisci il codice esistente copiando e incollando quanto segue:
```
import json
import hmac
import hashlib
import os
def lambda_handler(event, context):
# Get the webhook secret from environment variables
webhook_secret = os.environ['WEBHOOK_SECRET']
# Verify the webhook signature
if not verify_signature(event, webhook_secret):
return {
'statusCode': 401,
'body': json.dumps({'error': 'Invalid signature'})
}
try:
# Parse the webhook payload
payload = json.loads(event['body'])
# Handle different event types
event_type = payload.get('type')
if event_type == 'payment.success':
# Handle successful payment
order_id = payload.get('orderId')
print(f"Processing successful payment for order {order_id}")
# Add your business logic here
# For example, update database, send notifications, etc.
elif event_type == 'payment.failed':
# Handle failed payment
order_id = payload.get('orderId')
print(f"Processing failed payment for order {order_id}")
# Add your business logic here
else:
print(f"Received unhandled event type: {event_type}")
# Return success response
return {
'statusCode': 200,
'body': json.dumps({'received': True})
}
except json.JSONDecodeError:
return {
'statusCode': 400,
'body': json.dumps({'error': 'Invalid JSON payload'})
}
except Exception as e:
print(f"Error processing webhook: {e}")
return {
'statusCode': 500,
'body': json.dumps({'error': 'Internal server error'})
}
def verify_signature(event, webhook_secret):
"""
Verify the webhook signature using HMAC
"""
try:
# Get the signature from headers
signature = event['headers'].get('x-webhook-signature')
if not signature:
print("Error: Missing webhook signature in headers")
return False
# Get the raw body (return an empty string if the body key doesn't exist)
body = event.get('body', '')
# Create HMAC using the secret key
expected_signature = hmac.new(
webhook_secret.encode('utf-8'),
body.encode('utf-8'),
hashlib.sha256
).hexdigest()
# Compare the expected signature with the received signature to authenticate the message
is_valid = hmac.compare_digest(signature, expected_signature)
if not is_valid:
print(f"Error: Invalid signature. Received: {signature}, Expected: {expected_signature}")
return False
return True
except Exception as e:
print(f"Error verifying signature: {e}")
return False
```
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione.
------
#### [ Node.js ]
**Creazione della funzione Lambda**
1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda.
1. Crea una funzione di base «Hello world» effettuando le seguenti operazioni:
1. Scegli **Crea funzione**.
1. Scegli **Crea da zero**.
1. Nel campo **Function name (Nome funzione)**, immettere **myLambdaWebhook**.
1. **Per **Runtime**, seleziona nodejs24.x.**
1. Scegli **Crea funzione**.
1. Nel riquadro **Codice sorgente**, sostituisci il codice esistente copiando e incollando quanto segue:
```
import crypto from 'crypto';
export const handler = async (event, context) => {
// Get the webhook secret from environment variables
const webhookSecret = process.env.WEBHOOK_SECRET;
// Verify the webhook signature
if (!verifySignature(event, webhookSecret)) {
return {
statusCode: 401,
body: JSON.stringify({ error: 'Invalid signature' })
};
}
try {
// Parse the webhook payload
const payload = JSON.parse(event.body);
// Handle different event types
const eventType = payload.type;
switch (eventType) {
case 'payment.success': {
// Handle successful payment
const orderId = payload.orderId;
console.log(`Processing successful payment for order ${orderId}`);
// Add your business logic here
// For example, update database, send notifications, etc.
break;
}
case 'payment.failed': {
// Handle failed payment
const orderId = payload.orderId;
console.log(`Processing failed payment for order ${orderId}`);
// Add your business logic here
break;
}
default:
console.log(`Received unhandled event type: ${eventType}`);
}
// Return success response
return {
statusCode: 200,
body: JSON.stringify({ received: true })
};
} catch (error) {
if (error instanceof SyntaxError) {
// Handle JSON parsing errors
return {
statusCode: 400,
body: JSON.stringify({ error: 'Invalid JSON payload' })
};
}
// Handle all other errors
console.error('Error processing webhook:', error);
return {
statusCode: 500,
body: JSON.stringify({ error: 'Internal server error' })
};
}
};
// Verify the webhook signature using HMAC
const verifySignature = (event, webhookSecret) => {
try {
// Get the signature from headers
const signature = event.headers['x-webhook-signature'];
if (!signature) {
console.log('No signature found in headers:', event.headers);
return false;
}
// Get the raw body (return an empty string if the body key doesn't exist)
const body = event.body || '';
// Create HMAC using the secret key
const hmac = crypto.createHmac('sha256', webhookSecret);
const expectedSignature = hmac.update(body).digest('hex');
// Compare expected and received signatures
const isValid = signature === expectedSignature;
if (!isValid) {
console.log(`Invalid signature. Received: ${signature}, Expected: ${expectedSignature}`);
return false;
}
return true;
} catch (error) {
console.error('Error during signature verification:', error);
return false;
}
};
```
1. Nella sezione **DEPLOY**, scegli **Implementa** per aggiornare il codice della tua funzione.
------
## Crea la chiave segreta
Per autenticare la richiesta webhook, la funzione Lambda utilizza una chiave segreta che condivide con l'applicazione chiamante. In questo esempio, la chiave viene memorizzata in una variabile di ambiente. In un'applicazione di produzione, non includere informazioni sensibili come le password nel codice funzione. Invece, [crea un Gestione dei segreti AWS segreto](https://docs.aws.amazon.com/secretsmanager/latest/userguide/create_secret.html) e poi [usa l'estensione Lambda AWS Parameters and Secrets](with-secrets-manager.md) per recuperare le credenziali nella funzione Lambda.
**Crea e archivia la chiave segreta del webhook**
1. Genera una stringa lunga e casuale utilizzando un generatore di numeri casuali crittograficamente sicuro. Puoi usare i seguenti frammenti di codice in Python o Node.js per generare e stampare un segreto di 32 caratteri o usare il tuo metodo preferito.
------
#### [ Python ]
**Example codice per generare un segreto**
```
import secrets
webhook_secret = secrets.token_urlsafe(32)
print(webhook_secret)
```
------
#### [ Node.js ]
**Example codice per generare un segreto (formato del modulo ES)**
```
import crypto from 'crypto';
let webhookSecret = crypto.randomBytes(32).toString('base64');
console.log(webhookSecret)
```
------
1. Memorizza la stringa generata come variabile di ambiente per la tua funzione effettuando le seguenti operazioni:
1. Nella scheda **Configurazione** della funzione, seleziona **Variabili di ambiente**.
1. Scegli **Modifica**.
1. Scegli **Add environment variable (Aggiungi variabile d'ambiente)**.
1. Per **Chiave****WEBHOOK\$1SECRET**, inserisci, quindi per **Valore**, inserisci il segreto generato nel passaggio precedente.
1. Scegli **Save** (Salva).
Dovrai utilizzare nuovamente questo segreto più avanti nel tutorial per testare la tua funzione, quindi prendine nota ora.
## Crea l'endpoint URL della funzione
Crea un endpoint per il tuo webhook utilizzando l'URL di una funzione Lambda. Poiché utilizzi il tipo di autenticazione di `NONE` per creare un endpoint con accesso pubblico, chiunque disponga dell'URL può richiamare la tua funzione. Per ulteriori informazioni sul controllo dell'accesso alla funzione, consulta. URLs [Controlla l'accesso alla funzione Lambda URLs](urls-auth.md) Se hai bisogno di opzioni di autenticazione più avanzate per il tuo webhook, prendi in considerazione l'utilizzo di API Gateway.
**Crea l'endpoint URL della funzione**
1. Nella scheda **Configurazione** della funzione, selezionate **Function URL**.
1. Scegli **Crea URL della funzione**.
1. Per il **tipo di autenticazione**, seleziona **NESSUNA**.
1. Scegli **Save** (Salva).
L'endpoint per l'URL della funzione appena creato viene visualizzato nel riquadro **URL della funzione**. Copia l'endpoint per utilizzarlo più avanti nel tutorial.
## Prova la funzione nella console
Prima di utilizzare una richiesta HTTP per richiamare la funzione utilizzando l'endpoint URL, testala nella console per confermare che il codice funzioni come previsto.
Per verificare la funzione nella console, devi prima calcolare una firma webhook utilizzando il segreto generato in precedenza nel tutorial con il seguente payload JSON di test:
```
{
"type": "payment.success",
"orderId": "1234",
"amount": "99.99"
}
```
Usa uno dei seguenti esempi di codice Python o Node.js per calcolare la firma del webhook usando il tuo segreto.
------
#### [ Python ]
**Calcola la firma del webhook**
1. Salva il codice seguente come file denominato`calculate_signature.py`. Sostituisci il webhook secret nel codice con il tuo valore.
```
import secrets
import hmac
import json
import hashlib
webhook_secret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M"
body = json.dumps({"type": "payment.success", "orderId": "1234", "amount": "99.99"})
signature = hmac.new(
webhook_secret.encode('utf-8'),
body.encode('utf-8'),
hashlib.sha256
).hexdigest()
print(signature)
```
1. Calcola la firma eseguendo il comando seguente dalla stessa directory in cui hai salvato il codice. Copia la firma generata dal codice.
```
python calculate_signature.py
```
------
#### [ Node.js ]
**Calcola la firma del webhook**
1. Salva il codice seguente come file denominato`calculate_signature.mjs`. Sostituisci il webhook secret nel codice con il tuo valore.
```
import crypto from 'crypto';
const webhookSecret = "arlbSDCP86n_1H90s0fL_Qb2NAHBIBQOyGI0X4Zay4M"
const body = "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}";
let hmac = crypto.createHmac('sha256', webhookSecret);
let signature = hmac.update(body).digest('hex');
console.log(signature);
```
1. Calcola la firma eseguendo il comando seguente dalla stessa directory in cui hai salvato il codice. Copia la firma generata dal codice.
```
node calculate_signature.mjs
```
------
Ora puoi testare il codice della funzione utilizzando una richiesta HTTP di prova nella console.
**Prova la funzione nella console**
1. Seleziona la scheda **Codice** relativa alla tua funzione.
1. Nella sezione **EVENTI DI TEST**, scegli **Crea nuovo evento di test**
1. Per **Event name** (Nome evento), immettere **myEvent**.
1. Sostituisci il JSON esistente copiando e incollando quanto segue nel riquadro **Event** JSON. Sostituisci la firma del webhook con il valore calcolato nel passaggio precedente.
```
{
"headers": {
"Content-Type": "application/json",
"x-webhook-signature": "2d672e7a0423fab740fbc040e801d1241f2df32d2ffd8989617a599486553e2a"
},
"body": "{\"type\": \"payment.success\", \"orderId\": \"1234\", \"amount\": \"99.99\"}"
}
```
1. Scegli **Save** (Salva).
1. Scegli **Richiama **.
Verrà visualizzato un output simile al seguente:
------
#### [ Python ]
```
Status: Succeeded
Test Event Name: myEvent
Response:
{
"statusCode": 200,
"body": "{\"received\": true}"
}
Function Logs:
START RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 Version: $LATEST
Processing successful payment for order 1234
END RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6
REPORT RequestId: 50cc0788-d70e-453a-9a22-ceaa210e8ac6 Duration: 1.55 ms Billed Duration: 2 ms Memory Size: 128 MB Max Memory Used: 36 MB Init Duration: 136.32 ms
```
------
#### [ Node.js ]
```
Status: Succeeded
Test Event Name: myEvent
Response:
{
"statusCode": 200,
"body": "{\"received\":true}"
}
Function Logs:
START RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 Version: $LATEST
2025-01-10T18:05:42.062Z e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 INFO Processing successful payment for order 1234
END RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4
REPORT RequestId: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 Duration: 60.10 ms Billed Duration: 61 ms Memory Size: 128 MB Max Memory Used: 72 MB Init Duration: 174.46 ms
Request ID: e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4
```
------
## Prova la funzione utilizzando una richiesta HTTP
Usa lo strumento da riga di comando curl per testare il tuo endpoint webhook.
**Prova la funzione usando le richieste HTTP**
1. In un terminale o in un programma shell, esegui il seguente comando curl. Sostituisci l'URL con il valore dell'endpoint URL della tua funzione e sostituisci la firma del webhook con la firma calcolata utilizzando la tua chiave segreta.
```
curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \
-H "Content-Type: application/json" \
-H "x-webhook-signature: d5f52b76ffba65ff60ea73da67bdf1fc5825d4db56b5d3ffa0b64b7cb85ef48b" \
-d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}'
```
Verrà visualizzato l’output seguente:
```
{"received": true}
```
1. Esamina CloudWatch i log della tua funzione per confermare che abbia analizzato correttamente il payload effettuando le seguenti operazioni:
1. Apri la pagina del [gruppo Logs](https://console.aws.amazon.com/cloudwatch/home#logsV2:log-groups) nella CloudWatch console Amazon.
1. Seleziona il gruppo di log della tua funzione (`/aws/lambda/myLambdaWebhook`).
1. Seleziona il flusso di log più recente.
Dovresti vedere un output simile al seguente nei log della tua funzione:
------
#### [ Python ]
```
Processing successful payment for order 1234
```
------
#### [ Node.js ]
```
2025-01-10T18:05:42.062Z e54fe6c7-1df9-4f05-a4c4-0f71cacd64f4 INFO Processing successful payment for order 1234
```
------
1. Verifica che il codice rilevi una firma non valida eseguendo il seguente comando curl. Sostituisci l'URL con il tuo endpoint URL della funzione.
```
curl -X POST https://ryqgmbx5xjzxahif6frvzikpre0bpvpf.lambda-url.us-west-2.on.aws/ \
-H "Content-Type: application/json" \
-H "x-webhook-signature: abcdefg" \
-d '{"type": "payment.success", "orderId": "1234", "amount": "99.99"}'
```
Verrà visualizzato l’output seguente:
```
{"error": "Invalid signature"}
```
## Pulizia delle risorse
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 carico. Account AWS
**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**.
Quando hai creato la funzione Lambda nella console, Lambda ha anche creato un [ruolo di esecuzione](lambda-intro-execution-role.md) per la tua funzione.
**Come eliminare il ruolo di esecuzione**
1. Aprire la pagina [Ruoli](https://console.aws.amazon.com/iam/home#/roles) della console IAM.
1. Seleziona il ruolo di esecuzione creato da Lambda. Il ruolo ha il formato `myLambdaWebhook-role-` del nome.
1. Scegliere **Elimina**.
1. Inserisci il nome del ruolo nel campo di immissione testo e seleziona **Elimina**.