Verwendung von AWS Lambda mit API-Gateway

Verwenden von AWS Lambda mit API Gateway

1. Überblick

AWS Lambda ist ein serverloser Computerdienst, der von Amazon Web Services bereitgestellt wird.

In zwei vorherigen Artikeln haben wir sowohlhow to create an AWS Lambda function using Java als auchhow to access DynamoDB from a Lambda function besprochen.

In diesem Tutorial werden wirhow to publish a Lambda function as a REST endpoint, using AWS Gateway diskutieren.

Wir werden uns die folgenden Themen genauer ansehen:

Grundlegende Konzepte und Begriffe von API Gateway
Integration von Lambda-Funktionen mit API-Gateway unter Verwendung der Lambda-Proxy-Integration
Erstellung einer API, ihrer Struktur und Zuordnung der API-Ressourcen zu Lambda-Funktionen
Bereitstellung und Test der API

2. Grundlagen und Begriffe

API-Gateway ist einfully managed service that enables developers to create, publish, maintain, monitor, and secure APIs at any scale.

Wir können eine konsistente und skalierbare HTTP-basierte Programmierschnittstelle (auch als RESTful-Services bezeichnet)to access backend services like Lambda functions, further AWS services (e.g., EC2, S3, DynamoDB), and any HTTP endpoints implementieren.

Eigenschaften umfassen, sind aber nicht beschränkt auf:

Verkehrsregelung
Autorisierung und Zugangskontrolle
Überwachung
API-Versionsverwaltung
Drosselung von Anforderungen, um Angriffe zu verhindern

API Gateway wird wie AWS Lambda automatisch verkleinert und pro API-Aufruf abgerechnet.

Detaillierte Informationen finden Sie inofficial documentation.

2.1. Bedingungen

API Gateway ist ein AWS-Service, der das Erstellen, Bereitstellen und Verwalten einer RESTful-Anwendungsprogrammierschnittstelle unterstützt, um Backend-HTTP-Endpunkte, AWS Lambda-Funktionen und andere AWS-Services verfügbar zu machen.

EinAPI Gateway API ist eine Sammlung von Ressourcen und Methoden, die in Lambda-Funktionen, andere AWS-Services oder HTTP-Endpunkte im Backend integriert werden können. Die API besteht aus Ressourcen, die die API-Struktur bilden. Jede API-Ressource kann eine oder mehrere API-Methoden verfügbar machen, die eindeutige HTTP-Verben aufweisen müssen.

Um eine API zu veröffentlichen, müssen wir einAPI deployment erstellen und es einem sogenanntenstage zuordnen. Eine Phase ist wie eine Momentaufnahme der API. Wenn wir eine API erneut bereitstellen, können wir entweder eine vorhandene Stufe aktualisieren oder eine neue erstellen. Auf diese Weise sind verschiedene Versionen einer API gleichzeitig möglich, beispielsweise einedev-Stufe, einetest-Stufe und sogar mehrere Produktionsversionen, wiev1,v2 usw.

Lambda Proxy integration ist eine vereinfachte Konfiguration für die Integration zwischen Lambda-Funktionen und API-Gateway.

Das API-Gateway sendet die gesamte Anforderung als Eingabe an eine Lambda-Backend-Funktion. Das API-Gateway wandelt die Ausgabe der Lambda-Funktion in eine Frontend-HTTP-Antwort um.

3. Abhängigkeiten

Wir benötigen dieselben Abhängigkeiten wie im Artikel vonAWS Lambda Using DynamoDB With Java.

Darüber hinaus benötigen wir die BibliothekJSON Simple:


    com.googlecode.json-simple
    json-simple
    1.1.1

4. Entwickeln und Bereitstellen der Lambda-Funktionen

In diesem Abschnitt werden wir unsere Lambda-Funktionen in Java entwickeln und erstellen, sie mithilfe der AWS-Konsole bereitstellen und einen kurzen Test durchführen.

Um die grundlegenden Funktionen der Integration von API Gateway in Lambda zu demonstrieren, erstellen wir zwei Funktionen:

Function 1: empfängt eine Nutzlast von der API unter Verwendung einer PUT-Methode
Function 2: zeigt, wie ein HTTP-Pfadparameter oder ein HTTP-Abfrageparameter verwendet wird, der von der API stammt

In Bezug auf die Implementierung erstellen wir eineRequestHandler-Klasse mit zwei Methoden - eine für jede Funktion.

4.1. Modell

Bevor wir den eigentlichen Anforderungshandler implementieren, werfen wir einen kurzen Blick auf unser Datenmodell:

public class Person {

    private int id;
    private String name;

    public Person(String json) {
        Gson gson = new Gson();
        Person request = gson.fromJson(json, Person.class);
        this.id = request.getId();
        this.name = request.getName();
    }

    public String toString() {
        Gson gson = new GsonBuilder().setPrettyPrinting().create();
        return gson.toJson(this);
    }

    // getters and setters
}

Unser Modell besteht aus einer einfachenPerson-Klasse mit zwei Eigenschaften. Der einzige bemerkenswerte Teil ist der KonstruktorPerson(String), der einen JSON-String akzeptiert.

4.2. Implementierung der RequestHandler-Klasse

Genau wie im Artikel vonAWS Lambda With Javaerstellen wir eine Implementierung der Schnittstelle vonRequestStreamHandler:

public class APIDemoHandler implements RequestStreamHandler {

    private static final String DYNAMODB_TABLE_NAME = System.getenv("TABLE_NAME");

    @Override
    public void handleRequest(
      InputStream inputStream, OutputStream outputStream, Context context)
      throws IOException {

        // implementation
    }

    public void handleGetByParam(
      InputStream inputStream, OutputStream outputStream, Context context)
      throws IOException {

        // implementation
    }
}

Wie wir sehen können, definiert dieRequestStreamHander-Schnittstelle nur eine Methode,handeRequest(). Wie auch immer, wir können weitere Funktionen in derselben Klasse definieren, wie wir es hier getan haben. Eine andere Möglichkeit wäre, eine Implementierung vonRequestStreamHander für jede Funktion zu erstellen.

In unserem speziellen Fall haben wir die erstere der Einfachheit halber gewählt. Die Auswahl muss jedoch von Fall zu Fall getroffen werden, wobei Faktoren wie die Leistung und die Wartbarkeit des Codes zu berücksichtigen sind.

Wir lesen auch den Namen unserer DynamoDB-Tabelle aus der Senvironment-VariablenTABLE_NAME . Wir werden diese Variable später während der Bereitstellung definieren.

4.3. Implementierung von Funktion 1

In unserer ersten Funktion wollen wirhow to get a payload (like from a PUT or POST request) from the API Gateway demonstrieren:

public void handleRequest(
  InputStream inputStream,
  OutputStream outputStream,
  Context context)
  throws IOException {

    JSONParser parser = new JSONParser();
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    JSONObject responseJson = new JSONObject();

    AmazonDynamoDB client = AmazonDynamoDBClientBuilder.defaultClient();
    DynamoDB dynamoDb = new DynamoDB(client);

    try {
        JSONObject event = (JSONObject) parser.parse(reader);

        if (event.get("body") != null) {
            Person person = new Person((String) event.get("body"));

            dynamoDb.getTable(DYNAMODB_TABLE_NAME)
              .putItem(new PutItemSpec().withItem(new Item().withNumber("id", person.getId())
                .withString("name", person.getName())));
        }

        JSONObject responseBody = new JSONObject();
        responseBody.put("message", "New item created");

        JSONObject headerJson = new JSONObject();
        headerJson.put("x-custom-header", "my custom header value");

        responseJson.put("statusCode", 200);
        responseJson.put("headers", headerJson);
        responseJson.put("body", responseBody.toString());

    } catch (ParseException pex) {
        responseJson.put("statusCode", 400);
        responseJson.put("exception", pex);
    }

    OutputStreamWriter writer = new OutputStreamWriter(outputStream, "UTF-8");
    writer.write(responseJson.toString());
    writer.close();
}

Wie bereits erwähnt, konfigurieren wir die API später für die Verwendung der Lambda-Proxy-Integration. Wir erwarten, dass das API-Gateway die vollständige Anforderung im ParameterInputStreaman die Lambda-Funktion übergibt.

Wir müssen lediglich die relevanten Attribute aus der enthaltenen JSON-Struktur auswählen.

Wie wir sehen können, besteht die Methode im Wesentlichen aus drei Schritten:

Abrufen desbody-Objekts aus unserem Eingabestream und Erstellen einesPerson-Objekts daraus
Speichern desPerson-Objekts in einer DynamoDB-Tabelle
Erstellen eines JSON-Objekts, das mehrere Attribute enthalten kann, z. B.body für die Antwort, benutzerdefinierte Header sowie einen HTTP-Statuscode

Ein Punkt, der hier erwähnt werden sollte: API Gateway erwartet, dassbodyString sind (sowohl für die Anforderung als auch für die Antwort).

Da wir erwarten, dassString alsbody vom API-Gateway abgerufen werden, wandeln wirbody inString um und initialisieren unserPerson-Objekt:

Person person = new Person((String) event.get("body"));

API Gateway erwartet außerdem, dass die AntwortbodyString beträgt:

responseJson.put("body", responseBody.toString());

Dieses Thema wird in der offiziellen Dokumentation nicht explizit erwähnt. Wenn wir jedoch genau hinschauen, können wir sehen, dass das body-Attribut in beiden Snippetsfor the request undfor the response einString ist.

Der Vorteil sollte klar sein: Auch wenn JSON das Format zwischen API-Gateway und der Lambda-Funktion ist, kann der eigentliche Body Klartext, JSON, XML oder was auch immer enthalten. Es liegt dann in der Verantwortung der Lambda-Funktion, das Format richtig zu handhaben.

Wir werden später sehen, wie der Anforderungs- und Antworttext aussieht, wenn wir unsere Funktionen in der AWS-Konsole testen.

Gleiches gilt auch für die folgenden beiden Funktionen.

4.4. Implementation of Funktion 2

In einem zweiten Schritt möchten wirhow to use a path parameter or a query string parameter zum Abrufen einesPerson-Elements aus der Datenbank unter Verwendung seiner ID demonstrieren:

public void handleGetByParam(
  InputStream inputStream, OutputStream outputStream, Context context)
  throws IOException {

    JSONParser parser = new JSONParser();
    BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
    JSONObject responseJson = new JSONObject();

    AmazonDynamoDB client = AmazonDynamoDBClientBuilder.defaultClient();
    DynamoDB dynamoDb = new DynamoDB(client);

    Item result = null;
    try {
        JSONObject event = (JSONObject) parser.parse(reader);
        JSONObject responseBody = new JSONObject();

        if (event.get("pathParameters") != null) {
            JSONObject pps = (JSONObject) event.get("pathParameters");
            if (pps.get("id") != null) {
                int id = Integer.parseInt((String) pps.get("id"));
                result = dynamoDb.getTable(DYNAMODB_TABLE_NAME).getItem("id", id);
            }
        } else if (event.get("queryStringParameters") != null) {
            JSONObject qps = (JSONObject) event.get("queryStringParameters");
            if (qps.get("id") != null) {

                int id = Integer.parseInt((String) qps.get("id"));
                result = dynamoDb.getTable(DYNAMODB_TABLE_NAME)
                  .getItem("id", id);
            }
        }
        if (result != null) {
            Person person = new Person(result.toJSON());
            responseBody.put("Person", person);
            responseJson.put("statusCode", 200);
        } else {
            responseBody.put("message", "No item found");
            responseJson.put("statusCode", 404);
        }

        JSONObject headerJson = new JSONObject();
        headerJson.put("x-custom-header", "my custom header value");

        responseJson.put("headers", headerJson);
        responseJson.put("body", responseBody.toString());

    } catch (ParseException pex) {
        responseJson.put("statusCode", 400);
        responseJson.put("exception", pex);
    }

    OutputStreamWriter writer = new OutputStreamWriter(outputStream, "UTF-8");
    writer.write(responseJson.toString());
    writer.close();
}

Auch hier sind drei Schritte relevant:

Wir prüfen, ob einpathParameters- oder einqueryStringParameters-Array mit einemid-Attribut vorhanden ist.
Wenntrue, verwenden wir den zugehörigen Wert, um einPerson-Element mit dieser ID aus der Datenbank anzufordern.
Wir fügen der Antwort eine JSON-Darstellung des empfangenen Elements hinzu.

Die offizielle Dokumentation enthält eine detailliertere Erläuterung voninput format undoutput format für die Proxy-Integration.

4.5. Bau Code

Auch hier können wir unseren Code einfach mit Maven erstellen:

mvn clean package shade:shade

Die JAR-Datei wird im Ordnertargeterstellt.

4.6. Erstellen der DynamoDB-Tabelle

Wir können die Tabelle wie inAWS Lambda Using DynamoDB With Java erläutert erstellen.

Wählen SiePerson als Tabellennamen,id als Primärschlüsselname undNumber als Typ des Primärschlüssels.

4.7. Bereitstellen von Code über AWS Console

Nachdem wir unseren Code erstellt und die Tabelle erstellt haben, können wir nun die Funktionen erstellen und den Code hochladen.

Dies kann erreicht werden, indem die Schritte 1 bis 5 aus dem ArtikelAWS Lambda with Javaeinmal für jede unserer beiden Methoden wiederholt werden.

Verwenden wir die folgenden Funktionsnamen:

StorePersonFunction für diehandleRequest-Methode (Funktion 1)
GetPersonByHTTPParamFunction für die MethodehandleGetByParam (Funktion 2)

Wir müssen auch eine UmgebungsvariableTABLE_NAME mit dem Wert“Person” definieren.

4.8. Testen der Funktionen

Bevor wir mit dem eigentlichen API-Gateway-Teil fortfahren, können wir einen kurzen Test in der AWS-Konsole durchführen, um zu überprüfen, ob unsere Lambda-Funktionen ordnungsgemäß ausgeführt werden und das Proxy-Integrationsformat verarbeiten können.

Das Testen einer Lambda-Funktion über die AWS-Konsole funktioniert wie im Artikel vonAWS Lambda with Javabeschrieben.

Allerdingswhen we create a test event, we have to consider the special Proxy Integration format, die unsere Funktionen erwarten. Wir können entweder die VorlageAPI Gateway AWS Proxyverwenden und diese an unsere Bedürfnisse anpassen, oder wir können die folgenden Ereignisse kopieren und einfügen:

Für dieStorePersonFunction sollten wir Folgendes verwenden:

{
    "body": "{\"id\": 1, \"name\": \"John Doe\"}"
}

Wie bereits erwähnt, müssenbody den TypString haben, auch wenn sie eine JSON-Struktur enthalten. Der Grund ist, dass das API-Gateway seine Anforderungen im gleichen Format sendet.

Die folgende Antwort sollte zurückgegeben werden:

{
    "isBase64Encoded": false,
    "headers": {
        "x-custom-header": "my custom header value"
    },
    "body": "{\"message\":\"New item created\"}",
    "statusCode": 200
}

Hier können wir sehen, dassbody unserer AntwortString ist, obwohl es eine JSON-Struktur enthält.

Schauen wir uns die Eingabe fürGetPersonByHTTPParamFunction.an

Zum Testen der Funktionalität der Pfadparameter sieht die Eingabe folgendermaßen aus:

{
    "pathParameters": {
        "id": "1"
    }
}

Und die Eingabe zum Senden eines Abfragezeichenfolgenparameters wäre:

{
    "queryStringParameters": {
        "id": "1"
    }
}

Als Antwort sollten wir für beide Fälle die folgenden Methoden erhalten:

{
  "headers": {
    "x-custom-header": "my custom header value"
  },
  "body": "{\"Person\":{\n  \"id\": 88,\n  \"name\": \"John Doe\"\n}}",
  "statusCode": 200
}

Wiederum istbody einString.

5. Erstellen und Testen der API

Nachdem wir die Lambda-Funktionen im vorherigen Abschnitt erstellt und bereitgestellt haben,we can now create the actual API using the AWS Console.

Schauen wir uns den grundlegenden Workflow an:

Erstellen Sie eine API in unserem AWS-Konto.
Fügen Sie der Ressourcenhierarchie der API eine Ressource hinzu.
Erstellen Sie eine oder mehrere Methoden für die Ressource.
Stellen Sie die Integration zwischen einer Methode und der zugehörigen Lambda-Funktion ein.

In den folgenden Abschnitten wiederholen wir die Schritte 2 bis 4 für jede unserer beiden Funktionen.

5.1. API erstellen

Zum Erstellen der API müssen wir:

Melden Sie sich beihttps://console.aws.amazon.com/apigateway bei der API-Gateway-Konsole an
Klicken Sie auf "Erste Schritte" und wählen Sie dann "Neue API"
Geben Sie den Namen unserer API (TestAPI) ein und bestätigen Sie, indem Sie auf "API erstellen" klicken.

Nachdem wir die API erstellt haben, können wir nun die API-Struktur erstellen und sie mit unseren Lambda-Funktionen verknüpfen.

5.2. API-Struktur für Funktion 1

Die folgenden Schritte sind für unsereStorePersonFunction erforderlich:

Wählen Sie das übergeordnete Ressourcenelement im Baum "Ressourcen" aus und wählen Sie dann "Ressource erstellen" aus dem Dropdown-Menü "Aktionen". Dann müssen wir im Bereich "Neue untergeordnete Ressource" Folgendes tun:
- Geben Sie "Personen" als Namen in das Eingabetextfeld "Ressourcenname" ein
- Behalten Sie den Standardwert im Eingabetextfeld „Ressourcenpfad“ bei
- Wählen Sie "Ressource erstellen"
Wählen Sie die soeben erstellte Ressource aus, wählen Sie im Dropdown-Menü "Aktionen" die Option "Methode erstellen" und führen Sie die folgenden Schritte aus:
- Wählen Sie in der Dropdown-Liste HTTP-Methode die Option PUT und klicken Sie dann auf das Häkchensymbol, um die Auswahl zu speichern
- Belassen Sie "Lambda-Funktion" als Integrationstyp und wählen Sie die Option "Lambda-Proxy-Integration verwenden"
- Wählen Sie unter „Lambda-Region“ die Region aus, in der wir zuvor unsere Lambda-Funktionen bereitgestellt haben
- Geben Sie“StorePersonFunction” in „Lambda-Funktion“ ein.
Wählen Sie "Speichern" und bestätigen Sie mit "OK", wenn Sie mit "Add Permission to Lambda Function" dazu aufgefordert werden.

5.3. API-Struktur für Funktion 2 - Pfadparameter

Die Schritte zum Abrufen der Pfadparameter sind ähnlich:

Wählen Sie das Ressourcenelement/personsim Baum "Ressourcen" aus und wählen Sie dann "Ressource erstellen" aus dem Dropdown-Menü "Aktionen". Dann müssen wir im Bereich Neue untergeordnete Ressource Folgendes tun:
- Geben Sie“Person” als Namen in das Eingabetextfeld "Ressourcenname" ein
- Ändern Sie das Eingabetextfeld „Ressourcenpfad“ in“{id}”
- Wählen Sie "Ressource erstellen"
Wählen Sie die soeben erstellte Ressource aus, wählen Sie im Dropdown-Menü "Aktionen" die Option "Methode erstellen" und führen Sie die folgenden Schritte aus:
- Wählen Sie in der Dropdown-Liste HTTP-Methode die Option GET und klicken Sie dann auf das Häkchensymbol, um die Auswahl zu speichern
- Belassen Sie "Lambda-Funktion" als Integrationstyp und wählen Sie die Option "Lambda-Proxy-Integration verwenden"
- Wählen Sie unter „Lambda-Region“ die Region aus, in der wir zuvor unsere Lambda-Funktionen bereitgestellt haben
- Geben Sie“GetPersonByHTTPParamFunction” in "Lambda-Funktion" ein.
Wählen Sie "Speichern" und bestätigen Sie mit "OK", wenn Sie mit "Add Permission to Lambda Function" dazu aufgefordert werden.

Hinweis: Hier ist es wichtig, den Parameter "Ressourcenpfad" auf“{id}” zu setzen, da unserGetPersonByPathParamFunction expect erwartet, dass dieser Parameter genau so benannt wird.

5.4. API-Struktur für Funktion 2 - Abfragezeichenfolgenparameter

Die Schritte zum Empfangen von Abfragezeichenfolgenparametern sind etwas anders alswe don’t have to create a resource, but instead have to create a query parameter for the id parameter:

Wählen Sie das Ressourcenelement/personsim Baum "Ressourcen" aus, wählen Sie "Methode erstellen" aus dem Dropdown-Menü "Aktionen" und führen Sie die folgenden Schritte aus:
- Wählen Sie in der Dropdown-Liste HTTP-Methode die Option GET und klicken Sie dann auf das Häkchensymbol, um die Auswahl zu speichern
- Belassen Sie "Lambda-Funktion" als Integrationstyp und wählen Sie die Option "Lambda-Proxy-Integration verwenden"
- Wählen Sie unter „Lambda-Region“ die Region aus, in der wir zuvor unsere Lambda-Funktionen bereitgestellt haben
- Geben Sie“GetPersonByHTTPParamFunction” in „Lambda-Funktion“ ein.
Wählen Sie "Speichern" und bestätigen Sie mit "OK", wenn Sie mit "Add Permission to Lambda Function" dazu aufgefordert werden.
Wählen Sie rechts „Method Request“ und führen Sie folgende Schritte durch:
- Erweitern Sie die Liste URL Query String Parameters
- Klicken Sie auf "Add Query String"
- Geben Sie“id” in das Namensfeld ein und wählen Sie das zu speichernde Häkchensymbol
- Aktivieren Sie das Kontrollkästchen "Erforderlich"
- Klicken Sie oben im Bereich auf das Stiftsymbol neben "Request validator", wählen Sie "Validate query string parameters and headers" und klicken Sie auf das Häkchensymbol

Hinweis: Es ist wichtig, den Parameter "Query String" auf“id” zu setzen, da unserGetPersonByHTTPParamFunction expect erwartet, dass dieser Parameter genau so benannt wird.

5.5. Testen der API

Unsere API ist jetzt fertig, aber noch nicht öffentlich. Before we publish it, we want to run a quick test from the Console first.

Dazu können wir im Baum „Ressourcen“ die jeweilige zu testende Methode auswählen und auf die Schaltfläche „Test“ klicken. Auf dem folgenden Bildschirm können wir unsere Eingabe so eingeben, als würden wir sie mit einem Client über HTTP senden.

FürStorePersonFunction müssen wir die folgende Struktur in das Feld "Request Body" eingeben:

{
    "id": 2,
    "name": "Jane Doe"
}

FürGetPersonByHTTPParamFunction mit Pfadparametern müssen wir2 als Wert in das Feld "{id}" unter "Pfad" eingeben.

Für dieGetPersonByHTTPParamFunction with-Abfragezeichenfolgenparameter müssen wirid=2 als Wert in das Feld "{Personen}" unter "Abfragezeichenfolgen" eingeben.

5.6. Bereitstellen der API

Bisher war unsere API nicht öffentlich und daher nur über die AWS-Konsole verfügbar.

Wie zuvor diskutiert,when we deploy an API, we have to associate it with a stage, which is like a snapshot in time of the API. If we redeploy an API, we can either update an existing stage or create a new one.

Mal sehen, wie das URL-Schema für unsere API aussehen wird:

https://{restapi-id}.execute-api.{region}.amazonaws.com/{stageName}

Die folgenden Schritte sind für die Bereitstellung erforderlich:

Wählen Sie die bestimmte API im Navigationsbereich „APIs“ aus
Wählen Sie im Ressourcennavigationsbereich "Aktionen" und im Dropdown-Menü "Aktionen" die Option "API bereitstellen"
Wählen Sie "[Neue Phase]" aus der Dropdown-Liste "Bereitstellungsphase", geben Sie“test” in "Stufenname" ein und geben Sie optional eine Beschreibung der Phase und Bereitstellung an
Lösen Sie die Bereitstellung aus, indem Sie "Bereitstellen" auswählen.

Nach dem letzten Schritt stellt die Konsole die Stamm-URL der API bereit, z. B.https://0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test.

5.7. Aufrufen des Endpunkts

Da die API jetzt öffentlich ist,we can call it using any HTTP client we want.

MitcURL würden die Aufrufe wie folgt aussehen.

StorePersonFunction:

curl -X PUT 'https://0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test/persons' \
  -H 'content-type: application/json' \
  -d '{"id": 3, "name": "Richard Roe"}'

GetPersonByHTTPParamFunction für Pfadparameter:

curl -X GET 'https://0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test/persons/3' \
  -H 'content-type: application/json'

GetPersonByHTTPParamFunction für Abfragezeichenfolgenparameter:

curl -X GET 'https://0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test/persons?id=3' \
  -H 'content-type: application/json'

6. Fazit

In diesem Artikel wurde untersucht, wie AWS Lambda-Funktionen mithilfe von AWS API Gateway als REST-Endpunkte verfügbar gemacht werden.

Wir haben die grundlegenden Konzepte und die Terminologie von API Gateway untersucht und gelernt, wie Lambda-Funktionen mithilfe der Lambda-Proxy-Integration integriert werden.

Schließlich haben wir gesehen, wie eine API erstellt, bereitgestellt und getestet wird.

Wie üblich ist der gesamte Code für diesen Artikel überon GitHub verfügbar.

TOC