Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutorial: Implemente una función Lambda actualizada con CodeDeploy y el modelo de aplicaciones AWS sin servidor
AWS SAM es un marco de código abierto para crear aplicaciones sin servidor. Transforma y expande la sintaxis YAML de una AWS SAM plantilla en CloudFormation sintaxis para crear aplicaciones sin servidor, como una función Lambda. Para obtener más información, consulte [¿Qué es AWS Serverless Application Model?](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/what-is-sam.html).
En este tutorial, usará AWS SAM para crear una solución que haga lo siguiente:
+ Crea una función de Lambda.
+ Crea el grupo CodeDeploy de aplicaciones y despliegues.
+ Crea dos funciones Lambda que ejecutan pruebas de validación de despliegue durante los enlaces CodeDeploy del ciclo de vida.
+ Detecta cuándo se actualiza la función de Lambda. La actualización de la función Lambda desencadena un despliegue CodeDeploy que desplaza gradualmente el tráfico de producción de la versión original de la función Lambda a la versión actualizada.
**nota**
Este tutorial requiere que cree recursos que podrían dar lugar a cargos en su cuenta de AWS . Estos incluyen posibles cargos para CodeDeploy Amazon CloudWatch y AWS Lambda. Para obtener más información, consulta [CodeDeploy precios](https://aws.amazon.com/codedeploy/pricing/), [ CloudWatch precios de Amazon](https://aws.amazon.com/cloudwatch/pricing/) y [AWS Lambda precios](https://aws.amazon.com/lambda/pricing/).
**Topics**
+ [Requisitos previos](tutorial-lambda-sam-prereqs.md)
+ [Paso 1: Configurar la infraestructura](tutorial-lambda-sam-setup-infrastructure.md)
+ [Paso 2: Actualizar la función de Lambda](tutorial-lambda-sam-update-function.md)
+ [Paso 3: Implementar la función de Lambda actualizada](tutorial-lambda-sam-deploy-update.md)
+ [Paso 4: Visualizar los resultados de la implementación](tutorial-lambda-sam-deploy-view-results.md)
+ [Paso 5: Eliminar](tutorial-lambda-clean-up.md)
# Requisitos previos
Para completar este tutorial, primero debe:
+ Realice los pasos que se indican en [Empezar con CodeDeploy](getting-started-codedeploy.md).
+ Instale la AWS Serverless Application Model CLI. Para obtener más información, consulte [Instalación de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-install.html).
+ Cree un bucket de S3. AWS SAM carga los artefactos a los que se hace referencia en la [plantilla de AWS SAM](https://docs.aws.amazon.com/en_us/codedeploy/latest/userguide/tutorial-lambda-sam-template.html) en este depósito.
# Paso 1: Configurar la infraestructura
En este tema, se muestra cómo AWS SAM crear archivos para la AWS SAM plantilla y las funciones de Lambda. A continuación, utilice los `deploy` comandos AWS SAM `package` y para generar los componentes de su infraestructura. Cuando la infraestructura esté lista, dispondrá de un grupo de CodeDeploy aplicaciones y despliegues, la función Lambda para actualizar e implementar y dos funciones Lambda que contienen pruebas de validación que se ejecutan al implementar la función Lambda. Cuando haya terminado, puede utilizarlos CloudFormation para ver los componentes en la consola de Lambda o AWS CLI para probar la función Lambda.
**Topics**
+ [Creación de archivos](tutorial-lambda-create-files.md)
+ [Package la aplicación AWS SAM](tutorial-lambda-sam-package.md)
+ [Implemente la aplicación AWS SAM](tutorial-lambda-sam-deploy.md)
+ [Inspección y prueba de la infraestructura (opcional)](tutorial-lambda-sam-confirm-components.md)
# Creación de archivos
Para crear su infraestructura, debe crear los siguientes archivos:
+ `template.yml`
+ `myDateTimeFunction.js`
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
**Topics**
+ [Cree su plantilla SAM AWS](tutorial-lambda-sam-template.md)
+ [Creación de un archivo para la función de Lambda](tutorial-lambda-sam-create-lambda-function.md)
+ [Cree un archivo para su función BeforeAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-before-traffic.md)
+ [Cree un archivo para su función AfterAllowTraffic Lambda](tutorial-lambda-sam-create-lambda-after-traffic.md)
# Cree su plantilla SAM AWS
Cree un archivo de plantilla AWS SAM que especifique los componentes de su infraestructura.
**Para crear su plantilla AWS SAM**
1. Cree un directorio llamado `SAM-Tutorial`.
1. En el directorio `SAM-Tutorial`, cree un archivo denominado `template.yml`.
1. Copie el código YAML siguiente en `template.yml`. Esta es la plantilla de 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
```
Esta plantilla especifica lo siguiente. Para obtener más información, consulte [Conceptos de la plantilla de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-template-basics.html).
**Una función de Lambda llamada `myDateTimeFunction`**
Cuando se publica esta función de Lambda, la línea `AutoPublishAlias` de la plantilla la vincula a un alias denominado `live`. Más adelante en este tutorial, una actualización de esta función desencadena una implementación AWS CodeDeploy que desplaza gradualmente el tráfico de producción de la versión original a la versión actualizada.
**Dos funciones de validación de implementación de Lambda**
Las siguientes funciones de Lambda se ejecutan durante los enlaces CodeDeploy del ciclo de vida. Las funciones contienen código que valida la implementación de `myDateTimeFunction` actualizado. El resultado de las pruebas de validación se transfiere a CodeDeploy utilizando su método de la API de `PutLifecycleEventHookExecutionStatus`. Si la prueba de validación falla, se produce un error en la implementación y se revisa.
+ `CodeDeployHook_beforeAllowTraffic` se ejecuta durante el enlace de `BeforeAllowTraffic`.
+ `CodeDeployHook_afterAllowTraffic` se ejecuta durante el enlace de `AfterAllowTraffic`.
El nombre de ambas funciones comienza por `CodeDeployHook_`. El rol de `CodeDeployRoleForLambda` permite llamadas al método de `invoke` de Lambda solo en funciones de Lambda con nombres que comienzan con este prefijo. Para obtener más información consulte [AppSpec sección de «ganchos» para una implementación de AWS Lambda](reference-appspec-file-structure-hooks.md#appspec-hooks-lambda) y [PutLifecycleEventHookExecutionStatus](https://docs.aws.amazon.com/codedeploy/latest/APIReference/API_PutLifecycleEventHookExecutionStatus.html) en la *Referencia de la API de CodeDeploy *.
**Detección automática de una función de Lambda actualizada**
El término `AutoPublishAlias` indica al marco de trabajo que detecte cuándo cambia la función de `myDateTimeFunction` y, a continuación, la implementa con el alias `live`.
**Una configuración de implementación**
La configuración de despliegue determina la velocidad a la que la CodeDeploy aplicación desplaza el tráfico de la versión original de la función Lambda a la nueva versión. Esta plantilla especifica la configuración de implementación predefinida `Linear10PercentEvery1Minute`.
No puede especificar una configuración de despliegue personalizada en una plantilla de AWS SAM. Para obtener más información, consulte [Cree una configuración de despliegue con CodeDeploy](deployment-configurations-create.md).
**Funciones de enlace de ciclo de vida de implementación**
La sección `Hooks` especifica las funciones que se van a ejecutar durante los enlaces de eventos del ciclo de vida. `PreTraffic` especifica la función que se ejecuta durante el enlace `BeforeAllowTraffic`. `PostTraffic` especifica la función que se ejecuta durante el enlace `AfterAllowTraffic`.
**Permisos para que Lambda invoque otra función de Lambda**
El `lambda:InvokeFunction` permiso especificado otorga permiso al rol utilizado por la aplicación AWS SAM para invocar una función Lambda. Esto es necesario cuando las funciones `CodeDeployHook_beforeAllowTraffic` y `CodeDeployHook_afterAllowTraffic` invocan la función de Lambda implementada durante las pruebas de validación.
# Creación de un archivo para la función de Lambda
Cree el archivo para la función que actualizará e implementará más adelante en este tutorial.
**nota**
Una función de Lambda puede utilizar cualquier tiempo de ejecución admitido por AWS Lambda. Para obtener más información, consulte [Tiempos de ejecución de AWS Lambda](https://docs.aws.amazon.com/lambda/latest/dg/lambda-runtimes.html).
**Para crear una función de Lambda**
1. Cree un archivo de texto y guárdelo como `myDateTimeFunction.js` en el directorio `SAM-Tutorial`.
1. Copie el siguiente código Node.js en `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 función de Lambda devuelve el día, el mes y el año de ayer, hoy o mañana. Más adelante en este tutorial, quite el comentario del código que actualiza la función para devolver información sobre el día o la hora que especifique (por ejemplo, el día, el mes y el año, o la hora, minuto y segundo actuales). El marco creado por AWS SAM detecta e implementa la versión actualizada de la función.
**nota**
Esta función Lambda también se utiliza en un AWS Cloud9 tutorial. AWS Cloud9 es un entorno de desarrollo integrado basado en la nube. Para obtener información sobre cómo crear, ejecutar, actualizar y depurar esta función en AWS Cloud9, consulte el [AWS Lambda tutorial de AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/tutorial-lambda.html).
# Cree un archivo para su función BeforeAllowTraffic Lambda
Cree el archivo para la función de Lambda del enlace `beforeAllowTraffic`.
1. Cree un archivo de texto y guárdelo como `beforeAllowTraffic.js` en el directorio `SAM-Tutorial`.
1. Copie el siguiente código Node.js en `beforeAllowTraffic.js`. Esta función se ejecuta durante el enlace `BeforeAllowTraffic` de la implementación.
```
'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");
}
});
}
});
}
```
# Cree un archivo para su función AfterAllowTraffic Lambda
Cree el archivo para la función de Lambda del enlace `afterAllowTraffic`.
1. Cree un archivo de texto y guárdelo como `afterAllowTraffic.js` en el directorio `SAM-Tutorial`.
1. Copie el siguiente código Node.js en `afterAllowTraffic.js`. Esta función se ejecuta durante el enlace `AfterAllowTraffic` de la implementación.
```
'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 la aplicación AWS SAM
Ahora debería tener cuatro archivos en su directorio `SAM-Tutorial`:
+ `beforeAllowTraffic.js`
+ `afterAllowTraffic.js`
+ `myDateTimeFunction.js`
+ `template.yml`
Ahora está listo para usar el **sam package** comando AWS SAM para crear y empaquetar artefactos para sus funciones y CodeDeploy aplicaciones de Lambda. Los artefactos se cargan en un bucket de S3. El resultado del comando es un nuevo archivo llamado `package.yml`. El **sam deploy** comando AWS SAM utilizará este archivo en el siguiente paso.
**nota**
Para obtener más información sobre el comando **sam package**, consulte la [Referencia de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) en la *Guía para desarrolladores de AWS Serverless Application Model *.
En el directorio `SAM-Tutorial`, ejecute el siguiente elemento.
```
sam package \
--template-file template.yml \
--output-template-file package.yml \
--s3-bucket amzn-s3-demo-bucket
```
Para el parámetro `s3-bucket`, especifique el bucket de Amazon S3 que ha creado como requisito previo para este tutorial. `output-template-file`Especifica el nombre del nuevo archivo que utiliza el **sam deploy** comando AWS SAM.
# Implemente la aplicación AWS SAM
Utilice el **sam deploy** comando AWS SAM con el `package.yml` archivo para crear sus funciones Lambda y su grupo de CodeDeploy aplicaciones y despliegues mediante. CloudFormation
**nota**
Para obtener más información sobre el comando **sam deploy**, consulte la [Referencia de la CLI de AWS SAM](https://docs.aws.amazon.com/serverless-application-model/latest/developerguide/serverless-sam-cli-command-reference.html) en la *Guía para desarrolladores de AWS Serverless Application Model *.
En el directorio `SAM-Tutorial`, ejecute el siguiente comando.
```
sam deploy \
--template-file package.yml \
--stack-name my-date-time-app \
--capabilities CAPABILITY_IAM
```
El parámetro `--capabilities CAPABILITY_IAM` es necesario para autorizar a CloudFormation a crear roles de IAM.
# Inspección y prueba de la infraestructura (opcional)
En este tema se muestra cómo ver los componentes de la infraestructura y probar la función de Lambda.
**Para ver el resultado de la pila después de ejecutar `sam deploy`, realice el siguiente procedimiento:**
1. Abra la CloudFormation consola en [https://console.aws.amazon.com/cloudformation](https://console.aws.amazon.com/cloudformation/).
1. En el panel de navegación, seleccione **Stacks** (Pilas). La pila `my-date-time-app` aparece en la parte superior.
1. Elija la pestaña **Events** (Eventos) para ver qué eventos se han completado. Puede ver los eventos mientras la creación de la pila está en curso. Cuando se haya completado la creación de la pila, podrá ver todos los eventos de creación esta.
1. Con la pila seleccionada, elija **Resources** (Recursos). En la columna **Tipo**, puede ver las funciones de Lambda `myDateTimeFunction`, `CodeDeployHook_beforeAllowTraffic` y `CodeDeployHook_afterAllowTraffic`. La columna **ID físico** de cada una de las funciones de Lambda contiene un enlace para ver las funciones en la consola de Lambda.
**nota**
El nombre de la función `myDateTimeFunction` Lambda va precedido del nombre de la CloudFormation pila y se le ha añadido un identificador, por lo que parece. `my-date-time-app-myDateTimeFunction-123456ABCDEF`
1. Abre la consola en CodeDeploy . [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/)
1. En el panel de navegación, expanda **Deploy (Implementar)** y después elija **Applications (Aplicaciones)**.
1. Debería ver una nueva CodeDeploy aplicación creada por CloudFormation con un nombre que comience por`my-date-time-app-ServerlessDeploymentApplication`. Elija esta aplicación.
1. Debería ver un grupo de implementaciones con un nombre que comienza por `my-date-time-app-myDateTimeFunctionDeploymentGroup`. Elija este grupo de implementaciones.
En **Configuración de despliegue**, deberías ver **CodeDeployDefault. LambdaLinear10 PercentEvery 1 minuto.**
**Para probar la función (consola) (opcional)**
1. Abre la AWS Lambda consola en. [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. En el panel de navegación, elija la función `my-date-time-app-myDateTimeFunction`. En la consola, su nombre contiene un identificador, por lo que tendrá un aspecto similar a `my-date-time-app-myDateTimeFunction-123456ABCDEF`.
1. Seleccione **Probar**
1. En **Event name** (Nombre del evento), escriba un nombre para el evento de prueba.
1. Escriba lo siguiente para el evento de prueba y, a continuación, elija **Create** (Crear).
```
{
"option": "date",
"period": "today"
}
```
1. Seleccione **Probar** Solo debería ver el evento de prueba en la lista de eventos de prueba.
En **Execution result** (Resultado de ejecución), debería ver **succeeded** (correcto).
1. En **Execution result** (Resultado de ejecución), expanda **Details** (Detalles) para ver los resultados. Debería ver el mes, día y año actuales.
**Para probar la función (AWS CLI) (opcional):**
1. Localice el ARN de la función de Lambda. Aparece en la parte superior de la consola de Lambda cuando se visualiza la función.
1. Ejecute el comando siguiente. *your-function-arn*Sustitúyala por la función ARN.
```
aws lambda invoke \
--function your-function-arn \
--cli-binary-format raw-in-base64-out \
--payload "{\"option\": \"date\", \"period\": \"today\"}" out.txt
```
1. Abra `out.txt` para confirmar que el resultado contiene el mes, el día y el año actuales.
# Paso 2: Actualizar la función de Lambda
En este tema, actualizará el archivo `myDateTimeFunction.js`. En el siguiente paso, utilizará el archivo para implementar la función actualizada. Esto desencadena CodeDeploy su implementación al cambiar el tráfico de producción de la versión actual de la función Lambda a la versión actualizada.
**Para actualizar la función de Lambda**
1. Abra `myDateTimeFunction.js`.
1. Elimine los dos marcadores de comentario ("`/*`" y "`*/`") y el texto explicativo al principio y al final del `case` denominado `time` en el bloque `switch`.
El código sin comentarios le permite transferir un nuevo parámetro, `time`, a la función. Si pasa `time` a la función actualizada, devuelve el valor actual `hour`, `minute` y `second`.
1. Guarde `myDateTimeFunction.js`. Debe parecerse a lo siguiente:
```
'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;
}
};
```
# Paso 3: Implementar la función de Lambda actualizada
En este paso, utilizará el `myDateTimeFunction.js` actualizado para actualizar e iniciar la implementación de la función de Lambda. Puede supervisar el progreso de la implementación en la AWS Lambda consola CodeDeploy o.
La `AutoPublishAlias: live` línea de la AWS SAM plantilla hace que la infraestructura detecte las actualizaciones de las funciones que utilizan el `live` alias. Una actualización de la función desencadena una implementación CodeDeploy que desplaza el tráfico de producción de la versión original de la función a la versión actualizada.
Los comandos **sam package** y **sam deploy** se utilizan para actualizar y activar la implementación de la función de Lambda. Ha ejecutado estos comandos en [Package la aplicación AWS SAM](tutorial-lambda-sam-package.md) y [Implemente la aplicación AWS SAM](tutorial-lambda-sam-deploy.md).
**Para implementar la función de Lambda actualizada**
1. En el directorio `SAM-Tutorial`, ejecute el siguiente comando.
```
sam package \
--template-file template.yml \
--output-template-file package.yml \
--s3-bucket amzn-s3-demo-bucket
```
Esto crea un nuevo conjunto de artefactos que hacen referencia a la función de Lambda actualizada en el bucket de S3.
1. En el directorio `SAM-Tutorial`, ejecute el siguiente comando.
```
sam deploy \
--template-file package.yml \
--stack-name my-date-time-app \
--capabilities CAPABILITY_IAM
```
Como el nombre de la pila sigue siendo`my-date-time-app`, CloudFormation reconoce que se trata de una actualización de la pila. Para ver la pila actualizada, regresa a la CloudFormation consola y, en el panel de navegación, selecciona **Pilas**.
**(Opcional) para ver el tráfico durante una implementación (CodeDeploy consola)**
1. Abra la CodeDeploy consola en [https://console.aws.amazon.com/codedeploy/](https://console.aws.amazon.com/codedeploy/).
1. En el panel de navegación, expanda **Aplicaciones** y, a continuación, elija su ServerlessDeploymentApplication aplicación **my-date-time-app-**.
1. En **Deployment groups** (Grupos de implementaciones), elija el grupo de implementaciones de la aplicación. Su estado debe ser **In progress** (En curso).
1. En **Deployment group history** (Historial de grupos de implementaciones), elija la implementación que está en curso.
La barra de progreso **Traffic shifting** (Desvío de tráfico) y los porcentajes de los cuadros **Original** y **Replacement** (Sustitución) de esta página muestran su progreso.
![\[La sección de progreso de los cambios de tráfico de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-codedeploy-console-20-percent-deployed.png)
**Para ver el tráfico durante una implementación (consola de Lambda) (opcional)**
1. Abre la AWS Lambda consola en [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).
1. En el panel de navegación, elija la función `my-date-time-app-myDateTimeFunction`. En la consola, su nombre contiene un identificador, por lo que tendrá un aspecto similar a `my-date-time-app-myDateTimeFunction-123456ABCDEF`.
1. Elija **Alias** y, a continuación, **directo**.
Las ponderaciones situadas junto a la versión original de la función (versión 1) y la versión actualizada de la función (versión 2) muestran la cantidad de tráfico que se ofrece a cada versión en el momento en que se cargó esta página de la consola de AWS Lambda . La página no actualiza las ponderaciones con el paso del tiempo. Si actualiza la página una vez al minuto, la ponderación de la versión 1 disminuye en un 10 por ciento y la ponderación de la versión 2 aumenta en un 10 por ciento hasta que la ponderación de la versión 2 es 100.
![\[La sección de alias de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-lambda-console-20-percent-deployed.png)
# Paso 4: Visualizar los resultados de la implementación
En este paso, podrá ver los resultados de la implementación. Si la implementación se realiza correctamente, puede confirmar que la función de Lambda actualizada recibe tráfico de producción. Si su implementación falla, puede usar CloudWatch los registros para ver el resultado de las pruebas de validación en la función Lambda que se ejecutan durante los ciclos de vida de la implementación.
**Topics**
+ [Prueba de la función implementada](#tutorial-lambda-sam-deploy-test-deployed-function)
+ [Vea los eventos de los enganches en los registros CloudWatch](#tutorial-lambda-view-hook-events)
## Prueba de la función implementada
El comando **sam deploy** actualiza la función de Lambda `my-date-time-app-myDateTimeFunction`. La versión de la función se actualiza a 2 y se añade al alias `live`.
**Para ver la actualización en la consola de Lambda**
1. Abra la consola en AWS Lambda . [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/)
1. En el panel de navegación, elija la función `my-date-time-app-myDateTimeFunction`. En la consola, su nombre contiene un identificador, por lo que tendrá un aspecto similar a `my-date-time-app-myDateTimeFunction-123456ABCDEF`.
1. Elija **Qualifiers** (Cualificadores) y, a continuación, **Aliases** (Alias). Una vez completada la implementación (aproximadamente 10 minutos), para el alias`live` alias, debería ver **Version: 2** (Versión: 2).
![\[La sección de alias de la CodeDeploy consola.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-function-version.png)
1. En **Function code** (Código de función), consulte el código fuente de la función. Deben aparecer los cambios.
1. Puede utilizar las instrucciones de prueba de [Paso 2: Actualizar la función de Lambda](tutorial-lambda-sam-update-function.md) para probar la función actualizada (opcional). Cree un nuevo evento de prueba con la siguiente carga y, a continuación, confirme que el resultado contiene la hora, el minuto y el segundo actuales.
```
{
"option": "time"
}
```
Para usar la AWS CLI función actualizada, ejecute el siguiente comando y, a continuación, ábralo `out.txt` para confirmar que el resultado contiene la hora, el minuto y el segundo actuales.
```
aws lambda invoke --function your-function-arn --payload "{\"option\": \"time\"}" out.txt
```
**nota**
Si lo utiliza AWS CLI para probar la función antes de que se complete la implementación, es posible que reciba resultados inesperados. Esto se debe a que transfiere CodeDeploy gradualmente el 10 por ciento del tráfico a la versión actualizada cada minuto. Durante la implementación, parte del tráfico sigue apuntando a la versión original, por lo que `aws lambda invoke` podría utilizar la versión original. Después de 10 minutos, la implementación se ha completado y todo el tráfico apunta a la nueva versión de la función.
## Vea los eventos de los enganches en los registros CloudWatch
Durante el `BeforeAllowTraffic` enlace, CodeDeploy ejecuta la función `CodeDeployHook_beforeAllowTraffic` Lambda. Durante el `AfterAllowTraffic` enlace, CodeDeploy ejecuta la función `CodeDeployHook_afterAllowTraffic` Lambda. Cada función ejecuta una prueba de validación que invoca la versión actualizada de la función mediante el nuevo parámetro `time`. Si la actualización de la función de Lambda se realiza correctamente, la opción `time` no provoca un error y la validación se realiza correctamente. Si la función no se ha actualizado, el parámetro no reconocido provoca un error y la validación falla. Estas pruebas de validación son solo para fines de demostración. Puede escribir sus propias pruebas para validar la implementación. Puede utilizar la consola de CloudWatch registros para ver las pruebas de validación.
**Para ver los eventos de tus CodeDeploy ganchos**
1. Abre la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs (Registros)**.
1. En la lista de grupos de registros, elija**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic** o**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**.
1. Elija el flujo de registros. Debe ver solo uno.
1. Expanda los eventos para ver sus detalles.
![\[El flujo de registros de un grupo de CodeDeployHook registros.\]](http://docs.aws.amazon.com/es_es/codedeploy/latest/userguide/images/lambda-tutorial-cloudwatch.png)
# Paso 5: Eliminar
Para evitar cargos adicionales por los recursos que utilizó durante este tutorial, elimine los recursos creados por la AWS SAM plantilla y los CloudWatch registros creados por las funciones de validación de Lambda.
**Para eliminar tu pila CloudFormation**
1. Inicia sesión en [https://console.aws.amazon.com/cloudformation Consola de administración de AWS](https://console.aws.amazon.com/cloudformation/) y abre la CloudFormation consola.
1. En la columna **Stacks** (Pilas), elija la pila de `my-date-time-app` y, a continuación, elija **Delete** (Eliminar).
1. Cuando se le solicite, seleccione **Delete stack** (Eliminar pila). Se eliminan las funciones Lambda, el grupo de CodeDeploy aplicaciones y despliegues y las funciones de IAM creadas por AWS SAM .
**Para eliminar sus registros en Logs CloudWatch**
1. Abre la CloudWatch consola en [https://console.aws.amazon.com/cloudwatch/](https://console.aws.amazon.com/cloudwatch/).
1. En el panel de navegación, elija **Logs (Registros)**.
1. En la lista de grupos de registros, pulse el botón situado junto a**/aws/lambda/CodeDeployHook\$1 beforeAllowTraffic**.
1. En **Actions** (Acciones), elija **Delete log group** (Eliminar grupo de registros), y, a continuación, **Yes, Delete** (Sí, eliminar).
1. En la lista de grupos de registros, pulse el botón situado junto a**/aws/lambda/CodeDeployHook\$1 afterAllowTraffic**.
1. En **Actions** (Acciones), elija **Delete log group** (Eliminar grupo de registros), y, a continuación, **Yes, Delete** (Sí, eliminar).