ในบทช่วยสอนนี้ คุณจะได้เรียนรู้วิธีใช้ 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 เพื่อสร้างเครื่องสถานะที่มีความสามารถในการลองใหม่และจับ ซึ่งตอบสนองต่อตรรกะที่แตกต่างกันโดยขึ้นอยู่กับข้อผิดพลาดที่ถูกกระตุ้นให้เกิดขึ้น

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

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

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

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

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

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

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')

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

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

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

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

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

 

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

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

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

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
    }
  }
}

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

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

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

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

{
    "statuscode": "200"
}

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

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

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

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

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

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

{
    "statuscode": "503"
}

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

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

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

{
    "statuscode": "429"
}

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

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

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

{
    "statuscode": "999"
}

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

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

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

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

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

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

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

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