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. # 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.