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: Erstellen Sie eine Rechner-REST-API mit zwei AWS Serviceintegrationen und einer Lambda-Non-Proxy-Integration
Das [Tutorial: Erstellen einer REST-API mit einer Lambda-Nicht-Proxy-Integration](getting-started-lambda-non-proxy-integration.md) verwendet ausschließlich `Lambda Function`-Integration. Die `Lambda Function`-Integration ist ein Sonderfall des `AWS Service`-Integrationstyps, der einen Großteil der Integrationseinrichtung für Sie durchführt, z. B. das automatische Hinzufügen der erforderlichen ressourcenbasierten Berechtigungen zum Aufrufen der Lambda-Funktion. Hier wird bei zwei der drei Integrationen die `AWS Service`-Integration verwendet. Bei diesem Integrationstyp haben Sie mehr Kontrolle, aber Sie müssen bestimmte Aufgaben manuell ausführen. Hierzu gehört z. B. das Erstellen und Angeben einer IAM-Rolle mit entsprechenden Berechtigungen.
In diesem Tutorial erstellen Sie eine `Calc`-Lambda-Funktion, die grundlegende Rechenoperationen implementiert und dabei Ein- und Ausgaben im JSON-Format annimmt und zurückgibt. Dann erstellen Sie eine REST-API und integrieren sie mit der Lambda-Funktion auf folgende Weise:
1. Verwenden einer `GET`-Methode für die `/calc`-Ressource, um die Lambda-Funktion aufzurufen, wobei die Eingabe als Abfragezeichenfolge-Parameter übergeben wird. (`AWS Service`-Integration)
1. Verwenden einer `POST`-Methode für die `/calc`-Ressource, um die Lambda-Funktion aufzurufen, wobei die Eingabe in der Methodenanforderungsnutzlast übergeben wird. (`AWS Service`-Integration)
1. Verwenden einer `GET`-Methode für verschachtelte `/calc/{operand1}/{operand2}/{operator}`-Ressourcen, um die Lambda-Funktion aufzurufen, wobei die Eingabe als Pfadparameter übergeben wird. (`Lambda Function`-Integration)
Über dieses Tutorial hinaus steht die [OpenAPI-Definitionsdatei](api-as-lambda-proxy-export-swagger-with-extensions.md) für die `Calc`-API, die Sie in API Gateway importieren können, bereit. Befolgen Sie dazu die Anweisungen in [Entwickeln APIs Sie REST mit OpenAPI in API Gateway](api-gateway-import-api.md).
**Topics**
+ [Übernehmbare IAM-Rolle erstellen](#api-as-lambda-proxy-setup-iam-role-policies)
+ [Erstellen einer `Calc`-Lambda-Funktion](#api-as-lambda-proxy-create-lambda-function)
+ [`Calc` Lambda-Funktion testen](#api-as-lambda-proxy-test-lambda-function-)
+ [Erstellen einer `Calc`-API](#api-as-lambda-proxy-create-api-resources)
+ [Integration 1: Erstellen Sie eine `GET`-Methode mit Abfrageparametern, um die Lambda-Funktion aufzurufen](#api-as-lambda-proxy-expose-get-method-with-query-strings-to-call-lambda-function)
+ [Integration 2: Erstellen Sie eine `POST`-Methode mit einem JSON-Payload für den Aufruf der Lambda-Funktion](#api-as-lambda-proxy-expose-post-method-with-json-body-to-call-lambda-function)
+ [Integration 3: Erstellen Sie eine `GET`-Methode mit Pfadparametern für den Aufruf der Lambda-Funktion](#api-as-lambda-proxy-expose-get-method-with-path-parameters-to-call-lambda-function)
+ [OpenAPI-Definitionen der mit einer Lambda-Funktion integrierten Beispiel-API](api-as-lambda-proxy-export-swagger-with-extensions.md)
## Übernehmbare IAM-Rolle erstellen
Damit Ihre API Ihre `Calc` Lambda-Funktion aufrufen kann, benötigen Sie eine IAM-Rolle, die von API Gateway übernommen werden kann, d. h. eine IAM-Rolle mit der folgenden vertrauenswürdigen Beziehung:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "apigateway.amazonaws.com"
},
"Action": "sts:AssumeRole"
}
]
}
```
------
Die Rolle, die Sie erstellen, benötigt eine [InvokeFunction](https://docs.aws.amazon.com/lambda/latest/api/API_Invoke.html)Lambda-Berechtigung. Andernfalls erhält der API-Aufrufer eine `500 Internal Server Error`-Antwort. Um der Rolle diese Berechtigung zu erteilen, hängen ihr die folgende IAM-Richtlinie an:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
Gehen Sie hierzu folgendermaßen vor:
**API Gateway erstellen, das die IAM-Rolle übernimmt**
1. Melden Sie sich bei der IAM-Konsole an.
1. Wählen Sie **Roles**.
1. Wählen Sie **Create Role** aus.
1. Wählen Sie unter **Select type of trusted entity** (Typ der vertrauenswürdigen Entität auswählen) die Option **AWS Service** aus.
1. Wählen Sie unter **Choose the service that will use this role** (Die Rolle auswählen, die diese Rollen verwenden wird) die Option **Lambda** aus.
1. Wählen Sie **Next: Permissions** aus.
1. Wählen Sie **Create Policy (Richtlinie erstellen)** aus.
Ein neues **Create Policy** Konsolen-Fenster wird geöffnet. Führen Sie in diesem Fenster folgende Schritte aus:
1. Ersetzen Sie auf der Registerkarte **JSON** die vorhandene Richtlinie durch Folgendes:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "lambda:InvokeFunction",
"Resource": "*"
}
]
}
```
------
1. Wählen Sie **Review policy (Richtlinie prüfen)** aus.
1. Gehen Sie unter **Review Policy** wie folgt vor:
1. Geben Sie unter **Name** einen Namen wie **lambda\$1execute** ein.
1. Wählen Sie **Create Policy (Richtlinie erstellen)** aus.
1. Führen Sie im ursprünglichen Konsolen-Fenster **Create Role** Folgendes aus:
1. Wählen Sie unter **Attach permissions policies (Berechtigungsrichtlinien hinzufügen)**, wählen die **lambda\$1execute** Richtlinie aus der Dropdown-Liste aus.
Wenn Ihre Richtlinie nicht in der Liste angezeigt wird, wählen Sie die Schaltfläche "Aktualisieren" oben in der Liste aus. (Aktualisieren Sie nicht die Browserseite\$1)
1. Wählen Sie **Next: Tags (Weiter: Tags)** aus.
1. Klicken Sie auf **Weiter: Prüfen**.
1. Geben Sie unter **Role name** einen Namen wie **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** ein.
1. Wählen Sie **Create role** aus.
1. Wählen Sie Ihre **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** aus der Rollen-Liste aus.
1. Wählen Sie die Registerkarte **Trust relationships (Vertrauensstellungen)**.
1. Wählen Sie **Edit Trust Relationship (Vertrauensstellungen bearbeiten)**.
1. Ersetzen Sie die vorhandene Richtlinie durch Folgendes:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"lambda.amazonaws.com",
"apigateway.amazonaws.com"
]
},
"Action": "sts:AssumeRole"
}
]
}
```
------
1. Wählen Sie **Update Trust Policy**.
1. Notieren Sie sich die Rolle ARN für die Rolle, die Sie gerade erstellt haben. Sie benötigen sie zu einem späteren Zeitpunkt.
## Erstellen einer `Calc`-Lambda-Funktion
Als Nächstes erstellen Sie eine Lambda-Funktion unter Verwendung der Lambda-Konsole.
1. Wählen Sie in der Lambda-Konsole **Create function (Funktion erstellen)**.
1. Wählen Sie **Author from scratch** aus.
1. Geben Sie als **Name** die Zeichenfolge „**Calc**“ ein.
1. Wählen Sie für **Laufzeit** die neueste unterstützte **Node.js**- oder **Python**-Laufzeit aus.
1. Verwenden Sie die Standardeinstellung für alle anderen Optionen.
1. Wählen Sie **Funktion erstellen**.
1. Kopieren Sie die folgende Lambda-Funktion in Ihre bevorzugte Laufzeit und fügen Sie sie in den Code-Editor in der Lambda-Konsole ein.
------
#### [ Node.js ]
```
export const handler = async function (event, context) {
console.log("Received event:", JSON.stringify(event));
if (
event.a === undefined ||
event.b === undefined ||
event.op === undefined
) {
return "400 Invalid Input";
}
const res = {};
res.a = Number(event.a);
res.b = Number(event.b);
res.op = event.op;
if (isNaN(event.a) || isNaN(event.b)) {
return "400 Invalid Operand";
}
switch (event.op) {
case "+":
case "add":
res.c = res.a + res.b;
break;
case "-":
case "sub":
res.c = res.a - res.b;
break;
case "*":
case "mul":
res.c = res.a * res.b;
break;
case "/":
case "div":
if (res.b == 0) {
return "400 Divide by Zero";
} else {
res.c = res.a / res.b;
}
break;
default:
return "400 Invalid Operator";
}
return res;
};
```
------
#### [ Python ]
```
import json
def lambda_handler(event, context):
print(event)
try:
(event['a']) and (event['b']) and (event['op'])
except KeyError:
return '400 Invalid Input'
try:
res = {
"a": float(
event['a']), "b": float(
event['b']), "op": event['op']}
except ValueError:
return '400 Invalid Operand'
if event['op'] == '+':
res['c'] = res['a'] + res['b']
elif event['op'] == '-':
res['c'] = res['a'] - res['b']
elif event['op'] == '*':
res['c'] = res['a'] * res['b']
elif event['op'] == '/':
if res['b'] == 0:
return '400 Divide by Zero'
else:
res['c'] = res['a'] / res['b']
else:
return '400 Invalid Operator'
return res
```
------
1. Wählen Sie unter "Ausführungsrolle" **Choose an existing role (Wählen Sie eine vorhandene Rolle aus)** aus.
1. Geben Sie den Rollen-ARN für die zuvor erstellte **lambda\$1invoke\$1function\$1assume\$1apigw\$1role**-Rolle ein.
1. Wählen Sie **Deploy (Bereitstellen)** aus.
Diese Funktion erfordert zwei Operanden (`a` und `b`) und einen Operator (`op`) aus dem Eingabeparameter `event`. Die Eingabe ist ein JSON-Objekt im folgenden Format:
```
{
"a": "Number" | "String",
"b": "Number" | "String",
"op": "String"
}
```
Diese Funktion gibt das berechnete Ergebnis (`c`) und die Eingabe zurück. Im Falle einer ungültigen Eingabe gibt die Funktion entweder den Wert null (0) oder die Zeichenfolge "Invalid op" als Ergebnis zurück. Die Ausgabe erfolgt im folgenden JSON-Format:
```
{
"a": "Number",
"b": "Number",
"op": "String",
"c": "Number" | "String"
}
```
Testen Sie die Funktion in der Lambda-Konsole, bevor Sie diese im nächsten Schritt in die API integrieren.
## `Calc` Lambda-Funktion testen
Hier erfahren Sie, wie Sie Ihre `Calc` Funktion in der Lambda-Konsole testen können:
1. Wählen Sie die Registerkarte **Test**.
1. Geben Sie für den Testereignisnamen ei **calc2plus5**.
1. Ersetzen Sie die Testereignisdefinition durch Folgendes:
```
{
"a": "2",
"b": "5",
"op": "+"
}
```
1. Wählen Sie **Save (Speichern)** aus.
1. Wählen Sie **Test** aus.
1. Erweitern Sie **Execution result: succeeded (Ausführungsergebnis: erfolgreich)**. Sie sollten Folgendes sehen:
```
{
"a": 2,
"b": 5,
"op": "+",
"c": 7
}
```
## Erstellen einer `Calc`-API
Das folgende Verfahren zeigt, wie Sie eine API für die gerade erstellte `Calc` Lambda-Funktion erstellen. In den folgenden Abschnitten fügen Sie dieser Ressourcen und Methoden hinzu.
**So erstellen Sie eine API**
1. Melden Sie sich bei der API Gateway Gateway-Konsole unter [https://console.aws.amazon.com/apigatewayan](https://console.aws.amazon.com/apigateway).
1. Wenn Sie API Gateway zum ersten Mal verwenden, sehen Sie eine Seite, die Sie mit den Funktionen des Service vertraut macht. Wählen Sie unter **REST-API** die Option **Erstellen** aus. Wenn das Popup-Fenster **Create Example API (Beispiel-API erstellen)** angezeigt wird, klicken Sie auf **OK**.
Wenn Sie API Gateway nicht zum ersten Mal verwenden, wählen Sie **Create API (API erstellen)**. Wählen Sie unter **REST-API** die Option **Build (Erstellen)** aus.
1. Geben Sie in **API name** (API-Name) **LambdaCalc** ein.
1. (Optional) Geben Sie unter **Description (Beschreibung)** eine Beschreibung ein.
1. Lassen Sie die Einstellung für **API-Endpunkttyp** bei **Regional**.
1. Wählen Sie als **IP-Adresstyp** die Option. **IPv4**
1. Wählen Sie **Create API (API erstellen)** aus.
## Integration 1: Erstellen Sie eine `GET`-Methode mit Abfrageparametern, um die Lambda-Funktion aufzurufen
Durch Erstellen einer `GET`-Methode, die Abfragezeichenfolgenparameter an die Lambda-Funktion übergibt, wird das Aufrufen der API über einen Browser aktiviert. Dieser Ansatz kann nützlich sein, insbesondere für solche APIs , die offenen Zugriff ermöglichen.
Nachdem Sie eine API erstellt haben, können Sie nun eine Ressource erstellen. In der Regel werden API-Ressourcen in einer Ressourcenstruktur organisiert, die der Anwendungslogik entspricht. In diesem Schritt erstellen Sie eine **/calc**-Ressource.
**So erstellen Sie eine **/calc**-Ressource**
1. Wählen Sie **Create Resource** (Ressource erstellen) aus.
1. Die **Proxy-Ressource** bleibt ausgeschaltet.
1. **Ressourcenpfad** wird als `/` beibehalten.
1. Geben Sie für **Resource name (Ressourcenname)** **calc** ein.
1. **CORS (Cross Origin Resource Sharing)** bleibt ausgeschaltet.
1. Wählen Sie **Create Resource** (Ressource erstellen) aus.
Durch Erstellen einer `GET`-Methode, die Abfragezeichenfolgenparameter an die Lambda-Funktion übergibt, wird das Aufrufen der API über einen Browser aktiviert. Dieser Ansatz kann sich als nützlich erweisen, insbesondere für solche APIs , die einen offenen Zugang ermöglichen.
Bei dieser Methode muss die `POST`-Anforderung verwendet wird, um eine Lambda-Funktion aufzurufen. Das Beispiel verdeutlicht, dass die HTTP-Methoden einer Frontend-Methodenanforderung und einer Backend-Integrationsanforderung unterschiedlich sein können.
**So erstellen Sie eine `GET`-Methode**
1. Wählen Sie die **/calc**-Ressource und klicken Sie dann auf **Methode erstellen**.
1. Wählen Sie als **Methodentyp** die Option **GET** (Abrufen) aus.
1. Für **Integrationstyp** wählen Sie **AWS-Service** aus.
1. Wählen Sie für den AWS-Region Ort aus **AWS-Region**, an dem Sie Ihre Lambda-Funktion erstellt haben.
1. Wählen Sie für **AWS-Service** **Lambda** aus.
1. Lassen Sie die **AWS -Subdomain** leer.
1. Wählen Sie für **HTTP-Methode** **POST** aus.
1. Wählen Sie für **Aktionstyp** **Pfadüberschreibung verwenden** aus. Mit dieser Option wird der ARN der [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html)-Aktion für die Ausführung der `Calc`-Funktion angegeben.
1. Geben Sie für **Pfadüberschreibung** **2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations** ein. Geben Sie für ** *account-id*** Ihre AWS-Konto ID ein. Geben Sie für den Ort ein***us-east-2***, AWS-Region an dem Sie Ihre Lambda-Funktion erstellt haben.
1. Geben Sie für **Ausführungsrolle** den Rollen-ARN für **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** ein.
1. Die Einstellungen für **Credential-Cache** und **Standard-Timeout** bleiben unverändert.
1. Klicken Sie auf **Einstellungen für Methodenanfragen**.
1. Wählen Sie für **Anforderungs-Validator** die Option **Abfragezeichenfolgeparameter und -Header validieren** aus.
Mit dieser Einstellung wird eine Fehlermeldung zurückgegeben, falls der Client die erforderlichen Parameter nicht vorgibt.
1. Klicken Sie auf **Parameter für URL-Abfragezeichenfolgen**.
Jetzt können Sie Parameter für die Abfrageeichenfolgen der **GET**-Methode in der **/calc**-Ressource einrichten sodass diese Eingaben im Namen der Backend-Lambda-Funktion empfangen kann.
Gehen Sie wie folgt vor, um die Parameter für die Abfragezeichenfolge zu erstellen:
1. Wählen Sie **Abfragezeichenfolge hinzufügen** aus.
1. Geben Sie unter **Name** **operand1** ein.
1. Aktivieren Sie die Option **Erforderlich**.
1. **Caching** bleibt ausgeschaltet.
Wiederholen Sie die obigen Schritte und erstellen Sie eine Abfragezeichenfolge mit dem Namen **operand2** sowie eine Abfragezeichenfolge mit dem Namen **operator**.
1. Wählen Sie **Methode erstellen** aus.
Als Nächstes erstellen Sie eine Zuordnungsvorlage, um die vom Client bereitgestellten Abfragezeichenfolgen wie für die `Calc`-Funktion erforderlich in die Integrationsanforderungs-Nutzlast zu übersetzen. Diese Vorlage weist die drei in **Method Request (Methodenanfrage)** deklarierten Abfragezeichenfolge-Parameter in entsprechende Eigenschaftswerte des JSON-Objekts um, das als Eingabe für die Lambda-Funktion im Backend dient. Das umgewandelte JSON-Objekt wird als Nutzlast der Integrationsanforderung eingebunden.
**Zuordnen von Eingabeparametern zur Integrationsanforderung**
1. Klicken Sie auf der Registerkarte **Integrationsanfrage** unter **Einstellungen für Integrationsanfragen** auf **Bearbeiten**.
1. Wählen Sie für **Anforderungstext-Pass-Through** die Option **Wenn keine Vorlagen definiert sind (empfohlen)** aus.
1. Wählen Sie **Zuordnungsvorlagen** aus.
1. Wählen Sie **Add mapping template**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
1. Geben Sie für **Vorlagentext** den folgenden Code ein:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": "$input.params('operator')"
}
```
1. Wählen Sie **Speichern**.
Sie können nun Ihre `GET`-Methode testen, um zu verifizieren, dass sie korrekt für einen Lambda-Funktionsaufruf eingerichtet wurde.
**So testen Sie die `GET`-Methode**
1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Für **Abfrage-Zeichenketten** geben Sie **operand1=2&operand2=3&operator=\$1** ein.
1. Wählen Sie **Test** aus.
Die Ergebnisse sollten in etwa wie folgt aussehen:
![\[API in API Gateway als Lambda-Proxy erstellen\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_new_console.png)
## Integration 2: Erstellen Sie eine `POST`-Methode mit einem JSON-Payload für den Aufruf der Lambda-Funktion
Wenn Sie eine `POST`-Methode mit einer JSON-Nutzlast für den Lambda-Funktionsaufruf erstellen, gehen Sie so vor, dass der Client die erforderlichen Eingaben im Anfragetext an die Backend-Funktion übermitteln muss. Damit sichergestellt ist, dass der Client die korrekten Eingabedaten hochlädt, aktivieren Sie die Anforderungsvalidierung für die Nutzlast.
**Erstellen einer `POST` -Methode mit einer JSON-Nutzlast**
1. Wählen Sie die **/calc**-Ressource und klicken Sie dann auf **Methode erstellen**.
1. Wählen Sie unter **Method type** (Methodentyp) die Option **POST** aus.
1. Für **Integrationstyp** wählen Sie **AWS-Service** aus.
1. Wählen Sie für den AWS-Region Ort aus **AWS-Region**, an dem Sie Ihre Lambda-Funktion erstellt haben.
1. Wählen Sie für **AWS-Service** **Lambda** aus.
1. Lassen Sie die **AWS -Subdomain** leer.
1. Wählen Sie für **HTTP-Methode** **POST** aus.
1. Wählen Sie für **Aktionstyp** **Pfadüberschreibung verwenden** aus. Mit dieser Option wird der ARN der [Invoke](https://docs.aws.amazon.com/lambda/latest/dg/API_Invoke.html)-Aktion für die Ausführung der `Calc`-Funktion angegeben.
1. Geben Sie für **Pfadüberschreibung** **2015-03-31/functions/arn:aws:lambda:*us-east-2*:*account-id*:function:Calc/invocations** ein. Geben Sie für ** *account-id*** Ihre AWS-Konto ID ein. Geben Sie für den Ort ein***us-east-2***, AWS-Region an dem Sie Ihre Lambda-Funktion erstellt haben.
1. Geben Sie für **Ausführungsrolle** den Rollen-ARN für **lambda\$1invoke\$1function\$1assume\$1apigw\$1role** ein.
1. Die Einstellungen für **Credential-Cache** und **Standard-Timeout** bleiben unverändert.
1. Wählen Sie **Methode erstellen** aus.
Sie können nun ein **Eingabe**-Modell erstellen, das die Struktur der Eingabedaten beschreibt und den eingehenden Anfragetext validiert.
**Erstellen eines Eingabemodells**
1. Klicken Sie im Navigationsbereich auf **Models** (Modelle).
1. Wählen Sie **Modell erstellen** aus.
1. Geben Sie unter **Name** **input** ein.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Geben Sie **\$1default** ein, um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden.
1. Geben Sie für **Modellschema** Folgendes ein:
```
{
"type":"object",
"properties":{
"a":{"type":"number"},
"b":{"type":"number"},
"op":{"type":"string"}
},
"title":"input"
}
```
1. Wählen Sie **Modell erstellen** aus.
Als Nächstes erstellen Sie ein **Ausgabe**-Modell. Dieses Modell definiert die Datenstruktur der berechneten Ausgabe vom Backend. Damit werden die Integrationsantwortdaten einem anderen Modell zugewiesen. In diesem Tutorial wird das Pass-Through-Verhalten verwendet, daher wird dieses Modell nicht benötigt.
**Erstellen eines Ausgabemodells**
1. Wählen Sie **Modell erstellen** aus.
1. Geben Sie unter **Name** **output** ein.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Geben Sie **\$1default** ein, um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden.
1. Geben Sie für **Modellschema** Folgendes ein:
```
{
"type":"object",
"properties":{
"c":{"type":"number"}
},
"title":"output"
}
```
1. Wählen Sie **Modell erstellen** aus.
Als Nächstes erstellen Sie ein **Ergebnis**-Modell. Dieses Modell definiert die Datenstruktur der zurückgegebenen Antwortdaten. Dieses Modell verweist auf die **Eingabe**- und **Ausgabe**-Schemata, die in Ihrer API definiert sind.
**Erstellen eines Ergebnismodells**
1. Wählen Sie **Modell erstellen** aus.
1. Geben Sie unter **Name** **result** ein.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Geben Sie **\$1default** ein, um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden.
1. Geben Sie für **Modellschema** das folgende Modell mit Ihrem *restapi-id* ein. Ihr *restapi-id* ist im folgenden Schema oben in der Konsole in Klammern aufgeführt: `API Gateway > APIs > LambdaCalc (abc123).`
```
{
"type":"object",
"properties":{
"input":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/input"
},
"output":{
"$ref":"https://apigateway.amazonaws.com/restapis/restapi-id/models/output"
}
},
"title":"result"
}
```
1. Wählen Sie **Modell erstellen** aus.
Als Nächstes konfigurieren Sie die Methodenanforderung Ihrer POST-Methode, um die Anforderungsvalidierung für den eingehenden Anforderungstext zu aktivieren.
**Anforderungsvalidierung für die POST-Methode aktivieren**
1. Klicken Sie im Hauptnavigationsbereich auf **Ressourcen** und wählen Sie dann die `POST`-Methode in der Ressourcenstruktur aus.
1. Wählen Sie auf der Registerkarte **Methodenanfrage** unter **Methodenanfrage-Einstellungen** die Option **Bearbeiten** aus.
1. Wählen Sie für **Anforderungs-Validator** die Option **Text validieren** aus.
1. Wählen Sie **Anforderungstext** aus und klicken Sie dann auf **Modell hinzufügen**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
Wenn kein passender Inhaltstyp gefunden wird, wird die Anforderungsvalidierung nicht durchgeführt. Geben Sie **\$1default** ein, um das gleiche Modell unabhängig vom Inhaltstyp zu verwenden.
1. Wählen Sie für **Modell** **Eingabe** aus.
1. Wählen Sie **Speichern**.
Sie können nun Ihre `POST`-Methode testen, um zu verifizieren, dass sie korrekt für einen Lambda-Funktionsaufruf eingerichtet wurde.
**So testen Sie die `POST`-Methode**
1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Geben Sie für **Anforderungstext** die folgende JSON-Nutzlast ein:
```
{
"a": 1,
"b": 2,
"op": "+"
}
```
1. Wählen Sie **Test** aus.
Die Ausgabe sollte folgendermaßen aussehen:
```
{
"a": 1,
"b": 2,
"op": "+",
"c": 3
}
```
## Integration 3: Erstellen Sie eine `GET`-Methode mit Pfadparametern für den Aufruf der Lambda-Funktion
Jetzt erstellen Sie für eine Ressource eine `GET`-Methode, die durch eine Abfolge von Pfadparametern angegeben wird, um damit die Lambda-Funktion im Backend aufzurufen. Die Werte der Pfadparameter geben die Eingabedaten für die Lambda-Funktion an. Sie definieren eine Mapping-Vorlage, um die eingehenden Pfadparameterwerte der erforderlichen Integrationsanforderungsnutzlast zuzuweisen.
Die resultierende API-Ressourcen-Struktur sieht etwa wie folgt aus:
![\[API in API Gateway als Lambda-Proxy erstellen\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/aws_proxy_lambda_create_api_resources_new_console.png)
**Erstellen einer **/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**-Ressource**
1. Wählen Sie **Create Resource** (Ressource erstellen) aus.
1. Wählen Sie für **Ressourcenpfad** `/calc` aus.
1. Geben Sie für **Resource name (Ressourcenname)** **\$1operand1\$1** ein.
1. **CORS (Cross Origin Resource Sharing)** bleibt ausgeschaltet.
1. Wählen Sie **Create Resource** (Ressource erstellen) aus.
1. Wählen Sie für **Ressourcenpfad** `/calc/{operand1}/` aus.
1. Geben Sie für **Resource name (Ressourcenname)** **\$1operand2\$1** ein.
1. **CORS (Cross Origin Resource Sharing)** bleibt ausgeschaltet.
1. Wählen Sie **Create Resource** (Ressource erstellen) aus.
1. Wählen Sie für **Ressourcenpfad** `/calc/{operand1}/{operand2}/` aus.
1. Geben Sie für **Resource name (Ressourcenname)** **\$1operator\$1** ein.
1. **CORS (Cross Origin Resource Sharing)** bleibt ausgeschaltet.
1. Wählen Sie **Create Resource** (Ressource erstellen) aus.
Dieses Mal verwenden Sie die standardmäßige Lambda-Integration in der API Gateway-Konsole zur Einrichtung der Methodenintegration.
**Einrichten einer Integrationsmethode**
1. Wählen Sie die **/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**-Ressource aus und klicken Sie dann auf **Methode erstellen**.
1. Wählen Sie als **Methodentyp** die Option **GET** (Abrufen) aus.
1. Wählen Sie für den **Integrationstyp** die Option **Lambda** aus.
1. Lassen Sie **Lambda proxy integration** (Lambda-Proxyintegration) deaktiviert.
1. Wählen Sie für **Lambda-Funktion** den Ort aus, AWS-Region an dem Sie Ihre Lambda-Funktion erstellt haben, und geben Sie ein. **Calc**
1. Das **Standard-Timeout** bleibt aktiviert.
1. Wählen Sie **Methode erstellen** aus.
Als Nächstes erstellen Sie eine Zuweisungsvorlage zur Zuweisung der drei URL-Pfadparameter, die beim Erstellen der **/calc/\$1operand1\$1/\$1operand2\$1/\$1operator\$1**-Ressource deklariert wurden. Mit dieser Vorlage werden dem JSON-Objekt die vorgegebenen Eigenschaftswerte zugewiesen. Da URL-Pfade eine URL-Codierung erfordern, muss der Operator für die Division mit `%2F` (anstatt `/`) angegeben werden. Diese Vorlage übersetzt den `%2F` in `'/'`, bevor er an die Lambda-Funktion übergeben wird.
**Erstellen einer Zuweisungsvorlage**
1. Klicken Sie auf der Registerkarte **Integrationsanfrage** unter **Einstellungen für Integrationsanfragen** auf **Bearbeiten**.
1. Wählen Sie für **Anforderungstext-Pass-Through** die Option **Wenn keine Vorlagen definiert sind (empfohlen)** aus.
1. Klicken Sie auf **Zuordnungsvorlage hinzufügen**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
1. Geben Sie für **Vorlagentext** den folgenden Code ein:
```
{
"a": "$input.params('operand1')",
"b": "$input.params('operand2')",
"op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
}
```
1. Wählen Sie **Speichern**.
Sie können nun Ihre `GET`-Methode testen, um zu verifizieren, dass sie korrekt für den Aufruf der Lambda-Funktion eingerichtet wurde, und dass die ursprüngliche Ausgabe ohne Zuweisung durch die Integrationsantwort weitergegeben wird.
**So testen Sie die `GET`-Methode**
1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Für **Pfad** gehen Sie wie folgt vor:
1. Geben Sie für **operand1** **1** ein.
1. Geben Sie für **operand2** **1** ein.
1. Geben Sie für **operator** **\$1** ein.
1. Wählen Sie **Test** aus.
1. Das Ergebnis sollte wie folgt aussehen:
![\[Testen Sie die GET-Methode in der API-Gateway-Konsole.\]](http://docs.aws.amazon.com/de_de/apigateway/latest/developerguide/images/aws_proxy_lambda_calc_get_method_test_path_parm_new_console.png)
Als Nächstes modellieren Sie die Datenstruktur für die Nutzlast der Methodenantwort nach dem `result`-Schema.
Standardmäßig wird dem Methodenantworttext ein leeres Modell zugeordnet. Dadurch wird der Integrationsantworttext ohne Zuweisung übergeben. Wenn Sie jedoch ein SDK für eine stark typisierte Sprache (wie z. B. Java oder Objective-C) erstellen, wird den SDK-Benutzern ein leeres Objekt als Ergebnis übergeben. Damit sichergestellt wird, dass sowohl REST- als auch SDK-Clients das gewünschte Ergebnis erhalten, müssen die Antwortdaten mit einem vordefinierten Schema modelliert werden. Nachfolgend definieren Sie ein Modell für den Methodenantworttext und zum Erstellen einer Mapping-Vorlage, mit der der Integrationsantworttext in den Methodenantworttext umgewandelt wird.
**Erstellen einer Methodenantwort**
1. Klicken Sie auf der Registerkarte **Methodenantwort** unter **Antwort 200** auf **Bearbeiten**.
1. Klicken Sie unter **Anforderungstext** auf **Modell hinzufügen**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
1. Wählen Sie für **Modell** **Ergebnis** aus.
1. Wählen Sie **Speichern**.
Durch die Definition eines Modells für den Methodenantworttext wird sichergestellt, dass die Antwortdaten an das `result`-Objekt eines bestimmten SDKs übergeben werden. Um sicherzustellen, dass die Integrationsantwortdaten entsprechend zugewiesen werden, benötigen Sie eine Mapping-Vorlage.
**Erstellen einer Zuweisungsvorlage**
1. Klicken Sie auf der Registerkarte **Integrationsantwort** unter **Standard - Antwort** auf **Bearbeiten**.
1. Klicken Sie auf **Zuordnungsvorlage hinzufügen**.
1. Geben Sie für **Content type** (Inhaltstyp) **application/json** ein.
1. Geben Sie für **Vorlagentext** den folgenden Code ein:
```
#set($inputRoot = $input.path('$'))
{
"input" : {
"a" : $inputRoot.a,
"b" : $inputRoot.b,
"op" : "$inputRoot.op"
},
"output" : {
"c" : $inputRoot.c
}
}
```
1. Wählen Sie **Speichern**.
**Testen der Zuweisungsvorlage**
1. Wählen Sie die Registerkarte **Test**. Möglicherweise müssen Sie die rechte Pfeiltaste wählen, um die Registerkarte anzuzeigen.
1. Für **Pfad** gehen Sie wie folgt vor:
1. Geben Sie für **operand1** **1** ein.
1. Geben Sie für **operand2** **2** ein.
1. Geben Sie für **operator** **\$1** ein.
1. Wählen Sie **Test** aus.
1. Die Antwort wird wie folgt aussehen:
```
{
"input": {
"a": 1,
"b": 2,
"op": "+"
},
"output": {
"c": 3
}
}
```
Momentan kann die API nur über die **Test**-Funktion in der API Gateway-Konsole aufgerufen werden. Wenn Sie die API für Clients verfügbar machen möchten, muss sie ihnen bereitgestellt werden. Stellen Sie immer sicher, dass Sie Ihre API erneut bereitstellen, wenn Sie eine Ressource oder Methode hinzufügen, ändern oder löschen, oder wenn Sie eine Datenzuweisung oder Stufeneinstellungen aktualisieren. Ohne diesen Schritt werden neue Features oder Aktualisierungen Ihrer API nicht für Clients verfügbar gemacht. Gehen Sie wie folgt vor:
**So stellen Sie die API bereit**
1. Klicken Sie auf **Deploy API**.
1. Wählen Sie für **Stufe** die Option **Neue Stufe** aus.
1. Geben Sie für **Stage name (Stufenname)** **Prod** ein.
1. (Optional) Geben Sie unter **Description (Beschreibung)** eine Beschreibung ein.
1. Wählen Sie **Bereitstellen**.
1. (Optional) Klicken Sie unter **Stufendetails** auf das Kopiersymbol für **Aufruf-URL**, um die URL Ihrer Aufruf-API zu kopieren. Sie können diese mit Tools wie [Postman](https://www.postman.com) und [cURL](https://curl.se/) zum Testen Ihrer API verwenden.
**Anmerkung**
Denken Sie daran, dass Sie Ihre API jedes Mal erneut bereitstellen müssen, wenn Sie eine Ressource oder Methode hinzufügen, ändern oder löschen, oder wenn Sie eine Datenzuweisung oder Stufeneinstellungen aktualisieren. Andernfalls sind neue Funktionen oder Aktualisierungen nicht für Clients Ihrer API verfügbar.
# OpenAPI-Definitionen der mit einer Lambda-Funktion integrierten Beispiel-API
------
#### [ OpenAPI 2.0 ]
```
{
"swagger": "2.0",
"info": {
"version": "2017-04-20T04:08:08Z",
"title": "LambdaCalc"
},
"host": "uojnr9hd57.execute-api.us-east-1.amazonaws.com",
"basePath": "/test",
"schemes": [
"https"
],
"paths": {
"/calc": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "query",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "query",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
},
"headers": {
"operand_1": {
"type": "string"
},
"operand_2": {
"type": "string"
},
"operator": {
"type": "string"
}
}
}
},
"x-amazon-apigateway-request-validator": "Validate query string parameters and headers",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseParameters": {
"method.response.header.operator": "integration.response.body.op",
"method.response.header.operand_2": "integration.response.body.b",
"method.response.header.operand_1": "integration.response.body.a"
},
"responseTemplates": {
"application/json": "#set($res = $input.path('$'))\n{\n \"result\": \"$res.a, $res.b, $res.op => $res.c\",\n \"a\" : \"$res.a\",\n \"b\" : \"$res.b\",\n \"op\" : \"$res.op\",\n \"c\" : \"$res.c\"\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_match",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\", \n \"op\": \"$input.params('operator')\" \n}"
},
"type": "aws"
}
},
"post": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"in": "body",
"name": "Input",
"required": true,
"schema": {
"$ref": "#/definitions/Input"
}
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-request-validator": "Validate body",
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : $inputRoot.op,\n \"c\" : $inputRoot.c\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"type": "aws"
}
}
},
"/calc/{operand1}/{operand2}/{operator}": {
"get": {
"consumes": [
"application/json"
],
"produces": [
"application/json"
],
"parameters": [
{
"name": "operand2",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operator",
"in": "path",
"required": true,
"type": "string"
},
{
"name": "operand1",
"in": "path",
"required": true,
"type": "string"
}
],
"responses": {
"200": {
"description": "200 response",
"schema": {
"$ref": "#/definitions/Result"
}
}
},
"x-amazon-apigateway-integration": {
"credentials": "arn:aws:iam::123456789012:role/apigAwsProxyRole",
"responses": {
"default": {
"statusCode": "200",
"responseTemplates": {
"application/json": "#set($inputRoot = $input.path('$'))\n{\n \"input\" : {\n \"a\" : $inputRoot.a,\n \"b\" : $inputRoot.b,\n \"op\" : \"$inputRoot.op\"\n },\n \"output\" : {\n \"c\" : $inputRoot.c\n }\n}"
}
}
},
"uri": "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:Calc/invocations",
"passthroughBehavior": "when_no_templates",
"httpMethod": "POST",
"requestTemplates": {
"application/json": "{\n \"a\": \"$input.params('operand1')\",\n \"b\": \"$input.params('operand2')\",\n \"op\": #if($input.params('operator')=='%2F')\"/\"#{else}\"$input.params('operator')\"#end\n \n}"
},
"contentHandling": "CONVERT_TO_TEXT",
"type": "aws"
}
}
}
},
"definitions": {
"Input": {
"type": "object",
"required": [
"a",
"b",
"op"
],
"properties": {
"a": {
"type": "number"
},
"b": {
"type": "number"
},
"op": {
"type": "string",
"description": "binary op of ['+', 'add', '-', 'sub', '*', 'mul', '%2F', 'div']"
}
},
"title": "Input"
},
"Output": {
"type": "object",
"properties": {
"c": {
"type": "number"
}
},
"title": "Output"
},
"Result": {
"type": "object",
"properties": {
"input": {
"$ref": "#/definitions/Input"
},
"output": {
"$ref": "#/definitions/Output"
}
},
"title": "Result"
}
},
"x-amazon-apigateway-request-validators": {
"Validate body": {
"validateRequestParameters": false,
"validateRequestBody": true
},
"Validate query string parameters and headers": {
"validateRequestParameters": true,
"validateRequestBody": false
}
}
}
```
------