streamalism.org

1. סקירה כללית

AWS למבה הוא שירות מחשוב ללא שרת המסופק על ידי שירותי האינטרנט של אמזון.

בשני מאמרים קודמים דנו כיצד ליצור פונקצית AWS Lambda באמצעות Java, וכן כיצד לגשת ל- DynamoDB מפונקציה Lambda.

במדריך זה נדון כיצד לפרסם פונקציית Lambda כנקודת קצה של REST, באמצעות AWS Gateway.

אנו נסתכל מפורט על הנושאים הבאים:

• מושגים בסיסיים ותנאי API Gateway
• שילוב של פונקציות Lambda עם Gateway API באמצעות שילוב Lambda Proxy
• יצירת API, המבנה שלו וכיצד למפות את משאבי ה- API לפונקציות Lambda
• פריסה ובדיקה של ה- API

2. יסודות ותנאים

ה- API Gateway הוא שירות מנוהל באופן מלא המאפשר למפתחים ליצור, לפרסם, לתחזק, לפקח ולאבטח ממשקי API בכל קנה מידה.

אנו יכולים ליישם ממשק תכנות מבוסס HTTP עקבי וניתן להרחבה (המכונה גם שירותי RESTful) כדי לגשת לשירותי backend כמו פונקציות Lambda, שירותי AWS נוספים (למשל, EC2, S3, DynamoDB) וכל נקודות קצה של HTTP.

התכונות כוללות, אך אינן מוגבלות, ל:

• ניהול תעבורה
• הרשאה ובקרת גישה
• ניטור
• ניהול גרסאות API
• בקשות חנק למנוע התקפות

כמו AWS Lambda, ה- API Gateway מוגדל אוטומטית ומחויב על פי שיחת API.

מידע מפורט ניתן למצוא בתיעוד הרשמי.

2.1. תנאים

שער ה- API הוא שירות AWS התומך ביצירה, פריסה וניהול ממשק תכנות יישומים RESTful לחשיפת נקודות קצה HTTP אחוריות, פונקציות AWS למבדה ושירותי AWS אחרים.

An ממשק API של Gateway API הוא אוסף של משאבים ושיטות הניתנים לשילוב עם פונקציות Lambda, שירותי AWS אחרים או נקודות קצה של HTTP בחלק האחורי. ה- API מורכב ממשאבים המהווים את מבנה ה- API. כל משאב API יכול לחשוף שיטת API אחת או יותר שחייבות לכלול פעלים ייחודיים ב- HTTP.

כדי לפרסם API, עלינו ליצור פריסת API ולקשר את זה עם מה שנקרא שלב. שלב הוא כמו תמונת מצב בזמן ה- API. אם נפרוס מחדש API, נוכל לעדכן שלב קיים או ליצור שלב חדש. על ידי כך, גרסאות שונות של ממשק API בו זמנית אפשריות, למשל א dev שלב, א מִבְחָן במה, ואפילו גרסאות הפקה מרובות, כמו v1, v2, וכו.

Lambda Proxy שילוב היא תצורה פשוטה לשילוב בין פונקציות Lambda ו- API Gateway.

שער ה- API שולח את כל הבקשה כקלט לפונקציה למבדה backend. מבחינה תגובה, API Gateway הופך את פלט פונקציית Lambda בחזרה לתגובת HTTP חזיתית.

3. תלות

אנו זקוקים לאותן תלות כמו במאמר AWS Lambda באמצעות DynamoDB עם Java.

נוסף על כך, אנו זקוקים גם לספריית JSON Simple:

 com.googlecode.json-simple json-simple 1.1.1 

4. פיתוח ופריסה של פונקציות למבדה

בחלק זה נפתח ונבנה את פונקציות ה- Lambda שלנו בג'אווה, נפרוס אותן באמצעות AWS Console ונבצע בדיקה מהירה.

מכיוון שאנחנו רוצים להדגים את היכולות הבסיסיות של שילוב ה- API Gateway עם Lambda, ניצור שתי פונקציות:

• פונקציה 1: מקבל מטען מממשק ה- API בשיטת PUT
• פונקציה 2: מדגים כיצד להשתמש בפרמטר נתיב HTTP או בפרמטר שאילתת HTTP המגיע מה- API

מבחינה יישומית, ניצור אחת RequestHandler בכיתה, שיש לה שתי שיטות - אחת לכל פונקציה.

4.1. דֶגֶם

לפני שאנחנו מיישמים את מטפל הבקשות בפועל, בואו נסתכל במהירות על מודל הנתונים שלנו:

אדם בכיתה ציבורית {מזהה פרטי פרטי; שם מחרוזת פרטי; אדם ציבורי (String json) {Gson gson = Gson new (); בקשת אדם = gson.fromJson (json, Person.class); this.id = request.getId (); this.name = request.getName (); } מחרוזת ציבורית toString () {Gson gson = GsonBuilder חדש (). setPrettyPrinting (). create (); החזר gson.toJson (זה); } // גטרים וקובעים}

המודל שלנו מורכב מאחד פשוט אדם class, שיש לו שני מאפיינים. החלק הבולט היחיד הוא אדם (מחרוזת) קונסטרוקטור, המקבל מחרוזת JSON.

4.2. יישום כיתת ה- RequestHandler

בדיוק כמו במאמר AWS Lambda With Java, ניצור יישום של ה- RequestStreamHandler מִמְשָׁק:

APIDemoHandler בכיתה ציבורית מיישם את RequestStreamHandler {סופי סטטי פרטי מחרוזת DYNAMODB_TABLE_NAME = System.getenv ("TABLE_NAME"); @Override public void handleRequest (InputStream inputStream, OutputStream outputStream, Context context) זורק IOException {// יישום} public void handleGetByParam (InputStream inputStream, OutputStream outputStream, Context context) זורק IOException {// יישום}}

כפי שאנו רואים, RequestStreamHander ממשק מגדיר רק שיטה אחת, handsRequest (). בכל מקרה, אנו יכולים להגדיר פונקציות נוספות באותו מחלקה, כפי שעשינו כאן. אפשרות נוספת תהיה ליצור יישום אחד של RequestStreamHander לכל פונקציה.

במקרה הספציפי שלנו, בחרנו בפעם הראשונה. עם זאת, הבחירה חייבת להיעשות על בסיס כל מקרה לגופו, תוך התחשבות בגורמים כמו ביצועים ושמירה על קוד.

קראנו גם את השם של טבלת DynamoDB שלנו מה- שם שולחן משתנה הסביבה. נגדיר את המשתנה מאוחר יותר במהלך הפריסה.

4.3. יישום פונקציה 1

בתפקידנו הראשון אנו רוצים להפגין כיצד להשיג מטען (כמו מבקשת PUT או POST) משער ה- API:

handle void publicRequest (InputStream inputStream, OutputStream outputStream, הקשר הקשר) זורק IOException {JSONParser מנתח = JSONParser חדש (); BufferedReader reader = BufferedReader חדש (InputStreamReader חדש (inputStream)); JSONObject responseJson = JSONObject חדש (); לקוח AmazonDynamoDB = AmazonDynamoDBClientBuilder.defaultClient (); DynamoDB dynamoDb = DynamoDB חדש (לקוח); נסה את {JSONObject event = (JSONObject) parser.parse (reader); if (event.get ("body")! = null) {Person person = Person new ((String) event.get ("body")); dynamoDb.getTable (DYNAMODB_TABLE_NAME) .putItem (PutItemSpec חדש (). withItem (פריט חדש (). withNumber ("id", person.getId ()) .withString ("שם", person.getName ()))); } JSONObject responseBody = JSONObject חדש (); responseBody.put ("הודעה", "פריט חדש נוצר"); כותרת JSONObject Json = JSONObject חדש (); headerJson.put ("כותרת x-custom", "ערך הכותרת המותאמת אישית שלי"); responseJson.put ("statusCode", 200); responseJson.put ("כותרות", כותרת Json); responseJson.put ("גוף", responseBody.toString ()); } לתפוס (ParseException pex) {responseJson.put ("statusCode", 400); responseJson.put ("חריג", pex); } כותב OutputStreamWriter = OutputStreamWriter חדש (outputStream, "UTF-8"); writer.write (responseJson.toString ()); author.close (); }

כפי שנדון קודם, נגדיר את ה- API מאוחר יותר לשימוש בשילוב proxy של Lambda. אנו מצפים משער ה- API להעביר את הבקשה המלאה לפונקציה למבה ב InputStream פָּרָמֶטֶר.

כל שעלינו לעשות הוא לבחור את התכונות הרלוונטיות ממבנה ה- JSON הכלול.

כפי שאנו רואים, השיטה בעצם מורכבת משלושה שלבים:

1. להביא את גוּף אובייקט מזרם הקלט שלנו ויצירת אדם חפץ מזה
2. אחסן את זה אדם אובייקט בטבלת DynamoDB
3. בניית אובייקט JSON, שיכול להכיל מספר תכונות, כמו a גוּף לתגובה, כותרות מותאמות אישית, כמו גם קוד מצב HTTP

נקודה אחת שכדאי להזכיר כאן: ה- API Gateway מצפה ש- גוּף להיות חוּט (הן לבקשה והן לתגובה).

כפי שאנו מצפים לקבל א חוּט כפי ש גוּף משער ה- API, אנחנו מלהקים את גוּף ל חוּט ולאתחל את שלנו אדם לְהִתְנַגֵד:

אדם אדם = אדם חדש ((מחרוזת) event.get ("גוף"));

API Gateway מצפה גם לתגובה גוּף להיות חוּט:

responseJson.put ("גוף", responseBody.toString ());

נושא זה אינו מוזכר במפורש בתיעוד הרשמי. עם זאת, אם יש לנו מבט מקרוב, אנו יכולים לראות כי תכונת הגוף היא a חוּט בשני קטעי המידע לבקשה וכן לתגובה.

היתרון צריך להיות ברור: גם אם JSON הוא הפורמט שבין API Gateway לפונקציה Lambda, הגוף בפועל יכול להכיל טקסט רגיל, JSON, XML, או כל דבר אחר. באחריות פונקציית למבדה לטפל נכון בפורמט.

נראה כיצד נראה גוף הבקשה והתגובה בהמשך כאשר נבדוק את הפונקציות שלנו במסוף AWS.

הדבר תקף גם לשתי הפונקציות הבאות.

4.4. יישום פונקציה 2

בשלב שני, אנו רוצים להפגין כיצד להשתמש בפרמטר נתיב או בפרמטר מחרוזת שאילתה לאחזור א אדם פריט ממסד הנתונים באמצעות תעודת הזהות שלו:

handle void publicGetByParam (InputStream inputStream, OutputStream outputStream, הקשר הקשר) זורק IOException {JSONParser parser = new JSONParser (); BufferedReader reader = BufferedReader חדש (InputStreamReader חדש (inputStream)); JSONObject responseJson = JSONObject חדש (); לקוח AmazonDynamoDB = AmazonDynamoDBClientBuilder.defaultClient (); DynamoDB dynamoDb = DynamoDB חדש (לקוח); תוצאת פריט = null; נסה את {JSONObject event = (JSONObject) parser.parse (reader); JSONObject responseBody = JSONObject חדש (); אם (event.get ("pathParameters")! = null) {JSONObject pps = (JSONObject) event.get ("pathParameters"); אם (pps.get ("id")! = null) {int id = Integer.parseInt ((String) pps.get ("id")); תוצאה = dynamoDb.getTable (DYNAMODB_TABLE_NAME) .getItem ("id", id); }} אחרת אם (event.get ("queryStringParameters")! = null) {JSONObject qps = (JSONObject) event.get ("queryStringParameters"); אם (qps.get ("id")! = null) {int id = Integer.parseInt ((String) qps.get ("id")); תוצאה = dynamoDb.getTable (DYNAMODB_TABLE_NAME) .getItem ("id", id); }} אם (תוצאה! = null) {אדם אדם = אדם חדש (result.toJSON ()); responseBody.put ("אדם", אדם); responseJson.put ("statusCode", 200); } אחר {responsBody.put ("הודעה", "לא נמצא פריט"); responseJson.put ("statusCode", 404); } כותרת JSONObjectJson = JSONObject חדש (); headerJson.put ("כותרת x-custom", "ערך הכותרת המותאמת אישית שלי"); responseJson.put ("כותרות", כותרת Json); responseJson.put ("גוף", responseBody.toString ()); } לתפוס (ParseException pex) {responseJson.put ("statusCode", 400); responseJson.put ("חריג", pex); } כותב OutputStreamWriter = OutputStreamWriter חדש (outputStream, "UTF-8"); writer.write (responseJson.toString ()); author.close (); }

שוב, שלושה שלבים רלוונטיים:

1. אנו בודקים האם א pathParameters או queryStringParameters מערך עם תְעוּדַת זֶהוּת תכונה קיימים.
2. אם נָכוֹן, אנו משתמשים בערך השייכות כדי לבקש a אדם פריט עם מזהה זה ממסד הנתונים.
3. אנו מוסיפים לתגובה ייצוג JSON של הפריט שהתקבל.

התיעוד הרשמי מספק הסבר מפורט יותר על פורמט קלט ופורמט פלט לשילוב פרוקסי.

4.5. קוד בניין

שוב, אנו יכולים פשוט לבנות את הקוד שלנו באמצעות Maven:

צל חבילה נקי mvn: צל

קובץ ה- JAR ייווצר תחת ה- יַעַד תיקיה.

4.6. יצירת טבלת DynamoDB

אנו יכולים ליצור את הטבלה כמוסבר ב- AWS Lambda באמצעות DynamoDB עם Java.

בואו נבחר אדם כשם הטבלה, תְעוּדַת זֶהוּת כשם המפתח הראשי, ו- מספר כסוג המפתח הראשי.

4.7. פריסת קוד באמצעות מסוף AWS

לאחר בניית הקוד שלנו ויצירת הטבלה, כעת נוכל ליצור את הפונקציות ולהעלות את הקוד.

ניתן לעשות זאת על ידי חזרה על שלבים 1-5 מתוך המאמר AWS Lambda with Java, פעם אחת לכל אחת משתי השיטות שלנו.

נשתמש בשמות הפונקציות הבאים:

• StorePersonFunction בשביל ה handleRequest שיטה (פונקציה 1)
• GetPersonByHTTPParamFunction בשביל ה handleGetByParam שיטה (פונקציה 2)

עלינו להגדיר משתנה סביבה שם שולחן עם ערך "אדם".

4.8. בדיקת הפונקציות

לפני שנמשיך עם החלק הממשלתי ב- API Gateway, נוכל לבצע בדיקה מהירה במסוף AWS, רק כדי לבדוק שפונקציות ה- Lambda שלנו פועלות כראוי ויכולות להתמודד עם פורמט שילוב ה- Proxy.

בדיקת פונקציית Lambda ממסוף AWS עובדת כמתואר במאמר AWS Lambda with Java.

למרות זאת, כשאנחנו יוצרים אירוע בדיקה, עלינו לקחת בחשבון את הפורמט המיוחד לשילוב Proxy, לפונקציות שלנו מצפים. אנחנו יכולים להשתמש ב- ממשק ה- API של Gateway AWS תבנית והתאמה אישית לצרכים שלנו, או שנוכל להעתיק ולהדביק את האירועים הבאים:

בשביל ה StorePersonFunctionעלינו להשתמש בזה:

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

כפי שנדון קודם, גוּף חייב להיות בעל הסוג חוּט, גם אם מכיל מבנה JSON. הסיבה היא ש- Gateway API ישלח את בקשותיו באותו פורמט.

יש להחזיר את התגובה הבאה:

{"isBase64Encoded": false, "headers": {"x-custom-header": "ערך הכותרת המותאמת אישית שלי"}, "body": "{\" message \ ": \" פריט חדש נוצר \ "}", "statusCode": 200}

כאן אנו יכולים לראות כי גוּף התגובה שלנו היא חוּט, למרות שהוא מכיל מבנה JSON.

בואו נסתכל על הקלט עבור GetPersonByHTTPParamFunction.

לבדיקת הפונקציונליות של פרמטר הנתיב, הקלט ייראה כך:

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

והקלט לשליחת פרמטר מחרוזת שאילתה יהיה:

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

כתגובה, עלינו לקבל את הדברים הבאים עבור שני השיטות:

{"headers": {"x-custom-header": "ערך הכותרת המותאמת אישית שלי"}, "body": "{\" אדם \ ": {\ n \" id \ ": 88, \ n \" שם \ ": \" ג'ון דו \ "\ n}}", "statusCode": 200}

שוב, ה גוּף הוא חוּט.

5. יצירה ובדיקת ה- API

לאחר שיצרנו ופרסנו את פונקציות ה- Lambda בסעיף הקודם, כעת אנו יכולים ליצור את ה- API בפועל באמצעות מסוף AWS.

בואו נסתכל על זרימת העבודה הבסיסית:

1. צור API בחשבון AWS שלנו.
2. הוסף משאב להיררכיית המשאבים של ה- API.
3. צור שיטה אחת או יותר עבור המשאב.
4. הגדר את האינטגרציה בין שיטה לפונקציית Lambda השייכת.

נחזור על שלבים 2-4 עבור כל אחת משתי הפונקציות שלנו בסעיפים הבאים.

5.1. יצירת ממשק ה- API

ליצירת ה- API, נצטרך:

1. היכנס למסוף ה- API של ה- Gateway בכתובת //console.aws.amazon.com/apigateway
2. לחץ על "התחל לעבוד" ואז בחר "API חדש"
3. הקלד את שם ה- API שלנו (TestAPI) והודה על ידי לחיצה על "צור API"

לאחר שיצרנו את ה- API, כעת אנו יכולים ליצור את מבנה ה- API ולקשר אותו לפונקציות Lambda שלנו.

5.2. מבנה API לפונקציה 1

השלבים הבאים נחוצים עבורנו StorePersonFunction:

1. בחר את פריט המשאב האב מתחת לעץ "משאבים" ואז בחר "צור משאב" מהתפריט הנפתח "פעולות". לאחר מכן, עלינו לבצע את הפעולות הבאות בחלונית "משאב חדש לילדים":
   • הקלד "אנשים" כשם בשדה הטקסט "שם משאב"
   • השאר את ערך ברירת המחדל בשדה הקלט "נתיב משאבים"
   • בחר "צור משאב"
2. בחר את המשאב שנוצר זה עתה, בחר "צור שיטה" מהתפריט הנפתח "פעולות" ובצע את השלבים הבאים:
   • בחר PUT מהרשימה הנפתחת של שיטת HTTP ואז בחר בסמל סימן הביקורת כדי לשמור את הבחירה
   • השאירו את "פונקציית למבדה" כסוג שילוב ובחרו באפשרות "השתמש באינטגרציה למבדה פרוקסי"
   • בחר את האזור מ"אזור למבדה ", שם פרסנו את פונקציות למבדה שלנו בעבר
   • סוּג "StorePersonFunction" ב"פונקצית למבדה "
3. בחר "שמור" והודה באמצעות "אישור" כאשר תתבקש "להוסיף הרשאה לפונקציה למבדה"

5.3. מבנה API לפונקציה 2 - פרמטרים לנתיב

השלבים לפרמטרים לאחזור נתיבים דומים:

1. בחר את /אנשים פריט משאבים מתחת לעץ "משאבים" ואז בחר "צור משאב" מהתפריט הנפתח "פעולות". לאחר מכן עלינו לבצע את הפעולות הבאות בחלונית משאבים לילד חדש:
   • סוּג "אדם" כשם בשדה הטקסט "שם משאב"
   • שנה את שדה הטקסט "נתיב משאבים" ל "{תְעוּדַת זֶהוּת}"
   • בחר "צור משאב"
2. בחר את המשאב שנוצר זה עתה, בחר "צור שיטה" מהתפריט הנפתח "פעולות" ובצע את השלבים הבאים:
   • בחר ב- GET מהרשימה הנפתחת של שיטת HTTP ואז בחר בסמל סימן הביקורת כדי לשמור את הבחירה
   • השאירו את "פונקציית למבדה" כסוג שילוב ובחרו באפשרות "השתמש באינטגרציה למבדה פרוקסי"
   • בחר את האזור מ"אזור למבדה ", שם פרסמנו את פונקציות למבדה שלנו בעבר
   • סוּג "GetPersonByHTTPParamFunction" ב"פונקצית למבדה "
3. בחר "שמור" והודה עם "אישור" כאשר תתבקש "להוסיף הרשאה לפונקציה למבדה"

הערה: חשוב כאן להגדיר את הפרמטר "נתיב משאבים" ל "{תְעוּדַת זֶהוּת}", כמו שלנו GetPersonByPathParamFunction מצפה שפרמטר זה ייקרא בדיוק כך.

5.4. מבנה API לפונקציה 2 - פרמטרים של מחרוזת שאילתות

השלבים לקבלת פרמטרים של מחרוזת שאילתה הם מעט שונים, כמו אנחנו לא צריכים ליצור משאב, אלא צריך ליצור פרמטר שאילתה עבור ה- תְעוּדַת זֶהוּת פָּרָמֶטֶר:

1. בחר את / אנשים פריט משאבים מתחת לעץ "משאבים", בחר "צור שיטה" מהתפריט הנפתח "פעולות" ובצע את השלבים הבאים:
   • בחר ב- GET מהרשימה הנפתחת של שיטת HTTP ואז בחר בסמל הסימון כדי לשמור את הבחירה
   • השאירו את "פונקציית למבדה" כסוג שילוב ובחרו באפשרות "השתמש באינטגרציה למבדה פרוקסי"
   • בחר את האזור מ"אזור למבדה ", שם פרסמנו את פונקציות למבדה שלנו בעבר
   • סוּג "GetPersonByHTTPParamFunction" ב"פונקצית למבה ".
2. בחר "שמור" והודה עם "אישור" כאשר תתבקש "להוסיף הרשאה לפונקציה למבדה"
3. בחר "בקשת שיטה" בצד ימין ובצע את השלבים הבאים:
   • הרחב את רשימת הפרמטרים של מחרוזת שאילתת URL
   • לחץ על "הוסף מחרוזת שאילתה"
   • סוּג "תְעוּדַת זֶהוּת" בשדה השם ובחר את סמל סימן הביקורת לשמירה
   • בחר בתיבת הסימון "חובה"
   • לחץ על סמל העט לצד "בקש מאמת" בחלק העליון של החלונית, בחר "אמת פרמטרים וכותרות מחרוזת שאילתה", ובחר את סמל סימן הביקורת.

הערה: חשוב להגדיר את הפרמטר "Query String" "תְעוּדַת זֶהוּת", כמו שלנו GetPersonByHTTPParamFunction מצפה שפרמטר זה ייקרא בדיוק כך.

5.5. בודקים את ה- API

ה- API שלנו מוכן כעת, אך הוא עדיין לא ציבורי. לפני שאנחנו מפרסמים אותו, אנחנו רוצים להריץ בדיקה מהירה מהקונסולה.

לשם כך, אנו יכולים לבחור את השיטה המתאימה להיבדק בעץ "משאבים" וללחוץ על כפתור "בדיקה". במסך הבא, אנו יכולים להקליד את הקלט שלנו, שכן היינו שולחים אותו עם לקוח באמצעות HTTP.

ל StorePersonFunctionעלינו להקליד את המבנה הבא בשדה "גוף הבקשה":

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

בשביל ה GetPersonByHTTPParamFunction עם פרמטרים של נתיב, עלינו להקליד 2 כערך לשדה "{id}" תחת "נתיב".

בשביל ה GetPersonByHTTPParamFunction עם פרמטרים של מחרוזת שאילתה, עלינו להקליד id = 2 כערך לשדה "{persons}" תחת "מחרוזות שאילתה".

5.6. פריסת ה- API

עד כה, ה- API שלנו לא היה ציבורי ולכן היה זמין רק ממסוף AWS.

כפי שנדון קודם, כאשר אנו פורסים API, עלינו לשייך אותו לבמה, שהיא כמו תמונת מצב בזמן ה- API. אם נפרוס מחדש API, נוכל לעדכן שלב קיים או ליצור שלב חדש.

בואו נראה איך תראה תוכנית ה- URL של ה- API שלנו:

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

השלבים הבאים נדרשים לפריסה:

1. בחר את ה- API המסוים בחלונית הניווט "APIs"
2. בחר "פעולות" בחלונית הניווט משאבים ובחר "פרוס API" מהתפריט הנפתח "פעולות"
3. בחר "[שלב חדש]" מהתפריט הנפתח "שלב הפריסה" "מִבְחָן" ב "שם במה", ולתת אופציונלי תיאור של הבמה והפריסה
4. הפעל את הפריסה על ידי בחירה באפשרות "פריסה"

לאחר השלב האחרון, המסוף יספק את כתובת ה- URL הבסיסית של ה- API, למשל, //0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test.

5.7. קריאת נקודת הקצה

מכיוון שממשק ה- API ציבורי כעת, אנו יכולים לקרוא לזה באמצעות כל לקוח HTTP שנרצה.

עם סִלְסוּלהשיחות ייראו כך.

StorePersonFunction:

תלתל -X PUT '//0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test/persons' \ -H 'סוג תוכן: יישום / json' \ -d '{"id": 3, "name": "ריצ'רד רו"} '

GetPersonByHTTPParamFunction לפרמטרים של נתיב:

תלתל -X GET '//0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test/persons/3' \ -H 'סוג תוכן: יישום / json'

GetPersonByHTTPParamFunction לפרמטרים של מחרוזת שאילתה:

תלתל -X GET '//0skaqfgdw4.execute-api.eu-central-1.amazonaws.com/test/persons?id=3' \ -H 'סוג תוכן: יישום / json'

6. מסקנה

במאמר זה הסתכלנו כיצד להפוך פונקציות למבדה של AWS לזמינות כנקודות קצה של REST, באמצעות שער ה- AWS API.

בחנו את המושגים הבסיסיים והמינוחים של API Gateway, ולמדנו כיצד לשלב פונקציות למבדה באמצעות אינטגרציית Lambda Proxy.

לבסוף ראינו כיצד ליצור, לפרוס ולבדוק API.

כרגיל, כל הקוד עבור מאמר זה זמין ב- GitHub.