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.

# Variablen-Referenz
<a name="reference-variables"></a>

Dieser Abschnitt dient nur als Referenz. Informationen zum Erstellen von Variablen finden Sie unter [Arbeiten mit Variablen](actions-variables.md).

Mit Variablen können Sie Ihre Pipeline-Aktionen mit Werten konfigurieren, die zum Zeitpunkt der Pipeline- oder Aktionsausführung festgelegt werden.

Einige Aktionsanbieter erzeugen einen definierten Satz von Variablen. Sie wählen aus Standardvariablenschlüsseln für diesen Aktionsanbieter aus, z. B. eine Commit-ID.

**Wichtig**  
Geben Sie bei der Übergabe geheimer Parameter den Wert nicht direkt ein. Der Wert wird als Klartext gerendert und ist daher lesbar. Verwenden Sie aus Sicherheitsgründen keinen Klartext mit Geheimnissen. Wir empfehlen dringend, die Verwendung AWS Secrets Manager zum Speichern von Geheimnissen zu verwenden.

Um step-by-step Beispiele für die Verwendung von Variablen zu sehen:
+ Ein Tutorial mit einer Variablen auf Pipelineebene, die bei der Ausführung der Pipeline übergeben wird, finden Sie unter. [Tutorial: Variablen auf Pipeline-Ebene verwenden](tutorials-pipeline-variables.md)
+ Ein Tutorial mit einer Lambda-Aktion, die Variablen aus einer Upstream-Aktion (CodeCommit) verwendet und Ausgabevariablen generiert, finden Sie unter[Tutorial: Variablen mit Lambda-Aufrufaktionen verwenden](tutorials-lambda-variables.md).
+ Ein Tutorial mit einer CloudFormation Aktion, die auf Stack-Ausgabevariablen aus einer CloudFormation Upstream-Aktion verweist, finden Sie unter[Tutorial: Eine Pipeline erstellen, die Variablen aus AWS CloudFormation Bereitstellungsaktionen verwendet](tutorials-cloudformation-action.md).
+ Ein Beispiel für eine manuelle Genehmigungsaktion mit Nachrichtentext, der auf Ausgabevariablen verweist, die in die CodeCommit Commit-ID und die Commit-Nachricht aufgelöst werden, finden Sie unter[Beispiel: Variablen in manuellen Genehmigungen verwenden](actions-variables.md#actions-variables-examples-approvals).
+ Ein Beispiel für eine CodeBuild Aktion mit einer Umgebungsvariablen, die in den GitHub Branch-Namen aufgelöst wird, finden Sie unter[Beispiel: Verwenden Sie eine BranchName Variable mit CodeBuild Umgebungsvariablen](actions-variables.md#actions-variables-examples-env-branchname).
+ CodeBuild Aktionen erzeugen alle Umgebungsvariablen, die als Teil des Builds exportiert wurden, als Variablen. Weitere Informationen finden Sie unter [CodeBuild Ausgabevariablen für Aktionen](#reference-variables-list-configured-codebuild).

**Variablengrenzwerte**

Informationen zu Grenzwerten finden Sie unter [Kontingente in AWS CodePipeline](limits.md).

**Anmerkung**  
Wenn Sie die Variablensyntax in die Aktionskonfigurationsfelder eingeben, dürfen Sie die Obergrenze von 1000 Zeichen für die Konfigurationsfelder nicht überschreiten. Ein Validierungsfehler wird zurückgegeben, wenn dieser Grenzwert überschritten wird.

**Topics**
+ [Konzepte](#reference-variables-concepts)
+ [Anwendungsfälle für Variablen](#reference-variables-cases)
+ [Konfigurieren von Variablen](#reference-variables-workflow)
+ [Variablenauflösung](#reference-variables-resolution)
+ [Regeln für Variablen](#reference-variables-rules)
+ [Für Pipeline-Aktionen verfügbare Variablen](#reference-variables-list)

## Konzepte
<a name="reference-variables-concepts"></a>

In diesem Abschnitt werden wichtige Begriffe und Konzepte aufgeführt, die sich auf Variablen und Namespaces beziehen.

### Variablen
<a name="reference-variables-concepts-variablekeys"></a>

Variablen sind Schlüssel-Wert-Paare, die Sie für die dynamische Konfiguration von Aktionen in Ihrer Pipeline verwenden können. Derzeit gibt es drei Möglichkeiten, wie diese Variablen verfügbar gemacht werden können:
+ Zu Beginn jeder Pipeline-Ausführung gibt es einen Variablensatz, der implizit verfügbar ist. Dieser Satz enthält zurzeit `PipelineExecutionId`, die ID der aktuellen Pipeline-Ausführung.
+ Variablen auf Pipeline-Ebene werden definiert, wenn die Pipeline erstellt und zur Laufzeit der Pipeline aufgelöst wird.

  Sie geben Variablen auf Pipeline-Ebene an, wenn die Pipeline erstellt wird, und Sie können Werte zum Zeitpunkt der Pipeline-Ausführung angeben. 
+ Es gibt Aktionstypen, die Variablensätze erzeugen, wenn sie ausgeführt werden. Sie können sehen, welche Variablen durch eine Aktion erzeugt werden, indem Sie das `outputVariables` Feld überprüfen, das Teil der API ist. [ListActionExecutions](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_ListActionExecutions.html) Die Liste der verfügbaren Schlüsselnamen nach Aktionsanbieter finden Sie unter [Für Pipeline-Aktionen verfügbare Variablen](#reference-variables-list). Informationen darüber, welche Variablen die einzelnen Aktionstypen erzeugen, finden Sie unter CodePipeline [Referenz der Aktionsstruktur](action-reference.md).

Um in Ihrer Aktionskonfiguration auf diese Variablen zu verweisen, müssen Sie die Variablenreferenzsyntax mit dem richtigen Namespace verwenden. 

 Ein Beispiel für einen Variablen-Workflow finden Sie unter [Konfigurieren von Variablen](#reference-variables-workflow).

### Namespaces
<a name="reference-variables-concepts-namespaces"></a>

Um sicherzustellen, dass Variablen eindeutig referenziert werden können, müssen sie einem Namespace zugewiesen werden. Nachdem Sie einen Satz von Variablen einem Namespace zugewiesen haben, können sie in einer Aktionskonfiguration durch Verwendung des Namespace und Variablenschlüssels mit der folgenden Syntax referenziert werden:

```
#{namespace.variable_key}
```

Es gibt drei Arten von Namespaces, unter denen Variablen zugewiesen werden können:
+ **Der reservierte Namespace codepipeline **

  Dies ist der Namespace, der dem Satz impliziter Variablen zugewiesen ist, die zu Beginn der einzelnen Pipeline-Ausführungen verfügbar sind. Dieser Namespace ist `codepipeline`. Beispiel für eine Variablenreferenz:

  ```
  #{codepipeline.PipelineExecutionId}
  ```
+ **Der Variablen-Namespace auf Pipeline-Ebene**

  Dies ist der Namespace, der Variablen auf Pipeline-Ebene zugewiesen ist. Der Namespace für alle Variablen auf Pipeline-Ebene ist. `variables` Beispiel für eine Variablenreferenz:

  ```
  #{variables.variable_name}
  ```
+ **Einer Aktion zugewiesener Namespace**

  Dies ist ein Namespace, den Sie einer Aktion zuweisen. Alle Variablen, die von der Aktion erzeugt werden, werden diesem Namespace zugewiesen. Um die von einer Aktion erzeugten Variablen für die Verwendung in einer nachgeschalteten Aktionskonfiguration verfügbar zu machen, müssen Sie die erzeugende Aktion mit einem Namespace konfigurieren. Namespaces müssen in der Pipeline-Definition eindeutig sein und dürfen nicht mit Artefaktnamen in Konflikt stehen. Dies ist ein Beispiel für eine Variablenreferenz für eine Aktion, die mit dem Namespace `SourceVariables` konfiguriert ist.

  ```
  #{SourceVariables.VersionId}
  ```

## Anwendungsfälle für Variablen
<a name="reference-variables-cases"></a>

Im Folgenden sind einige der häufigsten Anwendungsfälle für Variablen auf Pipeline-Ebene aufgeführt, anhand derer Sie ermitteln können, wie Sie Variablen für Ihre spezifischen Anforderungen verwenden könnten.
+ Variablen auf Pipeline-Ebene sind für CodePipeline Kunden vorgesehen, die jedes Mal dieselbe Pipeline verwenden möchten, mit geringfügigen Abweichungen bei den Eingaben für die Aktionskonfiguration. Jeder Entwickler, der eine Pipeline startet, fügt den Variablenwert in der Benutzeroberfläche hinzu, wenn die Pipeline gestartet wird. Mit dieser Konfiguration übergeben Sie nur Parameter für diese Ausführung.
+ Mit Variablen auf Pipeline-Ebene können Sie dynamische Eingaben an Aktionen in der Pipeline übergeben. Sie können Ihre parametrisierten Pipelines zu migrieren, CodePipeline ohne verschiedene Versionen derselben Pipeline verwalten oder komplexe Pipelines erstellen zu müssen.
+ Sie können Variablen auf Pipeline-Ebene verwenden, um Eingabeparameter zu übergeben, die es Ihnen ermöglichen, eine Pipeline bei jeder Ausführung wiederzuverwenden, z. B. wenn Sie angeben möchten, welche Version Sie in einer Produktionsumgebung bereitstellen möchten, sodass Sie Pipelines nicht duplizieren müssen.
+ Sie können eine einzelne Pipeline verwenden, um Ressourcen für mehrere Build- und Bereitstellungsumgebungen bereitzustellen. Bei einer Pipeline mit einem CodeCommit Repository kann die Bereitstellung beispielsweise von einer bestimmten Branch- und Zielbereitstellungsumgebung aus mit CodeBuild übergebenen CodeDeploy Parametern auf Pipeline-Ebene erfolgen.

**Anmerkung**  
Für Amazon ECR, Amazon S3 oder CodeCommit Quellen können Sie auch eine Quellüberschreibung mithilfe des Eingabe-Transformationseintrags erstellen, um den `revisionValue` In EventBridge für Ihr Pipeline-Ereignis zu verwenden, wobei der von der Quellereignisvariablen für Ihren Objektschlüssel, Ihren Commit oder Ihre Image-ID abgeleitet `revisionValue` wird. Weitere Informationen finden Sie im optionalen Schritt für die Eingabe der Eingabetransformation, der in den Verfahren unter [Amazon ECR-Quellaktionen und Ressourcen EventBridge](create-cwe-ecr-source.md)[Verbindung zu Amazon S3 S3-Quellaktionen mit einer für Ereignisse aktivierten Quelle herstellen](create-S3-source-events.md), oder [CodeCommit Quellaktionen und EventBridge](triggering.md) enthalten ist.

## Konfigurieren von Variablen
<a name="reference-variables-workflow"></a>

Sie können Variablen auf Pipeline-Ebene oder Aktionsebene in der Pipeline-Struktur konfigurieren.

### Variablen auf Pipeline-Ebene konfigurieren
<a name="reference-variables-pipeline-level"></a>

Sie können eine oder mehrere Variablen auf Pipeline-Ebene hinzufügen. Sie können in der Konfiguration von CodePipeline Aktionen auf diesen Wert verweisen. Sie können die Variablennamen, Standardwerte und Beschreibungen hinzufügen, wenn Sie die Pipeline erstellen. Variablen werden zum Zeitpunkt der Ausführung aufgelöst.

**Anmerkung**  
Wenn für eine Variable auf Pipeline-Ebene kein Standardwert definiert ist, wird die Variable als erforderlich betrachtet. Sie müssen beim Starten einer Pipeline Überschreibungen für alle erforderlichen Variablen angeben, da andernfalls die Pipelineausführung mit einem Validierungsfehler fehlschlägt.

Sie stellen Variablen auf Pipeline-Ebene mithilfe des Variablen-Attributs in der Pipeline-Struktur bereit. Im folgenden Beispiel `Variable1` hat die Variable den Wert`Value1`.

```
       "variables": [
            {
                "name": "Variable1",
                "defaultValue": "Value1",
                "description": "description"
            }
        ]
```

Ein Beispiel für die JSON-Struktur der Pipeline finden Sie unter[Eine Pipeline, Phasen und Aktionen erstellen](pipelines-create.md).

Ein Tutorial mit einer Variablen auf Pipeline-Ebene, die bei der Ausführung der Pipeline übergeben wird, finden Sie unter. [Tutorial: Variablen auf Pipeline-Ebene verwenden](tutorials-pipeline-variables.md)

Beachten Sie, dass die Verwendung von Variablen auf Pipeline-Ebene in jeder Art von Quellaktion nicht unterstützt wird.

**Anmerkung**  
Wenn der `variables` Namespace bereits in einigen Aktionen innerhalb der Pipeline verwendet wird, müssen Sie die Aktionsdefinition aktualisieren und einen anderen Namespace für die widersprüchliche Aktion auswählen.

### Variablen auf Aktionsebene konfigurieren
<a name="reference-variables-action-level"></a>

Sie konfigurieren eine Aktion zur Erzeugung von Variablen, indem Sie einen Namespace für die Aktion deklarieren. Bei der Aktion muss es sich bereits um einen Aktionsanbieter handeln, der Variablen generiert. Andernfalls handelt es sich bei den verfügbaren Variablen um Variablen auf Pipeline-Ebene.

Sie deklarieren den Namespace auf eine von zwei Arten: 
+ Sie geben auf der Seite **Edit action (Aktion bearbeiten)** in der Konsole in **Variable namespace (Variablen-Namespace)** einen Namespace ein.
+ Sie geben in das `namespace`-Parameterfeld in der JSON-Pipelinestruktur einen Namespace ein. 

In diesem Beispiel fügen Sie der CodeCommit Quellaktion den `namespace` Parameter mit dem Namen hinzu`SourceVariables`. Hierdurch wird die Aktion für die Erzeugung der Variablen konfiguriert, die für diesen Aktionsanbieter verfügbar sind, z. B. `CommitId`. 

```
{
    "name": "Source",
    "actions": [
        {
            "outputArtifacts": [
                {
                    "name": "SourceArtifact"
                }
            ],
            "name": "Source",
            "namespace": "SourceVariables",
            "configuration": {
                "RepositoryName": "MyRepo",
                "BranchName": "mainline",
                "PollForSourceChanges": "false"
            },
            "inputArtifacts": [],
            "region": "us-west-2",
            "actionTypeId": {
                "provider": "CodeCommit",
                "category": "Source",
                "version": "1",
                "owner": "AWS"
            },
            "runOrder": 1
        }
    ]
},
```

Als Nächstes konfigurieren Sie die nachgeschaltete Aktion für die Verwendung der von der vorherigen Aktion erzeugten Variablen. Sie tun dies wie folgt:
+ Sie geben auf der Seite **Edit action (Aktion bearbeiten)** der Konsole die Variablensyntax (für die nachgeschaltete Aktion) in die Aktionskonfigurationsfelder ein.
+ Sie geben die Variablensyntax (für die nachgeschaltete Aktion) in die Aktionskonfigurationsfelder in der JSON-Pipelinestruktur ein.

In diesem Beispiel zeigt das Konfigurationsfeld der Build-Aktion Umgebungsvariablen an, die bei Aktionsausführung aktualisiert werden. Das Beispiel gibt den Namespace und die Variable für die Ausführungs-ID mit `#{codepipeline.PipelineExecutionId}` sowie den Namespace und die Variable für die Commit-ID mit **\$1\$1SourceVariables.CommitId\$1** an. 

```
{
    "name": "Build",
    "actions": [
        {
            "outputArtifacts": [
                {
                    "name": "BuildArtifact"
                }
            ],
            "name": "Build",
            "configuration": {
                "EnvironmentVariables": "[{\"name\":\"Release_ID\",\"value\":\"#{codepipeline.PipelineExecutionId}\",\"type\":\"PLAINTEXT\"},{\"name\":\"Commit_ID\",\"value\":\"#{SourceVariables.CommitId}\",\"type\":\"PLAINTEXT\"}]",
                "ProjectName": "env-var-test"
            },
            "inputArtifacts": [
                {
                    "name": "SourceArtifact"
                }
            ],
            "region": "us-west-2",
            "actionTypeId": {
                "provider": "CodeBuild",
                "category": "Build",
                "version": "1",
                "owner": "AWS"
            },
            "runOrder": 1
        }
    ]
},
```

## Variablenauflösung
<a name="reference-variables-resolution"></a>

Jedes Mal, wenn eine Aktion als Teil einer Pipeline-Ausführung ausgeführt wird, stehen die so erzeugten Variablen für jede Aktion zur Verfügung, die nach der erzeugenden Aktion garantiert ausgeführt wird. Um diese Variablen in einer verbrauchenden Aktion zu verwenden, können Sie sie mithilfe der im vorherigen Beispiel gezeigten Syntax zur Konfiguration der verbrauchenden Aktion hinzufügen. CodePipeline Löst vor der Ausführung einer aufwändigen Aktion alle Variablenverweise auf, die in der Konfiguration vorhanden sind, bevor die Ausführung der Aktion initiiert wird.



![\[Beispiel: Variablen für mehrere Aktionen\]](http://docs.aws.amazon.com/de_de/codepipeline/latest/userguide/images/variables-workflow-example.png)


## Regeln für Variablen
<a name="reference-variables-rules"></a>

Die folgenden Regeln helfen Ihnen bei der Konfiguration von Variablen:
+ Sie geben den Namespace und die Variable für eine Aktion über eine neue Aktionseigenschaft oder durch Bearbeiten einer Aktion an. 
+ Wenn Sie den Pipeline-Erstellungsassistenten verwenden, generiert die Konsole für jede mit dem Assistenten erstellte Aktion einen Namespace.
+ Wenn kein Namespace angegeben ist, können die von dieser Aktion erzeugten Variablen in keiner Aktionskonfiguration referenziert werden.
+ Um von einer Aktion erzeugte Variablen zu referenzieren, muss die referenzierende Aktion nach der Aktion ausgeführt werden, die die Variablen erzeugt. Das bedeutet, dass sie sich entweder in einer späteren Phase als die Aktion befindet, die die Variablen erzeugt, oder in derselben Phase, jedoch in einer höheren Ausführungsrangstufe.

## Für Pipeline-Aktionen verfügbare Variablen
<a name="reference-variables-list"></a>

Der Aktionsanbieter bestimmt, welche Variablen von der Aktion generiert werden können. 

 step-by-stepVerfahren zur Verwaltung von Variablen finden Sie unter. [Arbeiten mit Variablen](actions-variables.md)

### Aktionen mit definierten Variablenschlüsseln
<a name="reference-variables-list-defined"></a>

Im Gegensatz zu einem Namespace, den Sie wählen können, verwenden die folgenden Aktionen variable Schlüssel, die nicht bearbeitet werden können. Für den Amazon S3 S3-Aktionsanbieter sind beispielsweise nur die Schlüssel `ETag` und die `VersionId` Variablen verfügbar.

Jede Ausführung verfügt außerdem über eine Reihe von CodePipeline -generierten Pipeline-Variablen, die Daten über die Ausführung enthalten, z. B. die Pipeline-Release-ID. Diese Variablen können von jeder Aktion in der Pipeline verbraucht werden.

**Topics**
+ [CodePipeline Variable mit der Ausführungs-ID](#w2aac64c33b7b9)
+ [Ausgabevariablen für Amazon ECR-Aktionen](#reference-variables-output-ECR)
+ [CloudFormation StackSets Aktionsausgabevariablen](#reference-variables-output-StackSets)
+ [CodeCommit Aktionsausgabevariablen](#reference-variables-output-CodeCommit)
+ [CodeStarSourceConnection Aktionsausgabevariablen](#reference-variables-output-CodeConnections)
+ [GitHub Aktionsausgabevariablen (GitHub (über OAuth App) Aktion)](#reference-variables-output-GitHub-version1)
+ [Ausgabevariablen für S3-Aktionen](#reference-variables-output-S3)

#### CodePipeline Variable mit der Ausführungs-ID
<a name="w2aac64c33b7b9"></a>


**CodePipeline Ausführungs-ID-Variable**  

| Anbieter | Variablenschlüssel | Beispielwert | Beispiel für eine Variablensyntax | 
| --- | --- | --- | --- | 
| codepipeline | PipelineExecutionId | 8abc75f0-fbf8-4f4c-bfEXAMPLE | \$1\$1codepipeline.PipelineExecutionId\$1 | 

#### Ausgabevariablen für Amazon ECR-Aktionen
<a name="reference-variables-output-ECR"></a>


**Amazon ECR-Variablen**  

| Variablenschlüssel | Beispielwert | Beispiel für eine Variablensyntax | 
| --- | --- | --- | 
| ImageDigest | sha256: EXAMPLE1122334455 | \$1\$1SourceVariables.ImageDigest\$1 | 
| ImageTag | brandneue | \$1\$1SourceVariables.ImageTag\$1 | 
| ImageURI | 11111EXAMPLE.dkr.ecr.us-west-2.amazonaws.com/ecs-repo:latest | \$1\$1SourceVariables.ImageURI\$1 | 
| RegistryId | EXAMPLE12233 | \$1\$1SourceVariables.RegistryId\$1 | 
| RepositoryName | my-image-repo | \$1\$1SourceVariables.RepositoryName\$1 | 

#### CloudFormation StackSets Aktionsausgabevariablen
<a name="reference-variables-output-StackSets"></a>


**CloudFormation StackSets Variablen**  

| Variablenschlüssel | Beispielwert | Beispiel für eine Variablensyntax | 
| --- | --- | --- | 
| OperationId | 11111111-2bbb-111-2bbb-11111 Beispiel | \$1\$1DeployVariables.OperationId\$1 | 
| StackSetId | my-stackset:1111aaaa-1111-2222-2bbb-11111 Beispiel | \$1\$1DeployVariables.StackSetId\$1 | 

#### CodeCommit Aktionsausgabevariablen
<a name="reference-variables-output-CodeCommit"></a>


**CodeCommit Variablen**  

| Variablenschlüssel | Beispielwert | Beispiel für eine Variablensyntax | 
| --- | --- | --- | 
| AuthorDate | 2019-10-29T03:32:21Z | \$1\$1SourceVariables.AuthorDate\$1 | 
| BranchName | Entwicklung | \$1\$1SourceVariables.BranchName\$1 | 
| CommitId |  exampleb01f91b31  | \$1\$1SourceVariables.CommitId\$1 | 
| CommitMessage | Behebung eines Fehlers (maximale Größe 100 KB) | \$1\$1SourceVariables.CommitMessage\$1 | 
| CommitterDate | 2019-10-29T03:32:21Z | \$1\$1SourceVariables.CommitterDate\$1 | 
| RepositoryName | myCodeCommitRepo | \$1\$1SourceVariables.RepositoryName\$1 | 

#### CodeStarSourceConnection Aktionsausgabevariablen
<a name="reference-variables-output-CodeConnections"></a>

Die verfügbaren Ausgabevariablen hängen vom Triggertyp ab (Push, Pull-Request oder Tag). Variablen in der folgenden Tabelle, die als *Alle* gekennzeichnet sind, werden für jeden Triggertyp erzeugt. Variablen, die mit einem bestimmten Triggertyp gekennzeichnet sind, werden nur erzeugt, wenn die Pipeline-Ausführung durch diesen Trigger gestartet wird.


**`CodeStarSourceConnection`Variablen (Bitbucket Cloud GitHub, GitHub Enterprise Repository und GitLab .com)**  

| Variablenschlüssel | Beispielwert | Beispiel für eine Variablensyntax | Auslösertyp | 
| --- | --- | --- | --- | 
| AuthorDate | 2019-10-29T03:32:21Z | \$1\$1SourceVariables.AuthorDate\$1 | Alle | 
| AuthorDisplayName | Jane Doe | \$1\$1SourceVariables.AuthorDisplayName\$1 | Alle | 
| AuthorEmail | jane.doe@example.com | \$1\$1SourceVariables.AuthorEmail\$1 | Alle | 
| AuthorId | Janedoe | \$1\$1SourceVariables.AuthorId\$1 | Alle | 
| BranchName | Entwicklung | \$1\$1SourceVariables.BranchName\$1 | Drücken, Taggen | 
| CommitId | exampleb01f91b31 | \$1\$1SourceVariables.CommitId\$1 | Alle | 
| CommitMessage | Behebung eines Fehlers (maximale Größe 100 KB) | \$1\$1SourceVariables.CommitMessage\$1 | Alle | 
| ConnectionArn | arn:aws:codestar-verbindungen:region::connection/ account-id connection-id | \$1\$1SourceVariables.ConnectionArn\$1 | Alle | 
| DestinationBranchName | Haupt | \$1\$1SourceVariables.DestinationBranchName\$1 | Pull-Anforderung | 
| FullRepositoryName | Benutzername/ GitHubRepo | \$1\$1SourceVariables.FullRepositoryName\$1 | Alle | 
| ProviderType | GitHub | \$1\$1SourceVariables.ProviderType\$1 | Alle | 
| PullRequestId | 1 | \$1\$1SourceVariables.PullRequestId\$1 | Pull-Anforderung | 
| PullRequestTitle | Neues Feature hinzufügen | \$1\$1SourceVariables.PullRequestTitle\$1 | Pull-Anforderung | 
| SourceBranchName | Feature-Branch | \$1\$1SourceVariables.SourceBranchName\$1 | Pull-Anforderung | 
| TagName | v1.0.0 | \$1\$1SourceVariables.TagName\$1 | Markierung | 

#### GitHub Aktionsausgabevariablen (GitHub (über OAuth App) Aktion)
<a name="reference-variables-output-GitHub-version1"></a>


**GitHub Variablen GitHub (über OAuth App) Aktion)**  

| Variablenschlüssel | Beispielwert | Beispiel für eine Variablensyntax | 
| --- | --- | --- | 
| AuthorDate | 2019-10-29T03:32:21Z | \$1\$1SourceVariables.AuthorDate\$1 | 
| BranchName | Haupt | \$1\$1SourceVariables.BranchName\$1 | 
| CommitId |  exampleb01f91b31  | \$1\$1SourceVariables.CommitId\$1 | 
| CommitMessage |  Behebung eines Fehlers (maximale Größe 100 KB)  | \$1\$1SourceVariables.CommitMessage\$1 | 
| CommitterDate | 2019-10-29T03:32:21Z | \$1\$1SourceVariables.CommitterDate\$1 | 
| CommitUrl |  | \$1\$1SourceVariables.CommitUrl\$1 | 
| RepositoryName | myGitHubRepo | \$1\$1SourceVariables.RepositoryName\$1 | 

#### Ausgabevariablen für S3-Aktionen
<a name="reference-variables-output-S3"></a>


**S3-Variablen**  

| Variablenschlüssel | Beispielwert | Beispiel für eine Variablensyntax | 
| --- | --- | --- | 
| ETag | example28be1c3 | \$1\$1SourceVariables.ETag\$1 | 
| VersionId | Beispiel ta\$1 IUQCv | \$1\$1SourceVariables.VersionId\$1 | 

### Aktionen mit vom Benutzer konfigurierten Variablentasten
<a name="reference-variables-list-configured"></a>

Für CodeBuild CloudFormation, und Lambda-Aktionen werden die variablen Schlüssel vom Benutzer konfiguriert.

**Topics**
+ [CloudFormation Aktionsausgabevariablen](#w2aac64c33b9b7)
+ [CodeBuild Ausgabevariablen für Aktionen](#reference-variables-list-configured-codebuild)
+ [Ausgangsvariablen für Lambda-Aktionen](#w2aac64c33b9c11)

#### CloudFormation Aktionsausgabevariablen
<a name="w2aac64c33b9b7"></a>


**CloudFormation Variablen**  

| Variablenschlüssel | Beispiel für eine Variablensyntax | 
| --- | --- | 
| Bei CloudFormation Aktionen werden Variablen aus beliebigen Werten erzeugt, die im `Outputs` Abschnitt einer Stack-Vorlage angegeben sind. Beachten Sie, dass die einzigen CloudFormation Aktionsmodi, die Ausgaben generieren, diejenigen sind, die zur Erstellung oder Aktualisierung eines Stacks führen, wie z. B. die Erstellung von Stacks, Stack-Aktualisierungen und die Ausführung von Änderungssätzen. Die entsprechenden Aktionsmodi, die Variablen generieren, sind:[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/codepipeline/latest/userguide/reference-variables.html)Weitere Informationen zu diesen Aktionsmodi finden Sie unter[CloudFormation Aktionsreferenz bereitstellen](action-reference-CloudFormation.md). Ein Tutorial, das Ihnen zeigt, wie Sie eine Pipeline mit einer CloudFormation Bereitstellungsaktion in einer Pipeline erstellen, die CloudFormation Ausgabevariablen verwendet, finden Sie unter[Tutorial: Eine Pipeline erstellen, die Variablen aus AWS CloudFormation Bereitstellungsaktionen verwendet](tutorials-cloudformation-action.md). | \$1\$1DeployVariables.StackName\$1 | 

#### CodeBuild Ausgabevariablen für Aktionen
<a name="reference-variables-list-configured-codebuild"></a>


**CodeBuild Variablen**  

| Variablenschlüssel | Beispiel für eine Variablensyntax | 
| --- | --- | 
|  Bei CodeBuild Aktionen werden Variablen aus Werten erzeugt, die von exportierten Umgebungsvariablen generiert wurden. Richten Sie eine CodeBuild Umgebungsvariable ein, indem Sie Ihre CodeBuild Aktion in der Build-Spezifikation bearbeiten CodePipeline oder die Umgebungsvariable zur Build-Spezifikation hinzufügen. Fügen Sie Ihrer CodeBuild Build-Spezifikation Anweisungen hinzu, um die Umgebungsvariable im Abschnitt „Exportierte Variablen“ hinzuzufügen. *Weitere Informationen finden Sie unter [env/exported-variables](https://docs.aws.amazon.com/codebuild/latest/userguide/build-spec-ref.html#build-spec.env.exported-variables) im Benutzerhandbuch.AWS CodeBuild *  |  <pre>#{BuildVariables.EnvVar}</pre>  | 

#### Ausgangsvariablen für Lambda-Aktionen
<a name="w2aac64c33b9c11"></a>


**Lambda-Variablen**  

| Variablenschlüssel | Beispiel für eine Variablensyntax | 
| --- | --- | 
| [Die Lambda-Aktion erzeugt als Variablen alle Schlüssel-Wert-Paare, die im `outputVariables` Abschnitt der PutJobSuccessResult API-Anfrage enthalten sind.](https://docs.aws.amazon.com/codepipeline/latest/APIReference/API_PutJobSuccessResult.html) Ein Tutorial mit einer Lambda-Aktion, die Variablen aus einer Upstream-Aktion (CodeCommit) verwendet und Ausgabevariablen generiert, finden Sie unter[Tutorial: Variablen mit Lambda-Aufrufaktionen verwenden](tutorials-lambda-variables.md). | \$1\$1TestVariables.testRunId\$1 |