Grafana และ Prometheus คืออะไร? ทำไมต้องใช้คู่กัน?
Grafana คือแพลตฟอร์ม Open-Source สำหรับการทำ Data Visualization และ Monitoring ที่มีความสามารถสูง คุณสามารถสร้าง Dashboard ที่สวยงามและปรับแต่งได้หลากหลาย เพื่อแสดงผลข้อมูลจากแหล่งต่างๆ ได้มากมาย ไม่ว่าจะเป็นฐานข้อมูล, ระบบคลาวด์, หรือแม้กระทั่งแอปพลิเคชันที่คุณพัฒนาขึ้นเอง Grafana รองรับ Data Source ที่หลากหลาย ทำให้เป็นเครื่องมือที่ยืดหยุ่นอย่างมาก
ส่วน Prometheus เป็นระบบ Time-Series Database Monitoring และ Alerting ที่ได้รับความนิยมอย่างสูงเช่นกัน จุดเด่นของ Prometheus คือความสามารถในการดึงข้อมูล (Pull) จากเป้าหมาย (Target) ที่กำหนดไว้ โดยใช้ HTTP scraping และเก็บข้อมูลเหล่านั้นในรูปแบบ Time-Series ที่มีประสิทธิภาพสูง นอกจากนี้ยังมีความสามารถในการสร้าง Alert Rule เพื่อแจ้งเตือนเมื่อมีเหตุการณ์ผิดปกติเกิดขึ้น
การทำงานร่วมกันของ Grafana และ Prometheus จึงเป็นการผสมผสานจุดแข็งของทั้งสองเครื่องมือได้อย่างลงตัว Prometheus ทำหน้าที่เป็น 'สมอง' ในการรวบรวมและจัดเก็บข้อมูล Metrics ต่างๆ จากระบบของคุณอย่างมีประสิทธิภาพ ในขณะที่ Grafana ทำหน้าที่เป็น 'หน้าตา' ที่สวยงามในการนำเสนอข้อมูลเหล่านั้นออกมาในรูปแบบ Dashboard ที่เข้าใจง่าย ทำให้คุณเห็นภาพรวมของระบบได้อย่างชัดเจน และสามารถวิเคราะห์ปัญหาได้อย่างรวดเร็ว การตั้งค่าพื้นฐานสำหรับ Prometheus ในปี 2026 มักจะเริ่มจากการกำหนดค่า `scrape_configs` ในไฟล์ `prometheus.yml` เพื่อระบุว่าต้องการดึงข้อมูลจาก Service ใดบ้าง เช่น การ Monitor Service ที่รันบน Docker Container ด้วย Node Exporter หรือ Blackbox Exporter
Prometheus: หัวใจของการเก็บข้อมูล
Prometheus ทำงานโดยการส่ง HTTP request ไปยัง 'Target' ที่เรากำหนดไว้เป็นระยะๆ เพื่อ 'Scrape' ข้อมูล Metrics ที่ Target นั้นๆ เปิดเผยออกมา ข้อมูลเหล่านี้จะถูกเก็บไว้ในรูปแบบ Time-Series Database (TSDB) ของ Prometheus เอง ซึ่งออกแบบมาเพื่อการจัดการข้อมูลอนุกรมเวลาโดยเฉพาะ ทำให้การ Query ข้อมูลย้อนหลังทำได้อย่างรวดเร็วและมีประสิทธิภาพ การตั้งค่าเริ่มต้นสำหรับ Prometheus ในปี 2026 จะเน้นไปที่การกำหนด `scrape_interval` (ความถี่ในการดึงข้อมูล) และ `evaluation_interval` (ความถี่ในการประเมิน Alert Rules) เพื่อให้เหมาะสมกับลักษณะงานและทรัพยากรที่มี
Grafana: หน้าตาที่สวยงามของข้อมูล
เมื่อ Prometheus เก็บข้อมูลได้แล้ว หน้าที่ของ Grafana คือการนำข้อมูลเหล่านั้นมาแสดงผลให้เราเข้าใจได้ง่ายที่สุด คุณสามารถสร้างกราฟ, ตาราง, หรือ Panel ต่างๆ ได้อย่างอิสระ และเชื่อมต่อ Grafana เข้ากับ Prometheus ในฐานะ Data Source ทำให้ข้อมูลที่แสดงบน Dashboard เป็นข้อมูล Real-time จาก Prometheus โดยตรง การออกแบบ Dashboard ที่ดีในปี 2026 จะคำนึงถึงการแสดงผลบนอุปกรณ์หลากหลายขนาด (Responsive Design) และการจัดกลุ่มของ Metrics ที่เกี่ยวข้อง เพื่อให้ผู้ใช้งานสามารถเห็นภาพรวมและเจาะลึกปัญหาได้อย่างรวดเร็ว
ขั้นตอนการติดตั้ง Grafana และ Prometheus ฉบับมือใหม่ (ปี 2026)
การติดตั้งระบบ Monitor Server ด้วย Grafana และ Prometheus สามารถทำได้หลายวิธี แต่วิธีที่นิยมและง่ายที่สุดสำหรับผู้เริ่มต้นคือการใช้ Docker และ Docker Compose ซึ่งช่วยให้การจัดการ Environment เป็นไปอย่างสะดวก รวดเร็ว และแยกส่วนจากระบบหลักของคุณได้อย่างชัดเจน เราจะมาดูขั้นตอนการติดตั้งพื้นฐานกันครับ
**สิ่งที่ต้องเตรียม:** * ระบบปฏิบัติการ Linux (เช่น Ubuntu 22.04 LTS หรือใหม่กว่า) หรือ macOS * Docker และ Docker Compose ติดตั้งเรียบร้อยแล้ว * ความรู้พื้นฐานเกี่ยวกับ Command Line Interface (CLI)
**ขั้นตอนที่ 1: สร้าง Directory และไฟล์ Docker Compose** สร้าง Folder สำหรับเก็บไฟล์คอนฟิกและ Docker Compose ของคุณ เช่น `mkdir grafana-prometheus && cd grafana-prometheus` จากนั้นสร้างไฟล์ `docker-compose.yml` ขึ้นมา
**ขั้นตอนที่ 2: กำหนดค่าใน `docker-compose.yml`** ในไฟล์ `docker-compose.yml` ให้กำหนด Service สำหรับ Prometheus และ Grafana รวมถึงการตั้งค่า Volume เพื่อให้ข้อมูลไม่หายไปเมื่อ Docker Container มีการ Restart หรืออัปเดต
```yaml version: "3.7"
services: prometheus: image: prom/prometheus:v2.48.0 container_name: prometheus ports: - "9090:9090" volumes: - ./prometheus:/etc/prometheus/ command: - "--config.file=/etc/prometheus/prometheus.yml"
grafana: image: grafana/grafana-enterprise:11.0.0 container_name: grafana ports: - "3000:3000" volumes: - grafana-storage:/var/lib/grafana/
volumes: grafana-storage: ```
**ขั้นตอนที่ 3: สร้างไฟล์คอนฟิก Prometheus (`prometheus.yml`)** ใน Folder เดียวกัน ให้สร้างไฟล์ `prometheus.yml` เพื่อกำหนดค่า Scrape Targets ของ Prometheus โดยเบื้องต้นเราจะให้ Prometheus Monitor ตัวเองก่อน
```yaml global: scrape_interval: 15s
scrape_configs: - job_name: 'prometheus' static_configs: - targets: ['localhost:9090'] ```
**ขั้นตอนที่ 4: รัน Docker Compose** เปิด Terminal ใน Folder ที่คุณสร้างไว้ แล้วรันคำสั่ง `docker-compose up -d` เพื่อเริ่มการทำงานของ Service ทั้งสองแบบ Background
**ขั้นตอนที่ 5: เข้าใช้งาน Grafana** เปิด Web Browser ไปที่ `http://localhost:3000` คุณจะพบหน้า Login ของ Grafana โดย Default Username/Password คือ `admin`/`admin` (ระบบจะให้เปลี่ยนรหัสผ่านในการ Login ครั้งแรก)
**ขั้นตอนที่ 6: ตั้งค่า Data Source ใน Grafana** เมื่อ Login เข้า Grafana สำเร็จแล้ว ให้ไปที่เมนู Configuration -> Data Sources -> Add data source เลือก Prometheus และกรอก URL ของ Prometheus Service ใน Docker คือ `http://localhost:9090` จากนั้นกด Save & Test
**ขั้นตอนที่ 7: สร้าง Dashboard** คุณสามารถสร้าง Dashboard ใหม่ หรือ Import Dashboard สำเร็จรูปที่มีคนทำไว้แล้ว (เช่น Dashboard สำหรับ Node Exporter) เพื่อแสดงผลข้อมูลจาก Prometheus ได้ทันที การติดตั้งพื้นฐานนี้จะทำให้คุณมีระบบ Monitor Server พร้อมใช้งานในปี 2026
การติดตั้ง Prometheus ด้วย Docker Compose
การใช้ Docker Compose ช่วยให้การจัดการ Prometheus ง่ายขึ้นมาก โดยเราสามารถกำหนด Image ที่ต้องการใช้งาน, การ Mount Volume สำหรับเก็บข้อมูลและคอนฟิก, และการ Publish Port ออกมาให้เข้าถึงได้จาก Host Machine ไฟล์ `docker-compose.yml` จะเป็นศูนย์กลางในการจัดการ Service ทั้งหมด ทำให้การ Rollback หรือการ Deploy ซ้ำทำได้ง่ายดาย ในปี 2026 การใช้ Docker Compose ถือเป็น Best Practice สำหรับการเริ่มต้น
การติดตั้ง Grafana ด้วย Docker Compose
เช่นเดียวกับ Prometheus การติดตั้ง Grafana ด้วย Docker Compose ก็สะดวกอย่างยิ่ง เราสามารถกำหนด Image ของ Grafana ที่ต้องการ (เช่น Grafana OSS หรือ Grafana Enterprise), การ Mount Volume สำหรับ Data Storage เพื่อให้ข้อมูล Dashboard และ User Settings ไม่หายไป, และการ Publish Port 3000 เพื่อให้เข้าถึง Web UI ได้จาก Browser การตั้งค่านี้ช่วยลดความซับซ้อนในการติดตั้งและจัดการ Grafana ได้มาก
การกำหนดค่า Prometheus.yml เบื้องต้น
ไฟล์ `prometheus.yml` คือหัวใจของการกำหนดค่า Prometheus ในไฟล์นี้ เราจะระบุ Global Settings เช่น `scrape_interval` และส่วน `scrape_configs` ซึ่งจะบอกว่า Prometheus ควรจะไปดึงข้อมูล (Scrape) จาก Service ใดบ้าง โดยระบุเป็น `job_name` และ `targets` สำหรับมือใหม่ การกำหนดให้ Prometheus Monitor ตัวเอง (localhost:9090) เป็นจุดเริ่มต้นที่ดีในการทดสอบการทำงาน
การตั้งค่า Agent และ Exporter สำหรับการ Monitor
Prometheus สามารถดึงข้อมูลได้จาก Target ที่เปิดเผย Metrics ผ่าน HTTP Endpoint ในรูปแบบที่ Prometheus เข้าใจ แต่โดยปกติแล้ว ระบบปฏิบัติการหรือแอปพลิเคชันทั่วไปไม่ได้เปิดเผยข้อมูลเหล่านี้ออกมาโดยตรง เราจึงจำเป็นต้องใช้ 'Exporter' ซึ่งเป็น Agent ขนาดเล็กที่ทำหน้าที่รวบรวม Metrics จากระบบหรือแอปพลิเคชันนั้นๆ แล้วแปลงให้อยู่ในรูปแบบที่ Prometheus สามารถเข้าใจได้
สำหรับปี 2026 Exporter ที่นิยมใช้กันอย่างแพร่หลาย ได้แก่: * **Node Exporter:** ใช้สำหรับ Monitor ระบบปฏิบัติการ (OS) ของ Server เช่น CPU Usage, Memory Usage, Disk I/O, Network Traffic สามารถติดตั้งบน Linux, Windows, macOS ได้ * **Blackbox Exporter:** ใช้สำหรับ Monitor Service ที่ไม่สามารถ Scrape ได้โดยตรง เช่น HTTP, HTTPS, TCP, ICMP โดยการส่ง Request ไปยัง Target แล้ววัดผลการตอบสนอง เช่น Latency, Status Code * **App Exporter (Custom Exporter):** สำหรับแอปพลิเคชันเฉพาะทาง เช่น Database Exporter (MySQL, PostgreSQL), Nginx Exporter, Redis Exporter เป็นต้น
ในการตั้งค่า Prometheus ให้ Monitor Exporter เหล่านี้ เราจะต้องเพิ่ม Entry ในส่วน `scrape_configs` ของไฟล์ `prometheus.yml` เพื่อระบุ `job_name` และ `targets` ของ Exporter แต่ละตัว เช่น หากเราติดตั้ง Node Exporter บน Server อื่นที่มี IP Address `192.168.1.100` และรันอยู่บน Port `9100` เราจะเพิ่ม Config ประมาณนี้:
```yaml scrape_configs: - job_name: 'node' static_configs: - targets: ['192.168.1.100:9100'] ```
จากนั้นทำการ Restart Prometheus Service เพื่อให้การตั้งค่าใหม่มีผล และ Grafana ก็จะสามารถแสดงผลข้อมูลจาก Node Exporter ได้
Node Exporter: เก็บข้อมูลระดับ OS
Node Exporter เป็นเครื่องมือพื้นฐานที่สำคัญที่สุดในการ Monitor Server ของคุณ มันจะคอยรวบรวมข้อมูลเกี่ยวกับทรัพยากรของระบบปฏิบัติการ เช่น การใช้งาน CPU, RAM, พื้นที่ Disk, การรับส่งข้อมูล Network และแสดงผลออกมาผ่าน HTTP Port (Default คือ 9100) การติดตั้ง Node Exporter บน Server ที่ต้องการ Monitor และกำหนดให้ Prometheus ทำการ Scrape ข้อมูลจาก Port นี้ จะช่วยให้คุณมองเห็นภาพรวมประสิทธิภาพของ Server ได้อย่างละเอียด
Blackbox Exporter: ตรวจสอบการเข้าถึง Service
บางครั้งการ Monitor ไม่ใช่แค่การดูว่า Service ทำงานอยู่หรือไม่ แต่ต้องดูว่าผู้ใช้งานภายนอกสามารถเข้าถึง Service นั้นได้จริงหรือไม่ Blackbox Exporter จะเข้ามาช่วยในส่วนนี้ โดยมันสามารถจำลองการเชื่อมต่อไปยัง Service ต่างๆ เช่น เว็บไซต์ (HTTP/HTTPS), SSH (TCP), หรือแม้กระทั่ง Ping (ICMP) เพื่อตรวจสอบว่า Service นั้นตอบสนองอย่างไร และใช้เวลานานเท่าใด การตั้งค่า Prometheus ให้ Scrape ข้อมูลจาก Blackbox Exporter จะช่วยให้คุณสามารถสร้าง Alert เมื่อ Service ไม่สามารถเข้าถึงได้จากภายนอก
การตั้งค่า Target ใน Prometheus
การเพิ่ม Target เข้าไปใน `prometheus.yml` เป็นขั้นตอนสำคัญเพื่อให้ Prometheus รู้ว่าจะไปดึงข้อมูลจากที่ไหน โดยทั่วไปจะมีการกำหนด `job_name` เพื่อจัดกลุ่ม Target และ `static_configs` เพื่อระบุ List ของ Target (IP Address:Port) ที่ต้องการ Scrape สำหรับการใช้งานจริง อาจมีการใช้ Service Discovery เพื่อให้ Prometheus สามารถค้นหา Target ได้โดยอัตโนมัติ ซึ่งมีความยืดหยุ่นสูงกว่าการกำหนดแบบ Static
การสร้าง Dashboard ใน Grafana เพื่อแสดงผล
เมื่อ Prometheus ทำการรวบรวมข้อมูลและ Grafana เชื่อมต่อกับ Prometheus เป็น Data Source เรียบร้อยแล้ว ขั้นตอนต่อไปคือการสร้าง Dashboard เพื่อแสดงผลข้อมูล Metrics ที่น่าสนใจ การสร้าง Dashboard สามารถทำได้ 2 วิธีหลักๆ คือ การสร้าง Panel ด้วยตนเอง หรือ การ Import Dashboard สำเร็จรูป
**1. การสร้าง Panel ด้วยตนเอง:** * ไปที่เมนู Create -> Dashboard -> Add new panel. * เลือก Data Source ที่เป็น Prometheus ที่คุณตั้งค่าไว้. * ในช่อง Query ให้คุณเขียน PromQL (Prometheus Query Language) เพื่อดึงข้อมูล Metrics ที่ต้องการ เช่น `node_cpu_seconds_total` หรือ `http_requests_total`. * เลือกประเภทของ Visualization ที่ต้องการ เช่น Graph, Stat, Gauge, Table. * ปรับแต่งการแสดงผล เช่น ชื่อ Panel, หน่วย, สี, ช่วงเวลา. * กด Save เพื่อบันทึก Panel และ Dashboard.
**2. การ Import Dashboard สำเร็จรูป:** Grafana มี Community Dashboard ที่มีให้เลือกใช้งานมากมาย (สามารถค้นหาได้ที่ [grafana.com/grafana/dashboards/](https://grafana.com/grafana/dashboards/)) Dashboard เหล่านี้มักจะถูกออกแบบมาสำหรับ Exporter ยอดนิยม เช่น Node Exporter, Kubernetes, Docker เป็นต้น * ไปที่เมนู Create -> Import. * กรอก ID ของ Dashboard ที่ต้องการ หรือ Upload ไฟล์ JSON ของ Dashboard. * เลือก Data Source ที่เป็น Prometheus. * กด Import.
Dashboard ที่ Import เข้ามาส่วนใหญ่จะแสดงผลข้อมูลพื้นฐานที่จำเป็นอยู่แล้ว คุณสามารถเข้าไปแก้ไขหรือปรับแต่งเพิ่มเติมได้ตามต้องการ การเลือกใช้ Dashboard สำเร็จรูปจะช่วยประหยัดเวลาได้อย่างมากในปี 2026 และทำให้คุณเห็นแนวทางการแสดงผล Metrics ที่มีประสิทธิภาพ
การตั้งค่า Alerting ด้วย Prometheus และ Grafana
นอกจากการ Monitor และแสดงผลข้อมูลแล้ว การแจ้งเตือนเมื่อเกิดเหตุการณ์ผิดปกติก็เป็นฟังก์ชันที่สำคัญอย่างยิ่ง Prometheus สามารถกำหนด Alert Rules ได้ โดยเขียนเงื่อนไขในไฟล์คอนฟิก (`prometheus.yml`) หรือผ่าน Web UI ของ Prometheus เอง จากนั้น Prometheus จะส่ง Alert ไปยัง Alertmanager ซึ่งเป็น Component ที่ทำหน้าที่จัดการการแจ้งเตือน
**ขั้นตอนพื้นฐาน:** 1. **สร้าง Alert Rule:** กำหนดเงื่อนไขใน Prometheus เช่น `ALERT HighCpuUsage IF node_cpu_seconds_total{mode="idle"} < 1000 FOR 5m`. Rule นี้จะแจ้งเตือนเมื่อ CPU Idle ต่ำกว่า 10% เป็นเวลา 5 นาที. 2. **ตั้งค่า Alertmanager:** กำหนดการเชื่อมต่อระหว่าง Prometheus กับ Alertmanager ใน `prometheus.yml` และตั้งค่า Receiver (เช่น Slack, Email, PagerDuty) ในคอนฟิกของ Alertmanager. 3. **เชื่อมต่อ Grafana กับ Alertmanager:** ใน Grafana ให้เพิ่ม Alertmanager เป็น Notification Channel. 4. **สร้าง Alert ใน Grafana:** คุณสามารถสร้าง Alert โดยตรงบน Panel ของ Grafana ได้เช่นกัน โดยกำหนดเงื่อนไขการแจ้งเตือน และเลือก Notification Channel ที่ต้องการ.
การตั้งค่า Alerting ที่ดีในปี 2026 ควรจะมีการแบ่งระดับความรุนแรงของ Alert, กำหนดผู้รับที่เหมาะสม, และมี Runbook ที่ชัดเจน เพื่อให้ทีมสามารถตอบสนองต่อเหตุการณ์ได้อย่างรวดเร็วและถูกต้อง
ข้อควรระวังและแนวทางปฏิบัติที่ดี
แม้ว่า Grafana และ Prometheus จะเป็นเครื่องมือที่ทรงพลัง แต่การนำไปใช้งานจริงก็มีข้อควรพิจารณาและแนวทางปฏิบัติที่ดีเพื่อให้ระบบ Monitor ของคุณมีประสิทธิภาพสูงสุด:
1. **การจัดการทรัพยากร:** Prometheus และ Exporter ใช้ทรัพยากร (CPU, Memory, Disk) ในการทำงาน ควรจัดสรรทรัพยากรให้เพียงพอ โดยเฉพาะอย่างยิ่งหากคุณมี Target จำนวนมากหรือเก็บข้อมูลย้อนหลังเป็นเวลานาน 2. **การเลือก Exporter:** เลือกใช้ Exporter ที่เหมาะสมกับ Service หรือระบบที่คุณต้องการ Monitor เพื่อให้ได้ข้อมูลที่ถูกต้องและมีประโยชน์ หลีกเลี่ยงการติดตั้ง Exporter ที่ไม่จำเป็น เพราะจะเพิ่มภาระให้กับระบบ 3. **การตั้งค่า Scrape Interval:** การตั้งค่า `scrape_interval` ที่ถี่เกินไป (เช่น ทุก 5 วินาที) อาจทำให้เกิดภาระกับทั้ง Prometheus และ Target อย่างมาก ควรปรับให้เหมาะสมกับความต้องการและทรัพยากรที่มี 4. **การเก็บข้อมูล (Retention):** Prometheus มีการตั้งค่าการเก็บข้อมูล (`--storage.tsdb.retention.time`) ควรพิจารณาให้เหมาะสมกับพื้นที่ Disk ที่มี และความจำเป็นในการเก็บข้อมูลย้อนหลังนานแค่ไหน 5. **การทำ Indexing สำหรับ Alert:** การสร้าง Alert Rule ที่ซับซ้อนหรือใช้ Label จำนวนมาก อาจส่งผลต่อประสิทธิภาพของ Prometheus ควรออกแบบ Alert Rule ให้มีประสิทธิภาพ 6. **ความปลอดภัย:** หากเปิดให้เข้าถึง Grafana หรือ Prometheus จากภายนอก ควรมีการตั้งค่า Authentication และ Authorization ที่เหมาะสม รวมถึงการใช้ Firewall เพื่อจำกัดการเข้าถึง 7. **การทำ Backup:** ควรมีการสำรองข้อมูลคอนฟิกของ Prometheus และ Grafana รวมถึงข้อมูลใน Volume Storage เป็นประจำ เพื่อป้องกันข้อมูลสูญหาย 8. **การอัปเดตเวอร์ชัน:** ติดตามเวอร์ชันล่าสุดของ Grafana, Prometheus, และ Exporter ต่างๆ และทำการอัปเดตอย่างสม่ำเสมอ เพื่อรับฟีเจอร์ใหม่ๆ และการแก้ไขข้อผิดพลาดต่างๆ