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à. # Creazione e gestione della funzione Lambda URLs Un URL della funzione è un endpoint HTTP(S) dedicato alla funzione Lambda. È possibile creare e configurare un URL della funzione tramite la console Lambda o l'API Lambda. **Suggerimento** Lambda offre due modi per richiamare una funzione tramite un endpoint HTTP: funzione e Amazon API URLs Gateway. 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](furls-http-invoke-decision.md). Quando si crea un URL della funzione, Lambda genera automaticamente un endpoint URL univoco. Dopo aver creato un URL della funzione, il suo endpoint URL non cambia mai. Gli endpoint URL della funzione hanno il formato seguente: ``` https://.lambda-url..on.aws ``` **Nota** URLs Le funzioni non sono supportate nei seguenti paesi Regioni AWS: Asia Pacifico (Hyderabad) (`ap-south-2`), Asia Pacifico (Melbourne) (`ap-southeast-4`), Asia Pacifico (Malesia) (), Asia Pacifico (Nuova Zelanda`ap-southeast-5`) (), Asia Pacifico (Tailandia`ap-southeast-6`) () (), Asia Pacifico (Taipei`ap-southeast-7`) (), Canada occidentale (Calgary) (`ap-east-2`), Europa (Spagna) () `ca-west-1` (), Europa (Zurigo) (`eu-south-2`), Israele (Tel Aviv) `eu-central-2` (), e Medio Oriente (Emirati Arabi Uniti) (`il-central-1`). `me-central-1` URLs Le funzioni sono abilitate al dual stack, supportano IPv4 e IPv6. Dopo aver configurato un URL della funzione per la funzione utilizzata, è possibile richiamare la funzione attraverso il relativo endpoint HTTP(S) tramite un browser Web, curl, Postman o un client HTTP. **Nota** Puoi accedere all'URL della funzione solo tramite Internet pubblico. Sebbene le funzioni Lambda supportino AWS PrivateLink, le funzioni no URLs . La funzione Lambda URLs utilizza [politiche basate sulle risorse per la sicurezza e il controllo degli accessi](access-control-resource-based.md). La funzione supporta URLs anche le opzioni di configurazione CORS (Cross-Origin Resource Sharing). È possibile applicare la funzione URLs a qualsiasi alias di funzione o alla versione della funzione `$LATEST` non pubblicata. Non è possibile aggiungere un URL della funzione a nessun'altra versione della funzione. La sezione seguente mostra come creare e gestire l'URL di una funzione utilizzando la console Lambda e il AWS CLI modello CloudFormation **Topics** + [Creazione di un URL della funzione (console)](#create-url-console) + [Creazione di un URL di funzione (AWS CLI)](#create-url-cli) + [Aggiungere l'URL di una funzione a un CloudFormation modello](#urls-cfn) + [Cross-Origin Resource Sharing (CORS)](#urls-cors) + [Funzione di limitazione URLs](#urls-throttling) + [Funzione di disattivazione URLs](#urls-deactivating) + [Funzione di cancellazione URLs](#w2aac39c81c53) + [Controlla l'accesso alla funzione Lambda URLs](urls-auth.md) + [Richiamo di URL di funzioni Lambda](urls-invocation.md) + [Monitoraggio degli URL della funzione Lambda](urls-monitoring.md) + [Selezionare un metodo per richiamare la funzione Lambda tramite una richiesta HTTP](furls-http-invoke-decision.md) + [Tutorial: creazione di un endpoint webhook utilizzando l'URL di una funzione Lambda](urls-webhook-tutorial.md) ## Creazione di un URL della funzione (console) Segui queste fasi per creare un URL della funzione usando la console. ### Per creare un URL di funzione per una funzione esistente 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegli il nome della funzione per la quale desideri creare l'URL della funzione. 1. Scegli la scheda **Configurazione**, quindi scegli **URL della funzione**. 1. Scegli **Crea URL della funzione**. 1. Per il **tipo di autenticazione**, scegliete **AWS\$1IAM**o **NONE**. Per ulteriori informazioni sull'autenticazione dell'URL della funzione, consulta [Controllo accessi](urls-auth.md). 1. (Opzionale) Seleziona **Configura CORS** e quindi configura le impostazioni CORS per l'URL della funzione. Per ulteriori informazioni sulla funzionalità CORS, consulta [Cross-Origin Resource Sharing (CORS)](#urls-cors). 1. Scegli **Save** (Salva). In questo modo viene creato un URL di funzione per la versione non pubblicata di `$LATEST` della funzione. L'URL della funzione viene visualizzato nella sezione **Panoramica della funzione** della console. ### Per creare l'URL di una funzione per un alias esistente 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegli il nome della funzione con l'alias per cui desideri creare l'URL della funzione. 1. Seleziona la scheda **Aliases** (Alias) e quindi scegli il nome dell'alias per cui desideri creare l'URL della funzione. 1. Scegli la scheda **Configuration** (Configurazione), quindi scegli **Function URL** (URL della funzione). 1. Scegli **Crea URL della funzione**. 1. **Per il **tipo di autenticazione**, scegli **AWS\$1IAM**o NONE.** Per ulteriori informazioni sull'autenticazione dell'URL della funzione, consulta [Controllo accessi](urls-auth.md). 1. (Opzionale) Seleziona **Configura CORS** e quindi configura le impostazioni CORS per l'URL della funzione. Per ulteriori informazioni sulla funzionalità CORS, consulta [Cross-Origin Resource Sharing (CORS)](#urls-cors). 1. Scegli **Save** (Salva). In questo modo viene creato un URL della funzione per l'alias della funzione. L'URL della funzione viene visualizzato nella sezione **Panoramica della funzione** della console per l'alias. ### Per creare una nuova funzione con l'URL di una funzione **Creazione di una nuova funzione con un URL della funzione (console)** 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegli **Crea funzione**. 1. In **Basic information (Informazioni di base)** eseguire queste operazioni: 1. In **Function name** (Nome funzione), inserisci un nome per la funzione, ad esempio **my-function**. 1. Per **Runtime**, scegliete il linguaggio di runtime che preferite, ad esempio **Node.js 24**. 1. Per **Architecture** (Architettura), scegli **x86\$164** o **arm64**. 1. Espandi **Permissions** (Autorizzazioni), quindi scegli se creare un nuovo ruolo di esecuzione o usarne uno esistente. 1. Espandi **Advanced settings** (Impostazioni avanzate) e quindi seleziona **Function URL** (URL della funzione). 1. Per il **tipo di autenticazione**, scegliete **AWS\$1IAM**o **NONE**. Per ulteriori informazioni sull'autenticazione dell'URL della funzione, consulta [Controllo accessi](urls-auth.md). 1. (Opzionale) Seleziona **Configure cross-origin resource sharing (CORS)** (Configura CORS). Selezionando questa opzione durante la creazione della funzione, l'URL della funzione consente le richieste da tutte le origini per impostazione predefinita. È possibile modificare le impostazioni CORS per l'URL della funzione dopo aver creato la funzione. Per ulteriori informazioni sulla funzionalità CORS, consulta [Cross-Origin Resource Sharing (CORS)](#urls-cors). 1. Scegli **Crea funzione**. In questo modo viene creata una nuova funzione con un URL della funzione per la versione non pubblicata di `$LATEST` della funzione. L'URL della funzione viene visualizzato nella sezione **Function overview** (Panoramica della funzione) della console. ## Creazione di un URL di funzione (AWS CLI) Per creare un URL di funzione per una funzione Lambda esistente utilizzando AWS Command Line Interface (AWS CLI), esegui il comando seguente: ``` aws lambda create-function-url-config \ --function-name my-function \ --qualifier prod \ // optional --auth-type AWS_IAM --cors-config {AllowOrigins="https://example.com"} // optional ``` Un URL di funzione viene aggiunto al qualificatore **prod** per la funzione **my-function**. Per ulteriori informazioni su questi parametri di configurazione, consulta [CreateFunctionUrlConfig](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html) nella documentazione di riferimento delle API. **Nota** Per creare l'URL di una funzione tramite AWS CLI, la funzione deve già esistere. ## Aggiungere l'URL di una funzione a un CloudFormation modello Per aggiungere una `AWS::Lambda::Url` risorsa al CloudFormation modello, utilizzate la seguente sintassi: ### JSON ``` { "Type" : "AWS::Lambda::Url", "Properties" : { "AuthType" : String, "Cors" : Cors, "Qualifier" : String, "TargetFunctionArn" : String } } ``` ### YAML ``` Type: AWS::Lambda::Url Properties: AuthType: String Cors: Cors Qualifier: String TargetFunctionArn: String ``` ### Parameters + (Obbligatorio)`AuthType`: definisce il tipo di autenticazione per l'URL della funzione. I valori possibili sono `AWS_IAM` o `NONE`. Per limitare l'accesso solo agli utenti autenticati, imposta su `AWS_IAM`. Per ignorare l'autenticazione IAM e consentire a qualsiasi utente di effettuare richieste alla propria funzione, imposta su `NONE`. + (Opzionale)`Cors`: definisce le [impostazioni CORS](#urls-cors) per l'URL della funzione. Per aggiungere `Cors` alla `AWS::Lambda::Url` risorsa in CloudFormation, utilizzate la seguente sintassi. **Example AWS::Lambda::Url.Cors (JSON)** ``` { "AllowCredentials" : Boolean, "AllowHeaders" : [ String, ... ], "AllowMethods" : [ String, ... ], "AllowOrigins" : [ String, ... ], "ExposeHeaders" : [ String, ... ], "MaxAge" : Integer } ``` **Example AWS::Lambda::Url.Cors (YAML)** ``` AllowCredentials: Boolean AllowHeaders: - String AllowMethods: - String AllowOrigins: - String ExposeHeaders: - String MaxAge: Integer ``` + (Opzionale) `Qualifier`: il nome dell'alias. + (Obbligatorio)`TargetFunctionArn`: il nome o l'Amazon Resource Name (ARN) della funzione Lambda. I formati dei nomi validi includono quanto segue: + **Nome funzione** – `my-function` + **ARN funzione** – `arn:aws:lambda:us-west-2:123456789012:function:my-function` + **ARN parziale** – `123456789012:function:my-function`. ## Cross-Origin Resource Sharing (CORS) Per definire in che modo le diverse origini possono accedere all'URL della funzione, utilizza [cross-origin resource sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS). Si consiglia di configurare CORS se si intende chiamare l'URL della funzione da un dominio diverso. Lambda supporta le seguenti intestazioni CORS per la funzione. URLs | Intestazioni CORS | Proprietà di configurazione CORS | Valori di esempio | | --- | --- | --- | | [ Access-Control-Allow-Origin](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Origin) | `AllowOrigins` | `*` (consente tutte le origini) `https://www.example.com` `http://localhost:60905` | | [ Access-Control-Allow-Methods](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Methods) | `AllowMethods` | `GET`, `POST`, `DELETE`, `*` | | [ Access-Control-Allow-Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Headers) | `AllowHeaders` | `Date`, `Keep-Alive`, `X-Custom-Header` | | [ Access-Control-Expose-Headers](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Expose-Headers) | `ExposeHeaders` | `Date`, `Keep-Alive`, `X-Custom-Header` | | [ Access-Control-Allow-Credentials](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Allow-Credentials) | `AllowCredentials` | `TRUE` | | [ Access-Control-Max-Age](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Access-Control-Max-Age) | `MaxAge` | `5` (default), `300` | Quando configuri CORS per l'URL di una funzione utilizzando la console Lambda o il AWS CLI, Lambda aggiunge automaticamente le intestazioni CORS a tutte le risposte tramite l'URL della funzione. In alternativa, è possibile aggiungere manualmente le intestazioni CORS alla risposta della funzione. Se ci sono intestazioni in conflitto, il comportamento previsto dipende dal tipo di richiesta: + Per le richieste di preflight come le richieste OPTIONS, le intestazioni CORS configurate nella funzione URL hanno la precedenza. Lambda restituisce solo queste intestazioni CORS nella risposta. + Per le richieste non preflight come le richieste GET o POST, Lambda restituisce sia le intestazioni CORS configurate nella funzione URL, sia le intestazioni CORS restituite dalla funzione. Ciò può comportare intestazioni CORS duplicate nella risposta. È possibile che venga visualizzato un errore simile al seguente: `The 'Access-Control-Allow-Origin' header contains multiple values '*, *', but only one is allowed`. In generale, consigliamo di configurare tutte le impostazioni CORS nella funzione URL anziché inviare manualmente le intestazioni CORS nella risposta della funzione. ## Funzione di limitazione URLs Il throttling limita la frequenza con cui la funzione elabora le richieste. Ciò è utile in molte situazioni, ad esempio per impedire alla funzione di sovraccaricare le risorse a valle o per gestire un improvviso aumento delle richieste. È possibile limitare la frequenza delle richieste elaborate dalla funzione Lambda tramite un URL di funzione configurando la simultaneità riservata. La simultaneità riservata limita il numero massimo di richiami simultanei della funzione. La frequenza massima di richieste al secondo (RPS) della funzione equivale a 10 volte la simultaneità riservata configurata. Ad esempio, se si configura la funzione con una simultaneità riservata di 100, l'RPS massimo è 1.000. Ogni volta che la simultaneità della funzione supera la simultaneità riservata, l'URL della funzione restituisce un codice di stato HTTP `429`. Se la funzione riceve una richiesta che supera 10 volte l'RPS massimo in base alla simultaneità riservata configurata, viene ricevuto anche un errore HTTP `429`. Per ulteriori informazioni sulla simultaneità riservata, consulta [Configurazione della simultaneità riservata per una funzione](configuration-concurrency.md). ## Funzione di disattivazione URLs In caso di emergenza, potresti voler rifiutare tutto il traffico verso l'URL della funzione. Per disattivare l'URL della funzione, imposta la simultaneità riservata su zero. In questo modo vengono limitate tutte le richieste all'URL della funzione, con conseguenti risposte di stato HTTP `429`. Per riattivare l'URL della funzione, elimina la configurazione di simultaneità riservata o imposta la configurazione su una quantità maggiore di zero. ## Funzione di cancellazione URLs Quando si elimina un URL di funzione, non è possibile ripristinarlo. La creazione di un nuovo URL di funzione determinerà un indirizzo URL diverso. **Nota** Se elimini l'URL della funzione con il tipo di autenticazione `NONE`, Lambda non elimina automaticamente la policy basata sulle risorse associata. Se desideri eliminare questa policy, dovrai farlo manualmente. 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegliere il nome della funzione. 1. Scegli la scheda **Configurazione**, quindi scegli **URL della funzione**. 1. Scegli **Elimina**. 1. Inserisci la parola *delete* (elimina) nel campo per confermare l'eliminazione. 1. Scegli **Elimina**. **Nota** Quando si elimina una funzione con una funzione URL, Lambda elimina in modo asincrono la funzione URL. Se crei immediatamente una nuova funzione con lo stesso nome nello stesso account, è possibile che la funzione URL originale venga mappata alla nuova funzione anziché eliminata. # Controlla l'accesso alla funzione Lambda URLs **Nota** A partire da ottobre 2025, la nuova funzione URLs richiederà entrambe le `lambda:InvokeFunctionUrl` autorizzazioni`lambda:InvokeFunction`. Puoi controllare l'accesso alla tua funzione Lambda URLs utilizzando il [AuthType](https://docs.aws.amazon.com/lambda/latest/api/API_CreateFunctionUrlConfig.html#lambda-CreateFunctionUrlConfig-request-AuthType)parametro combinato con le [politiche basate sulle risorse](access-control-resource-based.md) allegate alla tua funzione specifica. La configurazione di questi due componenti determina chi può richiamare o eseguire altre azioni amministrative sull'URL della funzione. Il parametro `AuthType` determina il modo in cui Lambda autentica o autorizza le richieste all'URL della funzione. Quando configuri l'URL della funzione, è necessario specificare una delle seguenti opzioni `AuthType`: + `AWS_IAM`— Lambda utilizza AWS Identity and Access Management (IAM) per autenticare e autorizzare le richieste in base alla policy di identità del principale IAM e alla policy basata sulle risorse della funzione. Scegli questa opzione se desideri che solo gli utenti e i ruoli autenticati invochino la tua funzione utilizzando l'URL della funzione. + `NONE`: Lambda non esegue alcuna autenticazione prima di richiamare la funzione. Tuttavia, la policy basata sulle risorse della funzione è sempre valida e deve concedere l'accesso pubblico prima che l'URL della funzione possa ricevere richieste. Scegli questa opzione per consentire l'accesso pubblico e non autenticato all'URL della funzione. Per ulteriori approfondimenti sulla sicurezza, puoi utilizzare AWS Identity and Access Management Access Analyzer per ottenere un'analisi completa dell'accesso esterno all'URL della tua funzione. IAM Access Analyzer controlla inoltre le autorizzazioni nuove o aggiornate sulle funzioni Lambda per aiutarti a identificare le autorizzazioni che garantiscono l'accesso pubblico e tra account. Puoi utilizzare IAM Access Analyzer gratuitamente. Per le nozioni di base su IAM Access Analyzer, consulta [Utilizzo di AWS IAM Access Analyzer](https://docs.aws.amazon.com/IAM/latest/UserGuide/what-is-access-analyzer.html). Questa pagina contiene esempi di politiche basate sulle risorse per entrambi i tipi di autenticazione e come creare queste politiche utilizzando il funzionamento dell'[AddPermission](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html)API o la console Lambda. Per informazioni su come richiamare l'URL della funzione dopo aver impostato le autorizzazioni, consulta. [Richiamo di URL di funzioni Lambda](urls-invocation.md) **Topics** + [Utilizzo del tipo di autenticazione `AWS_IAM`](#urls-auth-iam) + [Utilizzo del tipo di autenticazione `NONE`](#urls-auth-none) + [Governance e controllo degli accessi](#urls-governance) ## Utilizzo del tipo di autenticazione `AWS_IAM` Se scegli il tipo di autenticazione `AWS_IAM`, gli utenti che hanno bisogno di richiamare l'URL della funzione Lambda devono avere le autorizzazioni `lambda:InvokeFunctionUrl` e `lambda:InvokeFunction`. A seconda di chi effettua la richiesta di invocazione, potrebbe essere necessario concedere questa autorizzazione utilizzando una [policy basata sulle risorse](access-control-resource-based.md). **Se il principale che effettua la richiesta è lo Account AWS stesso dell'URL della funzione, allora il principale deve disporre delle `lambda:InvokeFunction` autorizzazioni nella propria politica [basata sull'identità **oppure** avere le autorizzazioni `lambda:InvokeFunctionUrl` concesse nella politica basata sulle](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_identity-vs-resource.html) risorse della funzione.** In altre parole, una policy basata sulle risorse è facoltativa se l'utente ha già autorizzazioni `lambda:InvokeFunctionUrl` e `lambda:InvokeFunction` nella policy basata sull'identità. [La valutazione delle politiche segue le regole delineate nella logica di valutazione delle politiche.](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic.html) Se il principal che effettua la richiesta si trova in un account diverso, il principal deve avere **sia** una policy basata sull'identità che fornisce autorizzazioni `lambda:InvokeFunctionUrl` e `lambda:InvokeFunction`, **sia** autorizzazioni concesse in una policy basata sulle risorse nella funzione che si sta tentando di invocare. La valutazione delle politiche segue le regole descritte in [Determinare se è consentita una richiesta tra più account](https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_evaluation-logic-cross-account.html#policy-eval-cross-account). La seguente politica basata sulle risorse consente al `example` ruolo in di richiamare l'URL della funzione associata Account AWS `444455556666` alla funzione. `my-function` La chiave [lambda: InvokedViaFunctionUrl](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html#lambda-AddPermission-request-InvokedViaFunctionUrl) context limita l'azione alle chiamate URL di funzione. `lambda:InvokeFunction` Ciò significa che il principale deve utilizzare l'URL della funzione per richiamare la funzione. Se non lo includi`lambda:InvokedViaFunctionUrl`, il principale può richiamare la tua funzione tramite altri metodi di invocazione, oltre all'URL della funzione. **Example — Politica basata sulle risorse per più account** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action": "lambda:InvokeFunctionUrl", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-function", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "AWS_IAM" } } }, { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-1:123456789012:function:my-function", "Condition": { "Bool": { "lambda:InvokedViaFunctionUrl": "true" } } } ] } ``` È possibile creare questa politica basata sulle risorse tramite la console utilizzando i seguenti passaggi: **Per concedere le autorizzazioni di richiamo URL a un altro account (console)** 1. Aprire la pagina [Funzioni](https://console.aws.amazon.com/lambda/home#/functions) della console Lambda. 1. Scegli il nome della funzione per la quale desideri concedere autorizzazioni di richiamo URL. 1. Quindi, seleziona la scheda **Configuration** (Configurazione) e poi **Permissions** (Autorizzazioni). 1. In **Resource-based policy** (Policy basata sulle risorse), scegli **Add permissions** (Aggiungi autorizzazioni). 1. Scegli **Function URL** (URL funzione). 1. Per il tipo di **autenticazione**, scegli. **AWS\$1IAM** 1. Inserisci un **ID della dichiarazione** per la tua dichiarazione politica. 1. Per **Principal**, inserisci l'ID dell'account o l'Amazon Resource Name (ARN) dell'utente o del ruolo a cui desideri concedere le autorizzazioni. Ad esempio: **444455556666**. 1. Scegli **Save** (Salva). In alternativa, puoi creare questa policy utilizzando i seguenti comandi [add-permission](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/lambda/add-permission.html) AWS Command Line Interface ()AWS CLI. Quando si utilizza il AWS CLI, è necessario aggiungere le `lambda:InvokeFunction` istruzioni `lambda:InvokeFunctionUrl` and separatamente. Esempio: ``` aws lambda add-permission --function-name my-function \ --statement-id UrlPolicyInvokeURL \ --action lambda:InvokeFunctionUrl \ --principal 444455556666 \ --function-url-auth-type AWS_IAM ``` ``` aws lambda add-permission --function-name my-function \ --statement-id UrlPolicyInvokeFunction \ --action lambda:InvokeFunction \ --principal 444455556666 \ --invoked-via-function-url ``` ## Utilizzo del tipo di autenticazione `NONE` **Importante** Quando il tipo di autenticazione dell'URL della funzione è `NONE` e hai una [policy basata sulle risorse](access-control-resource-based.md) che garantisce l'accesso pubblico, qualsiasi utente non autenticato con l'URL della funzione può invocare la funzione. In alcuni casi, potreste volere che l'URL della funzione sia pubblico. Ad esempio, potrebbe essere preferibile inviare le richieste effettuate direttamente da un browser Web. Per consentire l'accesso pubblico all'URL della funzione, scegli il tipo di autenticazione `NONE`. Se scegli il tipo di autenticazione `NONE`, Lambda non utilizza IAM per autenticare le richieste all'URL della funzione. Tuttavia, la funzione deve avere una politica basata sulle risorse che consenta e. `lambda:InvokeFunctionUrl` `lambda:InvokeFunction` Quando crei un URL di funzione con tipo di autenticazione `NONE` utilizzando la console o AWS Serverless Application Model (AWS SAM), Lambda crea automaticamente la politica basata sulle risorse per te. Se utilizzi direttamente l'API Lambda AWS CLI AWS CloudFormation, o l'API Lambda, devi [aggiungere tu stesso la policy](#policy-cli). Ti consigliamo di includere la chiave [lambda: InvokedViaFunctionUrl](https://docs.aws.amazon.com/lambda/latest/api/API_AddPermission.html#lambda-AddPermission-request-InvokedViaFunctionUrl) context nelle politiche basate sulle risorse quando usi il tipo di autenticazione. `NONE` Questa chiave di contesto garantisce che la funzione possa essere richiamata solo tramite l'URL della funzione e non tramite altri metodi di invocazione. Tieni presente quanto segue su questa politica: + Tutte le entità possono chiamare `lambda:InvokeFunctionUrl` e`lambda:InvokeFunction`. Ciò significa che chiunque disponga dell'URL della tua funzione può richiamarla. + Il valore della chiave della `lambda:FunctionUrlAuthType` condizione è`NONE`. Ciò significa che l'informativa consente l'accesso solo quando lo è anche `NONE` il tipo di autenticazione dell'URL della funzione. + La `lambda:InvokedViaFunctionUrl` condizione garantisce che la funzione possa essere richiamata solo tramite l'URL della funzione e non tramite altri metodi di invocazione. **Example — Politica predefinita basata sulle risorse per il tipo di autenticazione NONE** **** ``` { "Version":"2012-10-17", "Statement": [ { "Sid": "FunctionURLAllowPublicAccess", "Effect": "Allow", "Principal": "*", "Action": "lambda:InvokeFunctionUrl", "Resource": "arn:aws:lambda:us-east-2:123456789012:function:my-function", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "NONE" } } }, { "Sid": "FunctionURLInvokeAllowPublicAccess", "Effect": "Allow", "Principal": "*", "Action": "lambda:InvokeFunction", "Resource": "arn:aws:lambda:us-east-2:123456789012:function:my-function", "Condition": { "Bool": { "lambda:InvokedViaFunctionUrl": "true" } } } ] } ``` **Creare la politica basata sulle risorse utilizzando il AWS CLI** A meno che non utilizzi la console o AWS SAM crei un URL di funzione con tipo di autenticazione`NONE`, devi aggiungere tu stesso la politica basata sulle risorse. Usa i comandi seguenti per creare istruzioni con le autorizzazioni `lambda:InvokeFunctionUrl` e `lambda:InvokeFunction`. Ogni istruzione deve essere aggiunta in un comando separato. ``` aws lambda add-permission \ --function-name UrlTestFunction \ --statement-id UrlPolicyInvokeURL \ --action lambda:InvokeFunctionUrl \ --principal * \ --function-url-auth-type NONE ``` ``` aws lambda add-permission \ --function-name UrlTestFunction \ --statement-id UrlPolicyInvokeFunction \ --action lambda:InvokeFunction \ --principal * \ --invoked-via-function-url ``` **Nota** Se elimini l'URL della funzione con il tipo di autenticazione `NONE`, Lambda non elimina automaticamente la policy basata sulle risorse associata. Se desideri eliminare questa policy, dovrai farlo manualmente. Se la politica basata sulle risorse di una funzione non concede `lambda:invokeFunctionUrl` `lambda:InvokeFunction` autorizzazioni, gli utenti riceveranno un codice di errore 403 Forbidden quando cercheranno di richiamare l'URL della funzione. Ciò si verificherà anche se l'URL della funzione utilizza il tipo di autenticazione. `NONE` ## Governance e controllo degli accessi Oltre ai permessi di invocazione dell'URL della funzione, puoi anche controllare l'accesso alle azioni utilizzate per configurare la funzione. URLs Lambda supporta le seguenti azioni politiche IAM per la funzione: URLs + `lambda:InvokeFunctionUrl`: richiamo di una funzione Lambda utilizzando l'URL della funzione. + `lambda:CreateFunctionUrlConfig`: creazione di un URL della funzione e impostazione del relativo `AuthType`. + `lambda:UpdateFunctionUrlConfig`: aggiornamento della configurazione dell'URL della funzione e del relativo `AuthType`. + `lambda:GetFunctionUrlConfig`: visualizzazione dei dettagli dell'URL della funzione. + `lambda:ListFunctionUrlConfigs`: elenco delle configurazioni dell'URL della funzione. + `lambda:DeleteFunctionUrlConfig`: eliminazione dell'URL della funzione. Per consentire o negare l'accesso all'URL della funzione ad altre AWS entità, includi queste azioni nelle policy IAM. Ad esempio, la seguente politica concede il `example` ruolo nelle Account AWS `444455556666` autorizzazioni per aggiornare l'URL della funzione per la funzione nell'account. **my-function** `123456789012` **Example Policy dell'URL della funzione tra account** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action": "lambda:UpdateFunctionUrlConfig", "Resource": "arn:aws:lambda:us-east-2:123456789012:function:my-function" } ] } ``` ### Chiavi di condizione Per un controllo granulare degli accessi alla funzione URLs, utilizzate i tasti contestuali delle condizioni. Lambda supporta i seguenti tasti contestuali per la funzione: URLs + `lambda:FunctionUrlAuthType`: definisce un valore enum che descrive il tipo di autenticazione utilizzato dall'URL della funzione. Il valore può essere `AWS_IAM` o `NONE`. + `lambda:InvokedViaFunctionUrl`— Limita l'`lambda:InvokeFunction`azione alle chiamate effettuate tramite l'URL della funzione. Ciò garantisce che la funzione possa essere richiamata solo utilizzando l'URL della funzione e non tramite altri metodi di invocazione. Per esempi di politiche basate sulle risorse che utilizzano la chiave di `lambda:InvokedViaFunctionUrl` contesto, consulta gli esempi in and. [Utilizzo del tipo di autenticazione `AWS_IAM`](#urls-auth-iam) [Utilizzo del tipo di autenticazione `NONE`](#urls-auth-none) È possibile utilizzare queste chiavi di contesto nelle politiche associate alla propria funzione. Ad esempio, potresti voler limitare chi può apportare modifiche alla configurazione della tua funzione URLs. Per negare tutte le richieste `UpdateFunctionUrlConfig` a qualsiasi funzione con tipo di autenticazione URL `NONE`, è possibile definire la seguente policy: **Example Policy dell'URL della funzione con rifiuto esplicito** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Principal": "*", "Action":[ "lambda:UpdateFunctionUrlConfig" ], "Resource": "arn:aws:lambda:us-east-1:123456789012:function:*", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "NONE" } } } ] } ``` Per concedere il `example` ruolo nelle Account AWS `444455556666` autorizzazioni `CreateFunctionUrlConfig` e nelle `UpdateFunctionUrlConfig` richieste sulle funzioni con tipo di autenticazione URL`AWS_IAM`, puoi definire la seguente politica: **Example Policy dell'URL della funzione con permesso esplicito** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "AWS": "arn:aws:iam::444455556666:role/example" }, "Action":[ "lambda:CreateFunctionUrlConfig", "lambda:UpdateFunctionUrlConfig" ], "Resource": "arn:aws:lambda:us-east-1:123456789012:function:*", "Condition": { "StringEquals": { "lambda:FunctionUrlAuthType": "AWS_IAM" } } } ] } ``` È inoltre possibile utilizzare questa chiave di condizione in una [policy di controllo dei servizi](https://docs.aws.amazon.com/organizations/latest/userguide/orgs_manage_policies_scps.html) (SCP). Utilizzalo SCPs per gestire le autorizzazioni in un'intera organizzazione in. AWS Organizations Ad esempio, per impedire agli utenti di creare o aggiornare funzioni URLs che utilizzano qualcosa di diverso dal tipo di `AWS_IAM` autenticazione, utilizza la seguente politica di controllo del servizio: **Example SCP dell'URL della funzione con rifiuto esplicito** **** ``` { "Version":"2012-10-17", "Statement": [ { "Effect": "Deny", "Action":[ "lambda:CreateFunctionUrlConfig", "lambda:UpdateFunctionUrlConfig" ], "Resource": "arn:aws:lambda:*:123456789012:function:*", "Condition": { "StringNotEquals": { "lambda:FunctionUrlAuthType": "AWS_IAM" } } } ] } ``` # Richiamo di URL di funzioni Lambda Un URL della funzione è un endpoint HTTP(S) dedicato alla funzione Lambda. È possibile creare e configurare un URL della funzione tramite la console Lambda o l'API Lambda. **Suggerimento** Lambda offre due modi per richiamare una funzione tramite un endpoint HTTP: URL di funzione e Amazon API Gateway. Se non sei certo del metodo più adatto al tuo caso d'uso, consultare[Selezionare un metodo per richiamare la funzione Lambda tramite una richiesta HTTP](furls-http-invoke-decision.md). Quando si crea un URL della funzione, Lambda genera automaticamente un endpoint URL univoco. Dopo aver creato un URL della funzione, il suo endpoint URL non cambia mai. Gli endpoint URL della funzione hanno il formato seguente: ``` https://.lambda-url..on.aws ``` **Nota** Gli URL delle funzioni non sono supportati nei seguenti paesiRegioni AWS: Asia Pacifico (Hyderabad) (`ap-south-2`), Asia Pacifico (Melbourne) (`ap-southeast-4`), Asia Pacifico (Malesia) (), Asia Pacifico (Nuova Zelanda`ap-southeast-5`) (), Asia Pacifico (Tailandia) ()`ap-southeast-6`, Asia Pacifico (Taipei`ap-southeast-7`) (), Canada occidentale (Calgary) ()`ap-east-2`, Europa (Spagna) ()`ca-west-1`, Europa (Zurigo) () `eu-south-2``eu-central-2`, Israele (Tel Aviv) () e Medio Oriente (Emirati Arabi Uniti) (). `il-central-1` `me-central-1` Gli URL della funzione sono abilitati alla rete dual stack e supportano IPv4 e IPv6. Dopo aver configurato l'URL della funzione, è possibile richiamare la funzione attraverso il relativo endpoint HTTP(S) tramite un browser Web, curl, Postman o un client HTTP. Per richiamare un URL della funzione, è necessario disporre di autorizzazioni . Per ulteriori informazioni, consulta [Controllo accessi](urls-auth.md). **Topics** + [Nozioni di base sul richiamo di URL di funzioni](#urls-invocation-basics) + [Payload di richieste e risposte](#urls-payloads) ## Nozioni di base sul richiamo di URL di funzioni Se l'URL della funzione utilizza il tipo di autenticazione `AWS_IAM`, è necessario firmare ogni richiesta HTTP utilizzando [AWS Signature Version 4 (SigV4)](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html). Strumenti come awscurl, Postman e SigV4 Proxy offrono modalità integrate per firmare le richieste con Sigv4. Se non utilizzi uno strumento per firmare le richieste HTTP all'URL della funzione, è necessario firmare manualmente ogni richiesta utilizzando Sigv4. Quando l'URL della funzione riceve una richiesta, Lambda calcola anche la firma Sigv4. Lambda elabora la richiesta solo se le firme corrispondono. Per le istruzioni su come firmare manualmente le richieste con SigV4, consulta [Firma delle richieste AWS con Signature Version 4](https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html) nella *Guida di riferimento generale di Riferimenti generali di Amazon Web Services*. Se l'URL della funzione utilizza il tipo di autenticazione `NONE`, non è necessario firmare le richieste utilizzando Sigv4. Puoi richiamare la funzione utilizzando un browser Web, curl, Postman o un client HTTP. Per verificare semplici richieste `GET` alla funzione, usa un browser Web. Ad esempio, se l'URL della funzione è `https://abcdefg.lambda-url.us-east-1.on.aws` e richiede un parametro stringa `message`, l'URL della richiesta potrebbe essere simile al seguente: ``` https://abcdefg.lambda-url.us-east-1.on.aws/?message=HelloWorld ``` Per verificare altre richieste HTTP, ad esempio una richiesta `POST`, puoi utilizzare uno strumento come curl. Ad esempio, se desideri includere alcuni dati JSON in una richiesta `POST` all'URL della funzione, potresti utilizzare il comando curl seguente: ``` curl -v 'https://abcdefg.lambda-url.us-east-1.on.aws/?message=HelloWorld' \ -H 'content-type: application/json' \ -d '{ "example": "test" }' ``` ## Payload di richieste e risposte Quando un client chiama l'URL della funzione, Lambda mappa la richiesta a un oggetto evento prima di passarlo alla funzione. La risposta della funzione viene quindi mappata a una risposta HTTP che Lambda invia al client tramite l'URL della funzione. I formati degli eventi di richiesta e risposta seguono lo stesso schema del [tipo di formato del payload di Gateway Amazon API versione 2.0](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format). ### Formato del payload di richiesta Un payload di richiesta ha la seguente struttura: ``` { "version": "2.0", "routeKey": "$default", "rawPath": "/my/path", "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", "cookies": [ "cookie1", "cookie2" ], "headers": { "header1": "value1", "header2": "value1,value2" }, "queryStringParameters": { "parameter1": "value1,value2", "parameter2": "value" }, "requestContext": { "accountId": "123456789012", "apiId": "", "authentication": null, "authorizer": { "iam": { "accessKey": "AKIA...", "accountId": "111122223333", "callerId": "AIDA...", "cognitoIdentity": null, "principalOrgId": null, "userArn": "arn:aws:iam::111122223333:user/example-user", "userId": "AIDA..." } }, "domainName": ".lambda-url.us-west-2.on.aws", "domainPrefix": "", "http": { "method": "POST", "path": "/my/path", "protocol": "HTTP/1.1", "sourceIp": "123.123.123.123", "userAgent": "agent" }, "requestId": "id", "routeKey": "$default", "stage": "$default", "time": "12/Mar/2020:19:03:58 +0000", "timeEpoch": 1583348638390 }, "body": "Hello from client!", "pathParameters": null, "isBase64Encoded": false, "stageVariables": null } ``` | Parametro | Descrizione | Esempio | | --- | --- | --- | | `version` | Il tipo di formato del payload per questo evento. Gli URL della funzione Lambda attualmente supportano il [tipo di formato del payload versione 2.0](https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html#http-api-develop-integrations-lambda.proxy-format). | `2.0` | | `routeKey` | Gli URL della funzione non utilizzano questo parametro. Lambda lo imposta su `$default` come segnaposto. | `$default` | | `rawPath` | Percorso della richiesta. Ad esempio, se l'URL della richiesta è `https://{url-id}.lambda-url.{region}.on.aws/example/test/demo`, il valore raw del percorso è `/example/test/demo`. | `/example/test/demo` | | `rawQueryString` | La stringa raw contenente i parametri della stringa di query della richiesta. I caratteri supportati includono `a-z`, `A-Z`, `0-9`, `.`, `_`, `-`, `%`, `&`, `=` e `+`. | `"?parameter1=value1¶meter2=value2"` | | `cookies` | Un array contenente tutti i cookie inviati come parte della richiesta. | `["Cookie_1=Value_1", "Cookie_2=Value_2"]` | | `headers` | L'elenco delle intestazioni della richiesta, presentate come coppie chiave-valore. | `{"header1": "value1", "header2": "value2"}` | | `queryStringParameters` | I parametri di query per la richiesta. Ad esempio, se l'URL della richiesta è `https://{url-id}.lambda-url.{region}.on.aws/example?name=Jane`, il valore `queryStringParameters` è un oggetto JSON con una chiave di `name` e un valore di `Jane`. | `{"name": "Jane"}` | | `requestContext` | Un oggetto contenente informazioni aggiuntive sulla richiesta, ad esempio `requestId`, l'ora della richiesta e l'identità del chiamante se autorizzato tramite AWS Identity and Access Management (IAM). | | | `requestContext.accountId` | L'ID Account AWS del proprietario della funzione. | `"123456789012"` | | `requestContext.apiId` | L'ID dell'URL della funzione. | `"33anwqw8fj"` | | `requestContext.authentication` | Gli URL della funzione non utilizzano questo parametro. Lambda lo imposta su `null`. | `null` | | `requestContext.authorizer` | Un oggetto contenente informazioni sull'identità del chiamante, se l'URL della funzione utilizza il tipo di autenticazione `AWS_IAM`. Altrimenti, Lambda lo imposta su `null`. | | | `requestContext.authorizer.iam.accessKey` | La chiave di accesso dell'identità del chiamante. | `"AKIAIOSFODNN7EXAMPLE"` | | `requestContext.authorizer.iam.accountId` | L'ID Account AWS dell'identità del chiamante. | `"111122223333"` | | `requestContext.authorizer.iam.callerId` | L'ID (ID utente) del chiamante. | `"AIDACKCEVSQ6C2EXAMPLE"` | | `requestContext.authorizer.iam.cognitoIdentity` | Gli URL della funzione non utilizzano questo parametro. Lambda lo imposta su `null` o lo esclude dal JSON. | `null` | | `requestContext.authorizer.iam.principalOrgId` | L'ID dell'organizzazione principale associato all'identità del chiamante. | `"AIDACKCEVSQORGEXAMPLE"` | | `requestContext.authorizer.iam.userArn` | L'Amazon Resource Name (ARN) utente dell'identità del chiamante. | `"arn:aws:iam::111122223333:user/example-user"` | | `requestContext.authorizer.iam.userId` | L'ID utente dell'identità del chiamante. | `"AIDACOSFODNN7EXAMPLE2"` | | `requestContext.domainName` | Il nome di dominio dell'URL della funzione. | `".lambda-url.us-west-2.on.aws"` | | `requestContext.domainPrefix` | Il prefisso di dominio dell'URL della funzione. | `""` | | `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**.