Tutorial: Erstellen einer Calc-REST-API mit zwei AWS-Service Integrationen und einer Nicht-Proxy-Lambda-Integration

Im Erste-Schritte-Tutorial zur Nicht-Proxy-Integration wird ausschließlich die Lambda Function-Integration verwendet. 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)

2. 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)

3. 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 für die Calc-API, die Sie in API Gateway importieren können, bereit. Befolgen Sie dazu die Anweisungen in Konfigurieren einer REST-API mit OpenAPI.

Themen

• Übernehmbare IAM-Rolle erstellen
• Erstellen einer Calc-Lambda-Funktion
• Calc Lambda-Funktion testen
• Erstellen einer Calc-API
• Integration 1: Erstellen Sie eine GET-Methode mit Abfrageparametern, um die Lambda-Funktion aufzurufen
• Integration 2: Erstellen Sie eine POST-Methode mit einem JSON-Payload für den Aufruf der Lambda-Funktion
• Integration 3: Erstellen Sie eine GET-Methode mit Pfadparametern für den Aufruf der Lambda-Funktion
• OpenAPI-Definitionen der mit einer Lambda-Funktion integrierten Beispiel-API

Ü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:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "",
      "Effect": "Allow",
      "Principal": {
        "Service": "apigateway.amazonaws.com"
      },
      "Action": "sts:AssumeRole"
    }
  ]
}

Die von Ihnen erstellte Rolle muss über die Lambda-Berechtigung InvokeFunction verfügen. 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:

{
    "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.

2. Wählen Sie Roles.

3. Wählen Sie Create Role aus.

4. Wählen Sie unter Select type of trusted entity (Typ der vertrauenswürdigen Entität auswählen) die Option AWS Service aus.

5. 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.

6. Wählen Sie Next: Permissions aus.

7. 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:

      
      {
          "Version": "2012-10-17",
          "Statement": [
              {
                  "Effect": "Allow",
                  "Action": "lambda:InvokeFunction",
                  "Resource": "*"
              }
          ]
      }                        
              

   2. Wählen Sie Review policy (Richtlinie prüfen) aus.

   3. Gehen Sie unter Review Policy wie folgt vor:

      1. Geben Sie unter Name einen Namen wie lambda_execute ein.

      2. Wählen Sie Create Policy (Richtlinie erstellen) aus.

8. 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_execute 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!)

   2. Wählen Sie Next: Tags (Weiter: Tags) aus.

   3. Klicken Sie auf Weiter: Prüfen.

   4. Geben Sie unter Role name einen Namen wie lambda_invoke_function_assume_apigw_role ein.

   5. Wählen Sie Create role aus.

9. Wählen Sie Ihre lambda_invoke_function_assume_apigw_role aus der Rollen-Liste aus.

10. Wählen Sie die Registerkarte Trust relationships (Vertrauensstellungen).

11. Wählen Sie Edit Trust Relationship (Vertrauensstellungen bearbeiten).

12. Ersetzen Sie die vorhandene Richtlinie durch Folgendes:

    
    {
      "Version": "2012-10-17",
      "Statement": [
        {
          "Sid": "",
          "Effect": "Allow",
          "Principal": {
            "Service": [
              "lambda.amazonaws.com",
              "apigateway.amazonaws.com"
            ]
          },
          "Action": "sts:AssumeRole"
        }
      ]
    }                        
            

13. Wählen Sie Update Trust Policy.

14. 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).

2. Wählen Sie Author from scratch aus.

3. Geben Sie als Name die Zeichenfolge „Calc“ ein.

4. Wählen Sie Create function (Funktion erstellen).

5. Kopieren Sie die folgende Lambda-Funktion und fügen Sie sie in den Code-Editor in der Lambda-Konsole ein.

   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;
   };

6. Wählen Sie unter "Ausführungsrolle" Choose an existing role (Wählen Sie eine vorhandene Rolle aus) aus.

7. Geben Sie den Rollen-ARN für die zuvor erstellte lambda_invoke_function_assume_apigw_role-Rolle ein.

8. 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 im Dropdown-Menü Saved test events (Gespeicherte Testereignisse) Configure test events (Testereignisse konfigurieren) aus.

2. Geben Sie für den Testereignisnamen ei calc2plus5.

3. Ersetzen Sie die Testereignisdefinition durch Folgendes:

   
   {
     "a": "2",
     "b": "5",
     "op": "+"
   }
           

4. Wählen Sie Save (Speichern) aus.

5. Wählen Sie Test aus.

6. 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.

Erstellen der Calc-API

1. Melden Sie sich bei der API Gateway-Konsole unter https://console.aws.amazon.com/apigateway an.

2. 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 Build (Erstellen) aus. Wenn das Popup-Fenster Create Exampe 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.

3. Wählen Sie unter Create new API (Neue API erstellen) die Option New API (Neue API) aus.

4. Geben Sie unter API name (API-Name) LambdaCalc ein.

5. Lassen Sie die Description (Beschreibung) leer, und lassen Sie Endpoint Type (Endpunkttyp) auf Regional.

6. 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 hilfreich sein, insbesondere für APIs, die den offenen Zugriff gewähren.

So richten Sie die GET-Methode mit Abfragezeichenfolgenparametern ein:

1. Wählen Sie in der API Gateway-Konsole unter den Resources (Ressourcen) ihrer LambdaCalc-API /.

2. Wählen Sie im Dropdown-Menü Actions (Aktionen) die Option Create Resource (Ressource erstellen) aus.

3. Geben Sie für Resource Name (Ressourcenname) calc ein.

4. Wählen Sie Create Resource (Ressource erstellen) aus.

5. Wählen Sie die /calc-Ressource aus, die Sie gerade erstellt haben.

6. Wählen Sie im Dropdownmenü Actions (Aktionen) die Option Create Method (Methode erstellen) aus.

7. Wählen Sie im Dropdown-Menü Methode die Option GET aus.

8. Klicken Sie auf das Häkchen-Symbol, um Ihre AUswahl zu speichern.

9. Gehen Sie auf der folgenden Seite Set up wie folgt vor:

   1. Wählen Sie unter Integrationstyp die Option AWS-Service aus.

   2. Wählen Sie für AWS-Region die Region (z. B. us-west-2) aus, in der Sie die Lambda-Funktion erstellt haben.

   3. Wählen Sie unter AWS-Service die Option Lambda aus.

   4. Lassen Sie AWS-Subdomäne leer, da unsere Lambda-Funktion in keiner AWS-Subdomäne gehostet wird.

   5. Wählen Sie für HTTP method (HTTP-Methode) POST und wählen Sie das Häkchen-Symbol, um Ihre Wahl zu speichern. Lambda erfordert, dass die POST-Anfrage 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.

   6. Wählen Sie Use path override für Action Type. Mit dieser Option wird der ARN der Invoke-Aktion für die Ausführung der Calc-Funktion angegeben.

   7. Geben Sie /2015-03-31/functions/arn:aws:lambda:region:account-id:function:Calc/invocations in Pfadüberschreibung ein, wobei region der Region entspricht, in der Sie Ihre Lambda-Funktion erstellt haben, und account-id der Kontonummer des AWS-Kontos.

   8. Geben Sie für Execution role (Ausführungsrolle) den ARN der Rolle für die lambda_invoke_function_assume_apigw_role IAM-Rolle an, die Sie vorher erstellt haben.

   9. Lassen Sie die Content Handling auf Passthrough setzen, da diese Methode keine binären Daten verarbeitet.

   10. Lassen Sie die Option Use default Timeout aktiviert.

   11. Wählen Sie Save (Speichern) aus.

10. Wählen Sie Method Request (Methodenanforderung).

    Nun werden Sie Abfrageparameter für die GET-Methode auf /cal einrichten, damit sie im Auftrag der Backend-Lambda-Funktion Eingaben empfangen kann.

    1. Wählen Sie das Stiftsymbol neben Request Validator (Anfrage-Validierer) und wählen Sie Validate query string parameters and headers (Abfragezeichenfolgen-Parametern und -Header validieren) aus dem Dropdown-Menü aus. Mit dieser Einstellung wird eine Fehlermeldung zurückgegeben, die auf das Fehlen erforderlicher Parameter hinweist, wenn der Client diese nicht angibt. Der Backend-Aufruf wird Ihnen nicht berechnet.

    2. Klicken Sie auf das Häkchen-Symbol, um Ihre Änderungen zu speichern.

    3. Erweitern Sie den Abschnitt URL Query String Parameters.

    4. Wählen Sie Add query string aus.

    5. Geben Sie bei Name operand1 ein.

    6. Klicken Sie auf das Häkchen-Symbol, um die Parameter zu speichern.

    7. Wiederholen Sie die vorherigen Schritte zum Erstellen von Parameter mit den Namen operand2 und operator.

    8. Markieren Sie bei jedem Parameter die Option Required, damit alle validiert werden.

11. Wählen Sie Method Execution und wählen Sie Integration Request, um die Zuordnungsvorlage so einzurichten, dass die vom Client bereitgestellten Abfragezeichenfolgen wie von der Calc-Funktion gefordert in die Nutzdaten der Integrationsanforderung umgesetzt werden.

    1. Erweitern Sie den Abschnitt Mapping Templates.

    2. Wählen Sie When no template matches the request Content-Type header (Wenn keine Vorlage mit dem Content-Type-Header der Anfrage übereinstimmt) für Request body passthrough (Anfrage-Body-Passthrough).

    3. Unter Content-Type, wählen Sie Add mapping template.

    4. Geben Sie application/json im Feld ein und klicken Sie auf das Häkchen, um den Vorlageneditor zu öffnen.

    5. Wählen Sie Yes, secure this integration, um fortzufahren.

    6. Kopieren Sie das folgende Zuweisungsskript in den Mapping-Vorlagen-Editor:

       {
           "a":  "$input.params('operand1')",
           "b":  "$input.params('operand2')", 
           "op": "$input.params('operator')"   
       }

       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.

    7. Wählen Sie Save (Speichern) aus.

12. Wählen Sie Method Execution.

13. Sie können nun Ihre GET-Methode testen, um zu verifizieren, dass sie korrekt eingerichtet wurde, um die Lambda-Funktion aufzurufen:

    1. Für Abfrage-Zeichenketten (Query Strings) geben Sieoperand1=2&operand2=3&operator=+ ein.

    2. Wählen Sie Test aus.

       Die Ergebnisse sollten in etwa wie folgt aussehen:

       

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.

So richten Sie die POST-Methode mit einem JSON-Payload für den Aufruf einer Lambda-Funktion ein:

1. Wechseln Sie zur API Gateway-Konsole.

2. Wählen Sie APIs.

3. Wählen Sie die LambdaCalc-API aus, die Sie zuvor erstellt haben.

4. Wähöen Sie die /calc-Ressource im Bereich Resources.

5. Wählen Sie im Menü Actions (Aktionen) die Option Create Method (Methode erstellen) aus.

6. Wählen Sie POST aus der Dropdown-Liste für die Methode.

7. Klicken Sie auf das Häkchen-Symbol, um Ihre AUswahl zu speichern.

8. Gehen Sie auf der folgenden Seite Set up wie folgt vor:

   1. Wählen Sie unter Integrationstyp die Option AWS-Service aus.

   2. Wählen Sie für AWS-Region die Region (z. B. us-west-2) aus, in der Sie die Lambda-Funktion erstellt haben.

   3. Wählen Sie unter AWS-Service die Option Lambda aus.

   4. Lassen Sie AWS-Subdomäne leer, da unsere Lambda-Funktion in keiner AWS-Subdomäne gehostet wird.

   5. Wählen Sie in HTTP method POST. Das Beispiel verdeutlicht, dass die HTTP-Methoden einer Frontend-Methodenanforderung und einer Backend-Integrationsanforderung unterschiedlich sein können.

   6. Wählen Sie für Action (Aktion) Use path override für Action Type (Aktionstyp) aus. Mit dieser Option können Sie den ARN der Aufruf-Aktion für die Ausführung Ihrer Calc-Funktion angeben.

   7. Geben Sie /2015-03-31/functions/arn:aws:lambda:region:account-id:function:Calc/invocations für Pfadüberschreibung ein, wobei region der Region entspricht, in der Sie Ihre Lambda-Funktion erstellt haben, und account-id der Kontonummer des AWS-Kontos.

   8. Geben Sie für Execution role (Ausführungsrolle) den ARN der Rolle für die lambda_invoke_function_assume_apigw_role IAM-Rolle an, die Sie vorher erstellt haben.

   9. Lassen Sie die Content Handling auf Passthrough setzen, da diese Methode keine binären Daten verarbeitet.

   10. Lassen Sie die Option Use default Timeout aktiviert.

   11. Wählen Sie Save (Speichern) aus.

9. Wählen Sie im primären Navigationsbereich der API Gateway-Konsole Models (Modelle) unter Ihrer LambdaCalc-API, um Datenmodelle für die Ein- und Ausgabe der Methode zu erstellen:

   1. Wählen Sie Erstellen im Bereich Models aus. Geben Sie Input in Modellname und application/json unter Inhaltstyp ein, und kopieren Sie die folgende Schemadefinition in das Feld Modellschema:

      {
          "type":"object",
          "properties":{
              "a":{"type":"number"},
              "b":{"type":"number"},
              "op":{"type":"string"}
          },
          "title":"Input"
      }

      Dieses Modell definiert die Struktur der Eingabedaten und wird zur Validierung des eingehenden Anforderungstexts verwendet.

   2. Wählen Sie Create model aus.

   3. Wählen Sie Erstellen im Bereich Models aus. Geben Sie Output in Modellname und application/json unter Inhaltstyp ein, und kopieren Sie die folgende Schemadefinition in das Feld Modellschema:

      {
          "type":"object",
          "properties":{
              "c":{"type":"number"}
          },
          "title":"Output"
      }

      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.

   4. Suchen Sie die API-ID für Ihre API oben auf dem Konsolenbildschirm und notieren Sie diese. Es wird in Klammern hinter dem API-Namen angezeigt.

   5. Wählen Sie im Bereich Models (Modelle) die Option Create (Erstellen) aus.

   6. Geben Sie unter Model name (Modellname) Result ein.

   7. Geben Sie unter Content type (Inhaltstyp) application/json ein.

   8. Kopieren Sie die folgende Schemadefinition in das Feld Model schema (Modellschema) (wobei restapi-id die REST-API-ID ist, die Sie zuvor notiert haben):

      {
          "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":"Output"
      }

      Dieses Modell definiert die Datenstruktur der zurückgegebenen Antwortdaten. Damit werden die beiden Schemata Input und Output referenziert, die in der angegebenen API definiert wurden (restapi-id). Dieses Modell wird in diesem Tutorial ebenfalls nicht verwendet, da das Pass-Through-Verhalten genutzt wird.

   9. Wählen Sie Create model aus.

10. Wählen Sie im Hauptnavigationsbereich unter Ihrer LambdaCalc-API die Option Resources (Ressourcen) aus.

11. Wählen Sie im Bereich Resources die POSTMethode für Ihre API aus.

12. Wählen Sie Method Request (Methodenanforderung).

13. Führen Sie in den Konfigurationseinstellungen im Bereich Method Request die folgenden Schritte aus, um die Anforderungsvalidierung für den eingehenden Anforderungstext zu aktivieren:

    1. Wählen Sie das Stiftsymbol neben Request Validator, um Validate body auszuwählen. Klicken Sie auf das Häkchen-Symbol, um Ihre AUswahl zu speichern.

    2. Erweitern Sie den Abschnitt Request Body. und wählen Sie Add model aus.

    3. Geben Sie application/json in das Eingabefeld Content-Type ein und wählen Sie Input aus der Dropdownliste in der Spalte Model name aus. Klicken Sie auf das Häkchen-Symbol, um Ihre AUswahl zu speichern.

14. Um Ihre POST-Methode zu testen, gehen Sie folgendermaßen vor:

    1. Wählen Sie Method Execution.

    2. Wählen Sie Test aus.

15. Kopieren Sie die folgende JSON-Nutzlast in Request Body ein:

    
    {
        "a": 1,
        "b": 2,
        "op": "+"
    }
                    

16. Wählen Sie Test aus.

    Sie sollten die folgende Ausgabe im Response Body sehen:

    
    {
      "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.

Dieses Mal verwenden Sie die integrierte Lambda-Integrationsunterstützung in der API Gateway-Konsole, um die Methodenintegration einzurichten.

Die resultierende API-Ressourcen-Struktur sieht etwa wie folgt aus:

So richten Sie eine GET-Methode mit URL-Pfadparametern ein:

1. Wechseln Sie zur API Gateway-Konsole.

2. Wählen Sie unter APIs die LambdaCalc-API aus, die Sie zuvor erstellt haben.

3. Wählen Sie in der Ressourcen-Navigation der API/calc.

4. Wählen Sie im Dropdownmenü Actions die Option Create Resource aus.

5. Geben Sie bei Resource Name {operand1} ein.

6. Geben Sie für Resource Path (Ressourcenpfad) {operand1} ein.

7. Wählen Sie Create Resource (Ressource erstellen) aus.

8. Wählen Sie die /calc/{operand1} – Ressource, die Sie gerade erstellt haben.

9. Wählen Sie im Dropdownmenü Actions die Option Create Resource aus.

10. Geben Sie bei Resource Name {operand2} ein.

11. Geben Sie für Resource Path (Ressourcenpfad) {operand2} ein.

12. Wählen Sie Create Resource (Ressource erstellen) aus.

13. Wählen Sie die /calc/{operand1}/{operand2}– Ressource, die Sie gerade erstellt haben.

14. Wählen Sie im Dropdownmenü Actions die Option Create Resource aus.

15. Geben Sie für Resource Path (Ressourcenpfad) {operator} ein.

16. Geben Sie bei Resource Name {operator} ein.

17. Wählen Sie Create Resource (Ressource erstellen) aus.

18. Wählen Sie die /calc/{operand1}/{operand2}/{operator}– Ressource, die Sie gerade erstellt haben.

19. Wählen Sie im Dropdownmenü Actions (Aktionen) die Option Create Method (Methode erstellen) aus.

20. Wählen Sie im Dropdown-Menü für die Methode au GET.

21. Wählen Sie im Feld Setup Lambda Function für Integration type, um die vereinfachte Einrichtung über die Konsole zu verwenden.

22. Wählen Sie eine Region (z. B. us-west-2) für Lambda Region. Dies ist die Region, in der die Lambda-Funktion gehostet wird.

23. Wählen Sie Ihre bestehende Lambda-Funktion (Calc) für Lambda function (Lambda-Funktion).

24. Wählen Sie Speichern und dann OK, um der Auswahl Add Permissions to Lambda Function zuzustimmen.

25. Wählen Sie Integrationsanforderung aus.

26. Richten Sie die Mapping-Vorlage folgendermaßen ein:

    1. Erweitern Sie den Abschnitt Mapping Templates.

    2. Behalten Sie die Einstellung When no template matches the requested Content-Type header (Wenn keine Vorlage mit dem angeforderten Inhaltstyp-Header übereinstimmt) bei.

    3. Wählen Sie Add mapping template.

    4. Geben Sie application/json für Content-Type ein und wählen Sie dann das Häkchen-Symbol, um den Vorlageneditor zu öffnen.

    5. Wählen Sie Yes, secure this integration, um fortzufahren.

    6. Kopieren Sie das folgende Zuweisungsskript in den Vorlageneditor:

       {
          "a": "$input.params('operand1')",
          "b": "$input.params('operand2')",
          "op": #if($input.params('operator')=='%2F')"/"#{else}"$input.params('operator')"#end
          
       }

       Mit dieser Vorlage werden die drei URL-Pfadparameter, die beim Erstellen der /calc/{operand1}/{operand2}/{operator}-Ressource deklariert wurden, den entsprechenden Eigenschaftswerten des JSON-Objekts 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.

    7. Wählen Sie Save (Speichern) aus.

    Sofern die Methode korrekt eingerichtet ist, sehen die Einstellungen in etwa folgendermaßen aus:

    

27. Um Ihre GETFunktion zu testen, machen Sie Folgendes:

    1. Wählen Sie Method Execution.

    2. Wählen Sie Test aus.

    3. Geben Sie jeweils 1, 1 und + in die Felder {operand1}, {operand2} und {operator} ein.

    4. Wählen Sie Test aus.

    5. Das Ergebnis sollte wie folgt aussehen:

       

    Das Testergebnis zeigt die ursprüngliche Ausgabe der Lambda-Funktion im Backend, die von der Integrationsantwort ohne Zuweisung übergeben wird, da es keine Mapping-Vorlage gibt. Als Nächstes modellieren Sie die Datenstruktur für die Nutzlast der Methodenantwort mit dem Result-Schema.

28. 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.

    1. Wählen Sie /calc/{operand1}/{operand2}/{operator} aus.

    2. Wählen Sie GET aus.

    3. Wählen Sie Method Execution.

    4. Wählen Sie Method Response (Methodenantwort) aus.

    5. Erweitern Sie die Antwort 200

    6. Wählen Sie unter Response Body for 200 das Stiftsymbol neben dem Modell für den application/jsonInhaltstyp aus.

    7. Wählen Sie in der Models- Dropdown-Liste Result.

    8. Klicken Sie auf das Häkchen-Symbol, um Ihre AUswahl zu 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.

29. Gehen Sie folgendermaßen vor, um die Mapping-Vorlage zu erstellen:

    1. Wählen Sie Method Execution.

    2. Wählen Sie Integration Response und erweitern Sie den Methodenantworteintrag „200“.

    3. Erweitern Sie den Abschnitt Mapping Templates.

    4. Wählen Sie application/json aus der Liste Content-Type aus.

    5. Wählen Sie Result aus der Dropdownliste Generate template aus, um die Vorlage Result aufzurufen.

    6. Ändern Sie die Vorlage folgendermaßen:

       #set($inputRoot = $input.path('$'))
       {
         "input" : {
           "a" : $inputRoot.a,
           "b" : $inputRoot.b,
           "op" : "$inputRoot.op"
         },
         "output" : {
           "c" : $inputRoot.c
         }
       }

    7. Wählen Sie Save (Speichern) aus.

30. Gehen Sie folgendermaßen vor, um die Mapping-Vorlage zu testen:

    1. Wählen Sie Method Execution.

    2. Wählen Sie Test aus.

    3. Geben Sie jeweils 1, 2 und + in die Eingabefelder operand1, operand2 und operator ein.

       Die Integrationsantwort der Lambda-Funktion wird einem Result-Objekt zugeordnet.

    4. Wählen Sie Test aus. In der Konsole sehen Sie Folgendes unter Response Body (Antworttext):

       {
         "input": {
           "a": 1,
           "b": 2,
           "op": "+"
         },
         "output": {
           "c": 3
         }
       }

31. Zu diesem Zeitpunkt kann die API nur über Test Invoke (Aufruf testen) in der API Gateway-Konsole aufgerufen werden. Um sie für Clients verfügbar zu machen, müssen Sie sie bereitstellen. Gehen Sie dazu wie folgt vor:

    1. Wählen Sie im Dropdown-Menü Actions (Aktionen) die Option Deploy API (API bereitstellen) aus.

    2. Wählen Sie [New Stage] ([Neue Stufe]) aus dem Deployment Stage (Bereitstellungsstufe)-Dropdown-Menü aus.

    3. Geben Sie für Stage Name (Stufenname) test ein.

    4. Wählen Sie Deploy (Bereitstellen) aus.

    5. Notieren Sie die Invoke URL (Aufruf-URL) oben im Konsolenfenster. Sie können diese mit Tools wie Postman und cURL zum Testen Ihrer API verwenden.

Anmerkung

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. Andernfalls sind neue Funktionen oder Aktualisierungen nicht für Clients Ihrer API verfügbar.