Kong API Gateway เป็นหนึ่งในเครื่องมือยอดนิยมที่นักพัฒนามืออาชีพใช้กันอย่างแพร่หลาย มีทั้ง Kong Enterprise & Kong Open-Source ซึ่งเป็นเครื่องมือที่ทรงพลังสำหรับการจัดการ API แต่การใช้งานอย่างมีประสิทธิภาพสูงสุดนั้นต้องอาศัยเทคนิคการ Optimize ที่เหมาะสม โดยบทความนี้จะเปิด 7 เทคนิคในการ Optimize Kong API Gateway Performance ที่ Developer มืออาชีพทุกคนควรรู้ เป็นไอเดียวเอาไปใช้งานจริงได้
1. ปรับแต่งการใช้ทรัพยากร
Kong ใช้ NGINX เป็น Core และถ่ายทอดด้วย Multi-processing ด้วยการตั้งค่าจำนวน Worker Processes ให้เหมาะสมจะช่วยให้ Kong ใช้ประโยชน์จาก Multi-core CPUs ได้อย่างเต็มที่
วิธีการปรับแต่ง
- ตรวจสอบจำนวน CPU cores โดยใช้คำสั่ง `nproc` หรือ `lscpu` บน Linux เพื่อดูจำนวน CPU cores ที่มี
- ตั้งค่า worker_processes: ปรับแต่งในไฟล์ `kong.conf` โดยตั้งค่า `nginx_worker_processes` ให้เท่ากับจำนวน CPU cores หรือน้อยกว่าเล็กน้อยเช่น
| nginx_worker_processes = auto |
หรือระบุจำนวนที่แน่นอน เช่น
| nginx_worker_processes = 4 |
- สำหรับระบบที่มี CPU Cores จำนวนมาก อาจไม่จำเป็นต้องใช้ทุก Core โดยให้ลองทดสอบประสิทธิภาพโดยใช้จำนวน Worker Processes ที่น้อยกว่าจำนวน Cores เล็กน้อย
- การตั้งค่า Worker Processes มากเกินไปอาจทำให้เกิดการแย่งชิงทรัพยากรและลดประสิทธิภาพโดยรวม ให้ระวังการใช้ `auto` ในบางกรณี เพราะอาจไม่ได้ค่าที่เหมาะสมที่สุดเสมอไป
2. เพิ่มประสิทธิภาพการ Caching
การเพิ่มประสิทธิภาพการ Caching โดยเฉพาะการเพิ่ม memory สำหรับ database caching เป็นวิธีที่มีประสิทธิภาพในการลด latency สำหรับ Kong API Gateway โดยเฉพาะอย่างยิ่งสำหรับ workload ที่ต้องการ latency ต่ำ เพราะ Kong ใช้ in-memory cache เพื่อลดการเรียกใช้ฐานข้อมูลซ้ำๆ ซึ่งช่วยลด latency ในการประมวลผล Request
การปรับแต่ง Database Caching
1. เพิ่มขนาด mem_cache_size
- ปรับแต่งค่า `mem_cache_size` ในไฟล์ `kong.conf` ให้มีขนาดใหญ่ที่สุดเท่าที่เป็นไปได้ โดยยังคงเหลือทรัพยากรเพียงพอสำหรับระบบปฏิบัติการและกระบวนการอื่นๆ
2. คำนวณหน่วยความจำสำหรับ Worker Processes
- แต่ละ worker process ใช้หน่วยความจำประมาณ 500MB ดังนั้นควรคำนวณให้เพียงพอตามจำนวน CPU cores ที่ใช้งาน
3. ตัวอย่างการคำนวณ
- สำหรับเครื่องที่มี 4 CPU cores และ RAM 8GB ควรจัดสรรประมาณ 4-6GB สำหรับ cache ผ่านการตั้งค่า `mem_cache_size`
4. ปรับแต่งตามประเภทของ Workload
- สำหรับ Latency-sensitive workload ให้เพิ่ม Memory สำหรับ Database caching จะให้ประโยชน์มากกว่าการเพิ่ม Compute power
- สำหรับ Throughput-sensitive workload ที่ต้องการทั้ง Memory และ CPU resources แต่การเพิ่ม Compute power จะให้ผลดีกว่า
5. ข้อแนะนำ
- จำนวน Consumers และ Credentials ให้เพิ่มจำนวนเหล่านี้จะต้องการหน่วยความจำมากขึ้นสำหรับการ Cache ข้อมูล
- ควรทำการ Benchmark เพื่อหาค่าที่เหมาะสมที่สุดสำหรับระบบของคุณ
3. ใช้ Dedicated Configuration Processing
เมื่อเปิดใช้งาน Dedicated Configuration Processing ระบบของ Kong จะแยกกระบวนการ CPU-intensive บางส่วนของการ Reconfigure Data Plane ไปยัง Worker Process ที่แยกต่างหาก จึงสามารถลด Proxy latency ระหว่างการ Reconfigure เพิ่มประสิทธิภาพการทำงานโดยรวมของ Kong Gateway ได้ เหมาะสำหรับระบบที่มี Configuration Entities มากกว่า 1,000 รายการ มีประโยชน์มากเมื่อ Kong Gateway ทำงานในโหมด Hybrid Mode วิธีการเปิดใช้งานคือ เปิดไฟล์ `kong.conf` และค้นหาหรือเพิ่มบรรทัดต่อไปนี้ การเปิดใช้งานจะเพิ่มการใช้หน่วยความจำเล็กน้อย แลกกับการลด Latency ควรทดสอบประสิทธิภาพก่อนและหลังเปิดใช้งานเพื่อยืนยันผลลัพธ์ที่ดีขึ้น
| dedicated_config_processing = on |
4. ปรับแต่ง ulimit
ulimit กำหนดจำนวนไฟล์ที่ระบบปฏิบัติการอนุญาตให้โปรเซสหนึ่งๆ เปิดได้ ซึ่งส่งผลโดยตรงต่อจำนวนการเชื่อมต่อที่ Kong สามารถจัดการได้ โดยแนะนำให้ตั้งค่า ulimit ควรตั้งไว้ที่อย่างน้อย 4096 ส่วนสำหรับระบบที่มีการใช้งานสูง แนะนำให้ตั้งค่าที่ 16384 หรือสูงกว่า แต่การตั้งค่า ulimit สูงเกินไปอาจส่งผลต่อประสิทธิภาพของระบบโดยรวม ซึ่งควรตรวจสอบให้แน่ใจว่าระบบปฏิบัติการและฮาร์ดแวร์สามารถรองรับค่า ulimit ที่ตั้งไว้ได้
วิธีการปรับแต่ง
- ตรวจสอบค่าปัจจุบัน ใช้คำสั่ง `ulimit -n` เพื่อดูค่า ulimit ปัจจุบัน
- การปรับค่าแบบชั่วคราว
| ulimit -n 16384 |
- การปรับค่าถาวร ทำได้โดยแก้ไขไฟล์ `/etc/security/limits.conf` โดยเพิ่มบรรทัด
| soft nofile 16384 hard nofile 16384 |
- สำหรับ systemd ให้แก้ไขไฟล์ service ของ Kong (`/etc/systemd/system/kong.service`) โดยเพิ่ม
| [Service] LimitNOFILE=16384 |
- ตรวจสอบหลังการปรับแต่ง โดยการรีสตาร์ท Kong และตรวจสอบค่า ulimit ของโปรเซส Kong ด้วยคำสั่ง
| cat /proc/<kong_process_id>/limits | grep ‘open files’ |
5. เพิ่ม Connection Reuse
การเพิ่ม Connection Reuse ผ่าน Keepalive connections เป็นวิธีที่มีประสิทธิภาพในการ Optimize Kong API Gateway โดยเฉพาะในสภาพแวดล้อมที่มี Traffic สูง โดย Keepalive connections ช่วยลดการสร้าง TCP connection ใหม่ในแต่ละ Request ซึ่งช่วยลด Latency และเพิ่ม Throughput ค่าที่เหมาะสมขึ้นอยู่กับ Workload และทรัพยากรของระบบ แต่การตั้งค่าสูงเกินไปอาจทำให้ใช้ทรัพยากรมากเกินความจำเป็น
วิธีการปรับแต่ง
- เปิดใช้งาน keepalive ในไฟล์ `kong.conf` และตั้งค่า
| upstream_keepalive_pool_size = 1000 |
- เพิ่มจำนวน keepalive requests
| upstream_keepalive_max_requests = 100000 |
- ปรับ keepalive timeout
| upstream_keepalive_idle_timeout = 60s |
- เพิ่ม keepalive connections สำหรับ Downstream
| nginx_http_keepalive_requests = 100000 |
6. ให้ตรวจสอบ Custom Plugins
การตรวจสอบและทดสอบ Custom Plugins อย่างละเอียดจะช่วยให้คุณเข้าใจผลกระทบของแต่ละ plugin ต่อประสิทธิภาพของ Kong API Gateway และสามารถตัดสินใจได้ว่าควรใช้หรือปรับแต่ง Plugins อย่างไรเพื่อให้ได้ประสิทธิภาพสูงสุด บาง Plugins อาจจำเป็นสำหรับความปลอดภัยหรือฟังก์ชันการทำงานที่สำคัญ ต้องชั่งน้ำหนักระหว่างประสิทธิภาพและความจำเป็น ซึ่งการตรวจสอบ Custom Plugins สามารถทำได้โดยดังนี้
- ตรวจสอบ Plugins ที่ใช้งานอยู่ทั้งหมด
- บันทึกการตั้งค่า Plugins ปัจจุบัน บันทึกรายละเอียดการตั้งค่าของแต่ละ Plugins ใช้คำสั่ง `curl` เพื่อดูรายละเอียดของแต่ละ Plugins
- ปิดการใช้งาน Custom Plugins ทั้งหมดชั่วคราว
- ทำการทดสอบ Performance ใช้เครื่องมือ benchmark เช่น Apache Bench หรือ wrk ทดสอบ Latency, Throughput, และการใช้ทรัพยากรบันทึกผลการทดสอบอย่างละเอียด
- ให้เปิดใช้งาน Custom Plugins กลับมาทีละตัว ทำการทดสอบ Performance หลังจากเปิดใช้งานแต่ละ Plugins และเปรียบเทียบผลกับการทดสอบที่ไม่มี Plugins
- เปรียบเทียบผลการทดสอบระหว่างมีและไม่มี Plugins
- สำหรับ Plugins ที่มีผลกระทบสูง พิจารณาปรับแต่งการตั้งค่า ให้ทดลองใช้ Alternatives หรือ Optimized Versions ของ Plugins นั้นๆ
7. จำกัดขนาด Request/Response
Kong ใช้ In-memory Buffers สำหรับ Request และ Response ที่มีขนาดเล็ก แต่จะใช้ Temporary files บนดิสก์สำหรับข้อมูลที่ใหญ่กว่า การเขียนและอ่านจากดิสก์จะทำให้เกิด latency สูงขึ้น โดยการรักษาขนาด Request body ให้ต่ำกว่า 8 KB และ Response body ต่ำกว่า 32 KB เพื่อหลีกเลี่ยงการ Buffer ข้อมูลลงดิสก์ ซึ่งจะช่วยเพิ่มประสิทธิภาพการทำงานโดยรวม ซึ่งวิธีการนี้จะไม่เหมาะสำหรับ สำหรับ APIs ที่จำเป็นต้องส่งข้อมูลขนาดใหญ่
วิธีการทำ
- ตั้งค่าขนาด Request ในไฟล์ `kong.conf` โดยกำหนดค่า
| nginx_http_client_body_buffer_size = 8k |
- ตั้งค่าขีดจำกัดขนาด Response ในไฟล์ `kong.conf` โดยให้กำหนดค่า
| nginx_http_proxy_buffer_size = 32k nginx_http_proxy_buffers = 8 32k |
- ใช้ Request Size Limiting Plugin โดยเปิดใช้งาน Plugin นี้เพื่อจำกัดขนาด Request
| bash curl -X POST http://kong:8001/routes/{route_id}/plugins \ –data “name=request-size-limiting” \ –data “config.allowed_payload_size=8” |
- แนะนำให้ปรับแต่ง Upstream Services โดยส่ง Response ที่มีขนาดเล็ก ใช้เทคนิคเช่น Pagination หรือ Streaming สำหรับข้อมูลขนาดใหญ่
- ใช้ Response Transformer Plugin โดยใช้ plugin นี้เพื่อลดขนาด Response ถ้าจำเป็น
| bash curl -X POST http://kong:8001/routes/{route_id}/plugins \ –data “name=response-transformer” \ –data “config.remove.json=unwanted_field” |
- เราสามารถใช้เครื่องมือมอนิเตอริ่งเพื่อตรวจสอบขนาด Request และ Response วิเคราะห์ Log Files เพื่อระบุ Endpoints ที่มักส่ง Request หรือ Response ขนาดใหญ่
เปลี่ยนผ่านสู่ระบบคลาวด์ที่ปลอดภัยและได้มาตรฐานกับ PROEN Cloud
ติดต่อทีมงานเพื่อรับคำปรึกษาและโซลูชันที่เหมาะกับองค์กรของคุณ
📞 โทร: 02-690-3888
📧 อีเมล: sales@proen.co.th
