Tutorial: Uso de variables con acciones de invocación de Lambda

Una acción de invocación de Lambda puede usar variables de otra acción como parte de su entrada y devolver nuevas variables junto con su salida. Para obtener información sobre las variables de las acciones en CodePipeline, consulteVariables.

Al final de este tutorial, tendrá:

• Una acción de invocación de Lambda que:

  • Consume la CommitId variable de una acción CodeCommit de origen

  • Da como resultado tres nuevas variables: dateTime, testRunId y region

• Una acción de aprobación manual que consume las nuevas variables de la acción de invocación de Lambda para proporcionar una URL de prueba y un ID de ejecución de prueba

• Una canalización actualizada con las nuevas acciones

Requisitos previos

Antes de comenzar, debe disponer de lo siguiente:

• Puede crear o utilizar la canalización con la CodeCommit fuente integradaTutorial: Crear una canalización sencilla (CodeCommitrepositorio).

• Edita tu canalización existente para que la acción CodeCommit de origen tenga un espacio de nombres. Asigne el espacio de nombres SourceVariables a la acción.

Paso 1: Crear una función de Lambda

Realice los pasos siguientes para crear una función de Lambda y un rol de ejecución de Lambda. Agregue la acción de Lambda a la canalización después de crear la función de Lambda.

Crear una función de Lambda y rol de ejecución

1. Inicia sesión AWS Management Console y abre la AWS Lambda consola en https://console.aws.amazon.com/lambda/.

2. Elija Crear función. Deje seleccionado Author from scratch (Crear desde cero).

3. En Function name (Nombre de la función), escriba el nombre de la función, como myInvokeFunction. En Runtime (Motor de ejecución), deje seleccionada la opción predeterminada.

4. Expanda Choose or create an execution role (Elegir o crear un rol de ejecución). Elija Create a new role with basic Lambda permissions (Crear un nuevo rol con permisos básicos de Lambda).

5. Elija Crear función.

6. Para usar una variable de otra acción, tendrá que pasar UserParameters a la configuración de acción de invocación de Lambda. Va a configurar la acción en nuestra canalización más adelante en el tutorial, pero agregará el código asumiendo que la variable se pasará.

   const commitId =
   event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
   

   Para producir nuevas variables, establezca una propiedad llamada outputVariables en la entrada a putJobSuccessResult. Tenga en cuenta que no puede producir variables como parte de putJobFailureResult.

   const successInput = {
     jobId: jobId,
     outputVariables: {
       testRunId: Math.floor(Math.random() * 1000).toString(),
       dateTime: Date(Date.now()).toString(),
       region: lambdaRegion
     }
   };
   

   En su nueva función, deje la opción Edit code-inline (Editar código insertado) seleccionada y pegue el siguiente código de ejemplo en index.js.

   var AWS = require('aws-sdk');
   
   exports.handler = function(event, context) {
       var codepipeline = new AWS.CodePipeline();
       
       // Retrieve the Job ID from the Lambda action
       var jobId = event["CodePipeline.job"].id;
       
       // Retrieve the value of UserParameters from the Lambda action configuration in CodePipeline,
       // in this case it is the Commit ID of the latest change of the pipeline.
       var params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters; 
       
       // The region from where the lambda function is being executed.
       var lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       var putJobSuccess = function(message) {
           var params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           codepipeline.putJobSuccessResult(params, function(err, data) {
               if(err) {
                   context.fail(err);      
               } else {
                   context.succeed(message);      
               }
           });
       };
       
       // Notify CodePipeline of a failed job
       var putJobFailure = function(message) {
           var params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           codepipeline.putJobFailureResult(params, function(err, data) {
               context.fail(message);      
           });
       };
       
       var sendResult = function() {
           try {
               console.log("Testing commit - " + params);
               
               // Your tests here
               
               // Succeed the job
               putJobSuccess("Tests passed.");
           } catch (ex) {
               // If any of the assertions failed then fail the job
               putJobFailure(ex);    
           }
       };
       
       sendResult();
   }; 

7. Seleccione Guardar.

8. Copie el nombre de recurso de Amazon (ARN) en la parte superior de la pantalla.

9. Como último paso, abre la consola AWS Identity and Access Management (IAM) en https://console.aws.amazon.com/iam/. Modifique la función de ejecución de Lambda para añadir la siguiente política:. AWSCodePipelineCustomActionAccess Para consultar los pasos necesarios para crear un rol de ejecución de Lambda o modificar la política de rol, consulte Paso 2: Crear la función de Lambda.

Paso 2: Añadir una acción de invocación de Lambda y una acción de aprobación manual a la canalización

En este paso, agregue una acción de invocación de Lambda a la canalización. Agregue la acción como parte de una etapa denominada Test (Prueba). El tipo de acción es una acción de invocación. A continuación, agregue una acción de aprobación manual después de la acción de invocación.

Para agregar una acción de Lambda y una acción de aprobación manual a la canalización

1. Abra la CodePipeline consola en https://console.aws.amazon.com/codepipeline/.

   Se muestran los nombres de todas las canalizaciones asociadas a tu AWS cuenta. Elija la canalización en la que desea agregar la acción.

2. Agregue la acción de prueba de Lambda a su canalización.

   1. Para editar la canalización, elija Edit (Editar). Agregue una etapa después de la acción de origen en la canalización existente. Escriba un nombre para la etapa, por ejemplo Test.

   2. En la nueva etapa, elija el icono para agregar una acción. En Action name (Nombre de la acción), escriba el nombre de la acción de invocación, como Test_Commit.

   3. En Proveedor de acción, seleccione AWS Lambda.

   4. En Input artifacts (Artefactos de entrada), elija el nombre del artefacto de salida de la acción de origen, como SourceArtifact.

   5. En Nombre de la función, elija el nombre de la función de Lambda que ha creado.

   6. En Parámetros de usuario, introduce la sintaxis de la variable para el ID de CodeCommit confirmación. Esto crea la variable de salida que se resuelve en la confirmación que se va a revisar y aprobar cada vez que se ejecuta la canalización.

      #{SourceVariables.CommitId}

   7. En el Variable namespace (Espacio de nombres de la variable), agregue el nombre del espacio de nombres, como TestVariables.

   8. Seleccione Listo.

3. Agregue la acción de aprobación manual a la canalización.

   1. Con la canalización todavía en modo de edición, agregue una etapa después de la acción de invocación. Escriba un nombre para la etapa, por ejemplo Approval.

   2. En la nueva etapa, elija el icono para agregar una acción. En Action name (Nombre de la acción), escriba el nombre de la acción de aprobación, como Change_Approval.

   3. En Action provider (Proveedor de acciones), elija Manual approval (Aprobación manual).

   4. En URL for review (URL para revisión), cree la URL agregando la sintaxis de variable para la variable region y la variable CommitId. Asegúrese de utilizar los espacios de nombres asignados a las acciones que proporcionan las variables de salida.

      En este ejemplo, la URL con la sintaxis variable de una CodeCommit acción tiene el espacio de nombres SourceVariables predeterminado. La variable de salida de región de Lambda tiene el espacio de nombres TestVariables. La URL tiene el siguiente aspecto.

      https://#{TestVariables.region}.console.aws.amazon.com/codesuite/codecommit/repositories/MyDemoRepo/commit/#{SourceVariables.CommitId}

      En Comments (Comentarios), cree el texto del mensaje de aprobación agregando la sintaxis de la variable para la variable testRunId. Para este ejemplo, la dirección URL con la sintaxis de variable para la variable de salida de Lambda testRunId tiene el espacio de nombres TestVariables. Escriba el siguiente mensaje.

      Make sure to review the code before approving this action. Test Run ID: #{TestVariables.testRunId}

4. Elija Done (Listo) para cerrar la pantalla de edición de la acción y, a continuación, elija Done (Listo) para cerrar la pantalla de edición de la etapa. Para guardar la canalización, elija Done (Listo). La canalización completada ahora contiene una estructura con etapas de origen, prueba, aprobación e implementación.

   Elija Release change (Publicar modificación) para ejecutar el último cambio a través de la estructura de la canalización.

5. Cuando la canalización llegue a la etapa de aprobación manual, elija Review (Revisar). Las variables resueltas aparecen como la URL del ID de confirmación. El aprobador puede elegir la URL para consultar la confirmación.

6. Después de que la canalización se ejecute de forma satisfactoria, también puede consultar los valores de las variables en la página del historial de ejecución de acciones.