Variablen-Referenz

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

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.

Um step-by-step Beispiele für die Verwendung von Variablen zu sehen:

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, wie diese Variablen verfügbar gemacht werden können:

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

Konfigurieren von Variablen

Sie können Variablen auf Pipeline-Ebene 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 Variablen-Attributs in der Pipeline-Struktur bereit. Im folgenden Beispiel Variable1 hat die Variable den WertValue1.

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

Ein Beispiel für die JSON-Struktur der Pipeline finden Sie unterEine Pipeline, Phasen und Aktionen erstellen.

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

Beachten Sie, dass die Verwendung von Variablen auf Pipeline-Ebene in jeder Art von Quellaktion 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 der CodeCommit Quellaktion den namespace Parameter 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 aufwändigen Aktion alle Variablenverweise auf, die in der Konfiguration vorhanden sind, bevor die Ausführung der Aktion 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.

step-by-stepVerfahren zur Verwaltung von Variablen finden Sie unter. Arbeiten mit Variablen

Aktionen mit definierten Variablenschlüsseln

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.

CodePipeline Variable mit der Ausführungs-ID

Ausgabevariablen für Amazon ECR-Aktionen

AWS CloudFormation StackSets Aktionsausgabevariablen

CodeCommit Aktionsausgabevariablen

CodeStarSourceConnection Aktionsausgabevariablen

GitHub Aktionsausgabevariablen (GitHub (über OAuth App) Aktion)

Ausgabevariablen für S3-Aktionen

Aktionen mit vom Benutzer konfigurierten Variablentasten

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

CloudFormation Aktionsausgabevariablen

CodeBuild Ausgabevariablen für Aktionen

#{BuildVariables.EnvVar}

Ausgangsvariablen für Lambda-Aktionen