Tutorial: Utilizzo delle variabili con le azioni di richiamo Lambda

Un'azione di richiamo Lambda può utilizzare variabili di un'altra azione come parte del suo input e restituire nuove variabili insieme al relativo output. Per informazioni sulle variabili per le azioni in CodePipeline, vedi. Variables

Alla fine di questo tutorial, avrai:

• Un'azione di richiamo Lambda che:

  • Consuma la CommitId variabile da un'azione di origine CodeCommit

  • Restituisce tre nuove variabili: dateTime, testRunId, e region

• Un'azione di approvazione manuale che utilizza le nuove variabili dell'azione di invocazione Lambda per fornire un URL di test e un ID di esecuzione del test.

• Una pipeline aggiornata con le nuove operazioni

Prerequisiti

Prima di iniziare, devi disporre di quanto segue:

• Puoi creare o utilizzare la pipeline con il codice sorgente inserito. CodeCommit Tutorial: crea una pipeline semplice (CodeCommitrepository)

• Modifica la pipeline esistente in modo che l'azione di CodeCommit origine abbia un namespace. Assegna all'operazione le SourceVariables dello spazio dei nomi.

Fase 1: Creazione di una funzione Lambda

Utilizza i seguenti passaggi per creare una funzione Lambda e un ruolo di esecuzione Lambda. L'azione Lambda viene aggiunta alla pipeline dopo aver creato la funzione Lambda.

Per creare una funzione Lambda e un ruolo di esecuzione

1. Accedi AWS Management Console e apri la AWS Lambda console all'indirizzo https://console.aws.amazon.com/lambda/.

2. Scegli Crea funzione. Lasciare selezionato Author from scratch (Crea da zero).

3. In Function name (Nome funzione), immettere il nome della funzione, ad esempio myInvokeFunction. In Runtime, lasciare selezionata l'opzione predefinita.

4. Espandere Choose or create an execution role (Scegli o crea un ruolo di esecuzione). Scegliere Create a new role with basic Lambda permissions (Crea un nuovo ruolo con le autorizzazioni Lambda di base).

5. Scegli Crea funzione.

6. Per utilizzare una variabile da un'altra operazione, deve essere passata ai UserParameters nella configurazione dell'operazione di invocazione Lambda. Configuri l'operazione nella pipeline più avanti in questo tutorial, ma aggiungi il codice presumendo che la variabile venga passata.

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

   Per produrre nuove variabili, imposta una proprietà denominata outputVariables sull'input di putJobSuccessResult. Tieni presente che non è possibile produrre variabili come parte di un file putJobFailureResult.

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

   Nella nuova funzione, lasciare selezionato Edit code inline (Modifica codice inline) e incollare il seguente codice di esempio in 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. Selezionare Salva.

8. Copiare l'Amazon Resource Name (ARN) nella parte superiore dello schermo.

9. Come ultimo passaggio, apri la console AWS Identity and Access Management (IAM) all'indirizzo https://console.aws.amazon.com/iam/. Modifica il ruolo di esecuzione Lambda per aggiungere la seguente politica:. AWSCodePipelineCustomActionAccess Per le fasi della creazione di un ruolo di esecuzione Lambda o della modifica della policy di ruolo, consulta Fase 2: Creare la funzione Lambda .

Passaggio 2: aggiungi un'azione di richiamo Lambda e un'azione di approvazione manuale alla tua pipeline

In questo passaggio, aggiungi un'azione di richiamo Lambda alla tua pipeline. È possibile aggiungere l'operazione come parte di una fase denominata Test. Il tipo di operazione è un'operazione di richiamo. È quindi possibile aggiungere un'operazione di approvazione manuale dopo l'operazione di richiamo.

Per aggiungere un'azione Lambda e un'azione di approvazione manuale alla pipeline

1. Apri la CodePipeline console all'indirizzo https://console.aws.amazon.com/codepipeline/.

   Vengono visualizzati i nomi di tutte le pipeline associate al tuo AWS account. Scegliere la pipeline in cui si desidera aggiungere l'operazione.

2. Aggiungi l'azione di test Lambda alla tua pipeline.

   1. Per modificare la pipeline, scegliere Edit (Modifica). Aggiungere una fase dopo l'operazione di origine nella pipeline esistente. Immettere un nome per la fase, ad esempio Test.

   2. Nella nuova fase, scegliere l'icona per aggiungere un'operazione. In Action name (Nome operazione), immettere il nome dell'operazione di richiamo, ad esempio Test_Commit.

   3. In Action provider, scegli. AWS Lambda

   4. In Input artifacts (Artefatti di input), scegliere il nome dell'artefatto di output dell'operazione di origine, ad esempio SourceArtifact.

   5. In Nome funzione, scegli il nome della funzione Lambda che hai creato.

   6. In Parametri utente, inserisci la sintassi della variabile per l'ID di CodeCommit commit. Questa operazione crea la variabile di output che si risolve nel commit da esaminare e approvare ogni volta che viene eseguita la pipeline.

      #{SourceVariables.CommitId}

   7. In Variable namespace (Spazio dei nomi delle variabili) aggiungere il nome dello spazio dei nomi, ad esempio TestVariables.

   8. Seleziona Fatto.

3. Aggiungere l'operazione di approvazione manuale alla pipeline.

   1. Con la pipeline ancora in modalità di modifica, aggiungere una fase dopo l'operazione di richiamo. Immettere un nome per la fase, ad esempio Approval.

   2. Nella nuova fase, scegliere l'icona per aggiungere un'operazione. In Action name (Nome operazione), immettere il nome dell'operazione di approvazione, ad esempio Change_Approval.

   3. In Action provider (Provider operazione), scegliere Manual approval (Approvazione manuale).

   4. In URL for review (URL per revisione), costruire l'URL aggiungendo la sintassi della variabile per le variabili region e CommitId. Assicurarsi di utilizzare gli spazi dei nomi assegnati alle operazioni che forniscono le variabili di output.

      Per questo esempio, l'URL con la sintassi variabile per un' CodeCommit azione ha lo spazio dei nomi predefinito. SourceVariables La variabile di output della regione Lambda ha lo spazio dei nomi TestVariables. L'URL ha il seguente aspetto:

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

      In Comments (Commenti), costruire il testo del messaggio di approvazione aggiungendo la sintassi della variabile per la variabile testRunId. Per questo esempio, l'URL con la sintassi della variabile di output testRunId Lambda ha lo spazio dei nomi TestVariables. Inserire il seguente messaggio.

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

4. Scegliere Done (Fatto) per chiudere la schermata di modifica per l'operazione, quindi scegliere Done (Fatto) per chiudere la schermata di modifica per la fase. Per salvare la pipeline, scegliere Done (Fatto). La pipeline completata ora contiene una struttura con fasi di origine, test, approvazione e distribuzione.

   Scegliere Release change (Rilascia modifica) per eseguire l'ultima modifica nella struttura della pipeline.

5. Quando la pipeline raggiunge la fase di approvazione manuale, scegliere Review (Revisione). Le variabili risolte vengono visualizzate come URL per l'ID commit. L'approvatore può scegliere l'URL per visualizzare il commit.

6. Dopo che la pipeline è stata eseguita correttamente, è anche possibile visualizzare i valori delle variabili nella pagina della cronologia dell'esecuzione delle operazioni.