Prometheus Grafana Monitoring ระบบ Server แบบ Pro

ในโลกยุคดิจิทัลที่ขับเคลื่อนด้วยข้อมูลและความเร็ว การรันระบบเซิร์ฟเวอร์หรือแอปพลิเคชันโดยปราศจากการมอนิเตอร์ที่ดีเปรียบเสมือนการขับรถโดยไม่มองมาตรวัดใด ๆ เลยครับ เราอาจไปถึงที่หมายได้ แต่เมื่อเกิดปัญหาขึ้นกลางทาง เราจะไม่มีทางรู้เลยว่าอะไรผิดปกติไปและจะแก้ไขได้อย่างไร การมอนิเตอร์จึงไม่ใช่แค่ทางเลือกอีกต่อไป แต่เป็นสิ่งจำเป็นอย่างยิ่งยวดสำหรับองค์กรที่ต้องการความเสถียร ประสิทธิภาพ และความพร้อมใช้งานของระบบตลอด 24 ชั่วโมง โดยเฉพาะอย่างยิ่งในสภาพแวดล้อมแบบคลาวด์เนทีฟ ไมโครเซอร์วิส และคอนเทนเนอร์ที่ซับซับซ้อนขึ้นทุกวัน

บทความนี้จะเจาะลึกถึงวิธีการยกระดับการมอนิเตอร์ระบบเซิร์ฟเวอร์ของคุณให้เป็นระดับ “Pro” ด้วยสองเครื่องมือโอเพนซอร์สที่ทรงพลังและได้รับความนิยมสูงสุดในปัจจุบัน นั่นคือ Prometheus สำหรับการเก็บและประมวลผล Metrics และ Grafana สำหรับการสร้าง Dashboard แสดงผลข้อมูลที่สวยงามและเข้าใจง่าย เราจะพาคุณไปสำรวจตั้งแต่แนวคิดพื้นฐาน การติดตั้ง การตั้งค่า ไปจนถึงเทคนิคขั้นสูง เพื่อให้คุณสามารถนำระบบไปปรับใช้และบริหารจัดการได้อย่างมีประสิทธิภาพสูงสุดครับ

สารบัญ

• ทำความเข้าใจโลกของการ Monitoring สมัยใหม่
• Prometheus: หัวใจของการเก็บข้อมูล Metrics
  • ส่วนประกอบสำคัญของ Prometheus
  • การติดตั้ง Prometheus Server
  • การติดตั้งและใช้งาน Node Exporter
  • ทำความเข้าใจ PromQL: ภาษาสำหรับการ Query ข้อมูล Metrics
• Grafana: การแสดงผลข้อมูลที่สวยงามและทรงพลัง
  • การติดตั้ง Grafana
  • การเชื่อมต่อ Grafana เข้ากับ Prometheus
  • การสร้าง Dashboard แรกของคุณบน Grafana
  • การใช้งาน Template Variables และ Pre-built Dashboards
• การตั้งค่า Alerting ด้วย Prometheus Alertmanager และ Grafana
  • การกำหนด Alerting Rules ใน Prometheus
  • Prometheus Alertmanager: ศูนย์กลางการจัดการ Alert
  • การตั้งค่า Alerting ผ่าน Grafana
• ขยายขีดความสามารถ: การมอนิเตอร์ระดับ Pro
  • Service Discovery สำหรับระบบขนาดใหญ่
  • การสร้าง Custom Exporters
  • การจัดการ Scalability และ Long-term Storage (Thanos/Cortex)
  • แนวทางปฏิบัติที่ดีที่สุด (Best Practices)
• เปรียบเทียบ Prometheus/Grafana กับเครื่องมืออื่น ๆ
• คำถามที่พบบ่อย (FAQ)
• สรุปและ Call to Action

ทำความเข้าใจโลกของการ Monitoring สมัยใหม่

ในอดีต การมอนิเตอร์ระบบเซิร์ฟเวอร์มักจะเน้นไปที่การตรวจสอบสถานะพื้นฐาน เช่น CPU Usage, Memory Usage, Disk Space และ Network I/O โดยใช้เครื่องมือแบบดั้งเดิมอย่าง Nagios, Zabbix หรือ cacti ซึ่งส่วนใหญ่เป็นแบบ Agent-based และมักจะใช้การตรวจสอบแบบ Polling เพื่อดึงข้อมูลจากแต่ละเซิร์ฟเวอร์ครับ

อย่างไรก็ตาม เมื่อสถาปัตยกรรมระบบพัฒนาไปสู่ Microservices, Containerization (Docker, Kubernetes) และ Cloud Computing (AWS, GCP, Azure) ที่มี Dynamic Nature สูงขึ้นอย่างรวดเร็ว เครื่องมือแบบดั้งเดิมเหล่านี้เริ่มแสดงข้อจำกัดออกมาอย่างชัดเจนครับ

• ความซับซ้อนที่เพิ่มขึ้น: จำนวนของ Service และ Instance เพิ่มขึ้นอย่างมหาศาล และมีการเกิดใหม่-ตายจากไปอย่างรวดเร็ว ทำให้การตั้งค่า Agent แบบ Manual หรือการกำหนด Target แบบ Static เป็นเรื่องที่จัดการได้ยากและไม่สามารถรองรับได้ทันท่วงทีครับ
• ความต้องการข้อมูลเชิงลึก: เราไม่ได้ต้องการแค่รู้ว่า “ระบบล่มหรือไม่” แต่ต้องการรู้ว่า “ทำไมถึงทำงานช้า” หรือ “เกิดอะไรขึ้นกับแต่ละส่วนประกอบของระบบ” ซึ่งต้องการข้อมูล Metrics ที่ละเอียดและเป็น Time-series Data ที่สามารถ Query ได้อย่างยืดหยุ่นครับ
• การทำงานร่วมกับระบบนิเวศ Cloud-Native: เครื่องมือสมัยใหม่จำเป็นต้อง Integrate เข้ากับ Container Orchestration Platforms (เช่น Kubernetes) และระบบคลาวด์ได้อย่างไร้รอยต่อ เพื่อให้สามารถค้นหา Service และเก็บข้อมูล Metrics ได้โดยอัตโนมัติครับ

นี่คือจุดที่ Prometheus และ Grafana เข้ามาตอบโจทย์ได้อย่างลงตัวครับ ทั้งคู่ถูกออกแบบมาเพื่อรองรับความต้องการเหล่านี้โดยเฉพาะ ด้วยสถาปัตยกรรมแบบ Pull-based, Time-series Database ที่มีประสิทธิภาพ, ภาษา Query ที่ทรงพลังอย่าง PromQL และความสามารถในการแสดงผลข้อมูลที่ยืดหยุ่นและสวยงาม ทำให้ Prometheus และ Grafana กลายเป็นมาตรฐาน (De Facto Standard) สำหรับการมอนิเตอร์ในยุค Cloud-Native ไปแล้วครับ

Prometheus: หัวใจของการเก็บข้อมูล Metrics

Prometheus คือระบบมอนิเตอร์และ Alerting แบบโอเพนซอร์สที่ถูกพัฒนาขึ้นครั้งแรกที่ SoundCloud ในปี 2012 และเปิดเป็นโอเพนซอร์สในปี 2015 ปัจจุบันเป็นส่วนหนึ่งของ Cloud Native Computing Foundation (CNCF) ครับ จุดเด่นของ Prometheus คือการออกแบบมาเพื่อเก็บข้อมูล Metrics ในรูปแบบ Time-series Data ซึ่งเหมาะอย่างยิ่งสำหรับการตรวจสอบพฤติกรรมของระบบเมื่อเวลาผ่านไปครับ

ส่วนประกอบสำคัญของ Prometheus

ระบบ Prometheus ประกอบด้วยส่วนประกอบหลักหลายอย่างที่ทำงานร่วมกัน ได้แก่:

• Prometheus Server: Core Component ที่ทำหน้าที่ดึง (Scrape) ข้อมูล Metrics จาก Target ที่กำหนดไว้ เก็บข้อมูลใน Time-series Database และรองรับการ Query ด้วยภาษา PromQL ครับ
• Exporters: แอปพลิเคชันขนาดเล็กที่รันบนเซิร์ฟเวอร์หรือ Service ต่าง ๆ เพื่อแปลงข้อมูล Metrics ของ Service นั้น ๆ ให้อยู่ในรูปแบบที่ Prometheus สามารถเข้าใจและดึงไปเก็บได้ เช่น Node Exporter สำหรับระบบปฏิบัติการ, cAdvisor สำหรับ Container, Blackbox Exporter สำหรับ HTTP/TCP Probing ครับ
• Pushgateway: สำหรับ Service ที่มีอายุสั้น (Short-lived Jobs) หรือ Batch Jobs ที่ไม่สามารถรอให้ Prometheus มา Scrape ได้ Pushgateway จะทำหน้าที่เป็นตัวกลางให้ Service เหล่านั้น Push Metrics เข้ามาเก็บชั่วคราว และ Prometheus จะมา Scrape จาก Pushgateway อีกทีครับ
• Alertmanager: ส่วนประกอบที่รับ Alerts จาก Prometheus Server มาทำการ Deduplicate, Grouping และ Route ไปยัง Notification Receiver ต่าง ๆ เช่น Email, Slack, PagerDuty เป็นต้นครับ
• Client Libraries: ไลบรารีสำหรับนักพัฒนาที่ต้องการฝังการเก็บ Metrics เข้าไปในแอปพลิเคชันของตนเองโดยตรง เพื่อให้แอปพลิเคชันสามารถ Expose Metrics ในรูปแบบที่ Prometheus เข้าใจได้ครับ

การติดตั้ง Prometheus Server

เราจะมาเริ่มจากการติดตั้ง Prometheus Server บนระบบ Linux กันนะครับ (ในที่นี้ใช้ Ubuntu เป็นตัวอย่างครับ)

ขั้นตอนที่ 1: สร้าง User สำหรับ Prometheus

sudo useradd --no-create-home --shell /bin/false prometheus
sudo mkdir /etc/prometheus
sudo mkdir /var/lib/prometheus

ขั้นตอนที่ 2: ดาวน์โหลดและแตกไฟล์ Prometheus

ไปที่หน้า Download ของ Prometheus เพื่อดูเวอร์ชันล่าสุดครับ

wget https://github.com/prometheus/prometheus/releases/download/v2.47.0/prometheus-2.47.0.linux-amd64.tar.gz
tar -xvf prometheus-2.47.0.linux-amd64.tar.gz
cd prometheus-2.47.0.linux-amd64

ขั้นตอนที่ 3: คัดลอกไฟล์ไบนารีและตั้งค่าสิทธิ์

sudo cp prometheus /usr/local/bin/
sudo cp promtool /usr/local/bin/
sudo chown prometheus:prometheus /usr/local/bin/prometheus
sudo chown prometheus:prometheus /usr/local/bin/promtool

ขั้นตอนที่ 4: คัดลอกไฟล์คอนฟิกและตั้งค่าสิทธิ์

sudo cp console_libraries /etc/prometheus
sudo cp consoles /etc/prometheus
sudo cp prometheus.yml /etc/prometheus

sudo chown -R prometheus:prometheus /etc/prometheus/
sudo chown prometheus:prometheus /var/lib/prometheus

ขั้นตอนที่ 5: สร้าง Systemd Service File

สร้างไฟล์ `/etc/systemd/system/prometheus.service` ด้วยเนื้อหาดังนี้ครับ

[Unit]
Description=Prometheus
Wants=network-online.target
After=network-online.target

[Service]
User=prometheus
Group=prometheus
Type=simple
ExecStart=/usr/local/bin/prometheus \
    --config.file /etc/prometheus/prometheus.yml \
    --storage.tsdb.path /var/lib/prometheus/ \
    --web.console.templates=/etc/prometheus/consoles \
    --web.console.libraries=/etc/prometheus/console_libraries

[Install]
WantedBy=multi-user.target

ขั้นตอนที่ 6: รีโหลด Systemd และเริ่ม Prometheus

sudo systemctl daemon-reload
sudo systemctl start prometheus
sudo systemctl enable prometheus
sudo systemctl status prometheus

ตอนนี้คุณสามารถเข้าถึง Prometheus UI ได้ที่ `http://YOUR_SERVER_IP:9090` ครับ

การติดตั้งและใช้งาน Node Exporter

Node Exporter เป็น Exporter ที่สำคัญที่สุดตัวหนึ่ง เพราะใช้สำหรับเก็บข้อมูล Metrics ระดับระบบปฏิบัติการ เช่น CPU, Memory, Disk I/O, Network I/O, Load Average และอื่น ๆ ครับ

ขั้นตอนที่ 1: สร้าง User สำหรับ Node Exporter

sudo useradd --no-create-home --shell /bin/false node_exporter

ขั้นตอนที่ 2: ดาวน์โหลดและแตกไฟล์ Node Exporter

ไปที่หน้า Download ของ Prometheus เพื่อดูเวอร์ชันล่าสุดของ Node Exporter ครับ

wget https://github.com/prometheus/node_exporter/releases/download/v1.7.0/node_exporter-1.7.0.linux-amd64.tar.gz
tar -xvf node_exporter-1.7.0.linux-amd64.tar.gz
cd node_exporter-1.7.0.linux-amd64

ขั้นตอนที่ 3: คัดลอกไฟล์ไบนารีและตั้งค่าสิทธิ์

sudo cp node_exporter /usr/local/bin/
sudo chown node_exporter:node_exporter /usr/local/bin/node_exporter

ขั้นตอนที่ 4: สร้าง Systemd Service File

สร้างไฟล์ `/etc/systemd/system/node_exporter.service` ด้วยเนื้อหาดังนี้ครับ

[Unit]
Description=Node Exporter
Wants=network-online.target
After=network-online.target

[Service]
User=node_exporter
Group=node_exporter
Type=simple
ExecStart=/usr/local/bin/node_exporter

[Install]
WantedBy=multi-user.target

ขั้นตอนที่ 5: รีโหลด Systemd และเริ่ม Node Exporter

sudo systemctl daemon-reload
sudo systemctl start node_exporter
sudo systemctl enable node_exporter
sudo systemctl status node_exporter

Node Exporter จะ Expose Metrics ที่พอร์ต `9100` ครับ คุณสามารถทดสอบได้โดยเข้าถึง `http://YOUR_SERVER_IP:9100/metrics`

ขั้นตอนที่ 6: เพิ่ม Node Exporter ในการตั้งค่า Prometheus

แก้ไขไฟล์ `/etc/prometheus/prometheus.yml` เพื่อเพิ่ม Node Exporter เข้าไปใน `scrape_configs` ครับ

# my global config
global:
  scrape_interval: 15s # Set the scrape interval to every 15 seconds. Default is 1m.
  evaluation_interval: 15s # Evaluate rules every 15 seconds. Default is 1m.
  # scrape_timeout is set to the global default (10s).

# A scrape configuration scraping Prometheus itself
scrape_configs:
  - job_name: "prometheus"
    static_configs:
      - targets: ["localhost:9090"]

  - job_name: "node_exporter"
    static_configs:
      - targets: ["localhost:9100"] # เปลี่ยนเป็น IP ของเซิร์ฟเวอร์ที่รัน Node Exporter ถ้าอยู่คนละเครื่อง

หลังจากแก้ไขไฟล์แล้ว ให้รีสตาร์ท Prometheus Server ครับ

sudo systemctl restart prometheus
sudo systemctl status prometheus

เข้าไปที่ Prometheus UI (http://YOUR_SERVER_IP:9090) เลือกเมนู “Status” -> “Targets” คุณจะเห็น `node_exporter` ปรากฏขึ้นมาพร้อมสถานะ “UP” ครับ

ทำความเข้าใจ PromQL: ภาษาสำหรับการ Query ข้อมูล Metrics

PromQL (Prometheus Query Language) คือภาษา Query ที่ทรงพลังของ Prometheus สำหรับการเลือกและรวมข้อมูล Time-series Data ครับ การเข้าใจ PromQL เป็นหัวใจสำคัญในการดึงข้อมูลเชิงลึกจากระบบของคุณครับ

องค์ประกอบพื้นฐานของ PromQL:

• Metric Names: ชื่อของ Metrics ที่ถูกเก็บ เช่น `node_cpu_seconds_total`
• Labels: คู่ Key-Value ที่ใช้ระบุคุณลักษณะเฉพาะของ Metrics นั้น ๆ เช่น `mode=”idle”`, `instance=”localhost:9100″`
• Selectors: ใช้ในการเลือก Metrics โดยอ้างอิงจาก Metric Name และ Labels
• Operators: สำหรับการคำนวณทางคณิตศาสตร์, ตรรกะ หรือการเปรียบเทียบ
• Functions: สำหรับการประมวลผลข้อมูล เช่น `rate()`, `sum()`, `avg()`

ตัวอย่าง PromQL Query:

1. การเลือก Metric พื้นฐาน:

เพื่อดูค่าปัจจุบันของ CPU Time (ในหน่วยวินาที) ที่ใช้ไปในแต่ละโหมดบนเซิร์ฟเวอร์ทั้งหมด:

node_cpu_seconds_total

ผลลัพธ์ที่ได้จะเป็น Time-series หลายชุด โดยแต่ละชุดจะมี Label `mode` (เช่น idle, user, system) และ `cpu` (เช่น 0, 1) ครับ

2. การกรองข้อมูลด้วย Labels:

เพื่อดูเฉพาะ CPU Time ในโหมด `idle`:

node_cpu_seconds_total{mode="idle"}

หรือถ้าต้องการเลือกจากหลายโหมด:

node_cpu_seconds_total{mode=~"idle|user"}

3. การคำนวณอัตราการเปลี่ยนแปลง (Rate of Change):

Metrics ส่วนใหญ่ เช่น `node_cpu_seconds_total` เป็นแบบ Counter คือจะเพิ่มขึ้นเรื่อย ๆ เพื่อดูอัตราการใช้งาน CPU เป็นเปอร์เซ็นต์ เราต้องใช้ฟังก์ชัน `rate()` หรือ `irate()` ร่วมกับ `sum()` และ `avg()` ครับ

การใช้งาน CPU รวมเป็นเปอร์เซ็นต์:

เราต้องคำนวณอัตราการเพิ่มขึ้นของ CPU Time ที่ไม่ได้อยู่ในโหมด idle, iowait, steal, guest, guest_nice แล้วนำมาหารด้วยจำนวน CPU Cores ครับ

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

• `node_cpu_seconds_total{mode=”idle”}`: เลือก CPU Time ที่อยู่ในโหมด idle
• `[5m]`: เลือกข้อมูลย้อนหลัง 5 นาที (Range Vector)
• `rate(…)`: คำนวณอัตราการเพิ่มขึ้นต่อวินาทีในช่วง 5 นาที
• `avg by (instance)`: คำนวณค่าเฉลี่ยของอัตราที่ได้ โดยแบ่งตามแต่ละ `instance` (เซิร์ฟเวอร์)
• `100 – (… * 100)`: แปลงให้อยู่ในรูปเปอร์เซ็นต์การใช้งานที่ไม่ใช่ idle

หรืออีกวิธีที่แม่นยำกว่าโดยการรวมทุกโหมดที่ไม่ใช่ idle:

100 * (1 - avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])))

การใช้งาน Memory เป็นเปอร์เซ็นต์:

100 * (node_memory_MemTotal_bytes - node_memory_MemAvailable_bytes) / node_memory_MemTotal_bytes

Metrics ที่ใช้: `node_memory_MemTotal_bytes` (หน่วยความจำรวม) และ `node_memory_MemAvailable_bytes` (หน่วยความจำที่พร้อมใช้งาน)

พื้นที่ Disk ที่เหลือเป็นเปอร์เซ็นต์:

100 - (node_filesystem_avail_bytes{fstype!="rootfs", mountpoint!~"/(boot|snap)($|/.*)"} / node_filesystem_size_bytes{fstype!="rootfs", mountpoint!~"/(boot|snap)($|/.*)"} * 100)

เลือกเฉพาะ Filesystem ที่สนใจและไม่รวม `rootfs`, `/boot`, `/snap`

การฝึกฝน PromQL จะช่วยให้คุณสามารถสร้าง Query ที่ซับซ้อนเพื่อเจาะลึกปัญหาและสร้าง Dashboard ที่มีประสิทธิภาพได้ครับ อ่านเพิ่มเติมเกี่ยวกับ PromQL

Grafana: การแสดงผลข้อมูลที่สวยงามและทรงพลัง

Grafana คือแพลตฟอร์มโอเพนซอร์สสำหรับการวิเคราะห์และการสร้าง Dashboard แสดงผลข้อมูลครับ Grafana ไม่ได้เก็บข้อมูลเอง แต่ทำหน้าที่ดึงข้อมูลจาก Data Source ต่าง ๆ (เช่น Prometheus, InfluxDB, Elasticsearch, MySQL, PostgreSQL) มาแสดงผลในรูปแบบกราฟ, ตาราง, หรือตัวเลขสถิติที่สวยงามและเข้าใจง่ายครับ ด้วยความสามารถในการปรับแต่งที่สูง Grafana จึงเป็นคู่หูที่สมบูรณ์แบบสำหรับ Prometheus ครับ

การติดตั้ง Grafana

เราจะมาติดตั้ง Grafana บนระบบ Linux (Ubuntu) กันนะครับ

ขั้นตอนที่ 1: ติดตั้งแพ็คเกจที่จำเป็น

sudo apt-get install -y apt-transport-https software-properties-common wget

ขั้นตอนที่ 2: เพิ่ม GPG Key ของ Grafana

wget -q -O - https://apt.grafana.com/gpg.key | sudo gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/grafana.gpg > /dev/null

ขั้นตอนที่ 3: เพิ่ม Repository ของ Grafana

echo "deb [signed-by=/etc/apt/trusted.gpg.d/grafana.gpg] https://apt.grafana.com stable main" | sudo tee -a /etc/apt/sources.list.d/grafana.list

ขั้นตอนที่ 4: อัปเดต APT Cache และติดตั้ง Grafana

sudo apt-get update
sudo apt-get install grafana

ขั้นตอนที่ 5: เริ่ม Grafana Service

sudo systemctl daemon-reload
sudo systemctl start grafana-server
sudo systemctl enable grafana-server
sudo systemctl status grafana-server

Grafana จะรันบนพอร์ต `3000` ครับ คุณสามารถเข้าถึงได้ที่ `http://YOUR_SERVER_IP:3000` โดย Default Username คือ `admin` และ Default Password คือ `admin` ระบบจะบังคับให้คุณเปลี่ยน Password เมื่อเข้าสู่ระบบครั้งแรกครับ

การเชื่อมต่อ Grafana เข้ากับ Prometheus

หลังจากติดตั้ง Grafana แล้ว ขั้นตอนต่อไปคือการเชื่อมต่อ Grafana เข้ากับ Prometheus Server เพื่อให้ Grafana สามารถดึงข้อมูล Metrics มาแสดงผลได้ครับ

ขั้นตอนที่ 1: เข้าสู่ระบบ Grafana

เปิดเว็บเบราว์เซอร์ไปที่ `http://YOUR_SERVER_IP:3000` และเข้าสู่ระบบด้วย `admin`/`admin` (แล้วตั้งรหัสผ่านใหม่ครับ)

ขั้นตอนที่ 2: เพิ่ม Data Source

• ที่เมนูด้านซ้าย ให้คลิกที่ไอคอน “Connections” (รูปปลั๊ก) หรือ “Configuration” (รูปเฟือง) แล้วเลือก “Data sources” ครับ
• คลิกปุ่ม “Add new data source”
• เลือก “Prometheus” จากรายการ Data Source ประเภทต่าง ๆ

ขั้นตอนที่ 3: ตั้งค่า Prometheus Data Source

• Name: ตั้งชื่อ Data Source ของคุณ เช่น `Prometheus Local` หรือ `My Prometheus`
• URL: ใส่ URL ของ Prometheus Server ของคุณ เช่น `http://localhost:9090` (ถ้า Prometheus และ Grafana รันอยู่บนเครื่องเดียวกัน) หรือ `http://PROMETHEUS_SERVER_IP:9090` ครับ
• Scrape Interval: ตั้งค่าให้ตรงกับ `scrape_interval` ในไฟล์ `prometheus.yml` (โดยปกติคือ `15s`)
• HTTP Method: เลือก `GET`
• กดปุ่ม “Save & test” ถ้าสำเร็จจะขึ้นข้อความว่า “Data source is working” ครับ

การสร้าง Dashboard แรกของคุณบน Grafana

มาลองสร้าง Dashboard ง่าย ๆ เพื่อแสดงผลการใช้งาน CPU จาก Node Exporter กันครับ

ขั้นตอนที่ 1: สร้าง Dashboard ใหม่

• ที่เมนูด้านซ้าย เลือกไอคอน “Dashboards” (รูปตาราง)
• คลิกปุ่ม “New dashboard”
• คลิก “Add a new panel”

ขั้นตอนที่ 2: ตั้งค่า Panel

• Query: ในส่วน Query Editor ให้เลือก Data Source ที่คุณสร้างไว้ (เช่น `Prometheus Local`) ครับ
• ในช่อง PromQL Query ให้ใส่ Query ที่เราได้เรียนรู้ไป เช่น สำหรับ CPU Usage:

  100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100)

• Panel Title: เปลี่ยนชื่อ Panel เป็น `CPU Usage`
• Visualization: เลือกประเภทกราฟที่ต้องการ เช่น “Graph” หรือ “Stat”
• Unit: ในส่วน “Standard options” ให้ตั้งค่า “Unit” เป็น `percent (0-100)` เพื่อให้แสดงผลเป็นเปอร์เซ็นต์อย่างถูกต้องครับ
• คุณสามารถปรับแต่งสี, เส้น, แกน Y และอื่น ๆ ได้ตามต้องการครับ
• คลิกปุ่ม “Apply” ที่มุมขวาบน

ขั้นตอนที่ 3: บันทึก Dashboard

• คลิกไอคอน “Save dashboard” (รูปดิสก์) ที่ด้านบนของหน้าจอ
• ตั้งชื่อ Dashboard ของคุณ เช่น `Server Monitoring`
• เลือก Folder (ถ้ามี) แล้วคลิก “Save”

ตอนนี้คุณก็มี Dashboard แรกที่แสดงผลการใช้งาน CPU ของเซิร์ฟเวอร์แล้วครับ คุณสามารถเพิ่ม Panel อื่น ๆ เช่น Memory Usage, Disk Space, Network I/O โดยใช้ PromQL Query ที่เหมาะสมได้เลยครับ

การใช้งาน Template Variables และ Pre-built Dashboards

Template Variables:

หากคุณมีเซิร์ฟเวอร์หลายเครื่อง การสร้าง Dashboard แยกกันสำหรับแต่ละเครื่องคงไม่สะดวกครับ Grafana มีฟีเจอร์ Template Variables ที่ช่วยให้คุณสร้าง Dashboard เดียวที่สามารถสลับดูข้อมูลของแต่ละเซิร์ฟเวอร์ได้ง่าย ๆ ครับ

• ไปที่ Dashboard ที่คุณสร้างไว้ คลิกไอคอน “Dashboard settings” (รูปเฟือง) ที่ด้านบน
• เลือก “Variables” -> “Add variable”
• Name: `instance`
• Type: `Query`
• Data source: `Prometheus Local`
• Query: `label_values(node_cpu_seconds_total, instance)` (PromQL Query นี้จะดึงค่า Label `instance` ทั้งหมดจาก Metric `node_cpu_seconds_total`)
• Multi-value: เปิดใช้งาน (Allow multi-value)
• All value: เปิดใช้งาน (Include All option)
• คลิก “Update” และ “Save dashboard”

หลังจากนี้ คุณจะเห็น Dropdown Menu ด้านบนของ Dashboard ครับ คุณสามารถใช้ตัวแปร `instance` นี้ใน PromQL Query ของ Panel ต่าง ๆ ได้โดยใช้ `$` เช่น:

100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle", instance=~"$instance"}[5m])) * 100)

เมื่อคุณเลือก `instance` จาก Dropdown Menu ข้อมูลใน Panel ก็จะเปลี่ยนไปตามเซิร์ฟเวอร์ที่คุณเลือกครับ

Pre-built Dashboards:

เพื่อประหยัดเวลาและเริ่มต้นใช้งานได้รวดเร็ว Grafana Labs มี Dashboard สำเร็จรูปมากมายที่คุณสามารถนำเข้าใช้งานได้ทันทีครับ โดยเฉพาะอย่างยิ่งสำหรับ Node Exporter ก็มี Dashboard ที่ได้รับความนิยมและครอบคลุมข้อมูลที่จำเป็นเกือบทั้งหมดครับ

• ไปที่ Grafana Dashboards เว็บไซต์
• ค้นหา “Node Exporter Full” (ID: 1860) หรือ “Node Exporter for Prometheus” (ID: 11074) ครับ
• คลิกที่ Dashboard ที่คุณต้องการ แล้วคัดลอก ID หรือ JSON Model ของ Dashboard นั้นมา
• ใน Grafana ของคุณ ที่เมนูด้านซ้าย เลือกไอคอน “Dashboards” -> “Import”
• วาง ID หรือ JSON Model ลงไป แล้วเลือก Data Source เป็น `Prometheus Local` (หรือชื่อที่คุณตั้งไว้)
• คลิก “Import” ครับ

คุณก็จะได้ Dashboard ที่สวยงามและพร้อมใช้งานได้ทันที ซึ่งคุณสามารถปรับแต่งเพิ่มเติมได้ตามความต้องการครับ

การตั้งค่า Alerting ด้วย Prometheus Alertmanager และ Grafana

การมอนิเตอร์ที่ดีไม่เพียงแค่แสดงผลข้อมูลเท่านั้น แต่ยังต้องสามารถแจ้งเตือนเมื่อเกิดเหตุการณ์ผิดปกติขึ้นได้ด้วยครับ Prometheus และ Grafana มีกลไกการ Alerting ที่ทรงพลัง ซึ่งช่วยให้คุณรับทราบปัญหาได้ทันท่วงที

การกำหนด Alerting Rules ใน Prometheus

Prometheus จะประเมิน Alerting Rules อย่างต่อเนื่อง หากเงื่อนไขของ Rule เป็นจริง จะมีการสร้าง Alert ขึ้นมาและส่งไปยัง Alertmanager ครับ

ขั้นตอนที่ 1: สร้างไฟล์ Alerting Rule

สร้างโฟลเดอร์สำหรับ Rules และสร้างไฟล์ เช่น `/etc/prometheus/rules/node_alerts.yml` ครับ

sudo mkdir /etc/prometheus/rules

ใส่เนื้อหาดังนี้ใน `/etc/prometheus/rules/node_alerts.yml` (ตัวอย่าง: แจ้งเตือนเมื่อ CPU สูงเกิน 80% หรือ Disk เหลือต่ำกว่า 10%):

groups:
  - name: node_exporter_alerts
    rules:
    - alert: HighCPULoad
      expr: 100 - (avg by (instance) (rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100) > 80
      for: 5m
      labels:
        severity: critical
      annotations:
        summary: "High CPU Load on {{ $labels.instance }}"
        description: "CPU utilization on {{ $labels.instance }} is above 80% for 5 minutes. Current value: {{ $value | humanize }}"

    - alert: LowDiskSpace
      expr: node_filesystem_avail_bytes{fstype!="rootfs", mountpoint!~"/(boot|snap)($|/.*)"} / node_filesystem_size_bytes{fstype!="rootfs", mountpoint!~"/(boot|snap)($|/.*)"} * 100 < 10
      for: 10m
      labels:
        severity: warning
      annotations:
        summary: "Low Disk Space on {{ $labels.instance }} mountpoint {{ $labels.mountpoint }}"
        description: "Disk space on {{ $labels.instance }} at mountpoint {{ $labels.mountpoint }} is less than 10%. Current value: {{ $value | humanize }}%"

คำอธิบาย:

• `alert`: ชื่อของ Alert
• `expr`: PromQL Query ที่เป็นเงื่อนไขในการ Trigger Alert
• `for`: ระยะเวลาที่เงื่อนไขต้องเป็นจริงต่อเนื่องก่อนจะ Trigger Alert เพื่อหลีกเลี่ยงการแจ้งเตือนแบบ False Positive
• `labels`: Labels เพิ่มเติมสำหรับ Alert (เช่น `severity`)
• `annotations`: ข้อมูลเพิ่มเติมเกี่ยวกับ Alert ที่จะถูกส่งไปยัง Alertmanager (เช่น `summary`, `description`)

ขั้นตอนที่ 2: เพิ่ม Rule File ใน Prometheus Configuration

แก้ไขไฟล์ `/etc/prometheus/prometheus.yml` เพื่อให้ Prometheus โหลด Rule file ที่สร้างขึ้นมาครับ

# ...
rule_files:
  - "/etc/prometheus/rules/*.yml" # หรือระบุชื่อไฟล์โดยตรง เช่น "/etc/prometheus/rules/node_alerts.yml"
# ...

ขั้นตอนที่ 3: รีสตาร์ท Prometheus Server

sudo systemctl restart prometheus

หลังจากรีสตาร์ท คุณสามารถตรวจสอบสถานะของ Rules ได้ที่ Prometheus UI (http://YOUR_SERVER_IP:9090) เลือกเมนู "Alerts" ครับ

Prometheus Alertmanager: ศูนย์กลางการจัดการ Alert

Alertmanager ทำหน้าที่รับ Alerts จาก Prometheus Server มาจัดการก่อนส่งออกไปยังผู้รับครับ คุณสมบัติหลักคือ:

• Grouping: รวม Alerts ที่คล้ายกันเข้าด้วยกันเพื่อลดการแจ้งเตือนที่ซ้ำซ้อน
• Inhibition: ระงับการแจ้งเตือนที่เกี่ยวข้องเมื่อมี Alert ที่สำคัญกว่าเกิดขึ้น (เช่น ไม่แจ้งเตือน Disk Full หาก Server Down)
• Silences: ปิดการแจ้งเตือนชั่วคราวในช่วงเวลาที่กำหนด (เช่น ช่วง Maintenance)
• Routing: กำหนดเส้นทาง Alerts ไปยังผู้รับที่แตกต่างกันตาม Label ของ Alert (เช่น Alerts ระดับ Critical ไปหาทีม SRE ผ่าน PagerDuty, Alerts ระดับ Warning ไปหา Slack Channel ทั่วไป)

การติดตั้ง Alertmanager:

ขั้นตอนที่ 1: สร้าง User และ Directory

sudo useradd --no-create-home --shell /bin/false alertmanager
sudo mkdir /etc/alertmanager
sudo mkdir /var/lib/alertmanager

ขั้นตอนที่ 2: ดาวน์โหลดและแตกไฟล์ Alertmanager

ไปที่หน้า Download ของ Prometheus เพื่อดูเวอร์ชันล่าสุดของ Alertmanager ครับ

wget https://github.com/prometheus/alertmanager/releases/download/v0.26.0/alertmanager-0.26.0.linux-amd64.tar.gz
tar -xvf alertmanager-0.26.0.linux-amd64.tar.gz
cd alertmanager-0.26.0.linux-amd64

ขั้นตอนที่ 3: คัดลอกไฟล์ไบนารีและตั้งค่าสิทธิ์

sudo cp alertmanager /usr/local/bin/
sudo cp amtool /usr/local/bin/
sudo chown alertmanager:alertmanager /usr/local/bin/alertmanager
sudo chown alertmanager:alertmanager /usr/local/bin/amtool

ขั้นตอนที่ 4: สร้างไฟล์คอนฟิก `alertmanager.yml`

สร้างไฟล์ `/etc/alertmanager/alertmanager.yml` ด้วยเนื้อหาดังนี้ (ตัวอย่าง: ส่งแจ้งเตือนผ่าน Slack)

global:
  resolve_timeout: 5m

route:
  group_by: ['alertname', 'instance']
  group_wait: 30s
  group_interval: 5m
  repeat_interval: 1h
  receiver: 'default-receiver'

receivers:
  - name: 'default-receiver'
    slack_configs:
      - channel: '#alerts-general' # เปลี่ยนเป็นชื่อ Slack Channel ของคุณ
        send_resolved: true
        api_url: 'https://hooks.slack.com/services/T00000000/B00000000/XXXXXXXXXXXXXXXXXXXXXXXX' # เปลี่ยนเป็น Slack Webhook URL ของคุณ
        title: '{{ .CommonLabels.alertname }} on {{ .CommonLabels.instance }} ({{ .Status | toUpper }})'
        text: '{{ range .Alerts }}{{ .Annotations.description }}\n{{ end }}'

# ตัวอย่างการกำหนด Receiver เพิ่มเติมสำหรับ Alerts ระดับ critical
#  - name: 'critical-pagerduty'
#    pagerduty_configs:
#      - service_key: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx'

# routes:
#   - match:
#       severity: 'critical'
#     receiver: 'critical-pagerduty'
#     continue: true

อย่าลืมตั้งค่า `api_url` สำหรับ Slack Webhook URL ของคุณครับ หากไม่มี ให้สร้างที่ Slack API

sudo chown -R alertmanager:alertmanager /etc/alertmanager/
sudo chown alertmanager:alertmanager /var/lib/alertmanager

ขั้นตอนที่ 5: สร้าง Systemd Service File

สร้างไฟล์ `/etc/systemd/system/alertmanager.service` ด้วยเนื้อหาดังนี้ครับ

[Unit]
Description=Alertmanager
Wants=network-online.target
After=network-online.target

[Service]
User=alertmanager
Group=alertmanager
Type=simple
ExecStart=/usr/local/bin/alertmanager \
    --config.file /etc/alertmanager/alertmanager.yml \
    --storage.path /var/lib/alertmanager

[Install]
WantedBy=multi-user.target

ขั้นตอนที่ 6: รีโหลด Systemd และเริ่ม Alertmanager

sudo systemctl daemon-reload
sudo systemctl start alertmanager
sudo systemctl enable alertmanager
sudo systemctl status alertmanager

Alertmanager UI จะอยู่ที่ `http://YOUR_SERVER_IP:9093` ครับ

ขั้นตอนที่ 7: เชื่อมต่อ Prometheus กับ Alertmanager

แก้ไขไฟล์ `/etc/prometheus/prometheus.yml` อีกครั้ง เพื่อเพิ่ม `alertmanagers` เข้าไปครับ

# ...
alerting:
  alertmanagers:
    - static_configs:
        - targets: ['localhost:9093'] # เปลี่ยนเป็น IP ของ Alertmanager ถ้าอยู่คนละเครื่อง
# ...

รีสตาร์ท Prometheus Server อีกครั้งครับ

sudo systemctl restart prometheus

ตอนนี้เมื่อ Alert Rules ใน Prometheus Trigger ก็จะส่ง Alert ไปยัง Alertmanager ซึ่งจะทำการ Grouping และส่ง Notification ไปยัง Slack Channel ของคุณครับ

การตั้งค่า Alerting ผ่าน Grafana

Grafana ก็มีความสามารถในการสร้าง Alert ได้โดยตรงจาก Panel บน Dashboard ครับ การ Alert จาก Grafana เหมาะสำหรับกรณีที่คุณต้องการ Alert จาก Data Source อื่นๆ ที่ไม่ใช่ Prometheus หรือต้องการเงื่อนไขการ Alert ที่ซับซ้อนกว่า Prometheus Rules ทั่วไปครับ

ข้อดีของ Grafana Alerts:

• สามารถ Alert จาก Data Source ใดก็ได้ที่ Grafana รองรับ
• เงื่อนไขการ Trigger Alert สามารถอ้างอิงจากข้อมูลที่แสดงในกราฟได้โดยตรง
• สามารถจัดการ Notification Channels ได้หลากหลาย (Email, Slack, Webhook, PagerDuty)

ขั้นตอนการสร้าง Grafana Alert:

• เปิด Dashboard และ Panel ที่คุณต้องการสร้าง Alert
• คลิกที่ชื่อ Panel แล้วเลือก "Edit"
• ไปที่แท็บ "Alert" (รูปกระดิ่ง)
• คลิก "Create alert"
• Name: ตั้งชื่อ Alert
• Evaluate every: กำหนดความถี่ในการประเมิน Alert Rule
• For: กำหนดระยะเวลาที่เงื่อนไขต้องเป็นจริงต่อเนื่อง
• Conditions: กำหนดเงื่อนไขการ Trigger Alert โดยอ้างอิงจาก Query ของ Panel นั้น ๆ เช่น `WHEN last() OF A IS ABOVE 80`
• No Data Option: กำหนดพฤติกรรมเมื่อไม่มีข้อมูล
• Notifications: เพิ่ม Notification Channel ที่ต้องการ โดยคุณสามารถตั้งค่า Channels ได้ที่ "Alerting" -> "Notification channels" ในเมนูด้านซ้ายของ Grafana ครับ
• คลิก "Save alert" ครับ

แม้ว่าทั้ง Prometheus Alertmanager และ Grafana Alerts จะสามารถแจ้งเตือนได้ แต่โดยทั่วไปแล้ว Prometheus Alertmanager เป็นทางเลือกที่แนะนำสำหรับการแจ้งเตือนที่สำคัญและเกี่ยวข้องกับ Metrics ของระบบ เพราะมีความสามารถในการ Grouping, Inhibition และ Routing ที่ซับซ้อนกว่า ซึ่งช่วยลด Alert Fatigue ได้ดีกว่าครับ Grafana Alerts มักใช้สำหรับ Dashboard-specific alerts หรือการ Alert จาก Data Source อื่นๆ ครับ

ขยายขีดความสามารถ: การมอนิเตอร์ระดับ Pro

การติดตั้ง Prometheus และ Grafana เบื้องต้นนั้นง่ายครับ แต่การจะใช้งานให้เต็มประสิทธิภาพในสภาพแวดล้อมจริงที่มีความซับซ้อน ต้องการแนวคิดและเทคนิคที่ลึกซึ้งขึ้น เรามาดูการขยายขีดความสามารถเพื่อการมอนิเตอร์ระดับ "Pro" กันครับ

Service Discovery สำหรับระบบขนาดใหญ่

ในสภาพแวดล้อมแบบ Cloud-Native หรือ Kubernetes ที่มี Service และ Instance เกิดขึ้นและหายไปตลอดเวลา การกำหนด `static_configs` ใน `prometheus.yml` เป็นเรื่องที่ไม่สามารถทำได้จริงครับ Prometheus รองรับ Service Discovery หลากหลายรูปแบบ เพื่อให้สามารถค้นหา Target ใหม่ ๆ ได้โดยอัตโนมัติครับ

• Kubernetes Service Discovery: Prometheus สามารถ Integrate กับ Kubernetes API เพื่อค้นหา Pods, Services, Endpoints และ Ingress ได้โดยอัตโนมัติครับ
• EC2 Service Discovery: สำหรับ AWS EC2 Instances, Prometheus สามารถดึงข้อมูล Instance จาก EC2 API มาเป็น Target ได้ครับ
• Consul / DNS-SD: สำหรับระบบที่ใช้ Service Registry เช่น Consul หรือ DNS-based Service Discovery

ตัวอย่าง `prometheus.yml` สำหรับ Kubernetes Service Discovery (บางส่วน):

scrape_configs:
  - job_name: 'kubernetes-nodes'
    kubernetes_sd_configs:
      - role: node
    relabel_configs:
      - source_labels: [__address__]
        regex: '(.*):10250'
        target_label: __address__
        replacement: '${1}:9100' # Scrape Node Exporter on port 9100
  - job_name: 'kubernetes-pods'
    kubernetes_sd_configs:
      - role: pod
    relabel_configs:
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_scrape]
        action: keep
        regex: true
      - source_labels: [__meta_kubernetes_pod_annotation_prometheus_io_path]
        action: replace
        target_label: __metrics_path__
        regex: (.+)
      - source_labels: [__address__, __meta_kubernetes_pod_annotation_prometheus_io_port]
        action: replace
        regex: (.+):(?:\d+);(\d+)
        replacement: ${1}:${2}
        target_label: __address__
      - action: labelmap
        regex: __meta_kubernetes_pod_label_(.+)
      - source_labels: [__meta_kubernetes_namespace]
        action: replace
        target_label: kubernetes_namespace
      - source_labels: [__meta_kubernetes_pod_name]
        action: replace
        target_label: kubernetes_pod_name

การใช้ `relabel_configs` เป็นสิ่งสำคัญมากในการปรับแต่ง Label และ Target Address ที่ได้จาก Service Discovery เพื่อให้ Prometheus Scrape ได้อย่างถูกต้องและเพื่อให้ Metrics มี Label ที่เหมาะสมสำหรับการ Query ครับ เรียนรู้เพิ่มเติมเกี่ยวกับ Service Discovery ใน Prometheus

การสร้าง Custom Exporters

Prometheus มี Exporter สำเร็จรูปมากมาย แต่บางครั้งคุณอาจมีแอปพลิเคชันหรือ Service เฉพาะทางที่ไม่สามารถหา Exporter ที่ตรงกับความต้องการได้ครับ ในกรณีนี้ คุณสามารถสร้าง Custom Exporter ของคุณเองได้

• Client Libraries: Prometheus มี Client Libraries สำหรับภาษาโปรแกรมยอดนิยม (Go, Python, Java, Ruby, Node.js) ที่ช่วยให้นักพัฒนาสามารถเพิ่ม Code เพื่อ Expose Metrics จากแอปพลิเคชันของตนเองได้โดยตรงครับ
• Textfile Collector: Node Exporter มีฟังก์ชัน `textfile` ที่ให้คุณสามารถเขียน Metrics ลงในไฟล์ข้อความ และ Node Exporter จะอ่านไฟล์นั้นและ Expose Metrics ให้ Prometheus Scrape ได้ เหมาะสำหรับ Batch Jobs หรือ Metrics ที่เปลี่ยนแปลงไม่บ่อยนักครับ

ตัวอย่าง Python Flask Custom Exporter:

from flask import Flask, Response
from prometheus_client import generate_latest, Counter, Gauge

app = Flask(__name__)

# Define Prometheus metrics
REQUEST_COUNT = Counter('app_requests_total', 'Total number of requests to the app', ['method', 'endpoint'])
IN_PROGRESS_REQUESTS = Gauge('app_requests_in_progress', 'Number of in progress requests')

@app.route('/')
def hello_world():
    REQUEST_COUNT.labels(method='GET', endpoint='/').inc()
    return 'Hello, World!'

@app.route('/metrics')
def metrics():
    return Response(generate_latest(), mimetype='text/plain')

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)

จาก Code ด้านบน เมื่อเรียก `/metrics` จะได้ Metrics ที่ Prometheus สามารถ Scrape ได้ครับ

การจัดการ Scalability และ Long-term Storage (Thanos/Cortex)

Prometheus Server โดยลำพังถูกออกแบบมาให้รันเป็น Single Instance และเก็บข้อมูลบน Local Disk ซึ่งอาจมีข้อจำกัดในเรื่องของ:

• High Availability (HA): หาก Prometheus Server ล่ม การมอนิเตอร์จะหยุดชะงัก
• Long-term Storage: เก็บข้อมูลได้จำกัดบน Local Disk
• Global View: หากมีหลาย Prometheus Server การ Query ข้อมูลจากทั้งหมดพร้อมกันเป็นเรื่องยาก

เพื่อแก้ปัญหาเหล่านี้ มีโปรเจกต์โอเพนซอร์สที่สร้างขึ้นมารอบ ๆ Prometheus:

• Thanos: ขยาย Prometheus ให้มีความสามารถในการเก็บข้อมูลระยะยาว (Long-term Storage) บน Object Storage (เช่น S3), Global Query View และ High Availability ด้วยการใช้ Sidecar และ Querier Components ครับ
• Cortex: เป็น Multi-tenant, Highly Available, Long-term Storage และ Global Query View สำหรับ Prometheus เหมาะสำหรับผู้ให้บริการ SaaS หรือองค์กรขนาดใหญ่ที่ต้องการ Centralized Monitoring ครับ

การใช้งาน Thanos หรือ Cortex จะช่วยให้คุณสามารถสร้างระบบมอนิเตอร์ที่ Scalable และ Resilient สำหรับองค์กรขนาดใหญ่ได้ครับ

แนวทางปฏิบัติที่ดีที่สุด (Best Practices)

เพื่อให้การมอนิเตอร์ด้วย Prometheus และ Grafana มีประสิทธิภาพสูงสุด ควรพิจารณาแนวทางปฏิบัติเหล่านี้ครับ

• ตั้งชื่อ Metrics และ Labels ให้ชัดเจน: ใช้ชื่อที่สื่อความหมายและ Labels ที่สอดคล้องกันทั่วทั้งระบบ เพื่อให้ง่ายต่อการ Query และทำความเข้าใจครับ
• Dashboard as Code: จัดการ Dashboard ของ Grafana ด้วย Code (JSON) และเก็บไว้ใน Version Control (Git) เพื่อให้สามารถ Track การเปลี่ยนแปลง, Review และ Deploy ได้อย่างอัตโนมัติครับ
• Alert Fatigue Management:
  • ตั้งค่า `for` ใน Alert Rules ให้เหมาะสม เพื่อลด False Positive
  • ใช้ Grouping และ Inhibition ของ Alertmanager อย่างชาญฉลาด
  • กำหนด Severity ของ Alert ให้ชัดเจน และ Route ไปยังผู้รับที่เหมาะสม
  • สร้าง Dashboard สำหรับ "Alerts Overview" เพื่อให้เห็นภาพรวมของ Alert ที่กำลังทำงานอยู่
• Capacity Planning: มอนิเตอร์ทรัพยากรของ Prometheus Server เองด้วย (เช่น `prometheus_tsdb_head_chunks_created_total`, `prometheus_tsdb_compaction_duration_seconds_sum`) เพื่อให้แน่ใจว่ามันสามารถรองรับ Workload ได้ครับ
• Security: จำกัดการเข้าถึงพอร์ต `9090` (Prometheus UI) และ `3000` (Grafana UI) ด้วย Firewall หรือ Reverse Proxy ที่มี Authentication ครับ

เปรียบเทียบ Prometheus/Grafana กับเครื่องมืออื่น ๆ

เพื่อให้เห็นภาพชัดเจนขึ้น เรามาเปรียบเทียบ Prometheus/Grafana กับเครื่องมือมอนิเตอร์ยอดนิยมอื่น ๆ กันครับ

จากตารางเปรียบเทียบ จะเห็นว่า Prometheus/Grafana โดดเด่นอย่างมากในด้านการจัดการ Metrics และการแสดงผลข้อมูลแบบ Time-series โดยเฉพาะในสภาพแวดล้อมแบบ Cloud-Native ที่มีการเปลี่ยนแปลงอยู่ตลอดเวลาครับ ในขณะที่ Zabbix และ Nagios ยังคงเป็นตัวเลือกที่ดีสำหรับระบบที่ Static กว่า และ ELK Stack เป็นผู้นำด้าน Log Management ครับ การเลือกเครื่องมือที่เหมาะสมขึ้นอยู่กับความต้องการและสถาปัตยกรรมของระบบของคุณเป็นหลักครับ

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

1. Prometheus และ Grafana ต่างกันอย่างไรครับ?

Prometheus ทำหน้าที่เป็นระบบเก็บข้อมูล Metrics แบบ Time-series โดยจะดึง (scrape) ข้อมูลจาก Service ต่าง ๆ และเก็บไว้ในฐานข้อมูลของตัวเอง รวมถึงมีภาษา Query ที่ชื่อ PromQL สำหรับดึงข้อมูลครับ ส่วน Grafana เป็นเครื่องมือสำหรับการแสดงผลข้อมูล (visualization) ครับ มันไม่ได้เก็บข้อมูลเอง แต่จะไปดึงข้อมูลจาก Data Source ต่าง ๆ (เช่น Prometheus) มาสร้างเป็น Dashboard ที่สวยงามและเข้าใจง่ายครับ โดยสรุปคือ Prometheus เก็บข้อมูล ส่วน Grafana แสดงผลข้อมูลที่ Prometheus เก็บไว้ครับ

2. จำเป็นต้องใช้ Prometheus คู่กับ Grafana เสมอไปไหมครับ?

ไม่จำเป็นต้องเสมอไปครับ Prometheus มี UI ของตัวเองที่สามารถใช้ Query ข้อมูลและดู Graph พื้นฐานได้ แต่ UI ของ Prometheus มีข้อจำกัดในการสร้าง Dashboard ที่ซับซ้อนและสวยงามครับ Grafana จึงเป็นที่นิยมอย่างมากในการนำมาใช้คู่กับ Prometheus เพื่อยกระดับความสามารถในการแสดงผลและวิเคราะห์ข้อมูลให้ดียิ่งขึ้นครับ การใช้ร่วมกันจะทำให้การมอนิเตอร์มีประสิทธิภาพและใช้งานง่ายขึ้นมากครับ

3. Prometheus เหมาะสำหรับมอนิเตอร์ Log ด้วยหรือไม่ครับ?

Prometheus ไม่ได้ถูกออกแบบมาสำหรับการมอนิเตอร์ Log โดยตรงครับ Prometheus เน้นที่การเก็บข้อมูล Metrics ซึ่งเป็นตัวเลขเชิงปริมาณที่เปลี่ยนแปลงตามเวลา (เช่น CPU Usage, จำนวน Request) ในขณะที่ Log เป็นข้อมูลแบบ Text ที่บันทึกเหตุการณ์ต่าง ๆ ครับ สำหรับ Log Management เครื่องมืออย่าง ELK Stack (Elasticsearch, Logstash, Kibana), Loki (สำหรับ Kubernetes logs), หรือ Splunk จะเหมาะสมกว่าครับ อย่างไรก็ตาม Prometheus สามารถเก็บ Metrics ที่ได้จากการ Parse Log ได้บ้าง แต่ไม่ใช่จุดแข็งหลักของมันครับ

4. การใช้ Prometheus/Grafana มีค่าใช้จ่ายอะไรบ้างครับ?

Prometheus และ Grafana ทั้งคู่เป็นโอเพนซอร์ส (Open Source) ครับ ดังนั้นไม่มีค่าใช้จ่ายในการใช้งานซอฟต์แวร์โดยตรงครับ ค่าใช้จ่ายหลัก ๆ ที่อาจเกิดขึ้นคือค่าใช้จ่ายสำหรับ Server หรือ Cloud Resources ที่ใช้ในการรัน Prometheus Server, Grafana Server และ Exporters ต่าง ๆ ครับ นอกจากนี้ หากคุณต้องการฟีเจอร์ระดับ Enterprise เพิ่มเติม Grafana ก็มีเวอร์ชัน Enterprise ที่มีค่าใช้จ่าย แต่สำหรับองค์กรส่วนใหญ่ เวอร์ชันโอเพนซอร์สก็เพียงพอต่อความต้องการแล้วครับ

5. Prometheus รองรับ High Availability (HA) และ Long-term Storage ได้อย่างไรครับ?

Prometheus Server โดยตัวมันเองไม่ได้รองรับ High Availability หรือ Long-term Storage แบบ Out-of-the-box ครับ มันถูกออกแบบมาให้เก็บข้อมูลบน Local Disk และรันแบบ Single Instance ครับ อย่างไรก็ตาม มีโปรเจกต์เสริมที่พัฒนาขึ้นมาเพื่อแก้ข้อจำกัดเหล่านี้ เช่น Thanos และ Cortex ครับ

• Thanos: ช่วยให้ Prometheus สามารถเก็บข้อมูลระยะยาวบน Object Storage (เช่น S3) และรวมข้อมูลจาก Prometheus Server หลาย ๆ ตัวเข้าด้วยกันเพื่อให้มี Global Query View รวมถึงรองรับ HA ได้ครับ
• Cortex: เป็นอีกทางเลือกหนึ่งที่ให้ความสามารถคล้ายกัน แต่ถูกออกแบบมาสำหรับ Multi-tenant และ Centralized Monitoring ในขนาดใหญ่ครับ

การใช้เครื่องมือเหล่านี้จะช่วยให้คุณสร้างระบบมอนิเตอร์ด้วย Prometheus ที่มีความทนทานต่อความผิดพลาดและสามารถเก็บข้อมูลได้ยาวนานขึ้นครับ

6. ถ้า Service หรือแอปพลิเคชันของผมไม่มี Exporter สำเร็จรูป จะมอนิเตอร์ด้วย Prometheus ได้อย่างไรครับ?

หากไม่มี Exporter สำเร็จรูปสำหรับ Service หรือแอปพลิเคชันของคุณ คุณมีหลายทางเลือกครับ:

• สร้าง Custom Exporter: คุณสามารถใช้ Prometheus Client Libraries (ที่มีให้เลือกหลายภาษา เช่น Go, Python, Java) เพื่อเพิ่ม Code ลงในแอปพลิเคชันของคุณโดยตรง เพื่อให้แอปพลิเคชัน Expose Metrics ในรูปแบบที่ Prometheus เข้าใจครับ
• ใช้ Pushgateway: สำหรับ Short-lived Jobs หรือ Batch Jobs ที่ไม่ได้รันตลอดเวลา คุณสามารถใช้ Pushgateway เป็นตัวกลางให้ Jobs เหล่านั้น Push Metrics เข้ามาเก็บชั่วคราว และ Prometheus จะมา Scrape จาก Pushgateway ครับ
• ใช้ Textfile Collector ของ Node Exporter: หากเป็น Metrics ที่เปลี่ยนแปลงไม่บ่อยนัก คุณสามารถเขียน Script ให้สร้างไฟล์ Text ที่มี Metrics ในรูปแบบ Prometheus และ Node Exporter จะอ่านไฟล์นั้นและ Expose Metrics ให้ Prometheus ครับ

ทางเลือกเหล่านี้ช่วยให้คุณสามารถมอนิเตอร์แอปพลิเคชันหรือ Service ใด ๆ ก็ตามด้วย Prometheus ได้อย่างยืดหยุ่นครับ

สรุปและ Call to Action

การมอนิเตอร์ระบบด้วย Prometheus และ Grafana ไม่ใช่แค่การรวบรวมข้อมูลเท่านั้นครับ แต่เป็นการปลดล็อกความสามารถในการทำความเข้าใจพฤติกรรมของระบบอย่างลึกซึ้ง คาดการณ์ปัญหา และตอบสนองต่อเหตุการณ์ได้อย่างรวดเร็ว ซึ่งเป็นสิ่งจำเป็นอย่างยิ่งในยุคที่ระบบโครงสร้างพื้นฐานมีความซับซ้อนและเปลี่ยนแปลงอยู่ตลอดเวลา การนำสองเครื่องมือโอเพนซอร์สที่ทรงพลังนี้มาใช้ร่วมกัน จะช่วยให้คุณยกระดับการมอนิเตอร์จากระดับพื้นฐานไปสู่ระดับ "Pro" ได้อย่างแท้จริงครับ

ไม่ว่าคุณจะเป็น DevOps Engineer, SRE, System Administrator หรือ Developer การเรียนรู้และประยุกต์ใช้ Prometheus และ Grafana จะเป็นทักษะที่ประเมินค่าไม่ได้ในการดูแลรักษาระบบให้มีประสิทธิภาพและความพร้อมใช้งานสูงสุดครับ ระบบที่เสถียรย่อมนำมาซึ่งความเชื่อมั่นของลูกค้าและลดความเสี่ยงทางธุรกิจได้อย่างมหาศาลครับ

หากคุณพร้อมที่จะยกระดับการมอนิเตอร์ระบบเซิร์ฟเวอร์ของคุณให้เป็นระดับมืออาชีพ หรือต้องการความช่วยเหลือในการออกแบบและติดตั้งระบบ Prometheus และ Grafana สำหรับองค์กรของคุณ ทีมผู้เชี่ยวชาญจาก SiamLancard.com ยินดีให้คำปรึกษาและบริการอย่างครบวงจรครับ เรามีประสบการณ์และความเชี่ยวชาญในการวางแผน, ติดตั้ง, ตั้งค่า และ Optimize ระบบ