Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Tutorial: Variablen mit Lambda-Aufrufaktionen verwenden
<a name="tutorials-lambda-variables"></a>

Eine Lambda-Aufrufaktion kann Variablen aus einer anderen Aktion als Teil ihrer Eingabe verwenden und neue Variablen zusammen mit ihrer Ausgabe zurückgeben. Hinweise zu Variablen für Aktionen in finden Sie CodePipeline unter. [Variablen-Referenz](reference-variables.md)

**Wichtig**  
Im Rahmen der Erstellung einer Pipeline wird ein vom Kunden bereitgestellter S3-Artefakt-Bucket von CodePipeline for Artifacts verwendet. (Dies unterscheidet sich von dem Bucket, der für eine S3-Quellaktion verwendet wird.) Wenn sich der S3-Artefakt-Bucket in einem anderen Konto befindet als das Konto für Ihre Pipeline, stellen Sie sicher, dass der S3-Artefakt-Bucket denjenigen gehört AWS-Konten , die sicher und zuverlässig sind.

Am Ende dieses Tutorials werden Sie Folgendes haben::
+ Eine Lambda-Aufrufaktion, die:
  + Verbraucht die `CommitId` Variable aus einer Quellaktion CodeCommit 
  + drei neue Variablen ausgibt: `dateTime`, `testRunId` und `region`
+ Eine manuelle Genehmigungsaktion, die die neuen Variablen aus Ihrer Lambda-Aufrufaktion verwendet, um eine Test-URL und eine Testlauf-ID bereitzustellen
+ Eine mit den neuen Aktionen aktualisierte Pipeline

**Topics**
+ [

## Voraussetzungen
](#lambda-variables-prereqs)
+ [

## Schritt 1: Erstellen einer Lambda-Funktion
](#lambda-variables-function)
+ [

## Schritt 2: Fügen Sie Ihrer Pipeline eine Lambda-Aufrufaktion und eine manuelle Genehmigungsaktion hinzu
](#lambda-variables-pipeline)

## Voraussetzungen
<a name="lambda-variables-prereqs"></a>

Sie benötigen Folgendes, um starten zu können: 
+ Sie können die Pipeline erstellen oder verwenden, in der sich die Quelle befindet. CodeCommit [Tutorial: Erstellen Sie eine einfache Pipeline (CodeCommit Repository)](tutorials-simple-codecommit.md)
+ Bearbeiten Sie Ihre bestehende Pipeline so, dass die CodeCommit Quellaktion einen Namespace hat. Weisen Sie der Aktion `SourceVariables` den Namespace zu.

## Schritt 1: Erstellen einer Lambda-Funktion
<a name="lambda-variables-function"></a>

Gehen Sie wie folgt vor, um eine Lambda-Funktion und eine Lambda-Ausführungsrolle zu erstellen. Sie fügen die Lambda-Aktion zu Ihrer Pipeline hinzu, nachdem Sie die Lambda-Funktion erstellt haben.

**So erstellen Sie eine Lambda-Funktion und eine Ausführungsrolle**

1. Melden Sie sich bei der an AWS-Managementkonsole und öffnen Sie die AWS Lambda Konsole unter [https://console.aws.amazon.com/lambda/](https://console.aws.amazon.com/lambda/).

1. Wählen Sie **Funktion erstellen**. Lassen Sie **Author from scratch (Von Grund auf erstellen)** ausgewählt.

1. Geben Sie unter **Funktionsname** den Namen Ihrer Funktion ein, z. B. **myInvokeFunction**. Lassen Sie in **Runtime (Laufzeit)** die Standardoption ausgewählt.

1. Erweitern Sie **Choose or create an execution role (Ausführungsrolle auswählen oder erstellen)**. Wählen Sie **Create a new role with basic Lambda permissions (Eine neue Rolle mit den grundlegenden Lambda-Berechtigungen erstellen)** aus.

1. Wählen Sie **Funktion erstellen**.

1. Um eine Variable aus einer anderen Aktion zu verwenden, muss sie an die `UserParameters` in der Lambda-Aufrufaktionskonfiguration übergeben werden. Sie werden die Aktion in unserer Pipeline später in diesem Tutorial konfigurieren, Sie fügen jedoch den Code hinzu, vorausgesetzt, dass die Variable übergeben wird.

   Um neue Variablen zu erzeugen, setzen Sie eine Eigenschaft mit der Bezeichnung `outputVariables` auf die Eingabe zu `putJobSuccessResult`. Beachten Sie, dass Sie keine Variablen als Teil eines `putJobFailureResult` erzeugen können.

   ```
    const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
   ```

   Fügen Sie in Ihrer neuen Funktion auf der Registerkarte **Code** den folgenden Beispielcode unter ein`index.mjs`.

   ```
   import { CodePipeline } from '@aws-sdk/client-codepipeline';
   
   export const handler = async (event, context) => {
       const codepipeline = new CodePipeline({});
       
       // Retrieve the Job ID from the Lambda action
       const jobId = event["CodePipeline.job"].id;
       
       // Retrieve UserParameters
       const params = event["CodePipeline.job"].data.actionConfiguration.configuration.UserParameters;
       
       // The region from where the lambda function is being executed
       const lambdaRegion = process.env.AWS_REGION;
       
       // Notify CodePipeline of a successful job
       const putJobSuccess = async (message) => {
           const params = {
               jobId: jobId,
               outputVariables: {
                   testRunId: Math.floor(Math.random() * 1000).toString(),
                   dateTime: Date(Date.now()).toString(),
                   region: lambdaRegion
               }
           };
           
           try {
               await codepipeline.putJobSuccessResult(params);
               return message;
           } catch (err) {
               throw err;
           }
       };
       
       // Notify CodePipeline of a failed job
       const putJobFailure = async (message) => {
           const params = {
               jobId: jobId,
               failureDetails: {
                   message: JSON.stringify(message),
                   type: 'JobFailed',
                   externalExecutionId: context.invokeid
               }
           };
           
           try {
               await codepipeline.putJobFailureResult(params);
               throw message;
           } catch (err) {
               throw err;
           }
       };
       
       try {
           console.log("Testing commit - " + params);
           
           // Your tests here
           
           // Succeed the job
           return await putJobSuccess("Tests passed.");
       } catch (ex) {
           // If any of the assertions failed then fail the job
           return await putJobFailure(ex);
       }
   };
   ```

1. Erlaube der Funktion, auto zu speichern.

1. Kopieren Sie den Amazon-Ressourcennamen (ARN), der im Feld **Function ARN** oben auf dem Bildschirm enthalten ist.

1. Öffnen Sie als letzten Schritt die AWS Identity and Access Management (IAM-) Konsole unter [https://console.aws.amazon.com/iam/](https://console.aws.amazon.com/iam/). Ändern Sie die Lambda-Ausführungsrolle, um die folgende Richtlinie hinzuzufügen: [AWSCodePipelineCustomActionAccess](https://console.aws.amazon.com/iam/home?region=us-west-2#/policies/arn%3Aaws%3Aiam%3A%3Aaws%3Apolicy%2FAWSCodePipelineCustomActionAccess). Die Schritte zum Erstellen einer Lambda-Ausführungsrolle oder zum Ändern der Rollenrichtlinie finden Sie unter [Schritt 2: Erstellen Sie die Lambda-Funktion](actions-invoke-lambda-function.md#actions-invoke-lambda-function-create-function) . 

## Schritt 2: Fügen Sie Ihrer Pipeline eine Lambda-Aufrufaktion und eine manuelle Genehmigungsaktion hinzu
<a name="lambda-variables-pipeline"></a>

In diesem Schritt fügen Sie Ihrer Pipeline eine Lambda-Aufrufaktion hinzu. Sie fügen die Aktion als Teil einer Phase namens **Test** hinzu. Der Aktionstyp ist eine Aufrufaktion. Anschließend fügen Sie nach der Aufrufaktion eine manuelle Genehmigungsaktion hinzu.

**Um der Pipeline eine Lambda-Aktion und eine manuelle Genehmigungsaktion hinzuzufügen**

1. Öffnen Sie die CodePipeline Konsole unter. [https://console.aws.amazon.com/codepipeline/](https://console.aws.amazon.com/codepipeline/)

   Die Namen aller Pipelines, die mit Ihrem AWS Konto verknüpft sind, werden angezeigt. Wählen Sie die Pipeline aus, in der Sie die Aktion hinzufügen möchten.

1. Fügen Sie die Lambda-Testaktion zu Ihrer Pipeline hinzu.

   1. Um die Pipeline zu bearbeiten, wählen Sie **Edit (Bearbeiten)**. Fügen Sie nach der Quellaktion einen Schritt in der vorhandenen Pipeline hinzu. Geben Sie einen Namen für die Phase ein, z. B. **Test**.

   1. Wählen Sie in der neuen Phase **Aktionsgruppe hinzufügen** aus, um eine Aktion hinzuzufügen. Geben Sie unter **Action name (Aktionsname)** den Namen der Aufrufaktion ein, z. B. **Test\$1Commit**.

   1. Wählen Sie **unter Aktionsanbieter** die Option **AWS Lambda**.

   1. Wählen Sie unter **Input artifacts (Eingabeartefakte)** den Namen des Ausgabeartefakts Ihrer Quellaktion aus, z. B. `SourceArtifact`.

   1. Fügen Sie **FunctionName**unter den ARN der Lambda-Funktion hinzu, die Sie erstellt haben.

   1. Fügen Sie unter **Variable namespace (Variablennamespace)** den Namespace-Namen hinzu, z. B. **TestVariables**.

   1. Fügen Sie unter **Ausgabeartefakte** den Namen des Ausgabeartefakts hinzu, z. B. **LambdaArtifact**

   1. Wählen Sie **Fertig** aus.

1. Fügen Sie der Pipeline die manuelle Genehmigungsaktion hinzu.

   1. Wenn sich Ihre Pipeline noch im Bearbeitungsmodus befindet, fügen Sie nach der Aufrufaktion eine Phase hinzu. Geben Sie einen Namen für die Phase ein, z. B. **Approval**.

   1. Wählen Sie in der neuen Phase das Symbol zum Hinzufügen einer Aktion aus. Geben Sie unter **Action name (Aktionsname)** den Namen der Genehmigungsaktion ein, z. B. **Change\$1Approval**.

   1. Wählen Sie unter **Action provider (Aktionsanbieter)** die Option **Manual approval (Manuelle Genehmigung)**.

   1. Erstellen Sie unter **URL for review (URL zur Überprüfung)** die URL, indem Sie die Variablensyntax für die `region`-Variable und die `CommitId`-Variable hinzufügen. Stellen Sie sicher, dass Sie die Namespaces verwenden, die denjenigen Aktionen zugewiesen sind, die die Ausgabevariablen bereitstellen. 

      In diesem Beispiel hat die URL mit der Variablensyntax für eine CodeCommit Aktion den `SourceVariables` Standard-Namespace. Die Ausgabevariable der Lambda-Region hat den Namespace „`TestVariables`“. Die URL sieht wie folgt aus:

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

      Erstellen Sie unter **Comments (Kommentare)** den Text der Genehmigungsmeldung, indem Sie die Variablensyntax für die `testRunId`-Variable hinzufügen. In diesem Beispiel hat die URL mit der Variablensyntax für die `testRunId`-Lambda-Ausgabevariable den Namespace „`TestVariables`“. Geben Sie die folgende Nachricht ein.

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

1. Wählen Sie **Done (Fertig)** aus, um den Bearbeitungsbildschirm für die Aktion zu schließen. Wählen Sie dann **Done (Fertig)** aus, um den Bearbeitungsbildschirm für die Phase zu schließen. Zum Speichern der Pipeline wählen Sie **Done (Fertig)** aus. Die abgeschlossene Pipeline enthält jetzt eine Struktur mit Quell-, Test-, Genehmigungs- und Bereitstellungsschritten.

   Wählen Sie **Release change (Änderung freigeben)** aus, um die letzte Änderung durch die Pipeline-Struktur auszuführen.

1. Wenn die Pipeline die manuelle Genehmigungsphase erreicht hat, wählen Sie **Review (Überprüfen) aus**. Die aufgelösten Variablen werden als URL für die Commit-ID angezeigt. Ihr Genehmiger kann die URL auswählen, um das Commit anzuzeigen.

1. Nachdem die Pipeline erfolgreich ausgeführt wurde, können Sie die Variablenwerte auch auf der Seite „Aktionsausführungsverlauf“ anzeigen.