จัดการข้อผิดพลาดในแอปพลิเคชันแบบไร้เซิร์ฟเวอร์

ด้วย AWS Step Functions และ AWS Lambda

ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีใช้ AWS Step Functions เพื่อจัดการข้อผิดพลาดเกี่ยวกับรันไทม์ของเวิร์กโฟลว์ AWS Step Functions คือบริการกระบวนการปฏิบัติแบบไร้เซิร์ฟเวอร์ที่ช่วยให้คุณประสานงานฟังก์ชันของ Lambda หลายๆ ฟังก์ชันอย่างง่ายดายลงในเวิร์กโฟลว์ที่ยืดหยุ่นซึ่งง่ายต่อการแก้จุดบกพร่องและการเปลี่ยนแปลง AWS Lambda คือบริการประมวลผลที่ช่วยให้คุณเรียกใช้โค้ดได้โดยไม่ต้องเตรียมหรือจัดการเซิร์ฟเวอร์ 

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

เพื่อหลีกเลี่ยงปัญหานี้ รวมถึงเพื่อลดจำนวนโค้ดที่คุณต้องเขียนเพื่อจัดการข้อผิดพลาด คุณสามารถใช้ AWS Step Functions สร้างเวิร์กโฟลว์แบบไร้เซิร์ฟเวอร์ที่สนับสนุนการจัดการข้อผิดพลาดของฟังก์ชันได้ ไม่ว่าข้อผิดพลาดดังกล่าวจะเป็นข้อผิดพลาดของฟังก์ชันที่นักพัฒนาสร้างขึ้น (เช่น ไม่พบไฟล์) หรือข้อผิดพลาดที่คาดการณ์ไม่ได้ (เช่น หน่วยความจำเต็ม) คุณก็สามารถกำหนดค่า Step Functions ให้ตอบสนองต่อตรรกะแบบมีเงื่อนไขโดยอิงตามประเภทของข้อผิดพลาดที่เกิดขึ้นได้ การแยกตรรกะเวิร์กโฟลว์ของคุณออกจากตรรกะทางธุรกิจด้วยวิธีนี้ทำให้คุณสามารถดัดแปลงวิธีการที่เวิร์กโฟลว์ตอบสนองต่อข้อผิดพลาดได้โดยไม่ต้องเปลี่ยนตรรกะทางธุรกิจของฟังก์ชัน Lambda ของคุณ

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

บทช่วยสอนนี้ต้องใช้บัญชี AWS

ไม่มีค่าบริการเพิ่มเติมสำหรับ AWS Step Functions หรือ AWS Lambda ทรัพยากรต่างๆ ที่คุณสร้างขึ้นในบทช่วยสอนนี้จะมีสิทธิ์ใช้งานแบบ Free Tier 

ข้อมูลเพิ่มเติมเกี่ยวกับ Free Tier >>


ขั้นตอนที่ 1 สร้างฟังก์ชัน Lambda เพื่อจำลอง API

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


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

01a
01a

(คลิกเพื่อขยาย)


b. เลือก สร้างฟังก์ชัน

01b
01b

(คลิกเพื่อขยาย)


c. เลือก เขียนใหม่ตั้งแต่ต้น ทิ้งไว้ ถัดไป ให้กำหนดค่าฟังก์ชัน Lambda ของคุณดังนี้:

สำหรับ ชื่อ ให้พิมพ์ว่า MockAPIFunction
สำหรับ รันไทม์ ให้เลือก Python 3.6
สำหรับ บทบาท ให้เลือก สร้างบทบาทแบบกำหนดเอง

หน้าต่าง IAM ใหม่จะเปิดขึ้นมา ปล่อย ชื่อบทบาท ไว้ให้เป็น lambda_basic_execution และคลิก อนุญาต ระบบจะพาคุณกลับไปยังคอนโซลของ Lambda โดยอัตโนมัติ

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

01c
01c

(คลิกเพื่อขยาย)


d. ในหน้าจอ MockAPIFunction ให้เลื่อนลงไปที่ส่วน โค้ดฟังก์ชัน ในบทช่วยสอนนี้ คุณจะได้สร้างฟังก์ชันที่ใช้ โมเดลการเขียนโปรแกรมสำหรับการเขียนฟังก์ชัน Lambda ใน Python ในหน้าต่างโค้ด ให้แทนที่โค้ดทั้งหมดด้วยโค้ดต่อไปนี้ จากนั้นเลือก บันทึก

class TooManyRequestsException(Exception): pass
class ServerUnavailableException(Exception): pass
class UnknownException(Exception): pass

def lambda_handler(event, context):
    statuscode = event["statuscode"]    
    if statuscode == "429":
        raise TooManyRequestsException('429 Too Many Requests')
    elif statuscode == "503":
        raise ServerUnavailableException('503 Server Unavailable')
    elif statuscode == "200":
        return '200 OK'
    else:
        raise UnknownException('Unknown error')
01d
01d

(คลิกเพื่อขยาย)


e. เมื่อคุณสร้างฟังก์ชัน Lambda แล้ว ให้เลื่อนขึ้นไปที่ด้านบนสุดของหน้าต่างและสังเกต Amazon Resource Name (ARN) ที่มุมขวาบนของหน้า Amazon Resource Name (ARN) จะระบุทรัพยากรของ AWS โดยเฉพาะ และช่วยให้คุณติดตามและใช้รายการและนโยบายของ AWS ทั่วบริการของ AWS และการเรียกใช้ API ได้ เราจำเป็นต้องทราบ ARN เมื่อคุณต้องการอ้างอิงทรัพยากรที่เฉพาะเจาะจงจาก Step Functions

01e
01e

(คลิกเพื่อขยาย)


ขั้นตอนที่ 2 สร้างบทบาทของ AWS Identity and Access Management (IAM)

AWS Step Functions สามารถดำเนินการโค้ดและเข้าถึงทรัพยากรอื่นๆ ของ AWS ได้ (เช่น ข้อมูลที่จัดเก็บในบัคเก็ต Amazon S3) เพื่อรักษาความปลอดภัย คุณจะต้องมอบสิทธิ์การเข้าถึง Step Functions ให้แก่ทรัพยากรเหล่านี้โดยใช้ AWS Identity and Access Management (IAM)


a. ในหน้าต่างเบราว์เซอร์อีกบานหนึ่ง ให้นำทางไปยัง AWS Management Console และพิมพ์ว่า IAM ลงในแถบค้นหา คลิก IAM เพื่อเปิดคอนโซลบริการ

02a
02a

(คลิกเพื่อขยาย)


b. คลิก บทบาท จากนั้นเลือก สร้างบทบาท

02b
02b

(คลิกเพื่อขยาย)


c. ในหน้า เลือกประเภทของเอนทิตีที่เชื่อถือได้ ภายใต้บริการของ AWS ให้เลือก Step Functions จากรายการ จากนั้นเลือก ถัดไป: สิทธิ์

02c
02c

(คลิกเพื่อขยาย)


d. ในหน้า แนบนโยบายสิทธิ์ ให้เลือก ถัดไป: ตรวจสอบ

 

02d
02d

(คลิกเพื่อขยาย)


e. ในหน้า ตรวจสอบ ให้พิมพ์ว่า step_functions_basic_execution สำหรับ ชื่อบทบาท และคลิก สร้างบทบาท

02e
02e

(คลิกเพื่อขยาย)


f. บทบาท IAM ใหม่ของคุณจะถูกสร้างขึ้นและปรากฏในรายการใต้บทบาท IAM สำหรับฟังก์ชัน Lambda ของคุณ

02f
02f

(คลิกเพื่อขยาย)


ขั้นตอนที่ 3 สร้างเครื่องสถานะ Step Functions

ตอนนี้เมื่อคุณได้สร้างฟังก์ชัน Lambda อย่างง่ายๆ ที่จำลองการตอบสนอง API แล้ว คุณก็สามารถสร้างเครื่องสถานะ Step Functions เพื่อเรียกใช้ API และจัดการข้อผิดพลาดได้

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


a. เปิด คอนโซล AWS Step Functions ในหน้า สร้างเครื่องสถานะ ให้เลือก เขียนใหม่ตั้งแต่ต้น ในส่วน รายละเอียด ให้ตั้งชื่อเครื่องสถานะของคุณว่า MyAPIStateMachine จากนั้นเลือก ฉันจะใช้บทบาทที่มีอยู่

03c
03c

(คลิกเพื่อขยาย)


b. ถัดไป คุณจะออกแบบเครื่องสถานะที่จะดำเนินการแตกต่างกันไปตามการตอบสนองจาก API จำลองของคุณ หากเข้าถึง API ไม่ได้ เวิร์กโฟลว์จะลองใหม่อีกครั้ง การลองใหม่คือวิธีการที่มีประโยชน์ในการจัดการข้อผิดพลาดชั่วคราว เวิร์กโฟลว์จะจับข้อผิดพลาดต่างๆ ที่ API จำลองส่งมาด้วยเช่นกัน

แทนที่เนื้อหาของส่วน ข้อกำหนดของเครื่องสถานะ ด้วยโค้ดต่อไปนี้:

{
  "Comment": "An example of using retry and catch to handle API responses",
  "StartAt": "Call API",
  "States": {
    "Call API": {
      "Type": "Task",
      "Resource": "arn:aws:lambda:REGION:ACCOUNT_ID:function:FUNCTION_NAME",
      "Next" : "OK",
      "Comment": "Catch a 429 (Too many requests) API exception, and resubmit the failed request in a rate-limiting fashion.",
      "Retry" : [ {
        "ErrorEquals": [ "TooManyRequestsException" ],
        "IntervalSeconds": 1,
        "MaxAttempts": 2
      } ],
      "Catch": [ 
        {
          "ErrorEquals": ["TooManyRequestsException"],
          "Next": "Wait and Try Later"
        }, {
          "ErrorEquals": ["ServerUnavailableException"],
          "Next": "Server Unavailable"
        }, {
          "ErrorEquals": ["States.ALL"],
          "Next": "Catch All"
        }
      ]
    },
    "Wait and Try Later": {
      "Type": "Wait",
      "Seconds" : 1,
      "Next" : "Change to 200"
    },
    "Server Unavailable": {
      "Type": "Fail",
      "Error":"ServerUnavailable",
      "Cause": "The server is currently unable to handle the request."
    },
    "Catch All": {
      "Type": "Fail",
      "Cause": "Unknown error!",
      "Error": "An error of unknown type occurred"
    },
    "Change to 200": {
      "Type": "Pass",
      "Result": {"statuscode" :"200"} ,
      "Next": "Call API"
    },
    "OK": {
      "Type": "Pass",
      "Result": "The request has succeeded.",
      "End": true
    }
  }
}
03d
03d

(คลิกเพื่อขยาย)


c. หาบรรทัด “ทรัพยากร” ในสถานะของงาน “เรียกใช้ API” (บรรทัดที่ 7) เมื่อต้องการอัปเดต ARN นี้ให้เป็น ARN ของฟังก์ชัน Lambda API จำลองที่คุณเพิ่งสร้างขึ้น ให้คลิกข้อความ ARN แล้วเลือก ARN จากรายการ

03e
03e

(คลิกเพื่อขยาย)


d. คลิกปุ่มรีเฟรชข้างบานหน้าต่างเวิร์กโฟลว์แบบภาพเพื่อให้ Step Functions สร้างแผนผังเครื่องสถานะที่สอดคล้องกับเวิร์กโฟลว์ที่คุณเพิ่งออกแบบ หลังจากตรวจสอบเวิร์กโฟลว์แบบภาพแล้ว ให้คลิก สร้างเครื่องสถานะ

03f
03f

(คลิกเพื่อขยาย)


ขั้นตอนที่ 4 ทดสอบเวิร์กโฟลว์การจัดการข้อผิดพลาดของคุณ

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


a. คลิกเริ่มดำเนินการ

04a
04a

(คลิกเพื่อขยาย)


b. กล่องโต้ตอบการดำเนินการใหม่จะปรากฏขึ้นมา ซึ่งคุณสามารถป้อนข้อมูลอินพุตสำหรับเครื่องสถานะของคุณได้ คุณจะทำหน้าที่เป็น API และส่งรหัสข้อผิดพลาดที่เราต้องการให้ API จำลองส่งคืนมา แทนที่ข้อความที่มีอยู่ด้วยโค้ดด้านล่าง จากนั้นเลือก เริ่มดำเนินการ:

{
    "statuscode": "200"
}
04b
04b

(คลิกเพื่อขยาย)


c. ในหน้าจอ รายละเอียดการดำเนินการ ให้คลิก อินพุต เพื่อดูข้อมูลอินพุตที่คุณให้ไว้กับเครื่องสถานะ ถัดไป ให้คลิก เอาต์พุต เพื่อดูผลลัพธ์ของการดำเนินการของเครื่องสถานะของคุณ คุณจะเห็นว่าเวิร์กโฟลว์ตีความรหัสสถานะ 200 ว่าเป็นการเรียกใช้ API ที่สำเร็จ

04c
04c

(คลิกเพื่อขยาย)


d. ภายใต้ เวิร์กโฟลว์แบบภาพ คุณจะเห็นเส้นทางการดำเนินการของการดำเนินการแต่ละรายการ โดยแสดงเป็นสีเขียวอยู่ในเวิร์กโฟลว์ คลิกสถานะของงาน “เรียกใช้ API” จากนั้นขยายช่อง อินพุต และ เอาต์พุต ในหน้าจอ รายละเอียดขั้นตอน

คุณจะเห็นว่าสถานะของงานนี้ประสบความสำเร็จในการเรียกฟังก์ชัน Lambda API จำลองด้วยข้อมูลอินพุตที่คุณให้ไว้ และจับเอาต์พุตของฟังก์ชัน Lambda นั้นว่า “200 OK”

04d
04d

(คลิกเพื่อขยาย)


e. ถัดไป ให้คลิกสถานะของงาน “OK” ในเวิร์กโฟลว์แบบภาพ ภายใต้ รายละเอียดขั้นตอน คุณจะเห็นว่าเอาต์พุตของขั้นตอนก่อนหน้านี้ (สถานะของงาน “เรียกใช้ API”) ถูกส่งผ่านเป็นอินพุตมายังขั้นตอนนี้ สถานะ OK คือสถานะ “ผ่าน” ซึ่งเป็นเพียงการส่งผ่านอินพุตมายังเอาต์พุตเท่านั้น แต่ไม่ได้ดำเนินการใดๆ สถานะผ่านมีประโยชน์เมื่อจะสร้างและแก้จุดบกพร่องของเครื่องสถานะ

04e
04e

(คลิกเพื่อขยาย)


ขั้นตอนที่ 5 ตรวจสอบการดำเนินการของเครื่องสถานะของคุณ


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

05a
05a

(คลิกเพื่อขยาย)


ข. คลิก เริ่มดำเนินการ อีกครั้ง และในครั้งนี้ให้ระบุข้อมูลอินพุตต่อไปนี้แล้วคลิก เริ่มดำเนินการ

{
    "statuscode": "503"
}
05b
05b

(คลิกเพื่อขยาย)


ค. ในส่วน ประวัติเหตุการณ์การดำเนินการ ให้ขยายขั้นตอนการดำเนินการแต่ละขั้นตอนเพื่อยืนยันว่าเวิร์กโฟลว์ของคุณทำงานตามที่คาดหวังไว้ เราคาดหวังว่าการดำเนินการนี้จะล้มเหลว ดังนั้นไม่ต้องตกใจไป คุณจะสังเกตว่า:

  1. Step Functions จับอินพุตของคุณ
  2. อินพุตนั้นถูกส่งผ่านไปยังสถานะของงาน “เรียกใช้ API”
  3. สถานะของงาน “เรียกใช้ API” เรียกใช้ MockAPIFunction ของคุณโดยใช้อินพุตดังกล่าว
  4. มีการดำเนินการ MockAPIFunction
  5. MockAPIFunction ล้มเหลวด้วยข้อผิดพลาด ServerUnavailableException
  6. คำสั่งจับในสถานะของงาน “เรียกใช้ API” ของคุณจับข้อผิดพลาดนั้นได้
  7. คำสั่งจับไม่สามารถดำเนินการตามเวิร์กโฟลว์ได้
  8. เครื่องสถานะของคุณดำเนินการเสร็จสมบูรณ์
05c
05c

(คลิกเพื่อขยาย)


ง. ถัดไป คุณจะจำลองข้อผิดพลาด 429 เลื่อนไปยังด้านบนสุดของหน้าจอ รายละเอียดการดำเนินการ และคลิก MyAPIStateMachine คลิก เริ่มดำเนินการ แล้วให้ข้อมูลอินพุตต่อไปนี้ และคลิก เริ่มดำเนินการ:

{
    "statuscode": "429"
}
05d
05d

(คลิกเพื่อขยาย)


จ. ตอนนี้คุณจะตรวจสอบลักษณะการลองใหม่ของเวิร์กโฟลว์ของคุณ ในส่วน ประวัติเหตุการณ์การดำเนินการ ให้ขยายขั้นตอนการดำเนินการแต่ละขั้นตอนอีกครั้งเพื่อยืนยันว่า Step Functions ได้พยายามเรียกใช้ฟังก์ชัน MockAPILambda เพิ่มอีกสองครั้ง และล้มเหลวทั้งสองครั้ง ณ ตอนนี้ เวิร์กโฟลว์ของคุณได้เปลี่ยนเป็นสถานะ “รอและลองในภายหลัง” (แสดงอยู่ในภาพทางด้านขวา) โดยคาดหวังว่า API ไม่ตอบสนองแค่เพียงชั่วคราวเท่านั้น

ถัดไป สถานะ “รอ” ใช้ Brute Force เปลี่ยนโค้ดการตอบสนองเป็น 200 และเวิร์กโฟลว์ของคุณดำเนินการเสร็จสมบูรณ์ วิธีที่คุณจะจัดการข้อผิดพลาด 429 ในแอปพลิเคชันจริงอาจไม่ได้เป็นเช่นนี้ แต่เราพยายามแสดงให้ดูอย่างง่ายๆ เนื่องจากนี่คือบทช่วยสอน

05e
05e

(คลิกเพื่อขยาย)


ฉ. เรียกใช้อินสแตนซ์ของเวิร์กโฟลว์ของคุณอีกหนึ่งอินสแตนซ์ และในครั้งนี้ ให้ระบุการตอบสนอง API แบบสุ่มที่ไม่ได้จัดการโดยเครื่องสถานะของคุณ:

{
    "statuscode": "999"
}

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

05f
05f

(คลิกเพื่อขยาย)


ขั้นตอนที่ 6 ยกเลิกทรัพยากรของคุณ

ในขั้นตอนนี้ คุณจะยกเลิกทรัพยากรที่เกี่ยวข้องกับ AWS Step Functions และ AWS Lambda

ข้อสำคัญ: การยกเลิกทรัพยากรที่ไม่ได้ใช้งานจะช่วยลดต้นทุนและเป็นแนวทางปฏิบัติที่ดีที่สุด การไม่ยกเลิกทรัพยากรของคุณอาจทำให้มีการเรียกเก็บค่าบริการ


ก. ที่ด้านบนของหน้าต่างคอนโซล AWS Step Functions ให้คลิก เครื่องสถานะ

06a
06a

(คลิกเพื่อขยาย)


ข. ในหน้าต่าง เครื่องสถานะ ให้คลิก MyAPIStateMachine และเลือก ลบ ยืนยันการดำเนินการโดยการเลือก ลบเครื่องสถานะ ในกล่องโต้ตอบ เครื่องสถานะของคุณจะถูกลบในหนึ่งหรือสองนาทีเมื่อ Step Functions ยืนยันแล้วว่าการดำเนินการที่ค้างอยู่ทั้งหมดได้เสร็จสิ้นแล้ว

06b
06b

(คลิกเพื่อขยาย)


ค. ถัดไป คุณจะลบฟังก์ชัน Lambda คลิก บริการ ในเมนู AWS Management Console จากนั้นเลือก Lambda

06c
06c

(คลิกเพื่อขยาย)


ง. ในหน้าจอ ฟังก์ชัน ให้คลิก MockAPIFunction เลือก การดำเนินการ แล้วเลือก ลบ ยืนยันการลบโดยการคลิก ลบ อีกครั้ง

06d
06d

(คลิกเพื่อขยาย)


จ. สุดท้าย คุณจะลบบทบาท IAM ของคุณ คลิก บริการ ในเมนู AWS Management Console จากนั้นเลือก IAM

06e
06e

(คลิกเพื่อขยาย)


ฉ. เลือกบทบาท IAM ทั้งสองบทบาทที่คุณสร้างขึ้นสำหรับบทช่วยสอนนี้ จากนั้นคลิก ลบบทบาท ยืนยันการลบโดยการคลิก ใช่ ลบออก บนกล่องโต้ตอบ


ตอนนี้คุณสามารถออกจากระบบ AWS Management Console ได้แล้ว

06f
06f

(คลิกเพื่อขยาย)


ขอแสดงความยินดี!

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

การผสมผสาน AWS Step Functions กับ AWS Lambda เข้าด้วยกันช่วยให้การควบคุมฟังก์ชัน AWS Lambda สำหรับแอปพลิเคชันแบบไร้เซิร์ฟเวอร์สามารถทำได้ง่าย Step Functions ช่วยให้คุณควบคุมเวิร์กโฟลว์ที่ซับซ้อนโดยใช้ฟังก์ชัน Lambda ได้โดยไม่ต้องมีการจัดการและการควบคุมสถานะแอปพลิเคชันพื้นฐาน นอกจากนี้คุณยังสามารถใช้ Step Functions สำหรับกระบวนการปฏิบัติของไมโครเซอร์วิสได้โดยใช้ทรัพยากรการประมวลผล เช่น Amazon EC2 และ Amazon ECS