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 einer REST-API mit einer Lambda-Nicht-Proxy-Integration

In dieser exemplarischen Vorgehensweise verwenden wir die API Gateway-Konsole zur Erstellung einer API, die es einem Client ermöglicht, Lambda-Funktionen über die Lambda Nicht-Proxy-Integration (auch als benutzerdefinierte Integration bekannt) aufzurufen. Weitere Informationen zu AWS Lambda und Lambda-Funktionen finden Sie im AWS Lambda -Entwicklerhandbuch.

Um das Lernen zu erleichtern, haben wir eine einfache Lambda-Funktion mit minimaler API-Einrichtung ausgewählt, um Sie durch die Schritte zur Erstellung einer API Gateway-API mit der benutzerdefinierten Lambda-Integration zu führen. Bei Bedarf werden wir Teile der Logik beschreiben. Ein ausführlicheres Beispiel für die benutzerdefinierte Lambda-Integration finden Sie unter Tutorial: Erstellen einer Rechner-REST-API mit zwei AWS-Serviceintegrationen und einer Nicht-Proxy-Lambda-Integration.

Bevor Sie die API erstellen, richten Sie das Lambda-Backend ein, indem Sie eine Lambda-Funktion in AWS Lambda Lambda erstellen, wie nachfolgend beschrieben.

Lambda-Funktion für die Nicht-Proxy-Integration von Lambda erstellen

In diesem Schritt erstellen Sie eine "Hello World"-ähnliche Lambda-Funktion für die benutzerdefinierte Integration von Lambda. In dieser schrittweisen Anleitung heißt die Funktion GetStartedLambdaIntegration.

Die Implementierung dieser GetStartedLambdaIntegration-Lambda-Funktion sieht wie folgt aus:

Node.js

'use strict';
var days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'];            
var times = ['morning', 'afternoon', 'evening', 'night', 'day'];

console.log('Loading function');

export const handler = function(event, context, callback) {
  // Parse the input for the name, city, time and day property values
  let name = event.name === undefined ? 'you' : event.name;
  let city = event.city === undefined ? 'World' : event.city;
  let time = times.indexOf(event.time)<0 ? 'day' : event.time;
  let day = days.indexOf(event.day)<0 ? null : event.day;

  // Generate a greeting
  let greeting = 'Good ' + time + ', ' + name + ' of ' + city + '. ';
  if (day) greeting += 'Happy ' + day + '!';
  
  // Log the greeting to CloudWatch
  console.log('Hello: ', greeting);
  
  // Return a greeting to the caller
  callback(null, {
      "greeting": greeting
  }); 
};

Python

import json

days = {
    'Sunday',
    'Monday',
    'Tuesday',
    'Wednesday',
    'Thursday',
    'Friday',
    'Saturday'}
times = {'morning', 'afternoon', 'evening', 'night', 'day'}


def lambda_handler(event, context):
    print(event)
    # parse the input for the name, city, time, and day property values
    try:
        if event['name']:
            name = event['name']
    except KeyError:
        name = 'you'
    try:
        if event['city']:
            city = event['city']
    except KeyError:
        city = 'World'
    try:
        if event['time'] in times:
            time = event['time']
        else:
            time = 'day'
    except KeyError:
        time = 'day'
    try:
        if event['day'] in days:
            day = event['day']
        else:
            day = ''
    except KeyError:
        day = ''
    # Generate a greeting
    greeting = 'Good ' + time + ', ' + name + ' of ' + \
        city + '.' + ['', ' Happy ' + day + '!'][day != '']
    # Log the greeting to CloudWatch
    print(greeting)

    # Return a greeting to the caller
    return {"greeting": greeting}

Für die benutzerdefinierte Lambda-Integration übergibt API Gateway die Eingabe an die Lambda-Funktion vom Client als Integrationsanforderungsdaten. Das event-Objekt des Lambda-Funktionshandlers ist die Eingabe.

Unsere Lambda-Funktion ist einfach. Sie analysiert das event-Objekt mit der Eingabe auf die Eigenschaften name, city, time und day. Sie gibt anschließend ein JSON-Objekt {"message":greeting} an den Aufrufer zurück. Die Nachricht nutzt das "Good [morning|afternoon|day], [name|you] in [city|World]. Happy day!"-Muster. Es wird angenommen, dass die Eingabe an die Lambda-Funktion das folgenden JSON-Objekt ist:

{
  "city": "...",
  "time": "...",
  "day": "...",
  "name" : "..."
}

Weitere Informationen finden Sie im AWS Lambda -Entwicklerhandbuch.

Darüber hinaus protokolliert die Funktion ihre Ausführung bei Amazon, CloudWatch indem sie aufruftconsole.log(...). Dies ist hilfreich, wenn Sie die Funktionsaufrufe zum Debuggen nachverfolgen möchten. Damit die GetStartedLambdaIntegration Funktion den Anruf protokollieren kann, richten Sie eine IAM-Rolle mit entsprechenden Richtlinien für die Lambda-Funktion ein, um die CloudWatch Streams zu erstellen und Protokolleinträge zu den Streams hinzuzufügen. Die Lambda-Konsole führt Sie durch die Erstellung der erforderlichen IAM-Rollen und Richtlinien.

Wenn Sie die API einrichten, ohne die API Gateway-Konsole zu verwenden, wie z. B. beim Import einer API aus einer OpenAPI-Datei, müssen Sie, falls erforderlich, explizit eine Aufrufrolle und Richtlinien für API Gateway erstellen und einrichten, um die Lambda-Funktionen aufzurufen. Weitere Informationen über das Einrichten von Lambda-Aufruf- und Ausführungsrollen für eine API Gateway-API finden Sie unter Zugriffskontrolle für eine API mit IAM-Berechtigungen.

Im Vergleich mit GetStartedLambdaProxyIntegration, der Lambda-Proxy-Integration, nimmt die GetStartedLambdaIntegration Lambda-Funktion für die benutzerdefinierte Lambda-Integration nur Eingaben aus den API Gateway API-Integrationsanforderungsdaten entgegen. Die Funktion kann eine Ausgabe als beliebiges JSON-Objekt, als Zeichenfolge, als Boolean oder sogar Binär-Blob zurückgeben. Die Lambda-Funktion für die Lambda-Proxy-Integration kann dagegen die Eingabe von beliebigen Anfragedaten entgegennehmen, muss aber ein bestimmtes JSON-Objekt zurückgeben. Die GetStartedLambdaIntegration-Funktion für die benutzerdefinierte Lambda-Integration kann API-Anfrageparameter als Eingabe nutzen, sofern API Gateway die erforderlichen API-Anfrageparameter vor dem Weiterleiten der Anfrage an das Backend zum Anfragetext zuordnet. Hierzu muss der API-Entwickler beim Erstellen der API eine Mapping-Vorlage für die API-Methode erstellen und konfigurieren.

Erstellen Sie jetzt die GetStartedLambdaIntegration Lambda-Funktion.

Als Zusatzaufgabe können Sie die IAM-Konsole verwenden, um die IAM-Rolle (GetStartedLambdaIntegrationRole) anzuzeigen, die bei der Erstellung der Lambda-Funktion erstellt wurde. An diese IAM-Rolle sind zwei Inline-Richtlinien angehängt. Eine legt die grundlegenden Berechtigungen für die Ausführung von Lambda fest. Es ermöglicht das CloudWatch CreateLogGroup Aufrufen aller CloudWatch Ressourcen Ihres Kontos in der Region, in der die Lambda-Funktion erstellt wurde. Diese Richtlinie ermöglicht auch das Erstellen der CloudWatch Streams und das Protokollieren von Ereignissen für die GetStartedLambdaIntegration Lambda-Funktion.

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": "logs:CreateLogGroup",
            "Resource": "arn:aws:logs:region:account-id:*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "logs:CreateLogStream",
                "logs:PutLogEvents"
            ],
            "Resource": [
                "arn:aws:logs:region:account-id:log-group:/aws/lambda/GetStartedLambdaIntegration:*"
            ]
        }
    ]
}

Das andere Richtliniendokument bezieht sich auf das Aufrufen eines anderen AWS Dienstes, der in diesem Beispiel nicht verwendet wird. Sie können sie überspringen.

Der IAM-Rolle ist eine vertrauenswürdige Entität zugeordnet. Diese ist lambda.amazonaws.com. Hier ist die Vertrauensstellung:

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

Die Kombination aus dieser Vertrauensbeziehung und der Inline-Richtlinie ermöglicht es der Lambda-Funktion, eine console.log() Funktion aufzurufen, um Ereignisse in Logs zu protokollieren. CloudWatch

API mit Lambda Nicht-Proxy-Integration erstellen

Wenn die Lambda-Funktion (GetStartedLambdaIntegration) erstellt und getestet ist, können Sie die Funktion über eine API Gateway-API zur Verfügung stellen. Zur Veranschaulichung stellen wir die Lambda-Funktion mit einer generischen HTTP-Methode bereit. Wir verwenden den Anforderungstext, eine URL-Pfadvariable, eine Abfragezeichenfolge und einen Header für den Empfang der erforderlichen Eingabedaten vom Client. Wir schalten den API Gateway-Anfragevalidierer für die API ein, um sicherzustellen, dass alle erforderlichen Daten korrekt definiert und spezifiziert sind. Wir konfigurieren eine Zuordnungsvorlage für API Gateway, um die vom Kunden bereitgestellten Anfragedaten in das Format zu transformieren, das von der Backend-Lambda-Funktion benötigt wird.

Nachdem Sie eine API erstellt haben, können Sie nun eine /{city}-Ressource erstellen. Dies ist ein Beispiel für eine Ressource mit einer Pfadvariablen, die Eingaben vom Client annimmt. In einem späteren Schritt werden Sie diese Pfadvariable der Lambda-Funktionseingabe mittels einer Zuordnungsvorlage zuweisen.

Nachdem Sie eine /{city}-Ressource erstellt haben, können Sie nun eine ANY-Methode erstellen. Das ANY HTTP-Verb ist ein Platzhalter für eine gültige HTTP-Methode, die ein Client zur Laufzeit sendet. Dieses Beispiel zeigt, dass die ANY-Methode sowohl für die benutzerdefinierte Integration von Lambda als auch für die Integration von Lambda-Proxys verwendet werden kann.

Nachdem Sie einen Anforderungs-Validator aktiviert haben, konfigurieren Sie die Integrationsanforderung für die ANY-Methode, indem Sie eine Textzuordnungsvorlage hinzufügen, um die eingehende Anfrage in eine JSON-Nutzlast umzuwandeln, wie es die Backend-Lambda-Funktion erfordert.

Testaufruf der API-Methode

Die API Gateway-Konsole bietet Ihnen eine Testmöglichkeit, mit der Sie den Aufruf der API testen können, bevor sie bereitgestellt wird. Sie verwenden die Testfunktion der Konsole, um die API über das Senden der folgenden Anforderung zu testen:

POST /Seattle?time=morning
day:Wednesday

{
    "callerName": "John"
}

In dieser Testanforderung legen Sie ANY auf POSTfest, {city} auf Seattle, weisen Wednesday als day-Header-Wert zu und weisen "John" als callerName-Wert zu.

Überprüfen Sie, ob die zurückgegebene Antwortnutzlast wie folgt lautet:

{
  "greeting": "Good morning, John of Seattle. Happy Wednesday!"
}

Sie können außerdem die Protokolle anzeigen, um zu untersuchen, wie API Gateway die Anfrage und Antwort verarbeitet.

Execution log for request test-request
Thu Aug 31 01:07:25 UTC 2017 : Starting execution for request: test-invoke-request
Thu Aug 31 01:07:25 UTC 2017 : HTTP Method: POST, Resource Path: /Seattle
Thu Aug 31 01:07:25 UTC 2017 : Method request path: {city=Seattle}
Thu Aug 31 01:07:25 UTC 2017 : Method request query string: {time=morning}
Thu Aug 31 01:07:25 UTC 2017 : Method request headers: {day=Wednesday}
Thu Aug 31 01:07:25 UTC 2017 : Method request body before transformations: { "callerName": "John" }
Thu Aug 31 01:07:25 UTC 2017 : Request validation succeeded for content type application/json
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request URI: https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request headers: {x-amzn-lambda-integration-tag=test-request, Authorization=****************************************************************************************************************************************************************************************************************************************************************************************************************************************338c72, X-Amz-Date=20170831T010725Z, x-amzn-apigateway-api-id=beags1mnid, X-Amz-Source-Arn=arn:aws:execute-api:us-west-2:123456789012:beags1mnid/null/POST/{city}, Accept=application/json, User-Agent=AmazonAPIGateway_beags1mnid, X-Amz-Security-Token=FQoDYXdzELL//////////wEaDMHGzEdEOT/VvGhabiK3AzgKrJw+3zLqJZG4PhOq12K6W21+QotY2rrZyOzqhLoiuRg3CAYNQ2eqgL5D54+63ey9bIdtwHGoyBdq8ecWxJK/YUnT2Rau0L9HCG5p7FC05h3IvwlFfvcidQNXeYvsKJTLXI05/yEnY3ttIAnpNYLOezD9Es8rBfyruHfJfOqextKlsC8DymCcqlGkig8qLKcZ0hWJWVwiPJiFgL7laabXs++ZhCa4hdZo4iqlG729DE4gaV1mJVdoAagIUwLMo+y4NxFDu0r7I0/EO5nYcCrppGVVBYiGk7H4T6sXuhTkbNNqVmXtV3ch5bOlh7 [TRUNCATED]
Thu Aug 31 01:07:25 UTC 2017 : Endpoint request body after transformations: {
  "city": "Seattle",
  "time": "morning",
  "day": "Wednesday",
  "name" : "John"
}
Thu Aug 31 01:07:25 UTC 2017 : Sending request to https://lambda.us-west-2.amazonaws.com/2015-03-31/functions/arn:aws:lambda:us-west-2:123456789012:function:GetStartedLambdaIntegration/invocations
Thu Aug 31 01:07:25 UTC 2017 : Received response. Integration latency: 328 ms
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response body before transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Endpoint response headers: {x-amzn-Remapped-Content-Length=0, x-amzn-RequestId=c0475a28-8de8-11e7-8d3f-4183da788f0f, Connection=keep-alive, Content-Length=62, Date=Thu, 31 Aug 2017 01:07:25 GMT, X-Amzn-Trace-Id=root=1-59a7614d-373151b01b0713127e646635;sampled=0, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Method response body after transformations: {"greeting":"Good morning, John of Seattle. Happy Wednesday!"}
Thu Aug 31 01:07:25 UTC 2017 : Method response headers: {X-Amzn-Trace-Id=sampled=0;root=1-59a7614d-373151b01b0713127e646635, Content-Type=application/json}
Thu Aug 31 01:07:25 UTC 2017 : Successfully completed execution
Thu Aug 31 01:07:25 UTC 2017 : Method completed with status: 200

Die Protokolle zeigen die eingehende Anforderung vor der Zuordnung und die Integrationsanforderung nach der Zuordnung. Wenn ein Test fehlschlägt, sind die Protokolle nützlich, um zu prüfen, ob die ursprüngliche Eingabe korrekt ist oder ob die Mapping-Vorlage ordnungsgemäß funktioniert.

Bereitstellen der API

Der Testaufruf ist eine Simulation und hat Einschränkungen. Beispielsweise umgeht er alle Autorisierungsmechanismen für die API. Zum Testen der API-Ausführung in Echtzeit müssen Sie die API bereitstellen. Um eine API bereitzustellen, können Sie einen Snapshot der API erstellen. Der Stufenname definiert den Basispfad entsprechend dem standardmäßigen Hostnamen der API. Die Root-Ressource der API wird nach dem Stufenamen angehängt. Wenn Sie die API ändern, müssen Sie sie erneut für eine neue oder bestehende Stufe bereitstellen, bevor die Änderungen wirksam werden.

Wählen Sie unter Stufendetails das Kopiersymbol aus, um die Aufruf-URL Ihrer API zu kopieren. Das allgemeine Muster der Basis-URL lautet https://api-id.region.amazonaws.com/stageName. Wenn beispielsweise die Basis-URL der API (beags1mnid) in der Region us-west-2 erstellt und für die Stufe test bereitgestellt wird, lautet der Name https://beags1mnid.execute-api.us-west-2.amazonaws.com/test.

Testen der API in einer Bereitstellungsstufe

Es gibt mehrere Möglichkeiten zum Testen einer bereitgestellten API. Für GET-Anforderungen mit nur URL-Pfadvariablen oder Parameter für Abfragezeichenfolgen können Sie die API-Ressourcen-URL in einem Browser eingeben. Für andere Methoden müssen Sie erweiterte REST-API-Testtools wie POSTMAN oder cURL verwenden.

Bereinigen

Wenn Sie die für diese Anleitung erstellten Lambda-Funktionen nicht mehr benötigen, können Sie diese nun löschen. Sie können auch die zugehörigen IAM-Ressourcen löschen.