Az AWS Lambda használata az API átjáróval

1. Áttekintés

Az AWS Lambda egy szerver nélküli számítási szolgáltatás, amelyet az Amazon Web Services nyújt.

Két korábbi cikkünkben megvitattuk, hogyan hozhatunk létre AWS Lambda függvényt Java használatával, valamint hogyan érhetjük el a DynamoDB-t egy Lambda függvényből.

Ebben az oktatóanyagban megvitatjuk hogyan lehet közzétenni egy Lambda függvényt REST végpontként az AWS Gateway használatával.

Részletesen áttekintjük a következő témákat:

  • Az API Gateway alapfogalmai és fogalmai
  • A Lambda funkciók integrálása az API átjáróval a Lambda Proxy integráció segítségével
  • API létrehozása, annak felépítése és az API erőforrások leképezése a Lambda függvényekre
  • Az API telepítése és tesztelése

2. Alapok és feltételek

Az API Gateway egy teljesen felügyelt szolgáltatás, amely lehetővé teszi a fejlesztők számára, hogy bármilyen léptékben hozzanak létre, publikáljanak, karbantarthassanak, figyeljenek és biztonságos API-kat.

Megoldhatunk egy következetes és méretezhető HTTP alapú programozási felületet (más néven RESTful szolgáltatásokat) hozzáférés a háttérszolgáltatásokhoz, például a Lambda funkciókhoz, további AWS szolgáltatásokhoz (pl. EC2, S3, DynamoDB) és az esetleges HTTP végpontokhoz.

A szolgáltatások közé tartoznak a következők:

  • Forgalomszervezés
  • Engedélyezés és hozzáférés-ellenőrzés
  • Monitoring
  • API verziókezelés
  • Fojtási kérelmek a támadások megakadályozására

Az AWS Lambda-hoz hasonlóan az API-átjárót is automatikusan méretezik és API-hívásonként számlázzák.

Részletes információk a hivatalos dokumentációban találhatók.

2.1. Feltételek

API-átjáró egy olyan AWS-szolgáltatás, amely támogatja a RESTful alkalmazás-programozási felület létrehozását, telepítését és kezelését a háttérbeli HTTP-végpontok, az AWS Lambda-funkciók és más AWS-szolgáltatások feltárásához.

An API Gateway API olyan erőforrások és módszerek gyűjteménye, amelyek integrálhatók a Lambda funkciókba, más AWS-szolgáltatásokba vagy a háttérben lévő HTTP-végpontokba. Az API az API struktúráját alkotó erőforrásokból áll. Minden API-erőforrás egy vagy több olyan API-módszert tárhat fel, amelyeknek egyedi HTTP-igékkel kell rendelkezniük.

Az API közzétételéhez létre kell hoznunk egy API telepítés és társítsa egy ún színpad. A szakasz olyan, mint az API pillanatképe. Ha újratervezünk egy API-t, frissíthetünk egy meglévő stádiumot, vagy létrehozhatunk egy újat. Ezzel az API különböző verziói egyidejűleg lehetségesek, például a dev szakasz, a teszt színpadon, sőt több produkciós verzió is tetszik v1, v2stb.

Lambda Proxy integráció a Lambda funkciók és az API Gateway közötti egyszerűsített konfiguráció.

Az API átjáró a teljes kérést bemenetként elküldi egy háttér-Lambda függvénynek. Válaszonként az API Gateway átalakítja a Lambda függvény kimenetét egy frontend HTTP válaszgá.

3. Függőségek

Ugyanazokra a függőségekre lesz szükségünk, mint az AWS Lambda DynamoDB használata Java alkalmazásával cikkében.

Ezen felül szükségünk van a JSON Simple könyvtárra is:

 com.googlecode.json-simple json-simple 1.1.1 

4. A lambda funkciók fejlesztése és telepítése

Ebben a szakaszban fejlesztjük és építjük a Java-ban a Lambda-függvényeket, az AWS Console segítségével telepítjük és egy gyors tesztet futtatunk.

Mivel szeretnénk bemutatni az API Gateway és a Lambda integrálásának alapvető képességeit, két funkciót hozunk létre:

  • 1. funkció: hasznos terhet kap az API-tól, PUT módszer segítségével
  • 2. funkció: bemutatja, hogyan kell használni az API-ból érkező HTTP elérési út vagy paramétert

Megvalósítás szempontjából létrehozunk egyet RequestHandler osztály, amelynek két módszere van - minden funkcióhoz egy.

4.1. Modell

Mielőtt bevezetnénk a tényleges kéréskezelőt, nézzük meg gyorsan az adatmodellünket:

public class Személy {private int id; privát karakterlánc neve; public Person (String json) {Gson gson = new Gson (); Személykérés = gson.fromJson (json, Személyosztály); this.id = request.getId (); this.name = request.getName (); } public String toString () {Gson gson = new GsonBuilder (). setPrettyPrinting (). create (); vissza gson.toJson (ez); } // szerelők és beállítók}

Modellünk egy egyszerűből áll Személy osztály, amelynek két tulajdonsága van. Az egyetlen figyelemre méltó rész a Személy (húr) konstruktor, amely elfogadja a JSON karakterláncot.

4.2. A RequestHandler osztály megvalósítása

Csakúgy, mint az AWS Lambda With Java cikkben, létrehozunk egy megvalósítást a RequestStreamHandler felület:

public class APIDemoHandler implementálja a RequestStreamHandler {private static final String DYNAMODB_TABLE_NAME = System.getenv ("TABLE_NAME"); A @Orride public void handleRequest (InputStream inputStream, OutputStream outputStream, Context context) az IOException {// implementáció} public void handleGetByParam (InputStream inputStream, OutputStream outputStream, Context context) dobja az IOException {// implementáció}}

Mint láthatjuk, a RequestStreamHander az interfész csak egy módszert határoz meg, handeRequest (). Mindenesetre további funkciókat definiálhatunk ugyanabban az osztályban, ahogy itt tettük. Egy másik lehetőség az lenne, ha létrehoznánk a RequestStreamHander minden funkcióhoz.

Konkrét esetünkben az előbbit választottuk az egyszerűség kedvéért. A választást azonban eseti alapon kell meghozni, figyelembe véve az olyan tényezőket, mint a teljesítmény és a kód fenntarthatósága.

A DynamoDB táblázatunk nevét is olvastuk a TABLE_NAME környezeti változó. Ezt a változót később definiáljuk a telepítés során.

4.3. Az 1. funkció megvalósítása

Első funkciónkban szeretnénk demonstrálni hogyan lehet hasznos terhet szerezni (például PUT vagy POST kérésből) az API átjáróból:

public void handleRequest (InputStream inputStream, OutputStream outputStream, Context context) dobja az IOException-t {JSONParser parser = new JSONParser (); BufferedReader olvasó = new BufferedReader (új InputStreamReader (inputStream)); JSONObject responseJson = új JSONObject (); AmazonDynamoDB kliens = AmazonDynamoDBClientBuilder.defaultClient (); DynamoDB dynamoDb = új DynamoDB (kliens); próbáld ki a {JSONObject esemény = (JSONObject) elemző.parse (olvasó); if (esemény.get ("test")! = null) {Személy személy = új Személy ((Karakterlánc) esemény.get ("test")); dynamoDb.getTable (DYNAMODB_TABLE_NAME) .putItem (new PutItemSpec (). withItem (new Item (). withNumber ("id", person.getId ()) .withString ("név", személy.getNév ()))); } JSONObject responseBody = új JSONObject (); responseBody.put ("üzenet", "Új elem létrehozva"); JSONObject fejlécJson = new JSONObject (); headerJson.put ("x-custom-header", "saját fejléc értékem"); responseJson.put ("statusCode", 200); responseJson.put ("fejlécek", headerJson); responseJson.put ("body", responseBody.toString ()); } catch (ParseException pex) {responseJson.put ("statusCode", 400); responseJson.put ("kivétel", pex); } OutputStreamWriter író = new OutputStreamWriter (outputStream, "UTF-8"); író.írja (responseJson.toString ()); író.zárja (); }

Amint azt korábban megbeszéltük, később konfiguráljuk az API-t a Lambda proxy integráció használatára. Arra számítunk, hogy az API Gateway átadja a teljes kérést a Lambda függvénynek a InputStream paraméter.

Csak annyit kell tennünk, hogy kiválasszuk a releváns attribútumokat a benne lévő JSON-struktúrából.

Mint láthatjuk, a módszer alapvetően három lépésből áll:

  1. A test objektumot a bemeneti adatfolyamunkból, és létrehozunk egy Személy objektum attól
  2. Ezt tárolva Személy objektumot egy DynamoDB táblában
  3. JSON objektum létrehozása, amely több attribútumot is tartalmazhat, például a test a válaszhoz, egyéni fejlécek, valamint egy HTTP állapotkód

Itt érdemes megemlíteni egy pontot: az API Gateway elvárja a test lenni Húr (kérés és válasz esetén egyaránt).

Ahogy arra számítunk, hogy a Húr mint test az API átjáróból leadjuk a test nak nek Húr és inicializálja a mi Személy tárgy:

Személy személy = új Személy ((Karakterlánc) esemény.get ("test"));

Az API Gateway szintén várja a választ test lenni Húr:

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

Ezt a témát a hivatalos dokumentáció nem említi kifejezetten. Ha azonban alaposan megnézzük, láthatjuk, hogy a test attribútum a Húr mindkét részletben a kérelemhez és a válaszhoz.

Az előnynek egyértelműnek kell lennie: még akkor is, ha a JSON az API Gateway és a Lambda függvény közötti formátum, a tényleges törzs tartalmazhat egyszerű szöveget, JSON-t, XML-t vagy bármi mást. Ezután a Lambda funkció felelős a formátum megfelelő kezeléséért.

Később meglátjuk, hogyan néz ki a kérés és a válasz teste, amikor teszteljük funkcióinkat az AWS konzolon.

Ugyanez vonatkozik a következő két funkcióra is.

4.4. A 2. funkció megvalósítása

A második lépésben szeretnénk demonstrálni hogyan lehet elérési útparamétert vagy lekérdezési karakterlánc-paramétert használni lekérésére a Személy elem az adatbázisból az azonosítóját használva:

public void handleGetByParam (InputStream inputStream, OutputStream outputStream, Context context) dobja az IOException-t {JSONParser parser = new JSONParser (); BufferedReader olvasó = new BufferedReader (új InputStreamReader (inputStream)); JSONObject responseJson = új JSONObject (); AmazonDynamoDB kliens = AmazonDynamoDBClientBuilder.defaultClient (); DynamoDB dynamoDb = új DynamoDB (kliens); Tétel eredménye = null; próbáld ki a {JSONObject esemény = (JSONObject) elemző.parse (olvasó); JSONObject responseBody = új 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")); eredmény = 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")); eredmény = dynamoDb.getTable (DYNAMODB_TABLE_NAME) .getItem ("id", id); }} if (eredmény! = null) {Személy személy = új Személy (eredmény.JSON-hoz ()); responseBody.put ("Személy", személy); responseJson.put ("statusCode", 200); } else {responseBody.put ("üzenet", "Nem található elem"); responseJson.put ("statusCode", 404); } JSONObject fejlécJson = new JSONObject (); headerJson.put ("x-custom-header", "saját fejléc értékem"); responseJson.put ("fejlécek", headerJson); responseJson.put ("body", responseBody.toString ()); } catch (ParseException pex) {responseJson.put ("statusCode", 400); responseJson.put ("kivétel", pex); } OutputStreamWriter író = new OutputStreamWriter (outputStream, "UTF-8"); író.írja (responseJson.toString ()); író.zárja (); }

Ismét három lépés releváns:

  1. Ellenőrizzük, hogy a pathParameters vagy egy queryStringParameters tömb egy id attribútum vannak jelen.
  2. Ha igaz, a hozzátartozó értéket használjuk az a kérésére Személy elem az adott azonosítóval az adatbázisból.
  3. A válaszhoz hozzáadjuk a beérkezett elem JSON-ábrázolását.

A hivatalos dokumentáció részletesebb magyarázatot ad a Proxy Integration beviteli és kimeneti formátumára.

4.5. Építési szabályzat

Ismét egyszerűen elkészíthetjük kódunkat a Maven használatával:

mvn tiszta csomagolás árnyalata: árnyék

A JAR fájl a cél mappába.

4.6. A DynamoDB táblázat létrehozása

A táblázatot az AWS Lambda DynamoDB Java használatával című részében ismertetett módon hozhatjuk létre.

Válasszunk Személy mint táblázat neve, id elsődleges kulcs névként, és Szám mint az elsődleges kulcs típusa.

4.7. Kód telepítése az AWS konzolon keresztül

A kódunk elkészítése és a táblázat létrehozása után most létrehozhatjuk a függvényeket és feltölthetjük a kódot.

Ezt úgy tehetjük meg, hogy megismételjük az AWS Lambda with Java cikk 1-5 lépéseit, egyszerre mindkét módszerünkhöz.

Használjuk a következő függvényneveket:

  • StorePersonFunction a handleRequest módszer (1. funkció)
  • GetPersonByHTTPParamFunction a handleGetByParam módszer (2. funkció)

Meg kell határoznunk egy környezeti változót is TABLE_NAME értékkel "Személy".

4.8. A funkciók tesztelése

Mielőtt folytatnánk a tényleges API Gateway részt, futtathatunk egy gyors tesztet az AWS konzolon, csak annak ellenőrzésére, hogy a Lambda funkcióink megfelelően működnek-e és képesek-e kezelni a Proxy Integration formátumot.

A Lambda függvény tesztelése az AWS konzolról az AWS Lambda with Java cikkben leírtak szerint működik.

Azonban, tesztesemény létrehozásakor figyelembe kell venni a speciális Proxy Integration formátumot, amelyet funkcióink várnak. Vagy használhatjuk a API átjáró AWS proxy sablont és testre szabhatja ezt az igényeinknek megfelelően, vagy másolhatjuk és beilleszthetjük a következő eseményeket:

A StorePersonFunction, ezt kell használnunk:

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

Amint azt korábban megbeszéltük, a test típusnak kell lennie Húr, még akkor is, ha JSON struktúrát tartalmaz. Ennek oka, hogy az API-átjáró ugyanabban a formátumban küldi el kéréseit.

A következő választ vissza kell adni:

{"isBase64Encoded": hamis, "fejlécek": {"x-custom-header": "saját fejlécem értéke"}, "body": "{\" message \ ": \" Új elem létrehozva \ "}", "statusCode": 200}

Itt láthatjuk, hogy a test válaszunk a Húr, bár JSON struktúrát tartalmaz.

Nézzük meg a GetPersonByHTTPParamFunction.

Az útparaméter-funkcionalitás teszteléséhez a bemenet a következőképpen néz ki:

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

A lekérdezési karakterlánc-paraméter küldésének bemenete a következő lenne:

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

Válaszként mindkét esetben a következőket kell kapnunk:

{"fejlécek": {"x-custom-header": "saját fejlécem értéke"}, "body": "{\" Személy \ ": {\ n \" id \ ": 88, \ n \" név \ ": \" John Doe \ "\ n}}", "statusCode": 200}

Ismét a test egy Húr.

5. API létrehozása és tesztelése

Miután létrehoztuk és telepítettük az előző szakaszban a Lambda függvényeket, most létrehozhatjuk a tényleges API-t az AWS Console segítségével.

Nézzük meg az alapvető munkafolyamatot:

  1. Hozzon létre egy API-t az AWS-fiókunkban.
  2. Adjon hozzá egy erőforrást az API erőforrás-hierarchiájához.
  3. Hozzon létre egy vagy több metódust az erőforráshoz.
  4. Állítsa be az integrációt a módszer és a hozzá tartozó Lambda függvény között.

A következő szakaszokban megismételjük a 2-4. Lépést mindkét funkciónkhoz.

5.1. Az API létrehozása

Az API létrehozásához:

  1. Jelentkezzen be az API Gateway konzolra a //console.aws.amazon.com/apigateway címen
  2. Kattintson az „Első lépések” elemre, majd válassza az „Új API” lehetőséget
  3. Írja be az API nevét (TestAPI) és nyugtázza az „API létrehozása” gombra kattintva

Az API létrehozása után létrehozhatjuk az API struktúrát és összekapcsolhatjuk a Lambda függvényeinkkel.

5.2. API struktúra az 1. funkcióhoz

A következő lépésekre van szükség StorePersonFunction:

  1. Válassza ki a szülő erőforrás elemet az „Erőforrások” fán, majd válassza az „Erőforrás létrehozása” lehetőséget a „Műveletek” legördülő menüből. Ezután a következőket kell tennünk az „Új gyermek erőforrás” panelen:
    • Írja be a „Személyek” nevet az „Erőforrás neve” beviteli szövegmezőbe
    • Hagyja az alapértelmezett értéket az „Erőforrás elérési útja” beviteli szövegmezőben
    • Válassza az „Erőforrás létrehozása” lehetőséget
  2. Válassza ki a most létrehozott erőforrást, válassza a „Műveletek” legördülő menü „Létrehozási mód” elemét, és hajtsa végre a következő lépéseket:
    • Válassza a PUT lehetőséget a HTTP módszer legördülő listából, majd válassza a pipa ikont a választás mentéséhez
    • Hagyja integrációs típusként a „Lambda Function” lehetőséget, és válassza a „Lambda Proxy integráció használata” lehetőséget
    • Válassza ki a régiót a „Lambda régió” közül, ahol korábban telepítettük a Lambda funkciókat
    • típus „StorePersonFunction” a „Lambda funkcióban”
  3. Válassza a „Mentés” lehetőséget, és nyugtázza az „OK” gombbal, amikor a „Engedély hozzáadása a lambda funkcióhoz” felirat kéri

5.3. API-struktúra a 2. funkcióhoz - útvonal-paraméterek

Az útvonal-paraméterek lekérésének lépései hasonlóak:

  1. Válaszd a /személyek erőforrás elemet az „Erőforrások” fa alatt, majd válassza az „Erőforrás létrehozása” lehetőséget a „Műveletek” legördülő menüből. Ezután a következőket kell tennünk az Új gyermek erőforrás ablaktáblán:
    • típus "Személy" névként az „Erőforrás neve” beviteli szövegmezőben
    • Módosítsa az „Erőforrás elérési útja” beviteli szövegmezőt erre: „{Id}”
    • Válassza az „Erőforrás létrehozása” lehetőséget
  2. Válassza ki a most létrehozott erőforrást, válassza a „Műveletek” legördülő menü „Létrehozási mód” elemét, és hajtsa végre a következő lépéseket:
    • Válassza a GET lehetőséget a HTTP módszer legördülő listájából, majd válassza a pipa ikont a választás mentéséhez
    • Hagyja integrációs típusként a „Lambda Function” lehetőséget, és válassza a „Lambda Proxy integráció használata” lehetőséget
    • Válassza ki a régiót a „Lambda régió” közül, ahol korábban telepítettük a Lambda funkciókat
    • típus „GetPersonByHTTPParamFunction” a „Lambda funkcióban”
  3. Válassza a „Mentés” lehetőséget, és nyugtázza az „OK” gombbal, amikor a „Engedély hozzáadása a Lambda funkcióhoz” felirat kéri.

Megjegyzés: itt fontos az „Erőforrás elérési útja” paraméter beállítása „{Id}”, mint a mienk GetPersonByPathParamFunction elvárja, hogy ezt a paramétert pontosan így nevezzék el.

5.4. API struktúra a 2. funkcióhoz - Lekérdezési karakterlánc-paraméterek

A lekérdezési karakterlánc-paraméterek fogadásának lépései kissé eltérnek, as nem kell erőforrást létrehoznunk, hanem létrehoznunk kell egy lekérdezési paramétert a id paraméter:

  1. Válaszd a / fő erőforrás elemet az „Erőforrások” fa alatt válassza a „Műveletek” legördülő menüből a „Létrehozási módszer” lehetőséget, és hajtsa végre a következő lépéseket:
    • Válassza a GET lehetőséget a HTTP módszer legördülő listából, majd válassza a pipa ikont a választás mentéséhez
    • Hagyja integrációs típusként a „Lambda Function” lehetőséget, és válassza a „Lambda Proxy integráció használata” lehetőséget
    • Válassza ki a régiót a „Lambda régió” közül, ahol korábban telepítettük a Lambda funkciókat
    • típus „GetPersonByHTTPParamFunction” a „Lambda funkcióban”.
  2. Válassza a „Mentés” lehetőséget, és nyugtázza az „OK” gombbal, amikor a „Engedély hozzáadása a Lambda funkcióhoz” felirat kéri.
  3. Válassza a jobb oldali „Módszerkérés” lehetőséget, és hajtsa végre a következő lépéseket:
    • Bontsa ki az URL-lekérdezési karakterlánc-paraméterek listát
    • Kattintson a „Lekérdezési karakterlánc hozzáadása” elemre
    • típus „Id” a név mezőben, és válassza a pipa ikont a mentéshez
    • Jelölje be a „Kötelező” jelölőnégyzetet
    • Kattintson a panel tetején a „Kérjen érvényesítőt” melletti toll szimbólumra, válassza a „Lekérdezési karakterlánc paramétereinek és fejléceinek érvényesítése” lehetőséget, majd válassza a pipa ikont

Megjegyzés: Fontos a „Query String” paraméter beállítása „Id”, mint a mienk GetPersonByHTTPParamFunction elvárja, hogy ezt a paramétert pontosan így nevezzék el.

5.5. Az API tesztelése

Az API-nk készen áll, de még nem nyilvános. Mielőtt közzétennénk, először egy gyors tesztet akarunk futtatni a konzolról.

Ehhez kiválaszthatjuk a megfelelő tesztelendő módszert az „Erőforrások” fában, és rákattinthatunk a „Teszt” gombra. A következő képernyőn beírhatjuk a bemenetünket, mivel azt egy klienssel küldjük HTTP-n keresztül.

Mert StorePersonFunction, be kell írnunk a következő struktúrát a „Request Body” mezőbe:

{"id": 2, "név": "Jane Doe"}

A GetPersonByHTTPParamFunction útparaméterekkel be kell írnunk 2 értékként az „Útvonal” alatti „{id}” mezőbe.

A GetPersonByHTTPParamFunction lekérdezési karakterlánc-paraméterekkel be kell írnunk id = 2 értékként a „Lekérdezési karakterláncok” mező „{persons}” mezőjébe.

5.6. Az API telepítése

Eddig az API-junk nem volt nyilvános, ezért csak az AWS konzolról volt elérhető.

Amint azt korábban megbeszéltük, API telepítésekor társítanunk kell egy szakaszhoz, amely olyan, mint az API pillanatképe. Ha újratervezünk egy API-t, frissíthetünk egy meglévő stádiumot, vagy létrehozhatunk egy újat.

Lássuk, hogyan fog kinézni az API-s URL-séma:

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

A telepítéshez a következő lépések szükségesek:

  1. Válassza ki az adott API-t az „API-k” navigációs panelen
  2. Válassza az Erőforrások navigációs ablaktáblán a „Műveletek” lehetőséget, majd a „Műveletek” legördülő menüből válassza az „API telepítése” lehetőséget
  3. A „Telepítés szakasza” legördülő menüből válassza az „[Új szakasz]” lehetőséget, írja be "teszt" a „Stage name” részben, és opcionálisan adja meg a szakasz és a telepítés leírását
  4. Indítsa el a telepítést a „Telepítés” kiválasztásával

Az utolsó lépés után a konzol megadja az API gyökér URL-jét, például //0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test.

5.7. A végpont meghívása

Mivel az API most nyilvános, bármely kívánt HTTP kliens segítségével hívhatjuk.

Val vel becsavar, a hívások a következőképpen néznének ki.

StorePersonFunction:

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

GetPersonByHTTPParamFunction az elérési út paramétereihez:

curl -X GET '//0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test/persons/3' \ -H 'tartalomtípus: alkalmazás / json'

GetPersonByHTTPParamFunction lekérdezési karakterlánc-paraméterekhez:

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

6. Következtetés

Ebben a cikkben megvizsgáltuk, hogyan lehet az AWS Lambda funkciókat REST végpontként elérhetővé tenni az AWS API átjáró használatával.

Felfedeztük az API Gateway alapfogalmait és terminológiáját, és megtanultuk, hogyan integráljuk a Lambda függvényeket a Lambda Proxy Integration segítségével.

Végül láttuk, hogyan lehet API-t létrehozni, telepíteni és tesztelni.

Szokás szerint a cikk összes kódja elérhető a GitHubon.