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à.
# 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");
}
});
}
});
}
```