Tutorial: Usar variáveis com ações de invocação do

Uma ação de invocação do pode usar variáveis de outra ação como parte de sua entrada e retornar novas variáveis juntamente com sua saída. Para obter informações sobre variáveis para ações no CodePipeline, consulte Variáveis.

No final deste tutorial, você terá:

• Uma ação de invocação do Lambda que:

  • Consome a variável de uma ação de origem do

  • Produz três novas variáveis: dateTime, testRunId e region

• Uma ação de aprovação manual que consome as novas variáveis da ação de invocação do para fornecer um URL de teste e um ID de execução de teste

• Um pipeline atualizado com as novas ações

Pré-requisitos

Antes de começar, você deve ter o seguinte:

• Você pode criar ou usar o pipeline com o de origem em .

• Edite o pipeline existente para que a ação de origem do tenha um namespace. Atribua o namespace SourceVariables à ação.

Etapa 1: criar uma função do Lambda

Use as etapas a seguir para criar uma função do e uma função de execução do . Adicione a ação do ao pipeline depois de criar a função do .

Para criar uma função de alternância e uma função de execução do Lambda

1. Faça login no AWS Management Console e abra o console AWS Lambda em https://console.aws.amazon.com/lambda/.

2. Escolha Criar função. Deixe Author from scratch (Criar do zero) selecionado.

3. Em Function Name (Nome da função), insira o nome da função, como myInvokeFunction. Em Runtime (Tempo de Execução), deixe a opção padrão marcada.

4. Expanda Choose or create an execution role (Escolher ou criar uma função de execução). Escolha Create a new role with basic Lambda permissions (Criar uma nova função com permissões básicas do Lambda).

5. Escolha Criar função.

6. Para usar uma variável de outra ação, ela precisará ser passada para UserParameters na configuração de ação de invocação do Lambda. A ação em nosso pipeline será configurada mais adiante no tutorial, mas será adicionado o código assumindo que a variável será transmitida.

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

   Para produzir novas variáveis, defina uma propriedade chamada outputVariables na entrada como putJobSuccessResult. Não é possível produzir variáveis como parte de um putJobFailureResult.

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

   Na nova função, deixe Edit code inline (Editar código inline) selecionado e cole o código de exemplo a seguir em 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. Escolha Save (Salvar).

8. Copie o nome de recurso da Amazon (ARN) na parte superior da tela.

9. Abra o console do IAM em https://console.aws.amazon.com/iam/AWS Identity and Access Management. Modifique a função de execução do Lambda para adicionar a seguinte política: AWSCodePipelineCustomActionAccess. Para ver as etapas para criar uma função de execução do Lambda ou modificar a política de função, consulte Etapa 2: Criar a função do Lambda.

Etapa 2: Adicionar uma ação de chamada do e uma ação de aprovação manual ao pipeline

Nesta etapa, você adiciona uma ação de chamada do ao pipeline. Você adiciona a ação como parte de um estágio chamado Test (Teste). O tipo de ação é uma ação de chamada. Em seguida, você adiciona uma ação de aprovação manual após a ação de chamada.

Para adicionar uma ação do e uma ação de aprovação manual ao pipeline

1. Abra o console do CodePipeline em https://console.aws.amazon.com/codesuite/codepipeline.

   Os nomes de todos os pipelines que são associados à sua conta da AWS são exibidos. Escolha o pipeline onde deseja adicionar a ação.

2. Adicione uma ação de teste do ao pipeline:

   1. Para editar o pipeline, escolha Edit (Editar). Adicione um estágio após a ação de origem no pipeline existente. Insira um nome para o estágio, como Test.

   2. No novo estágio, escolha o ícone para adicionar uma ação. Em Action Name (Nome da ação), insira o nome da ação de chamada, como Test_Commit.

   3. Em Action provider (Provedor de ação), selecione AWS Lambda.

   4. Em Input artifacts (Artefatos de entrada), escolha o nome do artefato de saída da ação de origem, como SourceArtifact.

   5. Em Function Name (Nome da função), selecione o nome da função do que você criou.

   6. Em User parameters (Parâmetros do usuário), insira a sintaxe da variável para o ID de confirmação do . Isto cria a variável de saída que resolve a confirmação a ser revisada e aprovada cada vez que o pipeline é executado.

      #{SourceVariables.CommitId}

   7. Em Variable namespace (Namespace de variável), adicione o nome do namespace, como TestVariables.

   8. Escolha Done (Concluído).

3. Adicionar a ação de aprovação manual ao pipeline.

   1. Com o pipeline ainda no modo de edição, adicione um estágio após a ação de chamada. Insira um nome para o estágio, como Approval.

   2. No novo estágio, escolha o ícone para adicionar uma ação. Em Action name (Nome da ação), insira o nome da ação de aprovação, como Change_Approval.

   3. Em Action provider (Provedor de ação), escolha Manual approval (Aprovação manual).

   4. No URL for review (URL para revisão), construa o URL adicionando a sintaxe da variável para a variável region e a variável CommitId. Certifique-se de usar os namespaces atribuídos às ações que fornecem as variáveis de saída.

      Para este exemplo, a URL com a sintaxe de variável para uma ação do tem o namespace padrão . A variável de saída da Região do Lambda tem o namespace TestVariables. O URL se parece ao seguinte:

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

      Em Comments (Comentários), construa o texto da mensagem de aprovação adicionando a sintaxe da variável para a variável testRunId. Para este exemplo, o URL com a sintaxe variável para a variável de saída do Lambda testRunId tem o namespace TestVariables. Insira a mensagem a seguir.

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

4. Escolha Done (Concluído) para fechar a tela de edição da ação e Done (Concluído) para fechar a tela de edição para o estágio. Para salvar o pipeline, escolha Done (Concluído). O pipeline concluído contém agora uma estrutura com estágios de origem, teste, aprovação e implantação.

   Escolha Relase Change (Alteração de versão), para executar a alteração mais recente através da estrutura do pipeline.

5. Quando o pipeline atingir o estágio de aprovação manual, selecione Review (Revisar). As variáveis resolvidas aparecem como o URL para o ID de confirmação. O aprovador pode escolher o URL para exibir a confirmação.

6. Depois que o pipeline for executado com êxito, você também poderá visualizar os valores das variáveis na página do histórico de execução da ação.