
Flask handles 50,000 requests before you notice lag — ประโยคนี้ฟังดูเกินจริงสำหรับหลายคน เพราะ Flask มักถูกมองว่าเป็นเฟรมเวิร์ก “เล็ก” ไว้ทำโปรเจกต์ส่วนตัว แต่ถ้าเข้าใจว่า Flask ทำงานภายในอย่างไร และตั้งค่า production ให้ถูกวิธี คุณจะสร้าง API ที่รับโหลดหนักได้จริง บทความนี้พาไล่ทีละขั้น ตั้งแต่ติดตั้ง อธิบายกลไกภายใน ไปจนถึงตั้งค่า Gunicorn, caching และวัดผลด้วย load test
TL;DR: Flask API ตัวเดียวไม่ได้รับ 50,000 คำขอต่อวินาทีด้วยโปรเซสเดียว แต่ทำได้เมื่อรันหลาย worker ด้วย Gunicorn (ค่าเริ่มต้นทั่วไป 4-12 workers ต่อเครื่อง) วางหลัง Nginx, ใช้ cache ลดงานซ้ำ และขยายแนวนอนหลายเครื่อง ส่วนตัวเฟรมเวิร์กเองมี routing และ request context ที่ออกแบบมาให้เบาพอ ปัญหาคอขวดส่วนใหญ่อยู่ที่โค้ดของเราและการตั้งค่าเซิร์ฟเวอร์ ไม่ใช่ Flask
- Flask’s routing system uses Werkzeug’s Map class which compiles URL rules into a single regex tree, reducing lookup time from O(n) to O(log n) for 100+ endpoints
- Instagram served 30 million users on Django before switching, but Pinterest still runs Flask APIs handling 250 billion pins with only 2.7ms average response time
- Flask’s request context uses LocalStack and LocalProxy objects that leverage Python’s threading.local, allowing 1,000+ concurrent requests per worker without variable collision
ทำไมต้องเรียนเรื่องนี้ และใช้ทำอะไร
คุณควรเข้าใจการสเกล Flask เพราะ API ที่ช้าหรือล่มตอนมีผู้ใช้เยอะ คือสาเหตุอันดับต้นๆ ที่ทำให้โปรเจกต์เสียโอกาส ไม่ว่าจะเป็นแอปมือถือ ระบบหลังบ้านของร้านค้าออนไลน์ หรือ API ที่เปิดขายให้นักพัฒนาอื่น ซึ่งเป็นแนวคิดเดียวกับที่อธิบายไว้ใน API สร้างรายได้ Passive บน RapidAPI ทำงานอย่างไร เพราะถ้า API ของคุณเสถียรและเร็ว ผู้ใช้ก็พร้อมจ่ายต่อเนื่อง
ตัวอย่างจากโลกจริงคือ Instagram ที่เคยให้บริการผู้ใช้ 30 ล้านคนบน Django ก่อนปรับสถาปัตยกรรม ในขณะที่ Pinterest ยังรัน Flask API จัดการ 250 billion pins ด้วยเวลาตอบสนองเฉลี่ย 2.7ms ตัวเลขนี้บอกเราว่าเฟรมเวิร์กไม่ใช่ตัวตัดสิน สิ่งที่ตัดสินคือวิธีใช้งาน (หมายเหตุ: ตัวเลขเชิงสถิติในบทความเป็นข้อมูลอ้างอิงเชิงภาพรวม ควร benchmark บนระบบของคุณเองก่อนตัดสินใจ)
Pinterest ยังรัน Flask APIs จัดการ 250 billion pins ด้วยเวลาตอบสนองเฉลี่ยเพียง 2.7ms — เฟรมเวิร์กที่คนมองว่า “เล็ก” รับงานระดับมหาศาลได้ ถ้าเราตั้งค่าถูกต้อง
สิ่งที่ต้องเตรียม (Prerequisites)
ก่อนเริ่ม คุณต้องมีพื้นฐานและเครื่องมือดังนี้
- Python 3.10 ขึ้นไป และเข้าใจ function, decorator เบื้องต้น (ถ้าอยากรู้ลึกว่าโค้ดถูกรันอย่างไร อ่าน Python ทำงานภายในอย่างไร: จากโค้ดสู่ Bytecode)
- เครื่อง Linux หรือ WSL สำหรับรัน Gunicorn (Gunicorn ไม่รองรับ Windows โดยตรง)
- เครื่องมือ load test เช่น
wrkหรือhey - ความรู้ terminal พื้นฐาน
เตรียมสภาพแวดล้อมด้วยคำสั่งต่อไปนี้
python -m venv venv
source venv/bin/activate
pip install flask gunicorn gevent
บรรทัดแรกสร้าง virtual environment เพื่อแยกแพ็กเกจของโปรเจกต์ บรรทัดสองเปิดใช้งาน และบรรทัดสามติดตั้ง Flask, Gunicorn (เซิร์ฟเวอร์ production) และ gevent (worker แบบ async)
ขั้นตอนโดยละเอียด
ขั้นตอนที่ 1: สร้างแอปด้วย Flask instantiation
การสร้าง Flask(__name__) คือการสร้าง WSGI application object ที่ผูกเข้ากับระบบของ Werkzeug (เช่น DispatcherMiddleware) และเตรียม url_map ที่ว่างเปล่าไว้เก็บเส้นทางทั้งหมด ทุกอย่างที่เราลงทะเบียนต่อจากนี้จะถูกเก็บไว้ที่นี่
from flask import Flask, jsonify, request
app = Flask(__name__) # สร้าง WSGI app และ url_map ว่าง
อาร์กิวเมนต์ __name__ ให้ Flask รู้ตำแหน่งโมดูลเพื่อหา resource ต่างๆ ได้ถูกต้อง
ขั้นตอนที่ 2: ลงทะเบียน route ด้วย @app.route
ตัว decorator @app.route จับ reference ของฟังก์ชัน แล้วเรียก add_url_rule() ซึ่งแปลง URL string เป็นออบเจกต์ Rule โดยใช้ routing parser ของ Werkzeug ข้อเท็จจริงที่น่าสนใจคือ The @app.route decorator actually calls add_url_rule() which stores endpoints in a dictionary with 47 bytes overhead per route in Flask 2.3.0 ดังนั้นต่อให้มี route หลายร้อยเส้น หน่วยความจำก็แทบไม่เพิ่ม
@app.route("/api/items/<int:item_id>")
def get_item(item_id):
# item_id ถูกแปลงเป็น int ให้อัตโนมัติโดย converter
return jsonify({"id": item_id, "name": f"item-{item_id}"})
ส่วน <int:item_id> เป็น converter ที่ทั้งตรวจชนิดข้อมูลและส่งค่าเข้าฟังก์ชัน ถ้า URL ไม่ใช่ตัวเลข Flask จะตอบ 404 โดยที่โค้ดเราไม่ต้องทำงานเลย
ขั้นตอนที่ 3: Rule ถูกคอมไพล์เป็นโครงสร้างค้นหาเร็ว
Rule แต่ละตัวจะถูกคอมไพล์เป็น regex pattern แล้วใส่เข้า Map ในรูปโครงสร้างแบบกราฟ (directed acyclic graph) เพื่อให้ค้นหาได้เร็ว ตามที่ระบุว่า Flask’s routing system uses Werkzeug’s Map class which compiles URL rules into a single regex tree, reducing lookup time from O(n) to O(log n) for 100+ endpoints ผลคือการเพิ่ม endpoint ไม่ได้ทำให้ทุกคำขอช้าลงเป็นเส้นตรง คุณไม่ต้องทำอะไรเพิ่มในขั้นนี้ แต่ควรรู้ไว้เมื่อต้องออกแบบ API ขนาดใหญ่ว่าการแยก route จำนวนมากไม่ใช่ปัญหาด้านความเร็ว
ขั้นตอนที่ 4: Request context และ thread-local storage
เมื่อคำขอเข้ามา Flask สร้าง RequestContext แล้ว push ลงใน stack ผ่านกลไก LocalStack ซึ่งเก็บข้อมูลแยกต่อ thread (ในเอกสารรุ่นเก่าเรียก _request_ctx_stack; Flask 2.3 ขึ้นไปย้ายไปใช้ contextvars แต่แนวคิดเหมือนกัน) นี่คือเหตุผลที่คุณใช้ตัวแปร request แบบ global ได้โดยไม่ชนกันข้ามคำขอ: Flask’s request context uses LocalStack and LocalProxy objects that leverage Python’s threading.local, allowing 1,000+ concurrent requests per worker without variable collision
@app.route("/api/echo", methods=["POST"])
def echo():
# request เป็น LocalProxy ชี้ไปยังคำขอของ thread นี้เท่านั้น
data = request.get_json(silent=True) or {}
return jsonify({"received": data})
พารามิเตอร์ silent=True ทำให้ถ้า body ไม่ใช่ JSON จะได้ None แทนที่จะเกิด error และเรา fallback เป็น dict ว่าง
ขั้นตอนที่ 5: URL matching
เมธอด match() ของ URL adapter จะไล่ทรีของ rule ที่คอมไพล์ไว้ ดึงตัวแปรใน path ออกมาเป็น dictionary และระบุว่า view function ตัวไหนต้องรัน ขั้นตอนนี้ไม่มีโค้ดให้เขียน แต่ช่วยอธิบายว่าทำไมการตั้งชื่อ route แบบชัดเจนและไม่ซ้อนทับกันช่วยทั้งความเร็วและการดีบัก
ขั้นตอนที่ 6: before_request hooks
ก่อนเรียก view Flask เรียก preprocess_request() ซึ่งรัน before_request hooks ทั้งหมดตามลำดับที่ลงทะเบียน จึงเหมาะกับการตรวจ API key, rate limit หรือหยุดคำขอตั้งแต่ต้น
import time
@app.before_request
def start_timer():
request.start = time.perf_counter() # จับเวลาเริ่มต้น
API_KEYS = {"demo-key-123"}
@app.before_request
def check_key():
if request.path.startswith("/api/") and request.headers.get("X-API-Key") not in API_KEYS:
return jsonify({"error": "unauthorized"}), 401 # คืนค่า = ยกเลิกคำขอทันที
ถ้า hook ใดคืนค่า Flask จะข้าม view ไปเลย ซึ่งประหยัดงานมากเมื่อมีคำขอที่ไม่ผ่านสิทธิ์จำนวนมาก
ขั้นตอนที่ 7: View function และ make_response()
view ที่ถูกจับคู่จะรันและคืนข้อมูล จากนั้น Flask เรียก make_response() ห่อเป็น Response พร้อม header เริ่มต้น เช่น Content-Type จุดที่ทำให้ API เร็วขึ้นมากที่สุดคือการลดงานใน view เอง เช่น cache ผลลัพธ์ที่คำนวณซ้ำ
_cache = {}
TTL = 5 # วินาที
def cached(key, producer):
now = time.time()
hit = _cache.get(key)
if hit and now - hit[0] < TTL:
return hit[1] # cache hit: ไม่ต้องคำนวณใหม่
value = producer() # cache miss: คำนวณแล้วเก็บ
_cache[key] = (now, value)
return value
@app.route("/api/stats")
def stats():
data = cached("stats", lambda: {"users": 1200, "orders": 340})
return jsonify(data)
แคชแบบนี้อยู่ในหน่วยความจำของแต่ละ worker ถ้าต้องการแคชร่วมกันทุก worker ให้ใช้ Redis แทน
ขั้นตอนที่ 8: after_request และการเก็บกวาด context
หลังสร้าง response แล้ว process_response() จะรัน after_request handlers ทั้งหมด จากนั้น LocalStack.pop() จะถอด request context ออก ทำให้ตัวแปร thread-local ถูกเคลียร์อัตโนมัติ
@app.after_request
def add_headers(resp):
ms = (time.perf_counter() - request.start) * 1000
resp.headers["X-Response-Time-ms"] = f"{ms:.2f}" # วัดเวลาต่อคำขอ
return resp # ต้อง return response เสมอ
ทำไมห้ามใช้ development server รับโหลดจริง?
ห้ามใช้ flask run ใน production เพราะเซิร์ฟเวอร์สำหรับพัฒนาไม่ได้ออกแบบมาเพื่อรับโหลด Flask’s development server uses Werkzeug’s BaseWSGIServer which forks from Python’s HTTPServer, limiting it to exactly 1 request at a time unlike Gunicorn’s 4-12 worker default (ในเวอร์ชันใหม่เปิด threaded ได้ แต่ยังไม่เหมาะกับ production อยู่ดี) ทางออกคือใช้ Gunicorn สร้างหลาย worker ขนานกัน
สร้างไฟล์ตั้งค่า gunicorn.conf.py ดังนี้
import multiprocessing
workers = multiprocessing.cpu_count() * 2 + 1 # สูตรเริ่มต้นที่นิยม
worker_class = "gevent" # รองรับ I/O จำนวนมากต่อ worker
worker_connections = 1000 # จำนวน connection พร้อมกันต่อ worker
bind = "0.0.0.0:8000"
keepalive = 5 # ใช้ connection ซ้ำ ลดต้นทุน handshake
max_requests = 10000 # restart worker เป็นระยะ กัน memory leak
max_requests_jitter = 500 # สุ่มเพื่อไม่ให้ restart พร้อมกัน
เริ่มรันด้วย gunicorn -c gunicorn.conf.py app:app บนเครื่อง 8 คอร์จะได้ 17 workers ซึ่งแต่ละตัวรับ connection ได้หลักพัน
ตัวอย่างโค้ดสมบูรณ์
นี่คือ app.py ฉบับรวมที่ใช้งานได้ทันที นำทุกขั้นตอนมารวมกัน
import time
from flask import Flask, jsonify, request
app = Flask(__name__)
API_KEYS = {"demo-key-123"}
_cache = {}
TTL = 5
def cached(key, producer):
now = time.time()
hit = _cache.get(key)
if hit and now - hit[0] < TTL:
return hit[1]
value = producer()
_cache[key] = (now, value)
return value
@app.before_request
def before():
request.start = time.perf_counter()
if request.path.startswith("/api/") and request.headers.get("X-API-Key") not in API_KEYS:
return jsonify({"error": "unauthorized"}), 401
@app.route("/api/items/<int:item_id>")
def get_item(item_id):
return jsonify({"id": item_id, "name": f"item-{item_id}"})
@app.route("/api/stats")
def stats():
return jsonify(cached("stats", lambda: {"users": 1200, "orders": 340}))
@app.route("/api/echo", methods=["POST"])
def echo():
return jsonify({"received": request.get_json(silent=True) or {}})
@app.after_request
def after(resp):
ms = (time.perf_counter() - request.start) * 1000
resp.headers["X-Response-Time-ms"] = f"{ms:.2f}"
return resp
if __name__ == "__main__":
app.run(debug=False)
ทดสอบโหลดด้วย wrk แล้วดูตัวเลข Requests/sec
wrk -t8 -c400 -d30s -H "X-API-Key: demo-key-123" http://127.0.0.1:8000/api/stats
แฟล็ก -t8 คือ 8 threads, -c400 คือ 400 connections พร้อมกัน และ -d30s คือรัน 30 วินาที endpoint ที่มีแคชบนเครื่องหลายคอร์มักได้หลักหมื่น req/s ต่อเครื่อง การไปถึง 50,000 req/s จึงต้องรวมหลายเครื่องหรือหลาย instance เข้าด้วยกัน
เคล็ดลับและข้อควรระวัง
- วัดก่อนปรับ: ใช้ header เวลาตอบสนองจากขั้นตอนที่ 8 และ
wrkหาคอขวดจริง อย่าเดา - วาง Nginx ไว้หน้า Gunicorn: ให้ Nginx จัดการ TLS, static files และ buffering ผู้ใช้ที่เน็ตช้าจะไม่กิน worker ของคุณ
- อย่าบล็อก worker: งานหนักอย่างส่งอีเมลหรือประมวลผลรูป ควรโยนไปคิว (Celery, RQ)
- ระวังตัวแปร global ที่เขียนได้: แต่ละ worker เป็นคนละโปรเซส ข้อมูลที่ต้องแชร์ให้เก็บใน Redis หรือฐานข้อมูล
- ใช้ connection pool ของฐานข้อมูล: การเปิด connection ใหม่ทุกคำขอคือคอขวดที่พบบ่อยที่สุด
- ตัวเลขทั้งหมดเป็นค่าอ้างอิง: ผลจริงขึ้นกับฮาร์ดแวร์ ขนาด payload และโค้ดของคุณ ต้องทดสอบบนระบบเอง
ถ้าสนใจเรื่องโครงสร้างพื้นฐานสำหรับ deploy ดูหมวด Hosting เพื่อเลือกเซิร์ฟเวอร์ที่เหมาะกับงานของคุณ
ขั้นตอนต่อไป (Next Steps)
- ย้ายแคชไป Redis เพื่อแชร์ข้าม worker และข้ามเครื่อง
- เพิ่ม rate limiting ด้วย Flask-Limiter เพื่อป้องกัน API ถูกยิงเกินขีดจำกัด
- ใส่ monitoring เช่น Prometheus และ Grafana ดู latency เป็น percentile (p95, p99)
- ห่อด้วย Docker แล้วขยายแนวนอนหลาย instance หลัง load balancer
- ถ้าต้องการต่อยอดเป็นรายได้ อ่าน API สร้างรายได้ Passive บน RapidAPI ทำงานอย่างไร และบทความอื่นในหมวด Coding
คำถามที่พบบ่อย (FAQ)
Flask API ตัวเดียวรับ 50,000 คำขอต่อวินาทีได้จริงไหม?
A: ด้วยโปรเซสเดียวไม่ได้ แต่ระบบที่ใช้ Flask รับระดับนี้ได้เมื่อรันหลาย worker ด้วย Gunicorn วางหลัง Nginx ใช้แคช และขยายหลายเครื่อง ค่าที่ทำได้จริงขึ้นกับความซับซ้อนของ endpoint และฮาร์ดแวร์ ควรวัดด้วย load test เสมอ
ทำไม flask run ไม่เหมาะกับ production?
A: เพราะเซิร์ฟเวอร์สำหรับพัฒนาออกแบบมาเพื่อความสะดวก ไม่ใช่ประสิทธิภาพและความเสถียร ไม่มีการจัดการ worker, ไม่รีสตาร์ทอัตโนมัติ และรับงานพร้อมกันได้จำกัด ควรใช้ Gunicorn หรือ uWSGI แทน
ควรเลือก worker class แบบไหนดี?
A: ถ้า API ส่วนใหญ่รอ I/O เช่น เรียกฐานข้อมูลหรือ API ภายนอก ให้ใช้ gevent หรือ gthread ถ้าเป็นงานคำนวณหนักที่กิน CPU ให้ใช้ sync workers จำนวนเท่ากับแกน CPU แล้วเพิ่มเครื่องแทน
Flask ช้าลงไหมเมื่อมี endpoint เป็นร้อย?
A: ไม่ช้าลงอย่างมีนัยสำคัญ เพราะ Werkzeug คอมไพล์ rule เป็นโครงสร้างค้นหาเดียว ทำให้เวลาจับคู่ URL โตช้ากว่าจำนวน endpoint มาก คอขวดจริงมักอยู่ที่ฐานข้อมูลและโค้ดใน view
But what happens when two requests hit the same endpoint at the exact same microsecond?
อัปเดตล่าสุด: 20 November 2026 บน AiDevThai
ปลั๊กอิน WordPress จากเรา: Exit Pop Pro
ป๊อปอัพ exit-intent ที่แจก PDF ฟรี แลกอีเมล — เก็บ subscriber เข้า WordPress ของคุณโดยตรง จ่ายครั้งเดียว $29 ไม่มีค่ารายเดือน ไม่ต้องง้อ SaaS