Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Tutorial: implementa una funzione Lambda aggiornata CodeDeploy con e AWS il modello di applicazione Serverless AWS SAM è un framework open source per la creazione di applicazioni serverless. Trasforma ed espande la sintassi YAML in un AWS SAM modello in CloudFormation sintassi per creare applicazioni serverless, come una funzione Lambda. [Per ulteriori informazioni, consulta What is the Serverless Application Model? AWS](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html) In questo tutorial, utilizzi AWS SAM per creare una soluzione che esegua le seguenti operazioni: + Crea la tua funzione Lambda. + Crea CodeDeploy l'applicazione e il gruppo di distribuzione. + Crea due funzioni Lambda che eseguono test di convalida della distribuzione durante CodeDeploy gli hook del ciclo di vita. + Rileva quando la funzione Lambda viene aggiornata. L'aggiornamento della funzione Lambda attiva una distribuzione CodeDeploy che sposta in modo incrementale il traffico di produzione dalla versione originale della funzione Lambda alla versione aggiornata. **Nota** Questo tutorial richiede la creazione di risorse che potrebbero comportare addebiti sull’account AWS . Questi includono possibili addebiti per CodeDeploy CloudWatch, Amazon e AWS Lambda. Per ulteriori informazioni, consulta [CodeDeploy i prezzi](https://aws.amazon.com/codedeploy/pricing/), [ CloudWatch i prezzi di Amazon](https://aws.amazon.com/cloudwatch/pricing/) e [AWS Lambda i prezzi](https://aws.amazon.com/lambda/pricing/). **Topics** + [Prerequisiti](tutorial-lambda-sam-prereqs.md) + [Fase 1: Configura la tua infrastruttura](tutorial-lambda-sam-setup-infrastructure.md) + [Fase 2: Aggiornare la funzione Lambda](tutorial-lambda-sam-update-function.md) + [Fase 3: Implementazione della funzione Lambda aggiornata](tutorial-lambda-sam-deploy-update.md) + [Fase 4: Visualizza i risultati della distribuzione](tutorial-lambda-sam-deploy-view-results.md) + [Fase 5: rimozione](tutorial-lambda-clean-up.md) # Prerequisiti Per completare questo tutorial, è necessario innanzitutto: + Completa le fasi descritte in [Guida introduttiva con CodeDeploy](getting-started-codedeploy.md). + Installa la AWS Serverless Application Model CLI. Per informazioni, consulta [Installare la CLI AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html). + Crea un bucket S3. AWS [SAM carica gli artefatti a cui si fa riferimento nel modello SAM in questo AWS bucket.](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/tutorial-lambda-sam-template.html) # Fase 1: Configura la tua infrastruttura Questo argomento mostra come utilizzare AWS SAM per creare file per il AWS SAM modello e le funzioni Lambda. Quindi, usi i `deploy` comandi AWS SAM `package` and per generare i componenti della tua infrastruttura. Quando l'infrastruttura è pronta, si dispone di un gruppo di CodeDeploy applicazioni e di distribuzione, della funzione Lambda per l'aggiornamento e la distribuzione e di due funzioni Lambda che contengono test di convalida eseguiti quando si distribuisce la funzione Lambda. Al termine, puoi utilizzarli CloudFormation per visualizzare i componenti nella console Lambda o AWS CLI per testare la funzione Lambda. **Topics** + [Crea i tuoi file](tutorial-lambda-create-files.md) + [Package dell'applicazione AWS SAM](tutorial-lambda-sam-package.md) + [Distribuire l'applicazione AWS SAM](tutorial-lambda-sam-deploy.md) + [(Facoltativo) ispeziona e testa la tua infrastruttura](tutorial-lambda-sam-confirm-components.md) # Crea i tuoi file Per creare l'infrastruttura, è necessario creare i file seguenti: + `template.yml` + `myDateTimeFunction.js` + `beforeAllowTraffic.js` + `afterAllowTraffic.js` **Topics** + [Crea il tuo modello AWS SAM](tutorial-lambda-sam-template.md) + [Crea un file per la tua funzione Lambda](tutorial-lambda-sam-create-lambda-function.md) + [Crea un file per la tua funzione BeforeAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-before-traffic.md) + [Crea un file per la tua funzione AfterAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-after-traffic.md) # Crea il tuo modello AWS SAM Crea un file modello AWS SAM che specifichi i componenti della tua infrastruttura. **Per creare il tuo modello AWS SAM** 1. Crea una directory denominata `SAM-Tutorial`. 1. Nella directory `SAM-Tutorial`, creare un file denominato `template.yml`. 1. Copiare il seguente codice YAML in `template.yml`. Questo è il modello AWS SAM . ``` AWSTemplateFormatVersion : '2010-09-09' Transform: AWS::Serverless-2016-10-31 Description: A sample SAM template for deploying Lambda functions. Resources: # Details about the myDateTimeFunction Lambda function myDateTimeFunction: Type: AWS::Serverless::Function Properties: Handler: myDateTimeFunction.handler Runtime: nodejs18.x # Instructs your myDateTimeFunction is published to an alias named "live". AutoPublishAlias: live # Grants this function permission to call lambda:InvokeFunction Policies: - Version: "2012-10-17" Statement: - Effect: "Allow" Action: - "lambda:InvokeFunction" Resource: '*' DeploymentPreference: # Specifies the deployment configuration Type: Linear10PercentEvery1Minute # Specifies Lambda functions for deployment lifecycle hooks Hooks: PreTraffic: !Ref beforeAllowTraffic PostTraffic: !Ref afterAllowTraffic # Specifies the BeforeAllowTraffic lifecycle hook Lambda function beforeAllowTraffic: Type: AWS::Serverless::Function Properties: Handler: beforeAllowTraffic.handler Policies: - Version: "2012-10-17" # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus Statement: - Effect: "Allow" Action: - "codedeploy:PutLifecycleEventHookExecutionStatus" Resource: !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*' - Version: "2012-10-17" # Grants this function permission to call lambda:InvokeFunction Statement: - Effect: "Allow" Action: - "lambda:InvokeFunction" Resource: !Ref myDateTimeFunction.Version Runtime: nodejs18.x # Specifies the name of the Lambda hook function FunctionName: 'CodeDeployHook_beforeAllowTraffic' DeploymentPreference: Enabled: false Timeout: 5 Environment: Variables: NewVersion: !Ref myDateTimeFunction.Version # Specifies the AfterAllowTraffic lifecycle hook Lambda function afterAllowTraffic: Type: AWS::Serverless::Function Properties: Handler: afterAllowTraffic.handler Policies: - Version: "2012-10-17" Statement: # Grants this function permission to call codedeploy:PutLifecycleEventHookExecutionStatus - Effect: "Allow" Action: - "codedeploy:PutLifecycleEventHookExecutionStatus" Resource: !Sub 'arn:aws:codedeploy:${AWS::Region}:${AWS::AccountId}:deploymentgroup:${ServerlessDeploymentApplication}/*' - Version: "2012-10-17" Statement: # Grants this function permission to call lambda:InvokeFunction - Effect: "Allow" Action: - "lambda:InvokeFunction" Resource: !Ref myDateTimeFunction.Version Runtime: nodejs18.x # Specifies the name of the Lambda hook function FunctionName: 'CodeDeployHook_afterAllowTraffic' DeploymentPreference: Enabled: false Timeout: 5 Environment: Variables: NewVersion: !Ref myDateTimeFunction.Version ``` Questo modello specifica quanto segue. Per ulteriori informazioni, consulta i [concetti relativi ai AWS SAM modelli](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html). **Una funzione Lambda chiamata `myDateTimeFunction`** Quando questa funzione Lambda viene pubblicata, la `AutoPublishAlias` riga del modello la collega a un alias denominato. `live` Più avanti in questo tutorial, un aggiornamento di questa funzione attiva una distribuzione AWS CodeDeploy che sposta in modo incrementale il traffico di produzione dalla versione originale alla versione aggiornata. **Due funzioni di convalida dell'implementazione Lambda** Le seguenti funzioni Lambda vengono eseguite durante gli hook del ciclo di CodeDeploy vita. Le funzioni contengono codice che convalida la distribuzione del codice `myDateTimeFunction` aggiornato. Il risultato dei test di convalida viene passato a CodeDeploy utilizzando il relativo metodo API `PutLifecycleEventHookExecutionStatus`. Se un test di convalida ha esito negativo, la distribuzione ha esito negativo e viene eseguito il rollback. + `CodeDeployHook_beforeAllowTraffic` viene eseguito durante l'hook `BeforeAllowTraffic`. + `CodeDeployHook_afterAllowTraffic` viene eseguito durante l'hook `AfterAllowTraffic`. Il nome di entrambe le funzioni inizia con `CodeDeployHook_`. Il `CodeDeployRoleForLambda` ruolo consente chiamate al `invoke` metodo Lambda solo nelle funzioni Lambda con nomi che iniziano con questo prefisso. Per ulteriori informazioni, consulta le pagine [AppSpec sezione 'hooks' per una distribuzione AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) e [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html) nella *Documentazione di riferimento dell'API CodeDeploy *. **Rilevamento automatico di una funzione Lambda aggiornata** Il termine `AutoPublishAlias` indica al framework di rilevare quando la funzione `myDateTimeFunction` cambia e quindi distribuirla utilizzando l'alias `live`. **Una configurazione della distribuzione** La configurazione di distribuzione determina la velocità con cui l' CodeDeployapplicazione sposta il traffico dalla versione originale della funzione Lambda alla nuova versione. Questo modello specifica la configurazione della distribuzione predefinita `Linear10PercentEvery1Minute`. Non è possibile specificare una configurazione di distribuzione personalizzata in un modello AWS SAM. Per ulteriori informazioni, consulta [Crea una configurazione di distribuzione con CodeDeploy](deployment-configurations-create.md). **Funzioni hook del ciclo di vita della distribuzione** La sezione `Hooks` specifica le funzioni da eseguire durante gli hook degli eventi del ciclo di vita. `PreTraffic` specifica la funzione che viene eseguita durante l'hook `BeforeAllowTraffic`. `PostTraffic` specifica la funzione che viene eseguita durante l'hook `AfterAllowTraffic`. **Autorizzazioni per Lambda per richiamare un'altra funzione Lambda** L'`lambda:InvokeFunction`autorizzazione specificata concede al ruolo utilizzato dall'applicazione AWS SAM il permesso di richiamare una funzione Lambda. Ciò è necessario quando `CodeDeployHook_afterAllowTraffic` le funzioni `CodeDeployHook_beforeAllowTraffic` and richiamano la funzione Lambda distribuita durante i test di convalida. # Crea un file per la tua funzione Lambda Creare il file per la funzione da aggiornare e distribuire più avanti in questo tutorial. **Nota** Una funzione Lambda può utilizzare qualsiasi runtime supportato da. AWS Lambda Per ulteriori informazioni, consulta [Tempi di esecuzione AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html). **Per creare la tua funzione Lambda** 1. Creare un file di testo e salvarlo come `myDateTimeFunction.js` nella directory `SAM-Tutorial`. 1. Copiare il seguente codice Node.js in `myDateTimeFunction.js`. ``` 'use strict'; exports.handler = function(event, context, callback) { if (event.body) { event = JSON.parse(event.body); } var sc; // Status code var result = ""; // Response payload switch(event.option) { case "date": switch(event.period) { case "yesterday": result = setDateResult("yesterday"); sc = 200; break; case "today": result = setDateResult(); sc = 200; break; case "tomorrow": result = setDateResult("tomorrow"); sc = 200; break; default: result = { "error": "Must specify 'yesterday', 'today', or 'tomorrow'." }; sc = 400; break; } break; /* Later in this tutorial, you update this function by uncommenting this section. The framework created by AWS SAM detects the update and triggers a deployment by CodeDeploy. The deployment shifts production traffic to the updated version of this function. case "time": var d = new Date(); var h = d.getHours(); var mi = d.getMinutes(); var s = d.getSeconds(); result = { "hour": h, "minute": mi, "second": s }; sc = 200; break; */ default: result = { "error": "Must specify 'date' or 'time'." }; sc = 400; break; } const response = { statusCode: sc, headers: { "Content-type": "application/json" }, body: JSON.stringify( result ) }; callback(null, response); function setDateResult(option) { var d = new Date(); // Today var mo; // Month var da; // Day var y; // Year switch(option) { case "yesterday": d.setDate(d.getDate() - 1); break; case "tomorrow": d.setDate(d.getDate() + 1); default: break; } mo = d.getMonth() + 1; // Months are zero offset (0-11) da = d.getDate(); y = d.getFullYear(); result = { "month": mo, "day": da, "year": y }; return result; } }; ``` La funzione Lambda restituisce il giorno, il mese e l'anno di ieri, oggi o domani. Più avanti in questo tutorial, si decomprimerà il codice che aggiorna la funzione per restituire informazioni sul giorno o sull'ora specificati (ad esempio, giorno, mese e anno o ora, minuto e secondo correnti). Il framework creato da AWS SAM rileva e distribuisce la versione aggiornata della funzione. **Nota** Questa funzione Lambda viene utilizzata anche in un AWS Cloud9 tutorial. AWS Cloud9 è un ambiente di sviluppo integrato basato sul cloud. [Per informazioni su come creare, eseguire, aggiornare ed eseguire il debug di questa funzione in AWS Cloud9, consulta AWS Lambda il tutorial per. AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html) # Crea un file per la tua funzione BeforeAllowTraffic Lambda Crea il file per la tua funzione Lambda dell'`beforeAllowTraffic`hook. 1. Creare un file di testo e salvarlo come `beforeAllowTraffic.js` nella directory `SAM-Tutorial`. 1. Copiare il seguente codice Node.js in `beforeAllowTraffic.js`. Questa funzione viene eseguita durante l'hook `BeforeAllowTraffic` della distribuzione. ``` 'use strict'; const AWS = require('aws-sdk'); const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'}); var lambda = new AWS.Lambda(); exports.handler = (event, context, callback) => { console.log("Entering PreTraffic Hook!"); // Read the DeploymentId and LifecycleEventHookExecutionId from the event payload var deploymentId = event.DeploymentId; var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId; var functionToTest = process.env.NewVersion; console.log("BeforeAllowTraffic hook tests started"); console.log("Testing new function version: " + functionToTest); // Create parameters to pass to the updated Lambda function that // include the newly added "time" option. If the function did not // update, then the "time" option is invalid and function returns // a statusCode of 400 indicating it failed. var lambdaParams = { FunctionName: functionToTest, Payload: "{\"option\": \"time\"}", InvocationType: "RequestResponse" }; var lambdaResult = "Failed"; // Invoke the updated Lambda function. lambda.invoke(lambdaParams, function(err, data) { if (err){ // an error occurred console.log(err, err.stack); lambdaResult = "Failed"; } else{ // successful response var result = JSON.parse(data.Payload); console.log("Result: " + JSON.stringify(result)); console.log("statusCode: " + result.statusCode); // Check if the status code returned by the updated // function is 400. If it is, then it failed. If // is not, then it succeeded. if (result.statusCode != "400"){ console.log("Validation succeeded"); lambdaResult = "Succeeded"; } else { console.log("Validation failed"); } // Complete the PreTraffic Hook by sending CodeDeploy the validation status var params = { deploymentId: deploymentId, lifecycleEventHookExecutionId: lifecycleEventHookExecutionId, status: lambdaResult // status can be 'Succeeded' or 'Failed' }; // Pass CodeDeploy the prepared validation test results. codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) { if (err) { // Validation failed. console.log("CodeDeploy Status update failed"); console.log(err, err.stack); callback("CodeDeploy Status update failed"); } else { // Validation succeeded. console.log("CodeDeploy status updated successfully"); callback(null, "CodeDeploy status updated successfully"); } }); } }); } ``` # Crea un file per la tua funzione AfterAllowTraffic Lambda Crea il file per la tua funzione Lambda dell'`afterAllowTraffic`hook. 1. Creare un file di testo e salvarlo come `afterAllowTraffic.js` nella directory `SAM-Tutorial`. 1. Copiare il seguente codice Node.js in `afterAllowTraffic.js`. Questa funzione viene eseguita durante l'hook `AfterAllowTraffic` della distribuzione. ``` 'use strict'; const AWS = require('aws-sdk'); const codedeploy = new AWS.CodeDeploy({apiVersion: '2014-10-06'}); var lambda = new AWS.Lambda(); exports.handler = (event, context, callback) => { console.log("Entering PostTraffic Hook!"); // Read the DeploymentId and LifecycleEventHookExecutionId from the event payload var deploymentId = event.DeploymentId; var lifecycleEventHookExecutionId = event.LifecycleEventHookExecutionId; var functionToTest = process.env.NewVersion; console.log("AfterAllowTraffic hook tests started"); console.log("Testing new function version: " + functionToTest); // Create parameters to pass to the updated Lambda function that // include the original "date" parameter. If the function did not // update as expected, then the "date" option might be invalid. If // the parameter is invalid, the function returns // a statusCode of 400 indicating it failed. var lambdaParams = { FunctionName: functionToTest, Payload: "{\"option\": \"date\", \"period\": \"today\"}", InvocationType: "RequestResponse" }; var lambdaResult = "Failed"; // Invoke the updated Lambda function. lambda.invoke(lambdaParams, function(err, data) { if (err){ // an error occurred console.log(err, err.stack); lambdaResult = "Failed"; } else{ // successful response var result = JSON.parse(data.Payload); console.log("Result: " + JSON.stringify(result)); console.log("statusCode: " + result.statusCode); // Check if the status code returned by the updated // function is 400. If it is, then it failed. If // is not, then it succeeded. if (result.statusCode != "400"){ console.log("Validation of time parameter succeeded"); lambdaResult = "Succeeded"; } else { console.log("Validation failed"); } // Complete the PostTraffic Hook by sending CodeDeploy the validation status var params = { deploymentId: deploymentId, lifecycleEventHookExecutionId: lifecycleEventHookExecutionId, status: lambdaResult // status can be 'Succeeded' or 'Failed' }; // Pass CodeDeploy the prepared validation test results. codedeploy.putLifecycleEventHookExecutionStatus(params, function(err, data) { if (err) { // Validation failed. console.log("CodeDeploy Status update failed"); console.log(err, err.stack); callback("CodeDeploy Status update failed"); } else { // Validation succeeded. console.log("CodeDeploy status updated successfully"); callback(null, "CodeDeploy status updated successfully"); } }); } }); } ``` # Package dell'applicazione AWS SAM Ora, la directory `SAM-Tutorial` dovrebbe contenere quattro file: + `beforeAllowTraffic.js` + `afterAllowTraffic.js` + `myDateTimeFunction.js` + `template.yml` Ora sei pronto per usare il **sam package** comando AWS SAM per creare e impacchettare artefatti per le tue funzioni e applicazioni Lambda. CodeDeploy Gli artefatti vengono caricati in un bucket S3. L'output del comando è un nuovo file denominato `package.yml`. Questo file viene utilizzato dal **sam deploy** comando AWS SAM nel passaggio successivo. **Nota** Per ulteriori informazioni sul **sam package** comando, consulta il [riferimento ai comandi AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) nella *AWS Serverless Application Model Developer* Guide. Nella directory `SAM-Tutorial`, eseguire il seguente comando. ``` sam package \ --template-file template.yml \ --output-template-file package.yml \ --s3-bucket amzn-s3-demo-bucket ``` Per il `s3-bucket` parametro, specifica il bucket Amazon S3 che hai creato come prerequisito per questo tutorial. `output-template-file`specifica il nome del nuovo file utilizzato dal comando SAM. AWS **sam deploy** # Distribuire l'applicazione AWS SAM Usa il **sam deploy** comando AWS SAM con il `package.yml` file per creare le funzioni Lambda, CodeDeploy l'applicazione e il gruppo di distribuzione utilizzando. CloudFormation **Nota** Per ulteriori informazioni sul **sam deploy** comando, consulta il [riferimento ai comandi AWS SAM CLI](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) nella *AWS Serverless Application Model Developer* Guide. Nella directory `SAM-Tutorial`, eseguire il seguente comando. ``` sam deploy \ --template-file package.yml \ --stack-name my-date-time-app \ --capabilities CAPABILITY_IAM ``` Il `--capabilities CAPABILITY_IAM` parametro è necessario per autorizzare la creazione CloudFormation di ruoli IAM. # (Facoltativo) ispeziona e testa la tua infrastruttura Questo argomento mostra come visualizzare i componenti dell'infrastruttura e testare la funzione Lambda. **Per visualizzare il risultato dello stack dopo aver eseguito `sam deploy`** 1. Apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/) 1. Nel riquadro di navigazione selezionare **Stacks (Stack)**. Lo stack `my-date-time-app` viene visualizzato nella parte superiore. 1. Scegliere la scheda **Events (Eventi)** per visualizzare quali eventi sono completi. È possibile visualizzare gli eventi mentre è in corso la creazione dello stack. Al termine della creazione dello stack, è possibile visualizzare tutti gli eventi di creazione dello stack. 1. Con lo stack selezionato, scegliere **Resources (Risorse)**. Nella colonna **Tipo**, puoi vedere le tue funzioni Lambda, `myDateTimeFunction``CodeDeployHook_beforeAllowTraffic`, e. `CodeDeployHook_afterAllowTraffic` La colonna **Physical ID** di ciascuna delle tue funzioni Lambda contiene un link per visualizzare le funzioni nella console Lambda. **Nota** Il nome della funzione `myDateTimeFunction` Lambda è preceduto dal nome dello CloudFormation stack e ha un identificatore aggiunto, quindi sembra. `my-date-time-app-myDateTimeFunction-123456ABCDEF` 1. Apri la console all'indirizzo. CodeDeploy [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/) 1. Nel riquadro di navigazione espandere **Deploy (Distribuisci)** e scegliere **Applications (Applicazioni)**. 1. Dovresti vedere una nuova CodeDeploy applicazione creata da CloudFormation con un nome che inizia con`my-date-time-app-ServerlessDeploymentApplication`. Scegliere questa applicazione. 1. Viene visualizzato un gruppo di distribuzione con un nome che inizia con `my-date-time-app-myDateTimeFunctionDeploymentGroup`. Scegliere questo gruppo di distribuzione. In **Configurazione di distribuzione**, dovresti vedere **CodeDeployDefault. LambdaLinear10 PercentEvery 1 minuto.** **(Facoltativo) per testare la funzionalità (console)** 1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Nel riquadro di navigazione, scegliere la funzione `my-date-time-app-myDateTimeFunction`. Nella console, il suo nome contiene un identificatore, quindi è simile a `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 1. Scegli **Test (Esegui test)**. 1. In **Event name (Nome evento)**, immettere un nome per l'evento di test. 1. Immettere quanto segue per l'evento di test, quindi scegliere **Create (Crea)**. ``` { "option": "date", "period": "today" } ``` 1. Scegli **Test (Esegui test)**. Viene visualizzato solo l'evento di test nell'elenco degli eventi di test. Per **Execution result (Risultato esecuzione)**, viene visualizzato **succeeded (riuscito)**. 1. In **Execution result (Risultato esecuzione)**, espandere **Details (Dettagli)** per visualizzare i risultati. Vengono visualizzati il mese, il giorno e l'anno corrente. **(Facoltativo) per testare la funzionalità (AWS CLI)** 1. Individua l'ARN della tua funzione Lambda. Viene visualizzato nella parte superiore della console Lambda quando visualizzi la funzione. 1. Eseguire il seguente comando seguente. Sostituire *your-function-arn* con la funzione ARN. ``` aws lambda invoke \ --function your-function-arn \ --cli-binary-format raw-in-base64-out \ --payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt ``` 1. Aprire `out.txt` per confermare che il risultato contenga il mese, il giorno e l'anno corrente. # Fase 2: Aggiornare la funzione Lambda Questo argomento illustra come aggiornare il file `myDateTimeFunction.js`. Nella fase successiva, si utilizzerà il file per distribuire la funzione aggiornata. Ciò avvia la distribuzione CodeDeploy spostando il traffico di produzione dalla versione corrente della funzione Lambda alla versione aggiornata. **Per aggiornare la funzione Lambda** 1. Aprire `myDateTimeFunction.js`. 1. Rimuovere i due contrassegni di commento ("`/*`" e "`*/`") e il testo esplicativo all'inizio e alla fine del `case` denominato `time` nel blocco `switch`. Il codice non commentato consente di passare un nuovo parametro `time` alla funzione. Se si passa `time` alla funzione aggiornata, restituisce i `hour`, `minute` e `second` correnti. 1. Salva `myDateTimeFunction.js`. Avrà un aspetto simile al seguente: ``` 'use strict'; exports.handler = function(event, context, callback) { if (event.body) { event = JSON.parse(event.body); } var sc; // Status code var result = ""; // Response payload switch(event.option) { case "date": switch(event.period) { case "yesterday": result = setDateResult("yesterday"); sc = 200; break; case "today": result = setDateResult(); sc = 200; break; case "tomorrow": result = setDateResult("tomorrow"); sc = 200; break; default: result = { "error": "Must specify 'yesterday', 'today', or 'tomorrow'." }; sc = 400; break; } break; case "time": var d = new Date(); var h = d.getHours(); var mi = d.getMinutes(); var s = d.getSeconds(); result = { "hour": h, "minute": mi, "second": s }; sc = 200; break; default: result = { "error": "Must specify 'date' or 'time'." }; sc = 400; break; } const response = { statusCode: sc, headers: { "Content-type": "application/json" }, body: JSON.stringify( result ) }; callback(null, response); function setDateResult(option) { var d = new Date(); // Today var mo; // Month var da; // Day var y; // Year switch(option) { case "yesterday": d.setDate(d.getDate() - 1); break; case "tomorrow": d.setDate(d.getDate() + 1); default: break; } mo = d.getMonth() + 1; // Months are zero offset (0-11) da = d.getDate(); y = d.getFullYear(); result = { "month": mo, "day": da, "year": y }; return result; } }; ``` # Fase 3: Implementazione della funzione Lambda aggiornata In questo passaggio, usi il tuo update `myDateTimeFunction.js` per aggiornare e avviare la distribuzione della tua funzione Lambda. Puoi monitorare l'avanzamento della distribuzione nella console CodeDeploy o AWS Lambda . La `AutoPublishAlias: live` riga del AWS SAM modello fa sì che l'infrastruttura rilevi gli aggiornamenti delle funzioni che utilizzano l'`live`alias. Un aggiornamento della funzione attiva una distribuzione CodeDeploy che sposta il traffico di produzione dalla versione originale della funzione alla versione aggiornata. I **sam deploy** comandi **sam package** and vengono utilizzati per aggiornare e attivare la distribuzione della funzione Lambda. Questi comandi sono stati eseguiti in [Package dell'applicazione AWS SAM](tutorial-lambda-sam-package.md) e [Distribuire l'applicazione AWS SAM](tutorial-lambda-sam-deploy.md). **Per distribuire la funzione Lambda aggiornata** 1. Nella directory `SAM-Tutorial`, eseguire il seguente comando. ``` sam package \ --template-file template.yml \ --output-template-file package.yml \ --s3-bucket amzn-s3-demo-bucket ``` Questo crea un nuovo set di artefatti che fanno riferimento alla funzione Lambda aggiornata nel bucket S3. 1. Nella directory `SAM-Tutorial`, eseguire il seguente comando. ``` sam deploy \ --template-file package.yml \ --stack-name my-date-time-app \ --capabilities CAPABILITY_IAM ``` Poiché il nome dello stack è fisso`my-date-time-app`, CloudFormation riconosce che si tratta di un aggiornamento dello stack. **Per visualizzare lo stack aggiornato, torna alla CloudFormation console e, dal pannello di navigazione, scegli Stacks.** **(Facoltativo) per visualizzare il traffico durante una distribuzione (console) CodeDeploy** 1. Apri la CodeDeploy console all'indirizzo [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/). 1. Nel riquadro di navigazione, espandi **Applicazioni**, quindi scegli la tua **my-date-time-app- ServerlessDeploymentApplication** applicazione. 1. In **Deployment groups (Gruppi di distribuzione)**, scegliere il gruppo di distribuzione dell'applicazione. Il suo stato deve essere **In progress (In corso)**. 1. In **Deployment group history (Cronologia gruppo di distribuzione)**, scegliere la distribuzione in corso. La barra di avanzamento di **Traffic shifting (Trasferimento traffico)** e le percentuali nelle caselle **Original (Origine)** e **Replacement (Sostituzione)** di questa pagina visualizzano l'avanzamento. ![\[La sezione relativa all'avanzamento dello spostamento del traffico della CodeDeploy console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-codedeploy-console-20-percent-deployed.png) **(Facoltativo) per visualizzare il traffico durante una distribuzione (console Lambda)** 1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Nel riquadro di navigazione, scegliere la funzione `my-date-time-app-myDateTimeFunction`. Nella console, il suo nome contiene un identificatore, quindi è simile a `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 1. Scegli **Alias**, quindi scegli **live**. I pesi accanto alla versione originale della funzione (versione 1) e alla versione della funzione aggiornata (versione 2) mostrano quanto traffico viene servito a ciascuna versione nel momento in cui questa pagina della AWS Lambda console è stata caricata. La pagina non aggiorna i pesi nel tempo. Se aggiorni la pagina una volta al minuto, il peso per la versione 1 diminuisce del 10% e il peso per la versione 2 aumenta del 10% fino a quando il peso per la versione 2 è 100. ![\[La sezione alias della CodeDeploy console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-lambda-console-20-percent-deployed.png) # Fase 4: Visualizza i risultati della distribuzione In questa fase, vengono visualizzati i risultati della distribuzione. Se l'implementazione ha esito positivo, puoi confermare che la funzione Lambda aggiornata riceva traffico di produzione. Se la distribuzione fallisce, puoi utilizzare CloudWatch Logs per visualizzare l'output dei test di convalida nella funzione Lambda che viene eseguita durante gli hook del ciclo di vita della distribuzione. **Topics** + [Metti alla prova la funzione distribuita](#tutorial-lambda-sam-deploy-test-deployed-function) + [Visualizza gli eventi degli hook nei registri CloudWatch](#tutorial-lambda-view-hook-events) ## Metti alla prova la funzione distribuita Il **sam deploy** comando aggiorna la funzione `my-date-time-app-myDateTimeFunction` Lambda. La versione della funzione viene aggiornata a 2 e aggiunta all'alias `live`. **Per vedere l'aggiornamento nella console Lambda** 1. Apri la AWS Lambda console all'indirizzo [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/). 1. Nel riquadro di navigazione, scegliere la funzione `my-date-time-app-myDateTimeFunction`. Nella console, il suo nome contiene un identificatore, quindi è simile a `my-date-time-app-myDateTimeFunction-123456ABCDEF`. 1. Scegliere **Qualifiers (Qualificatori)**, quindi **Aliases (Alias)**. Una volta completata la distribuzione (circa 10 minuti), per l'alias `live`, viene visualizzato **Version: 2 (Versione: 2)**. ![\[La sezione degli alias della CodeDeploy console.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-function-version.png) 1. In **Function code (Codice funzione)**, visualizzare il codice sorgente per la funzione. Verrà visualizzata la modifica. 1. (Facoltativo) È possibile utilizzare le istruzioni di test in [Fase 2: Aggiornare la funzione Lambda](tutorial-lambda-sam-update-function.md) per testare la funzione aggiornata. Creare un nuovo evento di test con il payload seguente, quindi confermare che il risultato contenga l'ora, il minuto e il secondo correnti. ``` { "option": "time" } ``` Per utilizzare la funzione AWS CLI per testare la funzione aggiornata, esegui il comando seguente, quindi apri `out.txt` per confermare che il risultato contenga l'ora, il minuto e il secondo correnti. ``` aws lambda invoke --function your-function-arn --payload "{\"option\": \"time\"}" out.txt ``` **Nota** Se utilizzi il AWS CLI per testare la tua funzione prima del completamento della distribuzione, potresti ricevere risultati imprevisti. Questo perché ogni minuto sposta CodeDeploy in modo incrementale il 10 percento del traffico verso la versione aggiornata. Durante la distribuzione, il traffico continua a puntare alla versione originale, quindi `aws lambda invoke` potrebbe utilizzare la versione originale. Dopo 10 minuti, la distribuzione è completa e tutto il traffico punta alla nuova versione della funzione. ## Visualizza gli eventi degli hook nei registri CloudWatch Durante l'`BeforeAllowTraffic`hook, CodeDeploy esegue la funzione `CodeDeployHook_beforeAllowTraffic` Lambda. Durante l'`AfterAllowTraffic`hook, CodeDeploy esegue la funzione `CodeDeployHook_afterAllowTraffic` Lambda. Ogni funzione esegue un test di convalida che richiama la versione aggiornata della funzione utilizzando il nuovo parametro `time`. Se l'aggiornamento della funzione Lambda ha esito positivo, l'`time`opzione non causa errori e la convalida ha esito positivo. Se la funzione non è stata aggiornata, il parametro non riconosciuto genera un errore e la convalida ha esito negativo. Questi test di convalida sono solo a scopo dimostrativo. È possibile scrivere i test per convalidare la distribuzione. Puoi utilizzare la console CloudWatch Logs per visualizzare i test di convalida. **Per visualizzare i tuoi eventi hook CodeDeploy** 1. Apri la CloudWatch console su [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/). 1. Nel riquadro di navigazione scegliere **Log**. 1. Dall'elenco dei gruppi di log, scegli**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic** o**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 1. Scegli il flusso di log. Ne viene visualizzato solo uno. 1. Espandere gli eventi per visualizzarne i dettagli. ![\[Il flusso di log di un gruppo di CodeDeployHook log.\]](http://docs.aws.amazon.com/it_it/codedeploy/latest/userguide/images/lambda-tutorial-cloudwatch.png) # Fase 5: rimozione Per evitare ulteriori addebiti per le risorse utilizzate durante questo tutorial, elimina le risorse create dal AWS SAM modello e CloudWatch i log creati dalle funzioni di convalida Lambda. **Per eliminare il tuo stack CloudFormation** 1. Accedi Console di gestione AWS e apri la CloudFormation console all'indirizzo [https://console.aws.amazon.com/cloudformazione.](https://console.aws.amazon.com/cloudformation/) 1. Nella colonna **Stacks (Stack)** scegliere lo stack `my-date-time-app`, quindi **Delete (Elimina)**. 1. Quando viene richiesto, scegliere nuovamente **Delete stack (Elimina stack)**. Le funzioni Lambda, il gruppo di CodeDeploy applicazioni e distribuzione e i ruoli IAM creati da AWS SAM vengono eliminati. **Per eliminare i log in Logs CloudWatch** 1. Apri la CloudWatch console all'indirizzo. [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/) 1. Nel riquadro di navigazione scegliere **Log**. 1. Dall'elenco dei gruppi di log, scegli il pulsante accanto a**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic**. 1. In **Actions (Operazioni)**, scegliere **Delete log group (Elimina gruppo di log)**, quindi **Yes, Delete (Sì, elimina)**. 1. Dall'elenco dei gruppi di log, scegli il pulsante accanto a**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**. 1. In **Actions (Operazioni)**, scegliere **Delete log group (Elimina gruppo di log)**, quindi **Yes, Delete (Sì, elimina)**.