Variablenreferenz

Dieser Abschnitt dient nur als Referenz. Informationen zum Erstellen von Variablen finden Sie unter Arbeiten mit Variablen.

Mithilfe von Variablen können Sie Ihre Pipeline-Aktionen mit Werten konfigurieren, die zum Zeitpunkt der Pipeline-Ausführung oder der 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.

Beispiele für die Verwendung von Variablen finden Sie Schritt für Schritt:

Variablengrenzwerte

Informationen zu Grenzwerten finden Sie unter Kontingente in AWS CodePipeline.

Konzepte

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

Variablen

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, diese Variablen verfügbar zu machen:

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.

Namespaces

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:

Anwendungsfälle für Variablen

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önnen.

Konfigurieren von Variablen

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

Variablen auf Pipeline-Ebene konfigurieren

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.

Sie stellen Variablen auf Pipeline-Ebene mithilfe des Variablenattributs in der Pipeline-Struktur bereit. Im folgenden Beispiel Variable1 hat die Variable einen Wert vonValue1.

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

Ein Beispiel für die JSON-Struktur der Pipeline finden Sie unterErstellen Sie eine Pipeline, Stufen und Aktionen.

Ein Tutorial mit einer Variablen auf Pipeline-Ebene, die zum Zeitpunkt der Pipeline-Ausführung übergeben wird, finden Sie unter. Tutorial: Variablen auf Pipeline-Ebene verwenden

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

Variablen auf Aktionsebene konfigurieren

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:

In diesem Beispiel fügen Sie den namespace Parameter der CodeCommit Quellaktion mit dem Namen hinzuSourceVariables. 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:

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 #{SourceVariables.CommitId} 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

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 Aktion alle Variablenreferenzen auf, die in der Konfiguration vorhanden waren, bevor die Aktionsausführung initiiert wird.

Regeln für Variablen

Die folgenden Regeln helfen Ihnen bei der Konfiguration von Variablen:

Für Pipeline-Aktionen verfügbare Variablen

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

Schritt-für-Schritt-Verfahren zum Verwalten von Variablen finden Sie unter Arbeiten mit Variablen.

Aktionen mit definierten Variablenschlüsseln

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

Jede Ausführung hat auch eine Reihe von CodePipeline-generated Pipeline-Variablen, die Daten über die Ausführung enthalten, wie z. B. die Pipeline-Release-ID. Diese Variablen können von jeder Aktion in der Pipeline verbraucht werden.

CodePipeline Ausführungs-ID-Variable

Ausgabevariablen für Amazon ECR-Aktionen

CloudFormation StackSets Aktionsausgabevariablen

CodeCommit Aktionsausgabevariablen

CodeStarSourceConnection Aktionsausgabevariablen

Die verfügbaren Ausgabevariablen hängen vom Triggertyp ab (Push, Pull Request oder Tag). Die in der folgenden Tabelle als Alle markierten Variablen 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.

GitHub Aktion, Ausgabevariablen GitHub (über die OAuth-App), Aktion)

Ausgabevariablen für S3-Aktionen

Aktionen mit benutzerkonfigurierten Variablenschlüsseln

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

CloudFormation Ausgabevariablen für Aktionen

CodeBuild Ausgabevariablen für Aktionen

#{BuildVariables.EnvVar}

Ausgabevariablen für Lambda-Aktionen