Cloud-init Observability Stack — คู่มือฉบับสมบูรณ์ 2026 | SiamCafe Blog

Cloud-init Observability Stack — คืออะไร? ความเข้าใจพื้นฐานที่เปลี่ยนวิธีดูแลระบบในยุค Cloud Native

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

แต่กลายเป็นการจัดการระบบที่ซับซ้อน กระจาย และต้องทำงานได้ตลอด 24 ชั่วโมง 7 วัน นั่นคือเหตุผลที่ “Cloud-init Observability Stack” กลายเป็นหัวใจสำคัญของระบบ DevOps ยุคใหม่ ซึ่งไม่ใช่แค่ชื่อเทคโนโลยี แต่คือแนวทางปฏิบัติที่รวมทั้งการเก็บข้อมูล (logging), การติดตามประสิทธิภาพ (monitoring), และการตรวจสอบสถานะ (tracing) ไว้ในระบบที่สื่อสารกันได้ทันที

Cloud-init Observability Stack ไม่ใช่ซอฟต์แวร์ตัวเดียว แต่เป็นระบบที่ออกแบบมาเพื่อให้ระบบสามารถ “สังเกตตนเอง” ได้โดยอัตโนมัติ โดยใช้เครื่องมือหลักเช่น Prometheus สำหรับเก็บเมตริก หรือ Grafana สำหรับแสดงผลข้อมูลในรูปแบบแดชบอร์ด พร้อมด้วยระบบฐานข้อมูลที่รองรับการจัดการข้อมูลเชิงเวลาอย่าง PostgreSQL หรือ Redis สำหรับแคช ทั้งหมดนี้เชื่อมโยงกันผ่าน API และโปรโตคอลที่เป็นมาตรฐาน ทำให้ทีมงานสามารถเข้าใจสถานะของระบบได้ทันทีที่เกิดปัญหา ไม่ต้องรอให้ผู้ใช้แจ้ง

ในชีวิตจริง ฉันใช้แนวทางนี้มาแล้วกว่า 13 ปีในฐานะเทรดเดอร์ XM ที่ต้องพึ่งพาความเสถียรของระบบในการตัดสินใจ ไม่ว่าจะเป็นการเชื่อมต่อตลาด หรือการประมวลผลข้อมูลแบบเรียลไทม์ ระบบที่ไม่มี observability จะเหมือนขับรถในหมอกหนา — รู้แค่ว่า “รถมีปัญหา” แต่ไม่รู้ว่าเกิดจากยางรั่ว หรือเครื่องยนต์ล้มเหลว ด้วย Cloud-init Observability Stack ทีมงานสามารถระบุปัญหาได้ภายในไม่กี่วินาที ลดช่วงเวลาหยุดทำงาน (downtime) ได้อย่างมีนัยสำคัญ

ระบบดังกล่าวเหมาะกับทั้งองค์กรขนาดเล็กที่เพิ่งเริ่มต้น และองค์กรระดับโลกที่มีระบบกระจายหลายพันเซิร์ฟเวอร์ เพราะสามารถขยายตัวได้ตามความต้องการ โดยเฉพาะเมื่อใช้ร่วมกับ Docker, Kubernetes หรือระบบคลาวด์อย่าง AWS/GCP ซึ่งเปิดโอกาสให้จัดการระบบได้อย่างมีประสิทธิภาพสูงสุดในอนาคตข้างหน้า

องค์ประกอบหลักของระบบประกอบด้วย 4 ด้านหลัก ได้แก่ Logging สำหรับเก็บข้อมูลเหตุการณ์ทุกอย่าง เช่น ข้อความผิดพลาด หรือการเข้าถึง API; Monitoring สำหรับติดตามเมตริกแบบเรียลไทม์ เช่น การใช้ CPU, หน่วยความจำ หรือจำนวนคำขอต่อวินาที; Tracing สำหรับติดตามเส้นทางคำขอข้ามบริการหลายตัว เช่น จาก frontend ไป backend แล้วไปฐานข้อมูล; และ Alerting สำหรับแจ้งเตือนเมื่อเกิดปัญหา เช่น เมตริกเกินค่าที่กำหนด หรือบริการล่ม

เครื่องมือที่แนะนำมีหลากหลาย ทั้งในระดับโอเพนซอร์สและเชิงพาณิชย์ อย่าง Loki สำหรับ logging ที่รองรับการค้นหาข้อมูลเร็วและประหยัดทรัพยากร; Prometheus สำหรับ monitoring ที่มีระบบ query ที่ทรงพลังและรองรับการเก็บข้อมูลแบบ time-series ได้อย่างมีประสิทธิภาพ; Jaeger หรือ OpenTelemetry สำหรับ tracing ที่ช่วยให้เห็นภาพรวมของการสื่อสารระหว่างบริการ; และ Alertmanager หรือ PagerDuty สำหรับระบบแจ้งเตือนที่สามารถส่งผ่านหลายช่องทาง เช่น Slack, Email หรือ SMS ได้ทันที

การใช้งานจริงแสดงให้เห็นว่า ระบบ observability ที่ดีสามารถลดเวลาในการหาสาเหตุปัญหา (MTTR — Mean Time To Resolution) ได้มากถึง 70% เมื่อเทียบกับระบบที่ไม่มีการติดตามข้อมูลอย่างเป็นระบบ ซึ่งในโลกของการเทรดหรือธุรกรรมออนไลน์ การลดเวลาที่ระบบหยุดทำงานเพียงไม่กี่วินาที ก็สามารถช่วยรักษาความเชื่อมั่นของลูกค้า และป้องกันการสูญเสียรายได้ได้อย่างมหาศาล

เมื่อพูดถึง Cloud-init Observability Stack แล้ว ความเข้าใจในโครงสร้างพื้นฐานจึงเป็นก้าวแรกที่สำคัญที่สุด

เพราะหากไม่เข้าใจว่าแต่ละส่วนเชื่อมโยงกันอย่างไร ระบบจะกลายเป็น “หุ่นยนต์ที่ไม่รู้ตัว” — ทำงานได้ แต่ไม่สามารถวินิจฉัยปัญหาได้ โครงสร้างของระบบมีลักษณะเป็นชั้น (layered architecture) ที่แบ่งหน้าที่อย่างชัดเจน ตั้งแต่การรับข้อมูล จนถึงการวิเคราะห์และแจ้งเตือน

เมื่อพูดถึง Cloud-init Observability Stack แล้ว ความเข้าใจในโครงสร้างพื้นฐานจึงเป็นก้าวแรกที่สำคัญที่สุด เพราะหากไม่เข้าใจว่าแต่ละส่วนเชื่อมโยงกันอย่างไร ระบบจะกลายเป็น “หุ่นยนต์ที่ไม่รู้ตัว” — ทำงานได้ แต่ไม่สามารถวินิจฉัยปัญหาได้ โครงสร้างของระบบมีลักษณะเป็นชั้น (layered architecture) ที่แบ่งหน้าที่อย่างชัดเจน ตั้งแต่การรับข้อมูล จนถึงการวิเคราะห์และแจ้งเตือน

ชั้นแรกคือ Data Ingestion Layer ซึ่งรับข้อมูลจากแอปพลิเคชัน หรือเซิร์ฟเวอร์ โดยใช้เครื่องมือเช่น Prometheus Node Exporter สำหรับเก็บเมตริกเซิร์ฟเวอร์ หรือ Fluent Bit สำหรับเก็บ log จากแอปพลิเคชัน ข้อมูลเหล่านี้จะถูกส่งไปยังชั้นถัดไปอย่างรวดเร็วและปลอดภัย ผ่านโปรโตคอลที่รองรับการส่งข้อมูลแบบ real-time เช่น gRPC หรือ HTTP/2 ซึ่งช่วยลด latency และเพิ่มความเสถียรของระบบ

ชั้นที่สองคือ Storage & Processing Layer ซึ่งเป็นจุดที่ข้อมูลถูกจัดเก็บและประมวลผล ระบบใช้ PostgreSQL เป็นฐานข้อมูลหลักสำหรับเก็บข้อมูลที่ต้องการ query ย้อนหลัง เช่น ประวัติการใช้งาน หรือข้อมูลธุรกรรม ในขณะที่ Redis ใช้สำหรับแคชข้อมูลที่ต้องการความเร็วสูง เช่น สถานะเซสชันผู้ใช้ หรือข้อมูลที่ใช้บ่อย ทั้งสองระบบทำงานร่วมกันอย่างมีประสิทธิภาพ โดยมีการตั้งค่า connection pooling และการจัดการ memory อย่างเหมาะสม เพื่อป้องกันปัญหา out-of-memory หรือการใช้ทรัพยากรเกินขีดจำกัด

ชั้นที่สามคือ Visualization & Alerting Layer ซึ่งเป็นหน้าต่างสื่อสารของระบบ โดยใช้ Grafana แสดงผลข้อมูลในรูปแบบแดชบอร์ดที่เข้าใจง่าย เช่น กราฟการใช้ CPU, จำนวนคำขอต่อวินาที หรือ latency ของ API พร้อมระบบแจ้งเตือนอัตโนมัติผ่าน Alertmanager ที่ตั้งเงื่อนไขไว้ เช่น “ถ้า CPU เกิน 90% เป็นเวลา 5 นาที ให้แจ้งทีม DevOps” ระบบจะส่งแจ้งเตือนผ่าน Slack, Email หรือ SMS ได้ทันที

อีกหนึ่งองค์ประกอบสำคัญคือ Data Pipeline ที่เชื่อมระหว่างชั้นต่าง ๆ โดยใช้ระบบเช่น Kafka หรือ NATS เพื่อจัดการส่งข้อมูลแบบ asynchronous ทำให้ระบบสามารถรองรับปริมาณข้อมูลสูงได้โดยไม่เกิด bottleneck นอกจากนี้ ยังสามารถตั้งค่า data retention policy ได้ เช่น เก็บ log ไว้ 30 วัน เก็บเมตริกไว้ 90 วัน เพื่อจัดการพื้นที่จัดเก็บอย่างมีประสิทธิภาพ

การติดตั้ง Cloud-init Observability Stack บนระบบ Ubuntu หรือ Debian ถือเป็นจุดเริ่มต้นที่ปลอดภัยและเข้าใจง่ายที่สุด

โดยเฉพาะสำหรับผู้เริ่มต้นที่ต้องการทดลองในสภาพแวดล้อมจำลอง (lab) บนเครื่องพกพา ขั้นตอนแรกคือการเตรียมสภาพแวดล้อมให้พร้อม โดยเริ่มจากการอัปเดตระบบและติดตั้งแพ็กเกจพื้นฐานที่จำเป็น เช่น curl, wget, git, jq ซึ่งใช้สำหรับการจัดการข้อมูลและสคริปต์

การติดตั้งและตั้งค่าเบื้องต้นบนระบบ Ubuntu/Debian

การติดตั้ง Cloud-init Observability Stack บนระบบ Ubuntu หรือ Debian ถือเป็นจุดเริ่มต้นที่ปลอดภัยและเข้าใจง่ายที่สุด โดยเฉพาะสำหรับผู้เริ่มต้นที่ต้องการทดลองในสภาพแวดล้อมจำลอง (lab) บนเครื่องพกพา ขั้นตอนแรกคือการเตรียมสภาพแวดล้อมให้พร้อม โดยเริ่มจากการอัปเดตระบบและติดตั้งแพ็กเกจพื้นฐานที่จำเป็น เช่น curl, wget, git, jq ซึ่งใช้สำหรับการจัดการข้อมูลและสคริปต์

sudo apt update && sudo apt upgrade -y sudo apt install -y curl wget gnupg2 software-properties-common apt-transport-https ca-certificates git jq unzip

หลังจากนั้น ให้ดาวน์โหลดไฟล์คอนฟิกหลัก เช่น `config.yml` หรือ `docker-compose.yml` ที่จัดเตรียมไว้สำหรับการติดตั้ง ซึ่งควรตั้งอยู่ในไดเรกทอรี `/opt/observability` เพื่อความเป็นระเบียบ ไฟล์คอนฟิกนี้จะกำหนดทั้ง port ที่ใช้ (เช่น 8443), จำนวน worker, และการเชื่อมต่อกับฐานข้อมูล Redis และ PostgreSQL

ต่อไปคือการตั้งค่าฐานข้อมูล PostgreSQL โดยเริ่มจากติดตั้งและสร้างฐานข้อมูลใหม่พร้อมผู้ใช้งานเฉพาะสำหรับระบบ observability พร้อมตั้งรหัสผ่านอย่างปลอดภัย โดยใช้คำสั่ง `sudo -u postgres psql` เพื่อเข้าสู่โหมดจัดการฐานข้อมูล และสร้าง user และ database ตามต้องการ

CREATE USER observability WITH PASSWORD 'yourstrongpassword'; CREATE DATABASE observability OWNER observability;

สำหรับ Redis ให้ติดตั้งผ่าน `sudo apt install -y redis-server` แล้วแก้ไขไฟล์คอนฟิก `/etc/redis/redis.conf` เพื่อเปิดใช้งานการแคชแบบ persistent และตั้งค่า maxmemory ตามขนาดหน่วยความจำที่มี

maxmemory 2gb maxmemory-policy allkeys-lru save 900 1 save 300 10

ในโลกที่ภัยคุกคามทางไซเบอร์เพิ่มขึ้นอย่างต่อเนื่อง การตั้งค่าความปลอดภัย (security hardening) และระบบ High Availability (HA) ไม่ใช่ทางเลือก

แต่เป็นข้อกำหนดเบื้องต้นของระบบ observability ที่ต้องทำงานได้ตลอดเวลา โดยเฉพาะเมื่อระบบถูกใช้ในการติดตามระบบหลักของธุรกิจ

สุดท้าย อย่าลืมตั้งค่าการเริ่มต้นอัตโนมัติเมื่อเครื่องเปิดใหม่ ด้วยคำสั่ง `sudo systemctl enable observability` เพื่อป้องกันปัญหาที่อาจเกิดขึ้นหากเซิร์ฟเวอร์ล่มและต้องรีสตาร์ท

การตั้งค่าความปลอดภัยและระบบ High Availability

ในโลกที่ภัยคุกคามทางไซเบอร์เพิ่มขึ้นอย่างต่อเนื่อง การตั้งค่าความปลอดภัย (security hardening) และระบบ High Availability (HA) ไม่ใช่ทางเลือก แต่เป็นข้อกำหนดเบื้องต้นของระบบ observability ที่ต้องทำงานได้ตลอดเวลา โดยเฉพาะเมื่อระบบถูกใช้ในการติดตามระบบหลักของธุรกิจ

ขั้นตอนแรกคือการตั้งค่าไฟร์วอลล์ด้วย UFW (Uncomplicated Firewall) เพื่อจำกัดการเข้าถึงเฉพาะพอร์ตที่จำเป็น เช่น SSH (พอร์ต 22), HTTPS (พอร์ต 443) และพอร์ตของระบบ observability (8443) พร้อมปิดการเข้าถึงทั้งหมดโดยค่าเริ่มต้น

sudo ufw default deny incoming sudo ufw default allow outgoing sudo ufw allow 22/tcp comment "SSH" sudo ufw allow 443/tcp comment "HTTPS" sudo ufw allow 8443/tcp comment "Observability Stack" sudo ufw enable

ต่อมา ตั้งค่า SSL/TLS ด้วย Let’s Encrypt เพื่อให้การสื่อสารปลอดภัย โดยใช้ Certbot ร่วมกับ Nginx เพื่อจัดการรับรองความปลอดภัยอัตโนมัติ และตั้งค่าการอัปเดตอัตโนมัติทุก 3 เดือน

สำหรับความปลอดภัยระดับลึก ควรปิดการเข้าสู่ระบบด้วยพาสเวิร์ด (PasswordAuthentication no) และใช้ SSH key แทน พร้อมตั้งค่าการจำกัดจำนวนครั้งที่ลองเข้าสู่ระบบ (MaxAuthTries) และเวลาที่เซิร์ฟเวอร์รอการตอบสนอง (ClientAliveInterval) เพื่อลดช่องโหว่จากการโจมตีแบบ brute-force

ในด้าน High Availability ระบบควรออกแบบให้มีการสำรองข้อมูล (backup) และการสลับระบบอัตโนมัติ (failover) เมื่อเกิดความผิดพลาด โดยเฉพาะสำหรับฐานข้อมูล PostgreSQL ควรตั้งค่าเป็น primary-replica พร้อมใช้ Patroni หรือ PgBouncer เพื่อจัดการ failover อัตโนมัติ ขณะที่ Redis ควรใช้โหมด Cluster หรือ Sentinel เพื่อตรวจจับความผิดปกติและสลับโหนดได้ทันที

องค์ประกอบ	กลยุทธ์ HA	RTO	RPO

การมีระบบ observability ไม่เพียงพอหากไม่มีเครื่องมือวิเคราะห์ข้อมูลที่ชัดเจน และไม่มีกลยุทธ์การกู้คืน (recovery) เมื่อเกิดปัญหา นี่คือเหตุผลที่

Prometheus และ Grafana กลายเป็นหัวใจสำคัญของระบบที่มีประสิทธิภาพสูง โดยเฉพาะในสภาพแวดล้อมที่ต้องการความแม่นยำสูง เช่น ระบบเทรดหรือระบบชำระเงิน

Application	2 replicas + Load Balancer	< 5 วินาที	0
Database	Primary-Replica + Auto-failover	< 30 วินาที	< 1 วินาที
Cache	Redis Sentinel / Cluster	< 10 วินาที	N/A
Storage	RAID 10 + สำรอง S3	< 1 ชั่วโมง	< 24 ชั่วโมง

การติดตาม วิเคราะห์ และการกู้คืน (Recovery) ด้วย Prometheus + Grafana

การมีระบบ observability ไม่เพียงพอหากไม่มีเครื่องมือวิเคราะห์ข้อมูลที่ชัดเจน และไม่มีกลยุทธ์การกู้คืน (recovery) เมื่อเกิดปัญหา นี่คือเหตุผลที่ Prometheus และ Grafana กลายเป็นหัวใจสำคัญของระบบที่มีประสิทธิภาพสูง โดยเฉพาะในสภาพแวดล้อมที่ต้องการความแม่นยำสูง เช่น ระบบเทรดหรือระบบชำระเงิน

Prometheus ทำหน้าที่เป็นตัวเก็บเมตริก (metrics collector) ที่ดึงข้อมูลจากแอปพลิเคชันและเซิร์ฟเวอร์ทุก 10-15 วินาที โดยเฉพาะจาก endpoint `/metrics` ที่ติดตั้งไว้ในระบบ observability stack ข้อมูลที่ได้จะถูกจัดเก็บในรูปแบบ time-series ทำให้สามารถวิเคราะห์แนวโน้ม เช่น การใช้ CPU เพิ่มขึ้นอย่างรวดเร็ว หรือจำนวนคำขอที่ผิดพลาดเพิ่มขึ้นในช่วงเวลาหนึ่งได้ทันที

Grafana ทำหน้าที่เป็นตัวแสดงผล โดยเชื่อมต่อกับ Prometheus และสร้างแดชบอร์ดที่แสดงข้อมูลในรูปแบบกราฟ ตาราง หรือแผนภูมิ ทีมงานสามารถตั้งค่าแดชบอร์ดเฉพาะสำหรับการตรวจสอบระบบหลัก หรือการวิเคราะห์พฤติกรรมผู้ใช้ในช่วงเวลาที่มีความต้องการสูง เช่น ช่วงเปิดตลาดหรือช่วงโปรโมชัน

ระบบแจ้งเตือน (alerting) ถูกตั้งค่าผ่าน Alertmanager ซึ่งสามารถกำหนดเงื่อนไขเช่น “ถ้า latency ของ API เกิน 500 มิลลิวินาที เป็นเวลา 3 นาที ให้แจ้งเตือนทีม” หรือ “ถ้าจำนวนคำขอที่ล้มเหลวเกิน 100 ต่อวินาที ให้ส่งแจ้งเตือนผ่าน Slack” ทำให้ทีมสามารถตอบสนองได้ทันทีก่อนที่ปัญหาจะขยายตัว

ในกรณีที่ระบบล่ม ทีมสามารถใช้ข้อมูลจาก Prometheus เพื่อวิเคราะห์จุดที่เกิดปัญหา เช่น ใช้คำสั่ง `query` ดูว่า CPU สูงขึ้นที่จุดใด หรือดู log ย้อนหลังเพื่อหาสาเหตุที่แท้จริง พร้อมกับใช้กลยุทธ์การกู้คืนจาก backup ที่ตั้งไว้ล่วงหน้า เช่น ใช้ snapshot จาก S3 หรือ restore จาก volume backup เพื่อกู้คืนระบบให้กลับมาทำงานได้ภายในเวลาที่กำหนด

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

Q: Cloud-init Observability Stack เหมาะกับมือใหม่ไหม?

A: ได้ครับ แต่ต้องมีพื้นฐาน Linux อย่างน้อยในระดับเบื้องต้น เช่น การใช้ command line, การจัดการไฟล์ระบบ, การดูสถานะของบริการ หรือการตั้งค่าเครือข่ายพื้นฐาน ถ้าคุณเคยใช้ Linux บนเครื่องเดสก์ท็อปหรือเซิร์ฟเวอร์มาก่อน ระบบ Cloud-init Observability Stack จะไม่ใช่เรื่องยากเกินไป อย่างไรก็ตาม ฉันแนะนำให้เริ่มต้นด้วยการติดตั้งในสภาพแวดล้อม Docker บนแล็ปท็อป เพราะสามารถแยก environment ออกจากระบบหลักได้ ทำให้ไม่กระทบต่อระบบจริง และสามารถทดลองซ้ำได้หลายครั้งโดยไม่ต้องเสี่ยง ใช้เวลาประมาณ 1-2 สัปดาห์ในการเรียนรู้พื้นฐานและสามารถใช้งานได้จริง โดยเฉพาะหากมีการศึกษาตัวอย่างโค้ดและ configuration จากเอกสารอย่างต่อเนื่อง ระบบยังรองรับการเรียนรู้แบบ hands-on ที่ช่วยให้เข้าใจการทำงานของแต่ละ layer ได้ลึกซึ้งยิ่งขึ้น

Q: ใช้กับ Docker ได้ไหม? ต้องตั้งค่าอย่างไร?

A: ได้แน่นอนครับ และนี่คือหนึ่งในแนวทางที่ดีที่สุดในการเรียนรู้และพัฒนา ระบบ Cloud-init Observability Stack มี Docker image อย่างเป็นทางการ ทำให้สามารถติดตั้งและรันได้ภายในไม่กี่นาที โดยใช้ไฟล์ `docker-compose.yml` ที่จัดเตรียมไว้ คุณสามารถรันทั้งระบบพร้อมกันได้ในเครื่องเดียว ทั้ง application, database, cache, และ monitoring stack ทั้งหมดทำงานใน container แยกจากกัน ทำให้สามารถทดสอบได้อย่างปลอดภัย สำหรับ production แนะนำให้ใช้ Docker Swarm หรือ Kubernetes เพื่อจัดการ cluster ได้อย่างมีประสิทธิภาพ โดยเฉพาะเมื่อต้องการ scale หรือจัดการ failover อัตโนมัติ ทั้งนี้ ต้องตั้งค่า network, volume, และ security context อย่างเหมาะสม เพื่อป้องกันช่องโหว่ และทำให้ระบบเสถียร

Q: ต้องใช้ทรัพยากรเซิร์ฟเวอร์เท่าไร?

A: ขึ้นอยู่กับว่าใช้ในระดับใด สำหรับการเรียนรู้หรือ development ระบบขั้นต่ำสามารถรันได้ด้วย CPU 2 คอร์, RAM 4 GB, และพื้นที่จัดเก็บ 50 GB SSD แต่สำหรับ production ที่ต้องรองรับผู้ใช้จำนวนมาก แนะนำให้ใช้ CPU 4 คอร์ขึ้นไป, RAM 16 GB ขึ้นไป, และพื้นที่จัดเก็บ 500 GB NVMe SSD หรือมากกว่า เพื่อรองรับการจัดเก็บข้อมูลเมตริกจำนวนมาก และป้องกันปัญหา disk full ที่อาจทำให้ระบบหยุดทำงานได้ อย่าลืมตั้งค่า logrotate และการสำรองข้อมูลเป็นประจำ เพื่อรักษาประสิทธิ

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

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

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

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

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

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