เชื่อมระบบหลังบ้านสู่โลกออนไลน์ ด้วย Ngrok และเสริมความทนทานให้ API

สวัสดีครับ โปรแกรมเมอร์ทุกท่าน

วันนี้ผมจะมาคุยเรื่องที่หลายคนอาจจะเคยเจอปัญหานะครับ คือเวลาเราพัฒนา API อยู่บนเครื่องเรานี่แหละ Localhost ของเราเนี่ยครับ แล้วเราอยากจะให้คนอื่นลองเข้ามาใช้งาน หรือว่าอยากจะให้ระบบภายนอก อย่างพวก Webhook ต่างๆ เนี่ย เชื่อมมาหา API ของเรา มันทำไม่ได้ใช่ไหมครับ เพราะมันอยู่แค่เครื่องเรา

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

1. Ngrok คืออะไร ทำไมเราถึงต้องใช้ มัน ครับ

Ngrok ก็คือเครื่องมือ ที่จะสร้าง Secure tunnel เชื่อมจาก Localhost ของเรา เนี่ย ไปยัง Public URL ให้เลยครับ แบบอัตโนมัติ ทำให้คนข้างนอก อินเตอร์เน็ต เนี่ย เข้ามาถึง API ของเราได้

ตัวอย่างที่ 1: การใช้ Ngrok ง่ายๆ

สมมุติ เรามี API ที่รันอยู่บนพอร์ต 8000 ของเครื่องเรานะครับ แบบนี้

# สั่งรัน API ของคุณก่อน
# uvicorn main:app --port 8000 # หรือคำสั่งอื่นๆ นะครับ

# จากนั้น เปิด terminal อีกอัน แล้วรัน Ngrok
ngrok http 8000

พอรันคำสั่ง ngrok http 8000 เสร็จเนี่ย มันก็จะให้ URL มาเลยครับ เช่น https://randomstring.ngrok-free.app เราก็เอา URL นี้ ไปให้เพื่อน หรือ ไปใส่ใน Webhook ที่เราอยากจะเทสได้เลยครับ สะดวกมากๆ เลยนะ

ข้อควรระวังนิดนึงนะครับ Ngrok เนี่ย มันสะดวกจริง แต่ไม่ควรเอาไปใช้ใน Production ที่จริงจังนะครับ เพราะมันไม่ได้ออกแบบมาเพื่อความปลอดภัย หรือ Performance ขนาดนั้น เอาไว้ Dev เทสอะไรแบบนี้ เหมาะสมที่สุดครับ

2. เพิ่มความทนทาน (Resilience) ให้ API ของเรา

เวลาเราพัฒนา API นะครับ แล้ว API ของเราเนี่ย ต้องไปเรียกใช้บริการจาก API ภายนอก เช่น Google API หรือบริการอื่นๆ มันมีโอกาสที่ API ปลายทางจะล่ม เน็ตหลุด หรือตอบช้า ได้ตลอดเลยใช่ไหมครับ ถ้าเราไม่จัดการดีๆ API ของเราก็จะพังไปด้วยเลย

Resilience หรือความทนทาน เนี่ย เป็นแนวคิด ที่ช่วยให้ระบบของเรา รับมือกับความผิดพลาด พวกนี้ได้ดีขึ้นครับ หลักๆ ที่นิยมใช้ก็จะมี Retry (ลองใหม่) กับ Circuit Breaker (วงจรเบรกเกอร์) นะครับ

ตัวอย่างที่ 2: การเรียก External API พร้อม Retry ใน Python

ผมจะยกตัวอย่างง่ายๆ เป็น Python นะครับ เพื่อแสดงให้เห็นว่า เราจะ Retry เวลาเรียก API ภายนอกยังไง

import requests
import time

def call_external_api_with_retry(url, max_retries=3, delay=2):
    print(f"กำลังจะเรียก API: {url} ครับ")
    for i in range(max_retries):
        try:
            response = requests.get(url, timeout=5) # ตั้ง Timeout ด้วยนะครับ สำคัญมาก
            response.raise_for_status() # ถ้า HTTP Error (4xx หรือ 5xx) ให้ Raise exception เลย
            print(f"เรียก API สำเร็จครับ! ครั้งที่ {i+1}")
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"เกิดข้อผิดพลาดในการเรียก API ครั้งที่ {i+1}: {e}")
            if i < max_retries - 1:
                print(f"รอ {delay} วินาที แล้วลองใหม่ครับ...")
                time.sleep(delay)
            else:
                print("พยายามครบจำนวนครั้งแล้วครับ แต่ก็ยังไม่สำเร็จ")
    print("เรียก API ไม่สำเร็จ หลังจากพยายามหลายครั้งครับ")
    return None

# สมมุติว่าเรามี API ที่รันอยู่บน Ngrok (ที่เราเปิดไว้) หรือจะเป็น Google API ก็ได้ครับ
# external_api_url = "https://your-ngrok-url.ngrok-free.app/data" # ตัวอย่างที่รันบน Ngrok
external_api_url = "https://jsonplaceholder.typicode.com/posts/1" # ตัวอย่าง Public API ทั่วไปคล้าย Google API ครับ

data = call_external_api_with_retry(external_api_url)
if data:
    print("ได้ข้อมูลกลับมาแล้วครับ:", data)
else:
    print("ไม่สามารถดึงข้อมูลได้ครับ")

จากโค้ดข้างบนนะครับ เราจะเห็นว่า เรามีการพยายามเรียก API ซ้ำๆ 3 ครั้ง ( max_retries=3 ) ถ้าเกิดความผิดพลาด ก็จะรอ 2 วินาที ( delay=2 ) ก่อนจะลองใหม่ วิธีนี้ช่วยลดโอกาสที่ API ของเราจะพัง เพราะ API ภายนอกมีปัญหาชั่วคราวได้เยอะเลยครับ

แนวคิด Circuit Breaker (วงจรเบรกเกอร์)

อันนี้ก็คล้ายๆ ฟิวส์ไฟบ้านเราเลยนะครับ คือถ้า API ภายนอกล่มบ่อยๆ แทนที่จะพยายามเรียกซ้ำๆ จนเปลืองทรัพยากร Circuit Breaker จะ "เปิดวงจร" คือหยุดการเรียกชั่วคราวไปเลยครับ พอเวลาผ่านไปซักพัก ก็จะลอง "ปิดวงจร" เพื่อลองเรียกใหม่ดู ถ้าสำเร็จก็กลับมาทำงานปกติ แต่ถ้ายังล่มอยู่ ก็จะ "เปิดวงจร" อีกครั้งครับ อันนี้จะซับซ้อนกว่า Retry นิดหน่อย แต่ช่วยปกป้องระบบเราได้ดีกว่าเดิมเยอะเลยครับ

3. เอาไปใช้กับ App Router หรือ Framework อื่นๆ ได้ยังไงบ้าง

ถ้าเราพัฒนา API ด้วย Framework อย่าง Flask, FastAPI, Next.js (App Router) หรืออื่นๆ ที่รันบน Localhost เราก็ใช้ Ngrok มาเปิดให้มันออกสู่โลกภายนอกได้ง่ายๆ เลยครับ

ส่วนเรื่อง Resilience เนี่ยครับ เราก็เอาแนวคิด หรือโค้ดตัวอย่างที่ผมให้ไป ไปปรับใช้ตรงส่วนที่เราต้อง call API ภายนอกครับ เพื่อให้ API ของเราเนี่ย ทำงานได้ทนทาน ไม่ว่า API ที่เราไปเรียกจะเจอปัญหาอะไรนะครับ

สรุปนะครับ

การใช้ Ngrok ช่วยให้เราพัฒนาและทดสอบระบบหลังบ้านที่ต้องเชื่อมกับภายนอกได้ง่ายขึ้นมากๆ นะครับ ส่วนการเพิ่ม Resilience เข้าไป ในโค้ดของเรา ก็เป็นการเพิ่มภูมิคุ้มกัน ให้ระบบของเราทนทานต่อความผิดพลาดต่างๆ ได้ดีขึ้น โดยเฉพาะกับการเชื่อมต่อกับพวก Google API หรือบริการ Cloud อื่นๆ ที่เราต้องพึ่งพาข้อมูลจากเค้านะครับ

หวังว่าบทความนี้จะเป็นประโยชน์กับเพื่อนๆ โปรแกรมเมอร์ทุกคนนะครับ สวัสดีครับ

แหล่งที่มา: - Ngrok Official Documentation - Python requests library documentation - Concepts of Resilient Systems Design