โปรเจกต์ใน AWS:

สร้างเว็บแอปพลิเคชันแบบไร้เซิร์ฟเวอร์

ด้วย AWS Lambda, Amazon API Gateway, AWS Amplify, Amazon DynamoDB และ Amazon Cognito

Serverless_Web_App_LP_assets-15
Serverless_Web_App_LP_assets-22

ข้อมูลเบื้องต้น

Progression-Bar-07

โฮสต์เว็บไซต์แบบสแตติก

Progression-Bar-08

จัดการผู้ใช้

Progression-Bar-15

สร้างแบ็คเอนด์แบบไร้เซิร์ฟเวอร์

Progression-Bar-10

ปรับใช้ RESTful API

Progression-Bar-11

ยกเลิกการใช้งานทรัพยากร

โมดูลที่ 3: แบ็คเอนด์บริการแบบไร้เซิร์ฟเวอร์

ในโมดูลนี้คุณจะต้องใช้งาน AWS Lambda และ Amazon DynamoDB เพื่อสร้างกระบวนการแบ็คเอนด์สำหรับการจัดการคำขอสำหรับเว็บแอปพลิเคชันของคุณ แอปพลิเคชันเบราว์เซอร์ซึ่งคุณปรับใช้ในโมดูลที่หนึ่งทำให้ผู้ใช้สามารถขอให้ส่งยูนิคอร์นไปยังตำแหน่งอุปกรณ์ของคุณ เพื่อดำเนินการตามคำขอเหล่านั้น JavaScript ที่ทำงานอยู่ในเบราว์เซอร์จำเป็นต้องเรียกใช้บริการที่ทำงานในระบบคลาวด์

ภาพรวมของสถาปัตยกรรม

Serverless_Web_App_LP_assets-04

คุณจะต้องนำฟังก์ชัน Lambda ซึ่งจะถูกเรียกใช้ในแต่ละครั้งที่ผู้ใช้งานขอยูนิคอร์นมาใช้งาน ฟังก์ชันจะเลือกยูนิคอร์นจากฟลีต บันทึกคำขอในตาราง DynamoDB และตอบสนองต่อแอปพลิเคชันเบื้องหน้าด้วยรายละเอียดเกี่ยวกับยูนิคอร์นที่ส่งมา

ฟังก์ชันจะถูกเรียกใช้งานจากเบราว์เซอร์โดยใช้ Amazon API Gateway คุณจะต้องนำการเชื่อมต่อนั้นมาใช้งานในโมดูลถัดไป สำหรับโมดูลนี้ คุณจะทำการทดสอบฟังก์ชันแบบแยกตัวเท่านั้น

ระยะเวลาที่ใช้ในการศึกษาโมดูล: 30 นาที

บริการที่ใช้: AWS Lambda, Amazon DynamoDB

คำแนะนำในการนำมาใช้งาน

ปฏิบัติตามคำแนะนำแบบทีละขั้นตอนด้านล่างเพื่อสร้างกระบวนการแบ็คเอนด์แบบไร้เซิร์ฟเวอร์ของคุณ คลิกหมายเลขขั้นตอนแต่ละหมายเลขเพื่อขยายส่วนนั้น

  • ขั้นตอนที่ 1 สร้างตาราง Amazon DynamoDB

    สร้างตาราง Amazon DynamoDB

    ใช้คอนโซล Amazon DynamoDB เพื่อสร้างตาราง DynamoDB ใหม่ เรียกใช้ Ride ตารางของคุณและตั้งชื่อคีย์แบ่ง RideId ด้วยด้วยประเภทสตริง ชื่อตารางและคีย์แบ่งมีความละเอียดอ่อน โปรดตรวจสอบให้แน่ใจว่าใช้รหัสที่ถูกต้องตามที่ให้ไว้ ใช้ค่าเริ่มต้นสำหรับการตั้งค่าทั้งหมด

    หลังจากที่คุณสร้างตารางแล้ว ให้บันทึก ARN ไว้สำหรับการใช้งานในขั้นตอนถัดไป

    1. จาก AWS Management Console ให้เลือก บริการ แล้วเลือก DynamoDB ภายใต้ฐานข้อมูล

    2. เลือก สร้างตาราง

    3. ป้อน Rides สำหรับ ชื่อตาราง ช่องนี้มีความละเอียดอ่อน

    4. ป้อน RideId สำหรับ คีย์แบ่ง และเลือก สตริง สำหรับประเภทคีย์ ช่องนี้มีความละเอียดอ่อน

    5. ทำเครื่องหมายในกล่อง ใช้การตั้งค่าเริ่มต้น แล้วเลือก สร้าง

    6. เลื่อนลงไปที่ส่วนภาพรวมของตารางใหม่แล้วบันทึก ARN คุณจะต้องใช้ในส่วนถัดไป

  • ขั้นตอนที่ 2 การสร้างบทบาท IAM สำหรับฟังก์ชัน Lambda ของคุณ

    การสร้างบทบาท IAM สำหรับฟังก์ชัน Lambda ของคุณ

    ทุกฟังก์ชัน Lambda จะมีบทบาท IAM ที่เกี่ยวข้องกัน โดยบทบาทนี้จะกำหนดบริการของ AWS อื่นๆ ที่ฟังก์ชันอนุญาตให้ทำงานด้วย สำหรับวัตถุประสงค์ของเวิร์กช็อปนี้ คุณจะต้องสร้างบทบาท IAM ซึ่งอนุญาตให้ฟังก์ชัน Lambda ของคุณเขียนบันทึกไปยัง Amazon CloudWatch Logs และเข้าถึงการเขียนรายการในตาราง DynamoDB ของคุณ

    ใช้คอนโซล IAM เพื่อสร้างบทบาทใหม่ ตั้งชื่อว่า WildRydesLambda และเลือก AWS Lambda สำหรับประเทภของบทบาท คุณจำเป็นต้องแนบนโยบายซึ่งให้อนุญาตแก่ฟังก์ชันของคุณเพื่อเขียน Amazon CloudWatch Logs และบันทึกรายการลงในตาราง DynamoDB ของคุณ

    แนบนโยบายที่ชื่อว่า AWSLambdaBasicExecutionRole ให้กับบทบาทนี้เพื่อให้สิทธิ์อนุญาตที่จำเป็นสำหรับ CloudWatch Logs นอกจากนี้ ให้สร้างนโยบายภายในแบบกำหนดเองสำหรับบทบาทของคุณซึ่งอนุญาตให้การดำเนินการ ddb:PutItem สำหรับตารางที่คุณสร้างไว้ในส่วนก่อนหน้า

    1. จาก AWS Management Console ให้คลิกที่ บริการ แล้วเลือก IAM ในส่วนของการรักษาความปลอดภัย ข้อมูลประจำตัว และการปฏิบัติตามข้อกำหนด

    2. เลือก บทบาท ในแถบการนำทางด้านซ้ายแล้วเลือก สร้างบทบาทใหม่

    3. เลือก Lambda สำหรับประเภทบทบาทจากกลุ่ม บริการของ AWS แล้วคลิก ถัดไป: สิทธิ์การใช้งาน

      หมายเหตุ: การเลือกประเภทบทบาทโดยอัตโนมัติจะสร้างนโยบายความน่าเชื่อถือสำหรับบทบาทของคุณซึ่งอนุญาตให้บริการของ AWS สมมติบทบาทนี้แทนคุณ หากคุณสร้างบทบาทนี้โดยใช้ CLI, AWS CloudFormation หรือกลไกอื่นๆ คุณจะต้องระบุนโยบายความน่าชื่อถือโดยตรง

    4. เริ่มพิมพ์ AWSLambdaBasicExecutionRole ในกล่องข้อความ ตัวกรอง และทำเครื่องหมายในกล่องถัดจากบทบาทนั้น

    5. เลือก ขั้นตอนถัดไป

    6. ป้อน WildRydesLambda สำหรับ ชื่อบทบาท

    7. เลือก สร้างบทบาท

    8. พิมพ์ WildRydesLambda ลงในกล่องข้อความตัวกรองในหน้าบทบาท และเลือกบทบาทที่คุณสร้างขึ้น

    9. ในแท็บสิทธิ์การใช้งาน ให้เลือกลิงก์ เพิ่มนโยบายภายใน ที่มุมขวาด้านล่างเพื่อสร้างนโยบายความน่าเชื่อถือใหม่

    10. เลือก เลือกบริการ

    11. เริ่มพิมพ์ DynamoDB ลงในกล่องการค้นหาที่มีข้อความกำกับว่า ค้นหาบริการ แล้วเลือก DynamoDB เมื่อปรากฏขึ้น

    12. เลือก เลือกการดำเนินการ

    13. เริ่มพิมพ์ PutItem ลงในกล่องการค้นหาที่มีข้อความกำกับว่า การดำเนินการของตัวกรอง และทำเครื่องหมายในกล่องถัดจาก PutItem เมื่อปรากฏขึ้น

    14. เลือกส่วน ทรัพยากร 

    15. โดยที่เลือกตัวเลือก เฉพาะ เอาไว้ ให้เลือกเพิ่มลิงก์ ARN ในส่วน ตาราง

    16. วาง ARN ของตารางที่คุณสร้างขึ้นในส่วนก่อนหน้าในช่อง กำหนด ARN สำหรับตาราง และเลือก เพิ่ม

    17. เลือก ตรวจสอบนโยบาย

    18. ป้อน DynamoDBWriteAccess สำหรับชื่อนโยบาบ แล้วเลือก สร้างนโยบาย

  • ขั้นตอนที่ 3 สร้างฟังก์ชัน Lambda สำหรับจัดการกับคำขอ

    สร้างฟังก์ชัน Lambda สำหรับจัดการกับคำขอ

    AWS Lambda จะเรียกใช้งานโค้ดของคุณสอดคล้องกับเหตุการณ์เช่น การขอ HTTP ในขั้นตอนนี้ คุณจะต้องสร้างฟังก์ชันหลักซึ่งจะประมวลผลคำขอ API จากเว็บแอปพลิเคชันเพื่อส่งยูนิคอร์น ในโมดูลถัดไป คุณจะต้องใช้ Amazon API Gateway เพื่อสร้าง RESTful API ซึ่งจะเปิดเผยตำแหน่งข้อมูล HTTP ซึ่งสามารถเรียกใช้ได้จากเบราวเซอร์ของผู้ใช้งานของคุณ จากนั้นคุณจะต้องเชื่อมต่อฟังก์ชัน Lambda ที่คุณสร้างในขั้นตอนนี้กับ API นั้นเพื่อสร้างแบ็คเอนด์ที่มีการทำงานสมบูรณ์สำหรับเว็บแอปพลิเคชันของคุณ

    ใช้คอนโซล AWS Lambda เพื่อสร้างฟังก์ชัน Lambda ใหม่ที่เรียกว่า RequestUnicorn ซึ่งจะประมวลผลคำขอ API ใช้ตัวอย่างการนำไปใช้งาน requestUnicorn.js สำหรับโค้ดฟังก์ชันของคุณ เพียงคัดลอกและวางจากไฟล์นั้นลงในเครื่องมือแก้ไขของคอนโซล AWS Lambda

    ตรวจสอบให้แน่ใจว่าได้กำหนดค่าฟังก์ชันของคุณให้ใช้บทบาท IAM WildRydesLambda ที่สร้างขึ้นในส่วนก่อนหน้านี้

    1. เลือก บริการ แล้วเลือก Lambda ในส่วนการประมวลผล

    2. คลิก สร้างฟังก์ชัน

    3. เก็บการ์ด เขียนใหม่ เริ่มต้นที่เลือกไว้

    4. ป้อน RequestUnicorn ลงในช่อง ชื่อ

    5. เลือก Node.js 6.10 สำหรับ Runtime

    6. ตรวจสอบว่าเลือก เลือกบทบาทที่มี จากรายการดรอปดาวน์ บทบาท

    7. เลือก WildRydesLambda จากรายการดรอปดาวน์ บทบาทที่มี

    8. คลิก สร้างฟังก์ชัน

    9. เลื่อนลงไปที่ส่วน โค้ดฟังก์ชัน แล้วแทนที่โค้ดเดิมที่มีอยู่ในเครื่องมือแก้ไขโค้ด index.js ด้วยเนื้อหาจาก requestUnicorn.js

    10. คลิก "บันทึก" ที่มุมขวาบนของหน้า

  • ขั้นตอนที่ 4 ทดสอบการนำไปใช้งานของคุณ

    ตรวจสอบความถูกต้องของการนำไปใช้งานของคุณ

    สำหรับโมดูลนี้ คุณจะต้องตรวจสอบฟังก์ชันที่คุณสร้างขึ้นโดยใช้คอนโซล AWS Lambda ในโมดูลถัดไป คุณจะต้องเพิ่ม REST API ด้วย API Gateway เพื่อให้คุณสามารถเรียกใช้ฟังก์ชันของคุณได้จากแอปพลิเคชันที่มีพื้นฐานจากเบราว์เซอร์ซึ่งคุณได้ปรับใช้ในโมดูลแรก

    1. จากหน้าจอการแก้ไขหลักสำหรับฟังก์ชันของคุณ ให้เลือก กำหนดค่าเหตุการณ์ทดสอบ จากเมนูดรอปดาวน์ เลือกเหตุการณ์ทดสอบ

    2. ให้เลือก สร้างเหตุการณ์การทดสอบใหม่ เอาไว้

    3. ป้อน TestRequestEvent ลงในช่อง ชื่อเหตุการณ์

    4. คัดลอกและวางเหตุการณ์ทดสอบดังต่อไปนี้ลงในเครื่องมือแก้ไข:

    {
    "path": "/ride",
    "httpMethod": "POST",
    "headers": {
        "Accept": "*/*",
        "Authorization": "eyJraWQiOiJLTzRVMWZs",
        "content-type": "application/json; charset=UTF-8"
    },
    "queryStringParameters": null,
    "pathParameters": null,
    "requestContext": {
        "authorizer": {
            "claims": {
                "cognito:username": "the_username"
            }
        }
    },
    "body": "{\"PickupLocation\":{\"Latitude\":47.6174755835663,\"Longitude\":-122.28837066650185}}"
}

    1. คลิก สร้าง

    2. ในหน้าจอการแก้ไขฟังก์ชันหลัก ให้คลิก ทดสอบ ด้วย TestRequestEvent ที่เลือกจากในเมนูดรอปดาวน์

    3. เลื่อนไปยังด้านบนสุดของหน้าและขยายส่วน รายละเอียด ของส่วน ผลการดำเนินการ

    4. ยืนยันว่าการดำเนินการประสบความสำเร็จและผลของฟังก์ชันนี้เป็นดังต่อไปนี้:

    {
    "statusCode": 201,
    "body": "{\"RideId\":\"SvLnijIAtg6inAFUBRT+Fg==\",\"Unicorn\":{\"Name\":\"Rocinante\",\"Color\":\"Yellow\",\"Gender\":\"Female\"},\"Eta\":\"30 seconds\"}",
    "headers": {
        "Access-Control-Allow-Origin": "*"
    }
}
ถัดไป: ปรับใช้ RESTful API