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.
# Stufenvariablen für eine REST-API in API Gateway verwenden
Bei Stufenvariablen handelt es sich um Wert-Paare, die Sie als Konfigurationsattribute für eine REST-API-Bereitstellungsstufe definieren können. Sie weisen dasselbe Verhalten auf wie Umgebungsvariablen und können für die API-Einrichtung und Mapping-Vorlagen verwendet werden. Mit den Bereitstellungsstufen in API Gateway können Sie für jede API mehrere Freigabestufen verwalten. Über die Stufenvariablen können Sie eine API-Bereitstellungsstufe für die Interaktion mit verschiedenen Backend-Endpunkten konfigurieren.
Stage-Variablen sind nicht dazu gedacht, für sensible Daten wie Anmeldeinformationen verwendet zu werden. Verwenden Sie einen AWS Lambda Autorisierer, um sensible Daten an Integrationen weiterzugeben. Sie können sensible Daten an Integrationen in der Ausgabe des Lambda-Genehmigers übergeben. Weitere Informationen hierzu finden Sie unter [Ausgabe von einem API-Gateway-Lambda-Genehmiger](api-gateway-lambda-authorizer-output.md).
## Anwendungsfälle für Stufenvariablen
Im Folgenden sehen Sie Anwendungsfälle für Ihre Stufenvariablen.
**Geben Sie einen anderen Backend-Endpunkt an**
Ihre API kann beispielsweise eine `GET`-Anforderung als HTTP-Proxy an den Backend-Webhost übergeben. Mit einer Stufenvariable können Sie veranlassen, dass API Gateway `example.com` aufruft, wenn API-Aufrufer Ihren Produktionsendpunkt aufrufen. Wenn API-Aufrufer dann die Beta-Phase aufrufen, ruft API Gateway einen anderen Webhost auf, z. B. `beta.example.com`. Ebenso lässt sich über Stufenvariablen für jede Stufe Ihrer API ein anderer AWS Lambda -Funktionsname angeben. Sie können eine Stufenvariable nicht für die Festlegung eines anderen Integrationsendpunkts verwenden, z. B. um die `GET`-Anforderung auf eine HTTP-Proxyintegration in einer Stufe, und eine Lambda-Proxyintegration in einer anderen Stufe zu verweisen.
Wenn Sie einen Lambda-Funktionsnamen als Stufenvariablenwert angeben, müssen Sie die Berechtigungen für die Lambda-Funktion manuell konfigurieren. Wenn Sie eine Lambda-Funktion in der API Gateway Gateway-Konsole angeben, erscheint ein AWS CLI Befehl zur Konfiguration der richtigen Berechtigungen. Sie können dazu auch den folgenden AWS CLI Befehl verwenden.
```
aws lambda add-permission --function-name "arn:aws:lambda:us-east-2:123456789012:function:my-function" --source-arn "arn:aws:execute-api:us-east-2:123456789012:api_id/*/HTTP_METHOD/resource" --principal apigateway.amazonaws.com --statement-id apigateway-access --action lambda:InvokeFunction
```
**Informationen mithilfe von Zuweisungsvorlagen übergeben**
Sie können in den Zuweisungsvorlagen auf Stufenvariablen zugreifen oder Konfigurationsparameter an Ihr AWS Lambda oder das HTTP-Backend übergeben. Beispielsweise möchten Sie vielleicht die gleiche Lambda-Funktion für mehrere Stufen in Ihrer API verwenden, jedoch soll die Funktion abhängig von der aufgerufenen Stufe jeweils Daten aus einer anderen Amazon DynamoDB-Tabelle auslesen. In den Mapping-Vorlagen, von denen die Anforderung für die Lambda-Funktion generiert wird, können Sie den Tabellennamen mit Stufenvariablen an Lambda übergeben.
Eine Stufenvariable muss zunächst konfiguriert und dann muss dieser ein Wert zugewiesen werden, bevor Sie die Stufenvariable verwenden können. Um beispielsweise den HTTP-Integrationsendpunkt anzupassen, erstellen Sie zuerst die `url`-Stufenvariable und geben dann den Wert der Stufenvariablen (**http://\$1\$1stageVariables.url\$1**) in der Integrationsanforderung Ihrer API ein. Mit diesem Wert wird API Gateway angewiesen, die Stufenvariable `${}` zur Laufzeit abhängig von der ausgeführten API-Stufe zu ersetzen. Weitere Informationen finden Sie unter [Stufenvariablen für REST APIs in API Gateway einrichten](how-to-set-stage-variables-aws-console.md).
# Stufenvariablen für REST APIs in API Gateway einrichten
In diesem Abschnitt erfahren Sie, wie Sie mit der Amazon-API-Gateway-Konsole verschiedene Stufenvariablen für zwei Bereitstellungsstufen einer Beispiel-API einrichten. Für ein besseres Verständnis, wie Stufenvariablen in API Gateway verwendet werden, empfehlen wir, dass Sie alle Schritte in diesem Abschnitt befolgen.
## Voraussetzungen
Überprüfen Sie vor Beginn, ob die folgenden Anforderungen erfüllt sind:
+ Es muss eine API in API Gateway verfügbar sein. Folgen Sie den Anweisungen in [Entwickeln Sie REST APIs in API Gateway](rest-api-develop.md).
+ Sie müssen die API mindestens einmal bereitgestellt haben. Folgen Sie den Anweisungen in [REST-APIs in API Gateway bereitstellen](how-to-deploy-api.md).
+ Sie müssen die erste Stufe für eine bereitgestellte API erstellt haben. Folgen Sie den Anweisungen in [Erstellen einer neuen Stufe](set-up-stages.md#how-to-create-stage-console).
## Aufrufen eines HTTP-Endpunkts über eine API mit einer Stufenvariable
In diesem Verfahren wird beschrieben, wie Sie eine Stufenvariable für einen HTTP-Endpunkt und zwei Stufen für Ihre API erstellen. Darüber hinaus erstellen Sie die Stufenvariablen `url`, `stageName` und `function`, die in den folgenden Abläufen in diesem Abschnitt verwendet werden.
**Aufrufen eines HTTP-Endpunkts über eine API mit einer Stufenvariable**
1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).
1. Erstellen Sie eine API und anschließend eine `GET`-Methode für die Root-Ressource der API. Stellen Sie den Integrationstyp auf **HTTP** und die **Endpunkt-URL** auf **http://\$1\$1stageVariables.url\$1**.
1. Stellen Sie die API für eine neue Stufe namens **beta** bereit.
1. Wählen Sie im Navigationsbereich **Stages** (Stufen) die Stufe **beta**.
1. Wählen Sie auf der Registerkarte **Stage variables** (Stufenvariablen) die Option **Edit** (Bearbeiten) aus.
1. Wählen Sie **Add stage variable** (Stufenvariable hinzufügen).
1. Geben Sie unter **Name** **url** ein. Geben Sie für **Value** (Wert) **httpbin.org/get** ein.
1. Wählen Sie **Add stage variable** (Stufenvariable hinzufügen) und gehen Sie wie folgt vor:
Geben Sie unter **Name** **stageName** ein. Geben Sie für **Value** (Wert) **beta** ein.
1. Wählen Sie **Add stage variable** (Stufenvariable hinzufügen) und gehen Sie wie folgt vor:
Geben Sie unter **Name** **function** ein. Geben Sie für **Value** (Wert) **HelloWorld** ein.
1. Wählen Sie **Speichern**.
1. Erstellen Sie nun eine zweite Stufe. Wählen Sie im Navigationsbereich **Stages** (Stufen) die Option **Create stage** (Stufe erstellen). Geben Sie für **Stage name (Stufenname)** **prod** ein. Wählen Sie in **Deployment** (Bereitstellung) eine kürzlich ausgeführte Bereitstellung und anschließend **Create stage** (Stufe erstellen) aus.
1. Legen Sie wie im Fall der Phase **beta** die gleichen drei Stufenvariablen (**url**, **stageName** und **function**) auf unterschiedliche Werte fest („**petstore-demo-endpoint.execute-api.com/petstore/pets**“, „**prod**“ und „**HelloEveryone**“).
1. Wählen Sie im Navigationsbereich **Stages** **beta**. Wählen Sie unter **Stage details** (Stufendetails) das Kopiersymbol, um die Aufruf-URL Ihrer API zu kopieren, und geben Sie dann die Aufruf-URL Ihrer API in einen Webbrowser ein. Hierdurch wird die **beta**-Stufen-Anforderung `GET` für die Stammressource der API gestartet.
**Anmerkung**
Der Link **Invoke URL** verweist auf die Stammressource der API auf der **beta**-Stufe. Durch die Eingabe der URL in einem Webbrowser wird die **beta**-Stufenmethode `GET` für die Stammressource aufgerufen. Wenn Methoden für untergeordnete Ressourcen und nicht für die Stammressource selbst definiert sind, erhalten Sie bei der Eingabe der URL in einen Webbrowser die Fehlermeldung `{"message":"Missing Authentication Token"}`. In diesem Fall müssen Sie dem Link **Invoke URL** den Namen einer spezifischen untergeordneten Ressource anfügen.
1. Im Folgenden wird die Antwort angezeigt, die Sie von der **beta**-Stufen-Anforderung `GET` erhalten. Sie können das Ergebnis auch überprüfen, indem Sie in einem Browser zu **http://httpbin.org/get** navigieren. Dieser Wert wurde der `url`-Variablen in der **beta**-Stufe zugewiesen. Die beiden Antworten sind identisch.
1. Wählen Sie im Navigationsbereich **Stages** die Stufe **prod**. Wählen Sie unter **Stage details** (Stufendetails) das Kopiersymbol, um die Aufruf-URL Ihrer API zu kopieren, und geben Sie dann die Aufruf-URL Ihrer API in einen Webbrowser ein. Hierdurch wird die **prod**-Stufen-Anforderung `GET` für die Stammressource der API gestartet.
1. Im Folgenden wird die Antwort angezeigt, die Sie von der **prod**-Stufen-Anforderung `GET` erhalten. Sie können das Ergebnis überprüfen, indem Sie in einem Browser zu **http://.execute-api navigieren. petstore-demo-endpoint com/petstore/pets**. Dieser Wert wurde der `url`-Variablen in der **prod**-Stufe zugewiesen. Die beiden Antworten sind identisch.
## Übergabe phasenspezifischer Metadaten an ein HTTP-Backend
In diesem Verfahren wird beschrieben, wie stufenbezogene Metadaten mittels eines Stufenvariablenwerts in einem Abfrageparameterausdruck an ein HTTP-Backend übergeben werden. Hier verwenden wir die `stageName`-Stufenvariable, die im vorangegangenen Verfahren deklariert wurde.
**Übergabe phasenspezifischer Metadaten an ein HTTP-Backend**
1. Wählen Sie im Navigationsbereich **Resource** die Methode **GET**.
Um der URL der Methode einen Abfragezeichenfolge-Parameter hinzuzufügen, wählen Sie die Registerkarte **Method Request** (Methodenanforderung) und anschließend im Abschnitt **Method request settings** (Einstellungen der Methodenanforderung) die Option **Edit** (Bearbeiten).
1. Wählen Sie **URL query string parameters** (URL-Abfragezeichenfolgen-Parameter) und gehen Sie wie folgt vor:
1. Wählen Sie **Abfragezeichenfolge hinzufügen** aus.
1. Geben Sie unter **Name** **stageName** ein.
1. Lassen Sie die Optionen **Required** (Obligatorisch) and **Caching** (Cache) deaktiviert.
1. Wählen Sie **Speichern**.
1. Wählen Sie die Registerkarte **Integration request** (Integrationsanforderung) und dann im Abschnitt **Integration request settings** (Einstellungen für Integrationsanforderungen) die Option **Edit** (Bearbeiten) aus.
1. Fügen Sie bei **Endpoint URL** (Endpunkt-URL) den Wert **?stageName=\$1\$1stageVariables.stageName\$1** an den zuvor definierten URL-Wert an, damit die gesamte **Endpoint URL** (Endpunkt-URL) **http://\$1\$1stageVariables.url\$1?stageName=\$1\$1stageVariables.stageName\$1** lautet.
1. Wählen Sie **Deploy API** (API bereitstellen) und wählen Sie die Stufe **beta** aus.
1. Klicken Sie im Hauptnavigationsbereich auf **Stages** (Stufen). Wählen Sie im Navigationsbereich **Stages** **beta**. Wählen Sie unter **Stage details** (Stufendetails) das Kopiersymbol, um die Aufruf-URL Ihrer API zu kopieren, und geben Sie dann die Aufruf-URL Ihrer API in einen Webbrowser ein.
**Anmerkung**
Sie verwenden hier die beta-Stufe, da der HTTP-Endpunkt (von der `url`-Variable mit "http://httpbin.org/get" angegeben) Abfrageparameterausdrücke annimmt und diese in der Antwort als `args`-Objekt zurückgibt.
1. Sie erhalten die folgende Antwort. Beachten Sie, dass `beta` (zugeordnet zur `stageName`-Stufenvariable) als `stageName`-Argument an das Backend übergeben wird.
![\[Antwort der GET-Methode der API über einen HTTP-Endpunkt mit der url-Stufenvariable.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/stageVariables-new-console-invoke-beta-stage-with-url-and-stageName-response.png)
## Aufrufen einer Lambda-Funktion über eine API mit einer Stufenvariable
In diesem Verfahren wird beschrieben, wie Sie eine Stufenvariable verwenden, um eine Lambda-Funktion als Backend der API aufzurufen. Hier verwenden Sie die `function`-Stufenvariable, die in [Aufrufen eines HTTP-Endpunkts über eine API mit einer Stufenvariable](#how-to-set-stage-variables-aws-console-http-endpoint) deklariert wurde.
Wenn Sie eine Lambda-Funktion als Wert einer Stufenvariable festlegen, verwenden Sie den lokalen Namen der Funktion und binden den Alias oder die Versionsangabe ein, z. B. **HelloWorld**, **HelloWorld:1** oder **HelloWorld:alpha**. Nutzen Sie nicht den ARN der Funktion (z. B, **arn:aws:lambda:us-east-1:123456789012:function:HelloWorld**). Die API Gateway-Konsole betrachtet den Stufenvariablenwert einer Lambda-Funktion als unvollständigen Funktionsnamen und erweitert die Stufenvariable zu einem ARN.
**Aufrufen einer Lambda-Funktion über eine API mit einer Stufenvariable**
1. Erstellen Sie eine Lambda-Funktion namens **HelloWorld** mit der Laufzeit Node.js. Der Code muss Folgendes enthalten:
```
export const handler = function(event, context, callback) {
if (event.stageName)
callback(null, 'Hello, World! I\'m calling from the ' + event.stageName + ' stage.');
else
callback(null, 'Hello, World! I\'m not sure where I\'m calling from...');
};
```
Weitere Informationen zum Erstellen einer Lambda-Funktion finden Sie unter [Erste Schritte mit der REST-API-Konsole](getting-started-rest-new-console.md#getting-started-rest-new-console-create-function).
1. Wählen Sie im Bereich **Ressources** (Ressourcen) die Option **Create resource** (Ressource erstellen) aus, und gehen Sie dann wie folgt vor:
1. Wählen Sie für **Resource path** (Ressourcenpfad) die Option**/**aus.
1. Geben Sie für **Resource name (Ressourcenname)** **lambdav1** ein.
1. Wählen Sie **Create Resource** (Ressource erstellen) aus.
1. Wählen Sie die **/lambdav1**-Ressource aus und klicken Sie dann auf **Methode erstellen**.
Führen Sie dann die folgenden Schritte aus:
1. Wählen Sie als **Methodentyp** die Option **GET** (Abrufen) aus.
1. Wählen Sie für den **Integration type** (Integrationstyp) die Option **Lambda function** (Lambda-Funktion) aus.
1. Lassen Sie **Lambda proxy integration** (Lambda-Proxyintegration) deaktiviert.
1. Geben Sie für die **Lambda function (Lambda-Funktion)** `${stageVariables.function}` ein.
![\[Erstellen einer GET-Methode, die in eine Lambda-Funktion integriert ist (wie festgelegt über die function-Stufenvariable)\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/stageVariables-new-console-create-lambda-get-method.png)
**Tipp**
Wenn Sie zur Eingabe des **Berechtigungsbefehl hinzufügen** aufgefordert werden, kopieren Sie den [add-permission](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html)-Befehl. Sie müssen den Befehl für jede Lambda-Funktion ausführen, die der `function`-Stufenvariable zugewiesen werden soll. Wenn der `$stageVariables.function`-Wert beispielsweise `HelloWorld` lautet, führen Sie den folgenden AWS CLI -Befehl aus:
```
aws lambda add-permission --function-name arn:aws:lambda:us-east-1:account-id:function:HelloWorld --source-arn arn:aws:execute-api:us-east-1:account-id:api-id/*/GET/lambdav1 --principal apigateway.amazonaws.com --statement-id statement-id-guid --action lambda:InvokeFunction
```
Falls das nicht geschieht, führt der Aufruf der Methode zur Fehlermeldung `500 Internal Server Error`. Ersetzen Sie `${stageVariables.function}` durch den Lambda-Funktionsnamen, der dieser Stufenvariable zugeordnet ist.
![\[AWS CLI Befehl, um der Lambda-Funktion die Erlaubnis zu geben, von der von Ihnen erstellten Methode aufgerufen zu werden.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/stageVariables-new-console-add-permission-to-lambda-function.png)
1. Wählen Sie **Methode erstellen** aus.
1. Stellen Sie die API in den Stufen **prod** und **beta** bereit.
1. Klicken Sie im Hauptnavigationsbereich auf **Stages** (Stufen). Wählen Sie im Navigationsbereich **Stages** **beta**. Wählen Sie unter **Stage details** (Stufendetails) das Kopiersymbol, um die Aufruf-URL Ihrer API zu kopieren, und geben Sie dann die Aufruf-URL Ihrer API in einen Webbrowser ein. Hängen Sie **/lambdav1** an die URL an, bevor Sie die Eingabetaste drücken.
Sie erhalten die folgende Antwort.
```
"Hello, World! I'm not sure where I'm calling from..."
```
## Übergeben von stufenbezogenen Metadaten an eine Lambda-Funktion über eine Stufenvariable
In diesem Verfahren wird beschrieben, wie stufenbezogene Konfigurationsmetadaten mittels einer Stufenvariable an eine Lambda-Funktion übergeben werden. Erstellen Sie eine `POST`-Methode und eine Eingabe-Mapping-Vorlage, um Nutzlast mit der zuvor deklarierten `stageName`-Stufenvariable zu generieren.
**Übergeben von stufenbezogenen Metadaten an eine Lambda-Funktion über eine Stufenvariable**
1. Wählen Sie die **/lambdav1**-Ressource aus und klicken Sie dann auf **Methode erstellen**.
Führen Sie dann die folgenden Schritte aus:
1. Wählen Sie unter **Method type** (Methodentyp) die Option **POST** aus.
1. Wählen Sie für den **Integration type** (Integrationstyp) die Option **Lambda function** (Lambda-Funktion) aus.
1. Lassen Sie **Lambda proxy integration** (Lambda-Proxyintegration) deaktiviert.
1. Geben Sie für die **Lambda function (Lambda-Funktion)** `${stageVariables.function}` ein.
1. Wenn Sie zur Eingabe des **Berechtigungsbefehl hinzufügen** aufgefordert werden, kopieren Sie den [add-permission](https://docs.aws.amazon.com/cli/latest/reference/lambda/add-permission.html)-Befehl. Sie müssen den Befehl für jede Lambda-Funktion ausführen, die der `function`-Stufenvariable zugewiesen werden soll.
1. Wählen Sie **Methode erstellen** aus.
1. Wählen Sie die Registerkarte **Integration request** (Integrationsanforderung) und dann im Abschnitt **Integration request settings** (Einstellungen für Integrationsanforderungen) die Option **Edit** (Bearbeiten) aus.
1. Wählen Sie **Mapping-Vorlagen** aus und klicken Sie dann auf **Mapping-Vorlage hinzufügen**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
1. Geben Sie für **Template body** (Vorlagentext) die folgende Vorlage ein:
```
#set($inputRoot = $input.path('$'))
{
"stageName" : "$stageVariables.stageName"
}
```
**Anmerkung**
In einer Mapping-Vorlage muss eine Stufenvariable in Anführungszeichen (wie in `"$stageVariables.stageName"` oder `"${stageVariables.stageName}"`) referenziert werden. An anderen Stellen muss sie ohne Anführungszeichen (wie in ) referenziert werd `${stageVariables.function}`).
1. Wählen Sie **Speichern**.
1. Stellen Sie die API in den Stufen **beta** und **prod** bereit.
1. Gehen Sie wie folgt vor, um einen REST-API-Client zum Übergeben von stufenspezifischen Metadaten zu verwenden:
1. Wählen Sie im Navigationsbereich **Stages** **beta**. Wählen Sie unter **Stage details** (Stufendetails) das Kopiersymbol, um die Aufruf-URL Ihrer API zu kopieren, und geben Sie dann die Aufruf-URL Ihrer API in das Eingabefeld eines REST-API-Clients ein. Hängen Sie **/lambdav1** an, bevor Sie Ihre Anfrage absenden.
Sie erhalten die folgende Antwort.
```
"Hello, World! I'm calling from the beta stage."
```
1. Wählen Sie im Navigationsbereich **Stages** (Stufen) die Option **prod**. Wählen Sie unter **Stage details** (Stufendetails) das Kopiersymbol, um die Aufruf-URL Ihrer API zu kopieren, und geben Sie dann die Aufruf-URL Ihrer API in das Eingabefeld eines REST-API-Clients ein. Hängen Sie **/lambdav1** an, bevor Sie Ihre Anfrage absenden.
Sie erhalten die folgende Antwort.
```
"Hello, World! I'm calling from the prod stage."
```
1. Gehen Sie wie folgt vor, um die Funktion **Test** zum Übergeben von stufenspezifischen Metadaten zu verwenden:
1. Wählen Sie im Navigationsbereich **Resources** (Ressourcen) die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Geben Sie für **function** **HelloWorld** ein.
1. Geben Sie für **stageName** **beta** ein.
1. Wählen Sie **Test** aus. Sie müssen Ihrer `POST`-Anfrage keinen Text hinzufügen.
Sie erhalten die folgende Antwort.
```
"Hello, World! I'm calling from the beta stage."
```
1. Sie können die vorherigen Schritte wiederholen, um die **Prod**-Stufe zu testen. Geben Sie für **stageName** **Prod** ein.
Sie erhalten die folgende Antwort.
```
"Hello, World! I'm calling from the prod stage."
```
# API Gateway-Stufenvariablenreferenz für REST APIs in API Gateway
Sie können die API Gateway-Stufenvariablen in folgenden Fällen verwenden.
## Parameter-Mapping-Ausdrücke
Eine Stufenvariable kann in einem Parameter-Mapping-Ausdruck für den Header-Parameter einer API-Methodenanforderung oder -antwort genutzt werden, und zwar ohne Teilsubstitution. Im folgenden Beispiel wird die Stufenvariable ohne `$` und umschließende `{...}` referenziert.
+ `stageVariables.`
## Mapping-Vorlagen
Eine Stufenvariable kann überall in einer Mapping-Vorlage verwendet werden, wie in den folgenden Beispielen dargestellt.
+ `{ "name" : "$stageVariables."}`
+ `{ "name" : "${stageVariables.}"}`
## HTTP-Integration URIs
Eine Stufenvariable kann als Teil einer HTTP-Integrations-URL verwendet werden, wie in den folgenden Beispielen dargestellt:
+ Eine vollständige URI ohne Protokoll – `http://${stageVariables.}`
+ Eine vollständige Domäne – `http://${stageVariables.}/resource/operation`
+ Eine Unterdomäne – `http://${stageVariables.}.example.com/resource/operation`
+ Ein Pfad – `http://example.com/${stageVariables.}/bar`
+ Eine Abfragezeichenfolge – `http://example.com/foo?q=${stageVariables.}`
## AWS Integration URIs
Eine Stufenvariable kann als Teil von AWS URI-Aktions- oder Pfadkomponenten verwendet werden, wie im folgenden Beispiel gezeigt.
+ `arn:aws:apigateway:::${stageVariables.}`
## AWS Integration URIs (Lambda-Funktionen)
Eine Stufenvariable kann anstelle des Lambda-Funktionsnamens (oder Version/Alias) verwendet werden, wie in den folgenden Beispielen dargestellt.
+ `arn:aws:apigateway::lambda:path/2015-03-31/functions/arn:aws:lambda:::function:${stageVariables.}/invocations`
+ `arn:aws:apigateway::lambda:path/2015-03-31/functions/arn:aws:lambda:::function::${stageVariables.}/invocations`
**Anmerkung**
Um eine Stufenvariable für eine Lambda-Funktion zu verwenden, muss sich die Funktion im selben Konto wie die API befinden. Stufenvariablen unterstützen keine kontoübergreifenden Lambda-Funktionen.
## Amazon-Cognito-Benutzerpool
Eine Stufenvariable kann anstelle eines Amazon-Cognito-Benutzerpools für einen `COGNITO_USER_POOLS`-Genehmiger verwendet werden.
+ `arn:aws:cognito-idp:::userpool/${stageVariables.}`
## AWS Anmeldeinformationen für die Integration
Eine Stufenvariable kann als Teil des ARN für AWS Benutzer-/Rollenanmeldedaten verwendet werden, wie im folgenden Beispiel gezeigt.
+ `arn:aws:iam:::${stageVariables.}`