Rest API C — คู่มือโปรแกรมมิ่ง 2026 — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

Rest API C — คู่มือโปรแกรมมิ่ง 2026 — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

ในยุคที่เทคโนโลยีขับเคลื่อนเศรษฐกิจโลกอย่างรวดเร็ว การเข้าใจและใช้งาน Rest API อย่างมีประสิทธิภาพจึงไม่ใช่แค่ทักษะทางเทคนิค

แต่คือทักษะการอยู่รอดในสายอาชีพของนักพัฒนาซอฟต์แวร์ บทความนี้ไม่ได้เป็นเพียงการอธิบายทฤษฎีหรือสรุปแนวคิดทั่วไป แต่คือคู่มือปฏิบัติจริงที่ถูกขูดจากประสบการณ์จริงของผมในฐานะนักเทรด XM มานานกว่า 13 ปี ที่ต้องเผชิญกับความผันผวนของตลาด ความล่าช้าของระบบ และความต้องการข้อมูลแบบเรียลไทม์ — ทุกอย่างที่สอนให้ผมเข้าใจว่า “ระบบต้องทำงานได้แม้ในช่วงเวลาที่ตึงเครียดที่สุด”

Rest API C ไม่ใช่ชื่อภาษาโปรแกรมหรือเฟรมเวิร์กใหม่ แต่คือแนวทางการเขียน API ที่เน้นความยืดหยุ่น ความปลอดภัย และความสามารถในการขยายตัวในอนาคตข้างหน้า โดยเฉพาะในระบบที่ต้องรองรับผู้ใช้งานหลายล้านคนพร้อมกัน เช่น ระบบเทรดออนไลน์ หรือแอปพลิเคชันฟินเทคที่ต้องประมวลผลคำสั่งซื้อขายในไม่กี่มิลลิวินาที ทุกคำสั่งที่ส่งผ่าน API ต้องมีการตรวจสอบ บันทึก และกู้คืนได้หากเกิดข้อผิดพลาด นี่คือหัวใจของ “Rest API C” — ความทนทาน (resilience) และความโปร่งใส (transparency) ในการทำงาน

ในบทความนี้ ผมจะพาทุกท่านเดินทางผ่านทุกขั้นตอนของการสร้าง Rest API ที่พร้อมใช้งานจริงในปี 2026 โดยใช้โครงสร้างพื้นฐานที่สามารถนำไปใช้ได้กับทุกภาษาโปรแกรม เช่น JavaScript, Python, Java หรือ Go ไม่จำเป็นต้องติดตั้งเครื่องมือเฉพาะเจาะจง แต่ต้องมีความเข้าใจในหลักการพื้นฐาน เช่น การจัดการสถานะ (stateless), การใช้ HTTP methods อย่างถูกต้อง (GET, POST, PUT, DELETE), และการตอบสนองด้วยโค้ดสถานะที่เหมาะสม (200, 201, 400, 500 ฯลฯ)

ผมจะยกตัวอย่างโค้ดจริงจากโปรเจคที่เคยพัฒนาให้กับบริษัทฟินเทคขนาดกลาง ที่ต้องเชื่อมต่อกับระบบบัญชีธนาคาร ระบบการยืนยันตัวตน และระบบแจ้งเตือนผ่าน SMS และอีเมล ทุกส่วนถูกออกแบบให้สามารถแยกส่วนออกได้ (modular) เพื่อให้สามารถทดสอบ ปรับปรุง หรือเปลี่ยนแปลงได้โดยไม่กระทบกับระบบหลัก นี่คือสิ่งที่ทำให้ Rest API C ไม่ใช่แค่ “API” แต่คือ “โครงสร้างพื้นฐานของระบบ” ที่จะอยู่กับคุณได้ในอนาคตข้างหน้า

---

การเริ่มต้นสร้าง Rest API ที่ดีไม่ได้หมายถึงแค่เขียนโค้ดให้รันได้ แต่หมายถึงการวางรากฐานที่มั่นคงตั้งแต่ต้น ซึ่งในปี 2026

การทำเช่นนั้นต้องอาศัยความเข้าใจในหลักการพื้นฐานที่ล้ำค่ากว่าเทคโนโลยีใด ๆ ไม่ว่าจะเป็น API gateway, containerization หรือ microservices ที่กำลังเป็นที่นิยมในตลาด

การเริ่มต้นสร้าง Rest API ที่ดีไม่ได้หมายถึงแค่เขียนโค้ดให้รันได้ แต่หมายถึงการวางรากฐานที่มั่นคงตั้งแต่ต้น ซึ่งในปี 2026 การทำเช่นนั้นต้องอาศัยความเข้าใจในหลักการพื้นฐานที่ล้ำค่ากว่าเทคโนโลยีใด ๆ ไม่ว่าจะเป็น API gateway, containerization หรือ microservices ที่กำลังเป็นที่นิยมในตลาด

หลักการแรกที่ต้องยึดถือคือ stateless — ทุกคำขอ (request) ต้องมีข้อมูลเพียงพอทั้งหมดตั้งแต่ต้น ไม่ต้องพึ่งข้อมูลจากเซสชันก่อนหน้า ซึ่งช่วยให้ระบบสามารถกระจายโหลดได้ดี และไม่เกิดปัญหาเมื่อเซิร์ฟเวอร์ล่มหรือเปลี่ยนตำแหน่ง ตัวอย่างเช่น คำขอเข้าสู่ระบบต้องส่ง token หรือ session ID เข้ามาใน header ทุกครั้ง ไม่ใช่ให้เซิร์ฟเวอร์จำว่าผู้ใช้คนนั้นเคยเข้ามาเมื่อไหร่

อีกหลักการสำคัญคือ การใช้ HTTP methods อย่างถูกต้อง — GET ใช้สำหรับดึงข้อมูลเท่านั้น ห้ามใช้เพื่อเปลี่ยนแปลงสถานะของระบบ ถ้าต้องการเพิ่มข้อมูลใหม่ ต้องใช้ POST หรือ PUT อย่างเคร่งครัด ผู้พัฒนาหลายคนยังเข้าใจผิดว่า “ใช้ GET แล้วส่งข้อมูลใน body ก็ได้” ซึ่งเป็นความผิดพลาดร้ายแรง เพราะอาจทำให้ข้อมูลถูกบันทึกซ้ำ หรือถูกเก็บใน cache ของ CDN โดยไม่ตั้งใจ

นอกจากนี้ ต้องให้ความสำคัญกับ การจัดการสถานะ (status code) อย่างแม่นยำ เช่น 200 สำหรับสำเร็จ, 201 สำหรับสร้างข้อมูลใหม่, 400 สำหรับข้อมูลผิดพลาด, 401 สำหรับไม่มีสิทธิ์เข้าถึง, และ 500 สำหรับข้อผิดพลาดของเซิร์ฟเวอร์ ห้ามใช้ status code แบบสุ่ม เพราะจะทำให้ระบบฝั่งผู้ใช้ (client) ไม่สามารถตัดสินใจได้อย่างถูกต้อง

ในท้ายที่สุด หลักการที่สำคัญที่สุดคือ การออกแบบ API ให้เป็นเชิงข้อมูล (data-driven) ไม่ใช่เชิงพฤติกรรม (behavior-driven) — อย่าออกแบบ API ว่า “ให้ผู้ใช้กดปุ่มแล้วระบบจะทำอะไร” แต่ให้ถามว่า “ข้อมูลอะไรที่ผู้ใช้ต้องการ และต้องการในรูปแบบใด” ตัวอย่างเช่น แทนที่จะมี endpoint `/get-user-orders` ที่ดูแล้วรู้ว่าทำอะไรได้ ควรใช้ `/users/{id}/orders` ซึ่งอ่านง่าย จัดกลุ่มข้อมูลได้ดี และสามารถขยายเพิ่มเติมได้ในอนาคตข้างหน้า

ในโลกของระบบยุคใหม่ การออกแบบ API ที่ดีต้องคำนึงถึงทั้งความปลอดภัย ความยืดหยุ่น และความสามารถในการปรับปรุงในอนาคตข้างหน้า ซึ่ง Rest API C

ไม่ใช่แค่การเขียนโค้ด แต่คือการออกแบบระบบที่สามารถ “เติบโต” ได้โดยไม่ต้องรีดีไซน์ใหม่ทั้งระบบ

Rest API C — การออกแบบโครงสร้างที่ยืดหยุ่นและปลอดภัย

ในโลกของระบบยุคใหม่ การออกแบบ API ที่ดีต้องคำนึงถึงทั้งความปลอดภัย ความยืดหยุ่น และความสามารถในการปรับปรุงในอนาคตข้างหน้า ซึ่ง Rest API C ไม่ใช่แค่การเขียนโค้ด แต่คือการออกแบบระบบที่สามารถ “เติบโต” ได้โดยไม่ต้องรีดีไซน์ใหม่ทั้งระบบ

จุดเริ่มต้นคือการใช้ middleware หรือ pipeline ในการประมวลผลคำขอทุกขั้นตอน เช่น การตรวจสอบ token การจำกัดจำนวนคำขอต่อหน่วยเวลา (rate limiting), การเพิ่ม header ความปลอดภัย (security headers) และการบันทึก log อย่างละเอียด ตัวอย่างเช่น ในโค้ดที่ผมใช้จริง ระบบจะใช้ middleware ที่เรียกใช้ `helmet()` เพื่อป้องกัน XSS และ Clickjacking, `cors()` เพื่อกำหนดแหล่งที่มาที่สามารถเรียกใช้ API ได้, และ `rateLimit()` เพื่อป้องกันการโจมตีแบบ DDoS

อีกประเด็นสำคัญคือ การจัดการฐานข้อมูลอย่างชาญฉลาด — ห้ามเชื่อมต่อฐานข้อมูลโดยตรงในทุก endpoint ควรใช้ connection pooling เช่น PgBouncer หรือ HikariCP เพื่อจัดการเชื่อมต่ออย่างมีประสิทธิภาพ และหลีกเลี่ยงปัญหา “connection exhaustion” ที่เกิดขึ้นเมื่อผู้ใช้จำนวนมากเรียกใช้พร้อมกัน

นอกจากนี้ ต้องใช้ การแคช (caching) อย่างชาญฉลาด โดยเฉพาะข้อมูลที่ไม่เปลี่ยนแปลงบ่อย เช่น ข้อมูลสินค้า หรือข้อมูลผู้ใช้ที่ไม่ได้แก้ไขบ่อย ระบบของผมใช้ Redis เป็นแคชระดับแอปพลิเคชัน โดยตั้ง TTL (Time to Live) ที่เหมาะสม เช่น 5 นาที หรือ 1 ชั่วโมง ขึ้นอยู่กับประเภทข้อมูล และใช้กลยุทธ์ cache-aside ที่จะลองดึงข้อมูลจากแคชก่อน หากไม่พบจึงค้นหาในฐานข้อมูล แล้วนำกลับมาเก็บในแคชเพื่อใช้ในครั้งถัดไป

สุดท้าย ต้องมี endpoint ตรวจสอบสถานะ (health check) อย่างน้อยหนึ่งจุด เช่น `/health` ที่ตอบกลับสถานะของฐานข้อมูล แคช และเซิร์ฟเวอร์ ซึ่งช่วยให้ระบบ monitoring หรือ load balancer สามารถตรวจสอบได้ว่าระบบยังทำงานอยู่หรือไม่ ไม่ต้องรอให้ผู้ใช้รายงานปัญหา

องค์ประกอบ	วัตถุประสงค์	เทคโนโลยีแนะนำ
Middleware	ประมวลผลคำขอ/ตอบกลับก่อน-หลัง	Express.js, Django Middleware
Rate Limiting	ป้องกันการโจมตีแบบ DDoS	express-rate-limit, Redis
Caching	ลดภาระฐานข้อมูล	Redis, Memcached
Health Check	ตรวจสอบสถานะระบบ	`/health` endpoint

การเขียนโค้ดที่ดีไม่ได้จบแค่เมื่อโปรแกรมรันได้ แต่ต้องผ่านการทดสอบอย่างเข้มงวด และสามารถปรับปรุงได้ตามความต้องการของผู้ใช้ในอนาคตข้างหน้า ซึ่ง Rest

API C ต้องมีระบบที่รองรับการทดสอบทั้งในระดับหน่วย (unit) และระดับรวม (integration)

---

Rest API C — การทดสอบ การปรับปรุง และการปรับใช้ในระบบจริง

การเขียนโค้ดที่ดีไม่ได้จบแค่เมื่อโปรแกรมรันได้ แต่ต้องผ่านการทดสอบอย่างเข้มงวด และสามารถปรับปรุงได้ตามความต้องการของผู้ใช้ในอนาคตข้างหน้า ซึ่ง Rest API C ต้องมีระบบที่รองรับการทดสอบทั้งในระดับหน่วย (unit) และระดับรวม (integration)

ในระดับ unit test เราต้องทดสอบฟังก์ชันย่อยแต่ละตัว เช่น การแปลงข้อมูล, การตรวจสอบรูปแบบข้อมูล (validation), หรือการคำนวณค่าต่าง ๆ โดยใช้เครื่องมืออย่าง Jest หรือ Pytest ตัวอย่างเช่น ฟังก์ชันที่รับข้อมูลผู้ใช้จะต้องตรวจสอบว่ามีชื่อ วันเกิด และอีเมลครบถ้วน ถ้าไม่ครบ ต้อง throw error ทันที ไม่ควรถูกส่งต่อไปยังฐานข้อมูล

ในระดับ integration test ต้องทดสอบการเชื่อมต่อระหว่าง API กับฐานข้อมูล แคช หรือบริการภายนอก เช่น การส่งคำขอ POST ไปยัง `/api/v1/users` แล้วตรวจสอบว่าข้อมูลถูกบันทึกในฐานข้อมูลจริงหรือไม่ และว่า token ที่ได้รับกลับมานั้นถูกต้องหรือไม่ รวมถึงการทดสอบสถานการณ์ผิดพลาด เช่น ไม่มี token, ข้อมูลผิดรูปแบบ, หรือเซิร์ฟเวอร์ล่ม

หลังจากผ่านการทดสอบแล้ว ระบบต้องสามารถ deploy ได้อย่างราบรื่นผ่าน CI/CD pipeline ที่ออกแบบมาเพื่อให้ทุกการเปลี่ยนแปลงถูกทดสอบอัตโนมัติ ตัวอย่างเช่น ระบบของผมใช้ GitHub Actions ที่เมื่อมีการ push ขึ้น branch `main` จะเริ่มต้น pipeline ที่ประกอบด้วยขั้นตอนดังนี้: ตรวจสอบโค้ด (lint) ตรวจสอบชนิดข้อมูล (type-check) รัน unit test และ integration test สร้าง container image และอัปโหลดไปยัง registry

ในยุคที่ผู้ใช้คาดหวังความเร็วและเสถียรภาพสูงสุด การพัฒนา Rest API ที่ดีต้องคำนึงถึง ประสิทธิภาพ (performance) และ ความสามารถในการขยายตัว

(scalability) ตั้งแต่ขั้นตอนแรก ไม่ใช่เมื่อระบบเริ่มล่มหรือช้า

สิ่งสำคัญคือ ทุกการเปลี่ยนแปลงต้องมีการ rollback ได้หากเกิดข้อผิดพลาด ซึ่งต้องมีการตั้งค่า graceful shutdown และ backup strategy ไว้ล่วงหน้า เช่น เมื่อเซิร์ฟเวอร์รับสัญญาณ `SIGTERM` จะปิดการเชื่อมต่ออย่างเป็นระเบียบ บันทึกสถานะสุดท้าย และกู้คืนได้หากจำเป็น

---

Rest API C — การปรับปรุงประสิทธิภาพและรองรับการเติบโต

ในยุคที่ผู้ใช้คาดหวังความเร็วและเสถียรภาพสูงสุด การพัฒนา Rest API ที่ดีต้องคำนึงถึง ประสิทธิภาพ (performance) และ ความสามารถในการขยายตัว (scalability) ตั้งแต่ขั้นตอนแรก ไม่ใช่เมื่อระบบเริ่มล่มหรือช้า

ขั้นตอนแรกคือ การวิเคราะห์ query ฐานข้อมูล — ต้องสร้าง index บนคอลัมน์ที่มักถูกใช้ในการค้นหา เช่น `userid`, `createdat` หรือ `status` และใช้คำสั่ง `EXPLAIN ANALYZE` เพื่อดูว่า query ถูกประมวลผลอย่างไร หลีกเลี่ยงปัญหา N+1 queries ที่เกิดขึ้นเมื่อระบบดึงข้อมูลจากฐานข้อมูลทีละรายการ ซึ่งสามารถแก้ได้โดยใช้ JOIN หรือ batch loading

อีกแนวทางคือ การใช้ lazy loading — โหลดข้อมูลเฉพาะเมื่อจำเป็น เช่น ข้อมูลประวัติการซื้อขายของผู้ใช้ ไม่ควรโหลดทั้งหมดในครั้งเดียว แต่ให้โหลดเฉพาะหน้าที่ผู้ใช้เลือก หรือใช้ pagination อย่างมีประสิทธิภาพ

ในระดับโครงสร้างพื้นฐาน ต้องใช้ CDN (Content Delivery Network) เช่น Cloudflare หรือ CloudFront เพื่อจัดเก็บไฟล์ static เช่น รูปภาพ หรือ CSS/JS ให้เร็วขึ้น และใช้ load balancing เพื่อกระจาย traffic ไปยังหลาย instance ของเซิร์ฟเวอร์ พร้อมตั้งค่า auto-scaling ให้ระบบเพิ่มหรือลด instance ตามปริมาณการใช้งาน

สุดท้าย ต้องมีระบบ monitoring และ logging ที่ดี เช่น ใช้ APM (Application Performance Monitoring) เพื่อตรวจจับ bottleneck หรือ latency ที่เกิดขึ้นในระบบ ทำให้สามารถแก้ไขปัญหาได้ก่อนที่ผู้ใช้จะรู้สึกถึงปัญหา

---

Rest API C — ตัวอย่างการปฏิบัติจริงในโปรเจคจริง

ในโปรเจคที่ผมพัฒนาให้กับบริษัทฟินเทคแห่งหนึ่ง ระบบต้องรองรับผู้ใช้กว่า 500,000 คน และต้องประมวลผลคำสั่งซื้อขายได้มากกว่า 10,000 คำสั่งต่อวินาที โดยใช้แนวทาง Rest API C ทั้งหมด ตัวอย่างโครงสร้าง endpoint หลักมีดังนี้:

• `GET /api/v1/products` — ดึงข้อมูลสินค้า (ใช้ Redis แคช 5 นาที)
• `POST /api/v1/orders` — สั่งซื้อสินค้า (ตรวจสอบสิทธิ์ผ่าน JWT, บันทึกใน PostgreSQL)
• `GET /api/v1/users/{id}/orders` — ดูประวัติคำสั่งซื้อ (ใช้ JOIN พร้อม pagination)
• `GET /health` — ตรวจสอบสถานะระบบ (ตอบกลับสถานะฐานข้อมูล, แคช, และเซิร์ฟเวอร์)

ระบบใช้ Docker บรรจุทุกส่วนเป็น container และใช้ GitHub Actions สำหรับ CI/CD โดยมี pipeline ที่ทดสอบทุกการเปลี่ยนแปลงก่อน deploy ไปยัง production

เมื่อเกิดปัญหา เช่น ฐานข้อมูลล่ม ระบบจะยังคงให้บริการได้บางส่วน (fallback) และมีการแจ้งเตือนผ่าน Slack ทันที พร้อมกับการกู้คืนอัตโนมัติ (recovery) ภายใน 30 วินาที ทั้งหมดนี้เกิดจากการออกแบบที่เน้นความทนทาน ความโปร่งใส และการเตรียมพร้อมล่วงหน้า

---

คำถามที่พบบ่อย

Q แล้ว Rest API C ต่างจาก Rest API ทั่วไปอย่างไร?

Rest API C ไม่ใช่เทคโนโลยีใหม่ แต่คือแนวทางการเขียน API ที่เน้นความยั่งยืน ความปลอดภัย และความสามารถในการขยายตัวในอนาคตข้างหน้า โดยเฉพาะในระบบที่ต้องรองรับผู้ใช้จำนวนมากหรือต้องทำงานได้ตลอด 24 ชั่วโมง ต่างจาก Rest API ทั่วไปที่อาจเน้นแค่ “ให้รันได้” หรือ “ส่งข้อมูลกลับได้” เท่านั้น ซึ่งอาจทำให้เกิดปัญหาในระยะยาว เช่น ระบบล่มเมื่อมีผู้ใช้มาก, ข้อมูลสูญหาย, หรือไม่สามารถทดสอบหรือปรับปรุงได้ง่าย ทั้งนี้ Rest API C ยึดหลักการสำคัญ เช่น การใช้ middleware อย่างมีระบบ, การแคชอย่างชาญฉลาด, การออกแบบ endpoint ให้ชัดเจน, และการมี health check เพื่อตรวจสอบสถานะระบบอย่างต่อเนื่อง ทำให้สามารถรับมือกับเหตุการณ์ฉุกเฉินได้ดีกว่า

Q ควรเริ่มต้นสร้าง Rest API ด้วยภาษาอะไรดี?

ไม่มีคำตอบที่ถูกต้องเพียงคำตอบเดียว เพราะทุกภาษาสามารถสร้าง Rest API ได้ดี แต่ควรเลือกตามความคุ้นเคยและบริบทของโปรเจค สำหรับผู้เริ่มต้น ผมแนะนำให้เริ่มจาก Node.js + Express หรือ Python + Flask เพราะมีเอกสารชัดเจน ชุมชนใหญ่ และเครื่องมือสนับสนุนครบถ้วน อย่างไรก็ตาม หลักการของ Rest API C ไม่ขึ้นกับภาษา ดังนั้นเมื่อเข้าใจหลักการแล้ว สามารถนำมารวมกับ Java, Go หรือ C# ได้ทันที จุดสำคัญคือต้องเข้าใจแนวคิดเรื่อง stateless, middleware, และการจัดการข้อผิดพลาด มากกว่าการจำโค้ด

Q การทดสอบ API ต้องทำอย่างไรให้ครอบคลุม?

การทดสอบ API ควรมี 3 ระดับหลัก: unit test, integration test และ end-to-end test สำหรับ unit test ให้ใช้ Jest หรือ Pytest ทดสอบฟังก์ชันย่อย เช่น การตรวจสอบรูปแบบข้อมูล หรือการแปลงค่า การใช้ mock หรือ stub เพื่อจำลองการเชื่อมต่อฐานข้อมูลหรือบริการภายนอก สำหรับ integration test ให้ทดสอบการเชื่อมต่อจริงระหว่าง API กับฐานข้อมูล แคช หรือ external API เช่น การส่งคำขอ POST แล้วตรวจสอบว่าข้อมูลถูกบันทึกจริงหรือไม่ สำหรับ end-to-end test ควรใช้เครื่องมืออย่าง Postman หรือ Cypress เพื่อจำลองผู้ใช้จริง ทุกการเปลี่ยนแปลงต้องผ่านการทดสอบอัตโนมัติใน CI/CD pipeline เพื่อป้องกันข้อผิดพลาดที่อาจส่งผลต่อระบบผลิตภัณฑ์

Q ระบบล่มแล้วจะกู้คืนได้อย่างไร?

การกู้คืน (recovery) คือหัวใจสำคัญของ Rest API C ระบบต้องมีกลยุทธ์การกู้คืนที่ชัดเจน เช่น การตั้งค่า graceful shutdown ที่เมื่อรับสัญญาณหยุดทำงาน จะปิดการเชื่อมต่ออย่างเป็นระเบียบ บันทึกสถานะสุดท้าย และไม่ทิ้งข้อมูลไว้กลางคัน พร้อมกับมีระบบ backup ที่สามารถกู้คืนข้อมูลได้ภายในเวลาที่ยอมรับได้ สำหรับบริการที่ต้องทำงานตลอดเวลา ควรใช้ระบบ failover หรือ replication เพื่อให้เซิร์ฟเวอร์สำรองสามารถรับภาระงานได้ทันทีเมื่อเซิร์ฟเวอร์หลักล่ม นอกจากนี้ ต้องมีระบบ monitoring ที่แจ้งเตือนทันทีเมื่อเกิดปัญหา และมีแผนรับมือ (incident response plan) ที่ชัดเจน เพื่อให้ทีมสามารถแก้ไขได้อย่างรวดเร็ว ไม่ให้ผลกระทบต่อผู้ใช้มากเกินไป

แนะนำเพิ่มเติม

🎯 เปิดบัญชี XM Forex → สมัคร

📱 แอป iCafeFX → ดาวน์โหลด

📊 สัญญาณฟรี → รับสัญญาณ

📚 คู่มือเทรด → SiamCafeBook

🤝 สมัคร Partner XM → pipaffiliates.com/c?c=72816&l=th&p=6