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 di una funzione Web Lambda
Per distribuire un'app con Lambda Web Functions, devi creare una funzione Web con una revisione e un endpoint per ricevere traffico. La console e il `aws lambda-web deploy` comando possono creare la funzione Web, la sua prima revisione e il suo primo endpoint. Le revisioni sono istantanee immutabili del codice e della configurazione. Un endpoint indirizza le richieste a una revisione attiva. Per ulteriori informazioni su queste risorse, vedere [Concetti principali](web-functions-how-it-works.md). Questo argomento mostra come crearli utilizzando la console Lambda e il. AWS CLI
## Prerequisiti
Prima di iniziare, assicurati di disporre di:
+ Un AWS account. Per crearne uno, [consulta Confronta le opzioni di registrazione](https://docs.aws.amazon.com/accounts/latest/reference/sign-up-for-aws.html) nella *Guida di riferimento per la gestione degli AWS account*.
+ Autorizzazioni per gestire le funzioni Web, passare il ruolo di esecuzione a Lambda `iam:PassRole` () e creare o utilizzare le risorse di supporto di Amazon S3 e IAM.
La console crea o riutilizza le risorse di cui la tua Web Function ha bisogno, tra cui un ruolo di esecuzione e un bucket Amazon S3 per il codice.
Per seguire la AWS CLI procedura, devi anche:
+ AWS CLI versione 2, in una versione che include i `aws lambda-web` comandi. Per controllare, esegui`aws lambda-web help`. Se lo hai installato AWS CLI utilizzando un programma di installazione o uno script di installazione ufficiale, `aws update` esegui l'aggiornamento alla versione più recente. Altrimenti, vedi [Installazione o aggiornamento alla versione più recente di AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/getting-started-install.html).
+ AWS credenziali e un file Regione AWS configurato per. AWS CLI
+ Per`aws lambda-web deploy`, autorizzazione a chiamare`sts:GetCallerIdentity`, `s3:ListBucket` sul bucket di distribuzione e `s3:PutObject``s3:GetObject`, e `s3:GetObjectVersion` sui relativi oggetti.
+ Se `aws lambda-web deploy` crea le risorse predefinite, il permesso di chiamare `iam:GetRole``iam:CreateRole`,`iam:PutRolePolicy`, `s3:CreateBucket``s3:PutBucketPolicy`, e`s3:PutBucketVersioning`.
+ (Facoltativo) Node.js 24 o versioni successive per lo sviluppo locale. Per l'installazioneNode.js, consulta [Download Node.js](https://nodejs.org/en/download/) sul Node.js sito Web.
## Creazione di una funzione Web (console)
Usa la console Lambda per creare una funzione Web, la sua prima revisione e il primo endpoint a ricevere traffico.
**Per creare una funzione Web e un endpoint (console)**
1. Apri la console Lambda all'indirizzo. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. Nel riquadro di navigazione, scegli **Funzioni Web**.
1. Scegli **Crea funzione Web**.
1. In **Basic information (Informazioni di base)** eseguire queste operazioni:
1. Per **Nome della funzione**, inserisci un nome per la tua funzione Web.
1. Per **Runtime**, mantieni il runtime predefinito.
1. Per **Code source**, mantieni **il modello Hello World** per iniziare da un'applicazione di esempio preconfigurata. Per distribuire invece il tuo codice, scegli **Carica file ZIP** o **Amazon** S3.
1. In **Configurazione dell'endpoint, procedi** come segue:
1. Per **Nome dell'endpoint**, inserisci un nome per l'endpoint.
1. Per **Tipo, mantieni**. **Home-Region** Un Home-Region endpoint viene eseguito in un'unica regione, il che lo rende la configurazione più semplice per la prima funzione Web. Per le opzioni multiregionali, consulta. [Endpoint della funzione Web Lambda](web-functions-endpoints.md)
**Nota**
Non è possibile modificare il tipo di endpoint dopo la creazione.
1. Per **Tipo di autenticazione**, scegli **Application-managed l'autenticazione**. Con questa opzione, Lambda inoltra tutte le richieste all'app, in modo che quest'ultima gestisca l'autenticazione. Per limitare invece l'accesso, scegli l'**autenticazione IAM**, che richiede ai chiamanti di firmare le richieste. Le richieste `HomeRegion` e gli `PerRegion` endpoint utilizzano AWS Signature Version 4 (SigV4). Le richieste agli `MultiRegion` endpoint utilizzano Signature Version 4a (SigV4a). Per ulteriori informazioni, consulta [Controllo dell'accesso agli endpoint Lambda Web Function](web-functions-endpoint-access-control.md).
1. **Per la **distribuzione automatica**, mantieni la revisione più recente.** **Con questa modalità, Lambda indirizza automaticamente tutto il traffico verso ogni nuova revisione dopo che è diventata attiva.** **Per il controllo manuale del traffico con pesi di revisione, scegli Disabilitato.** Per ulteriori informazioni, consulta [Modelli di implementazione](web-functions-deployment.md).
1. (Facoltativo) Espandi **Configurazioni aggiuntive** per sostituire le impostazioni predefinite. Per impostazione predefinita, Lambda crea un ruolo di esecuzione con l'autorizzazione a caricare i log su Amazon CloudWatch e un bucket Amazon S3 nel tuo account per archiviare il codice. In questa sezione puoi invece scegliere un ruolo IAM esistente o il tuo bucket Amazon S3 e puoi anche configurare la crittografia con una chiave gestita dal cliente, la massima concorrenza per ambiente, variabili di ambiente e tag.
1. Scegli **Crea funzione Web**.
Quando scegli **Crea funzione Web**, Lambda crea la risorsa Web Function insieme alla sua prima revisione e contemporaneamente crea l'endpoint. **La revisione inizia nello stato In **sospeso** mentre Lambda scarica il codice e ne prepara un elemento di codice, quindi passa a Active.** **L'endpoint inizia anche nello stato In sospeso.** La funzione Web, la sua revisione e il relativo endpoint procedono ciascuno attraverso questi stati in modo indipendente. Per ulteriori informazioni sulle revisioni e sugli stati del ciclo di vita, vedere. [Concetti principali](web-functions-how-it-works.md)
L'endpoint inizia a servire il traffico quando raggiunge **Active** ed è disponibile una revisione **attiva** verso cui indirizzarlo. Per trovare il nome di dominio dell'endpoint, nella pagina di dettaglio della funzione, scegli la scheda **Endpoints, quindi scegli l'endpoint**. Per servire l'app sul tuo dominio, metti una CloudFront distribuzione Amazon davanti all'endpoint. Per ulteriori informazioni sui tipi di endpoint e sui nomi di dominio, consulta. [Endpoint della funzione Web Lambda](web-functions-endpoints.md)
Per confermare che la tua app stia servendo traffico, invia una richiesta al nome di dominio. Poiché hai scelto **Application-managed l'autenticazione**, puoi inviare una semplice richiesta senza firmarla.
```
curl https://{{your-endpoint-domain-name}}/
```
Una risposta corretta significa che la tua funzione Web sta ricevendo traffico e l'app sta servendo le richieste.
## Creazione di una funzione Web (AWS CLI)
Crea e distribuisci una funzione Web dal tuo terminale. Il comando starter genera un piccolo server Node.js HTTP, lo distribuisce e restituisce un URL di endpoint HTTPS.
### Implementa e testa la tua funzione Web
**Per distribuire e testare una funzione Web iniziale**
1. Esegui il comando seguente:
```
aws lambda-web deploy --name my-web-app --hello-world
```
`--hello-world`scrive i file di avvio in`./my-web-app`, creando la directory se non esiste. Lo starter contiene`server.ts`, un server TypeScript HTTP e `package.json``README.md`, e. `AGENTS.md`
1. Una volta completata la distribuzione, copia l'URL dell'endpoint dall'output. L'URL è simile al seguente:
```
https://bcdfghjklmnpqrst.b7t.lambda-web.us-east-1.on.aws
```
1. Invia una richiesta all'URL dell'endpoint che hai copiato nel passaggio precedente. Sostituisci {{endpoint-url}} con quell'URL:
```
curl {{endpoint-url}}
```
Lo starter restituisce una risposta simile alla seguente:
```
{"message":"Hello from Lambda Web!","path":"/"}
```
Per impostazione predefinita, lo starter endpoint accetta richieste senza autenticazione. Per richiedere l'autorizzazione IAM, aggiungi. `--auth-type IamAuth` Per informazioni sul controllo dell'accesso all'endpoint, consulta[Controllo dell'accesso agli endpoint Lambda Web Function](web-functions-endpoint-access-control.md).
### Cosa crea il comando
Nella prima distribuzione, il comando:
+ Crea o riutilizza un bucket Amazon S3 con il controllo delle versioni abilitato per i pacchetti di distribuzione.
+ Crea o riutilizza un ruolo di esecuzione IAM con autorizzazioni Amazon CloudWatch Logs.
+ Crea la funzione Web e la sua prima revisione.
+ Crea un `HomeRegion` endpoint denominato `dev` e attende che lo diventi. `Active` Per usare un nome diverso, aggiungi. `--endpoint-name`
Una funzione Web contiene revisioni immutabili del codice e della configurazione. Nelle distribuzioni successive, il comando crea un'altra revisione. L'`dev`endpoint utilizza la `LatestRevision` modalità e fornisce la revisione dopo che è diventata attiva.
### Implementa una modifica
Dopo aver modificato l'applicazione di avvio, esegui:
```
aws lambda-web deploy \
--name my-web-app \
--code ./my-web-app
```
L'esecuzione di questo comando carica il pacchetto aggiornato, crea una revisione e attende che la revisione diventi. `Active` L'`dev`endpoint è `autoDeploymentMode` impostato `LatestRevision` e fornisce la revisione automaticamente. L'URL rimane lo stesso.
Per distribuire la tua app al posto dello starter, passa la relativa directory a. `--code` Il server deve ascoltare sull'host e sulla porta nella variabile di `AWS_LAMBDA_HTTP_ENDPOINT` ambiente. Per impostazione predefinita, il runtime viene caricato `index.js` nella radice del pacchetto di distribuzione. Per utilizzare un file di ingresso diverso, imposta la variabile di `AWS_LAMBDA_NODEJS_ENTRYPOINT` ambiente. Lambda non verifica che il server inizi ad ascoltare quando crea la revisione. Di conseguenza, la revisione e l'endpoint possono essere visualizzati `Active` anche se le richieste falliscono. Per ulteriori informazioni, consulta [Runtime della funzione Web Lambda](web-functions-runtimes.md).
### Usa quello esistente AWS risorse
Se gestisci già un bucket Amazon S3 o un ruolo di esecuzione IAM, usa il seguente comando per riutilizzare tali risorse anziché creare impostazioni predefinite. Il bucket deve avere il controllo delle versioni abilitato e una policy del bucket che garantisca il servizio Lambda principal () e. `lambda.amazonaws.com` `s3:GetObject` `s3:GetObjectVersion` Il comando non modifica la configurazione di un bucket specificato dall'utente. Per i requisiti del bucket, vedere. [Politica Bucket per Lambda](web-functions-code-s3.md#web-functions-code-s3-bucket-policy) Sostituisci i valori delle risorse di esempio con i tuoi.
```
aws lambda-web deploy \
--name my-web-app \
--code ./my-web-app \
--bucket-name amzn-s3-demo-bucket \
--execution-role-arn arn:aws:iam::111122223333:role/my-web-app-execution-role
```
Il ruolo di esecuzione deve consentire a Lambda di assumerlo e deve concedere le autorizzazioni necessarie all'applicazione. Per ulteriori informazioni, consulta [Ruolo di esecuzione](web-functions-permissions.md#web-functions-permissions-execution-role).
Puoi omettere entrambe le opzioni di risorsa per consentire `deploy` la creazione di impostazioni predefinite. Quando `deploy` crea una funzione Web senza `--hello-world` o aggiunge un endpoint, chiede di premere Invio per confermare. In uno script o in una CI/CD pipeline, aggiungi `--create` per confermare senza una richiesta.
### Usa direttamente i comandi API
Il `deploy` comando carica il codice su Amazon S3 e crea automaticamente la funzione Web, la revisione e l'endpoint. Per controllare autonomamente ogni passaggio, utilizza i AWS CLI comandi associati alle operazioni dell'API, ad esempio, e. `create-web-function` `create-web-function-revision` `update-web-function-endpoint` Nei comandi seguenti, sostituisci ogni segnaposto dell'input utente con le tue informazioni.
**Per creare una funzione Web con i comandi API (AWS CLI)**
1. Crea un pacchetto di distribuzione.zip dalla directory dell'app, con il file di immissione nella radice del pacchetto. Carica il pacchetto in un bucket Amazon S3 che soddisfi i requisiti di. [Prerequisiti](web-functions-code-s3.md#web-functions-code-s3-requirements) I seguenti comandi creano il pacchetto e lo utilizzano AWS CLI per caricarlo.
```
cd {{my-app}}
zip -r ../my-app.zip .
aws s3 cp ../my-app.zip s3://{{amzn-s3-demo-bucket}}/my-app.zip
```
1. Utilizzare il AWS CLI comando seguente per creare la funzione Web con la prima revisione e l'endpoint. In`revisionConfig`, `buildConfig` specifica la posizione e il runtime del codice e `serviceConfig` specifica il ruolo di esecuzione. La `endpointConfig` proprietà definisce l'endpoint.
```
aws lambda-web create-web-function \
--function-name {{my-web-app}} \
--revision-config '{
"buildConfig": {
"codeConfig": {
"s3Object": { "bucket": "{{amzn-s3-demo-bucket}}", "key": "my-app.zip" }
},
"runtimeConfig": { "runtime": "nodejs24.x" }
},
"serviceConfig": {
"executionRoleArn": "arn:aws:iam::{{111122223333}}:role/{{my-web-app-execution-role}}"
}
}' \
--endpoint-config '{
"endpointName": "{{my-endpoint}}",
"endpointType": "HomeRegion",
"authType": "ApplicationManaged",
"autoDeploymentMode": "LatestRevision"
}'
```
La proprietà `autoDeploymentMode` è facoltativa. Se la ometti, l'impostazione predefinita è `Disabled` e l'endpoint non indirizza automaticamente il traffico verso nuove revisioni. Annota `revisionId` la revisione nella risposta.
1. Attendi che la revisione sia pronta. `Active` Sostituisci {{rev-abc12}} con l'ID di revisione del passaggio precedente.
```
aws lambda-web wait web-function-revision-active \
--function-name {{my-web-app}} \
--revision-id {{rev-abc12}}
```
1. Ottieni i dettagli dell'endpoint.
```
aws lambda-web get-web-function-endpoint \
--function-name {{my-web-app}} \
--endpoint-name {{my-endpoint}}
```
Quando l'endpoint `state` è attivo`Active`, invia le richieste al suo. `domainName` La risposta è simile al seguente estratto.
```
{
"endpointName": "my-endpoint",
"endpointType": "HomeRegion",
"domainName": "bcdfghjklmnpqrst.b7t.lambda-web.us-east-1.on.aws",
"authType": "ApplicationManaged",
"autoDeploymentMode": "LatestRevision",
"state": "Active",
"updateStatus": "Successful"
}
```
**Per implementare una modifica con i comandi API (AWS CLI)**
+ Carica un nuovo pacchetto e crea una revisione. Una revisione è un'istantanea completa, quindi passala ogni volta per intero`buildConfig`. `serviceConfig`
```
aws s3 cp ../my-app.zip s3://{{amzn-s3-demo-bucket}}/my-app.zip
aws lambda-web create-web-function-revision \
--function-name {{my-web-app}} \
--build-config '{
"codeConfig": {
"s3Object": { "bucket": "{{amzn-s3-demo-bucket}}", "key": "my-app.zip" }
},
"runtimeConfig": { "runtime": "nodejs24.x" }
}' \
--service-config '{
"executionRoleArn": "arn:aws:iam::{{111122223333}}:role/{{my-web-app-execution-role}}"
}'
```
Poiché l'endpoint è `autoDeploymentMode` impostato su`LatestRevision`, indirizza tutto il traffico verso la nuova revisione dopo che la revisione è diventata effettiva. `Active` Se lo imposti`Disabled`, `autoDeploymentMode` indirizzerai invece il traffico utilizzando i pesi di revisione `update-web-function-endpoint` e i relativi pesi. Per ulteriori informazioni, consulta [Modelli di implementazione](web-functions-deployment.md).
## Eliminazione
Quando non ti serve più la funzione Web, eliminala:
```
aws lambda-web delete-web-function --function-name my-web-app
```
Questo comando elimina anche gli endpoint e le revisioni della funzione Web. Non elimina le risorse `deploy` create o utilizzate: il ruolo di esecuzione IAM (per impostazione `awscli-lambdaweb-my-web-app` predefinita), i pacchetti di distribuzione `lambda-web/my-web-app/` nel bucket Amazon S3 (per impostazione `awscli-lambdaweb-{{account-id}}-{{region}}-an` predefinita), incluse le versioni degli oggetti non correnti, o i gruppi di log di Amazon CloudWatch Logs per la funzione Web. Elimina queste risorse separatamente solo se non ti servono più. Il bucket Amazon S3 gestito può essere condiviso da altre distribuzioni nella stessa regione. Account AWS