การติดตั้งระบบมอนิเตอร์ Grafana + Prometheus บน VPS ของคุณ (คู่มือ Docker Compose)

หากคุณยังไม่แน่ใจว่า Prometheus และ Grafana คืออะไร ลองอ่านบทความของเราเรื่อง Prometheus เทียบกับ Grafana. แต่ถ้าคุณรู้ความแตกต่างอยู่แล้ว นี่คือวิธีรันทั้งสองตัวร่วมกัน

บทความนี้คือภาคปฏิบัติ โดยจะติดตั้ง Prometheus, Grafana และ Node Exporter บน VPS เครื่องเดียวด้วย Docker Compose วาง HTTPS ไว้หน้า Grafana ด้วย Caddy นำเข้าแดชบอร์ด Node Exporter Full (ID 1860) และแสดงวิธีดึงเมตริกจาก VPS เครื่องที่สองผ่าน WireGuard

การทดสอบครั้งแรกเมื่อเดือนเมษายน 2026 รันบน Ubuntu 24.04 LTS ด้วย Docker Engine 27.x และ Docker Compose v2.30 ส่วนเวอร์ชันที่ระบุไว้ในคอนฟิกด้านล่างได้รับการอัปเดตเป็นรุ่นที่รองรับในปัจจุบันแล้ว ในการทดสอบครั้งแรกที่มีห้าโฮสต์นั้น เครื่องฮับใช้ RAM ประมาณ 300 MB ขณะว่าง และ 530 ถึง 650 MB ขณะเก็บเมตริกต่อเนื่อง

TL;DR (สรุปย่อ)

• VPS ที่เป็นฮับจะรัน Prometheus, Grafana และ Node Exporter ในสแตก Compose เดียว โดยติดตั้ง Caddy ไว้บนโฮสต์เพื่อทำหน้าที่รีเวิร์สพร็อกซี
• Prometheus และ Grafana จะผูกกับ 127.0.0.1 เท่านั้น ส่วนการเข้าถึงจากภายนอกจะผ่าน Caddy ที่เปิด HTTPS อัตโนมัติ
• เพิ่มเซิร์ฟเวอร์ได้โดยติดตั้ง Node Exporter บนแต่ละเครื่อง แล้วเพิ่มรายการเข้าไปในไฟล์ prometheus.yml.
• WireGuard คือเส้นทางเครือข่ายที่แนะนำระหว่างฮับกับเครื่องปลายทาง ส่วนเครือข่ายส่วนตัวก็ใช้ได้ดีหากเซิร์ฟเวอร์ของคุณอยู่ในเครือข่ายส่วนตัวเดียวกันอยู่แล้ว
• VPS ขนาด 2 GB เพียงพอสำหรับการทดสอบห้าโฮสต์ด้านล่าง แต่ให้ถือว่าเป็นค่าอ้างอิงเริ่มต้น ไม่ใช่กฎตายตัวตามจำนวนโฮสต์

สิ่งที่คุณจะสร้าง

นี่คือภาพคร่าว ๆ ว่าระบบจะมีหน้าตาอย่างไรเมื่อคุณติดตั้งเสร็จ

                 +-------------------+
                 |  Your laptop      |
                 +---------+---------+
                           | HTTPS
                           v
+--------------------------+----------------------------+
| MONITORING HUB VPS    (2 GB RAM starting point) |
|  Caddy        (reverse proxy, auto HTTPS)             |
|  Grafana      (port 3000, only via Caddy)             |
|  Prometheus   (port 9090, internal only)              |
|  Node Exporter (port 9100, scraped on localhost)      |
+----+---------------------------------+----------------+
     |                                 |
     | scrape over WireGuard           | scrape over WG
     v                                 v
+----+--------+                  +-----+-------+
|  App VPS 1  |                  |  App VPS 2  |
|  Node Expo. |                  |  Node Expo. |
+-------------+                  +-------------+

VPS ฮับเพียงเครื่องเดียวเก็บระบบมอนิเตอร์ทั้งหมดไว้ ส่วน VPS เครื่องอื่นที่คุณต้องการเฝ้าดูจะรันแค่ Node Exporter เท่านั้น Prometheus บนฮับจะดึงเมตริกจากแต่ละเครื่อง Grafana นำมาแสดงผล และ Caddy จัดการเรื่อง HTTPS

สิ่งที่คุณต้องเตรียม

สำหรับการติดตั้งแบบนี้ คุณต้องมี VPS ที่รัน Ubuntu หนึ่งเครื่องสำหรับเป็นฮับ โดเมนหนึ่งชื่อ และสิทธิ์ sudo

• VPS ที่มี RAM อย่างน้อย 2 GB และรัน Ubuntu 24.04 LTS
• ชื่อโดเมนที่มีเรคคอร์ด A ชี้ไปยัง IP สาธารณะของ VPS (เช่น grafana.example.com) ซึ่งจำเป็นสำหรับ HTTPS
• สิทธิ์ root หรือ sudo ผ่าน SSH

ตลอดคู่มือนี้ ให้แทนที่ grafana.example.com ด้วยซับโดเมนจริงที่คุณชี้มายัง VPS สำหรับมอนิเตอร์ และใช้โดเมนเดียวกันนี้ทั้งในตัวแปรสภาพแวดล้อมของ Grafana การตรวจสอบ DNS และไฟล์ Caddyfile

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

ขั้นตอนที่ 1: เตรียมเซิร์ฟเวอร์

SSH เข้าไปยัง VPS ฮับด้วยผู้ใช้ที่มีสิทธิ์ sudo แล้วอัปเดตระบบก่อนเป็นอันดับแรก

sudo apt update && sudo apt upgrade -y

ติดตั้ง Docker Engine และปลั๊กอิน Compose จากรีโพซิทอรีอย่างเป็นทางการของ Docker

# Install prerequisites
sudo apt install -y ca-certificates curl gnupg lsb-release

# Add Docker's official GPG key
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | \
  sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg

# Add the Docker repository
echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] \
  https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | \
  sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

ตรวจสอบว่าติดตั้งทั้งสองอย่างเรียบร้อยแล้ว

docker --version
docker compose version

ทั้งสองคำสั่งควรแสดงเลขเวอร์ชันออกมาได้สำเร็จ ส่วนเวอร์ชันที่แน่นอนของ Docker Engine และ Compose จะขึ้นอยู่กับสิ่งที่รีโพซิทอรีอย่างเป็นทางการให้มา ณ ตอนที่คุณติดตั้ง

sudo usermod -aG docker $USER

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

ตั้งค่า UFW ให้อนุญาต SSH, HTTP และ HTTPS บนเครื่องฮับ พอร์ต 80 ใช้สำหรับเปลี่ยนเส้นทางจาก HTTP ไป HTTPS และการยืนยันแบบ ACME ส่วนตัว Grafana เองยังคงอยู่หลัง Caddy

sudo ufw allow OpenSSH
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw enable
sudo ufw status

อย่าเปิดพอร์ต 3000, 9090 หรือ 9100 ออกสู่อินเทอร์เน็ตสาธารณะ การที่บริการมอนิเตอร์ฟังอยู่บน 127.0.0.1 นั้นมีเหตุผล

ขั้นตอนที่ 2: สแตก Compose

สร้างไดเรกทอรีสำหรับสแตกและไฟล์คอนฟิกของ Prometheus

mkdir -p ~/monitoring/prometheus
cd ~/monitoring

เขียนไฟล์ Compose

# ~/monitoring/docker-compose.yml
services:
  prometheus:
    image: prom/prometheus:v3.13.2
    container_name: prometheus
    restart: unless-stopped
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--storage.tsdb.retention.time=15d'
      - '--web.enable-lifecycle'
      - '--web.listen-address=127.0.0.1:9090'
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
      - prometheus_data:/prometheus
    network_mode: host
  node-exporter:
    image: prom/node-exporter:v1.12.1
    container_name: node-exporter
    restart: unless-stopped
    pid: host
    network_mode: host
    command:
      - '--path.rootfs=/host'
      - '--web.listen-address=127.0.0.1:9100'
      - '--collector.filesystem.mount-points-exclude=^/(dev|proc|sys|var/lib/docker/.+|var/lib/kubelet/.+)($$|/)'
    volumes:
      - '/:/host:ro,rslave'
  grafana:
    image: grafana/grafana:13.1.3
    container_name: grafana
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=${GRAFANA_ADMIN_PASSWORD}
      - GF_USERS_ALLOW_SIGN_UP=false
      - GF_SERVER_ROOT_URL=https://grafana.example.com
      - GF_SERVER_HTTP_ADDR=127.0.0.1
    volumes:
      - grafana_data:/var/lib/grafana
    network_mode: host
    depends_on:
      - prometheus
volumes:
  prometheus_data:
  grafana_data:

ต่อไปให้เขียนไฟล์คอนฟิกของ Prometheus

# ~/monitoring/prometheus/prometheus.yml
global:
  scrape_interval: 15s
  evaluation_interval: 15s
  external_labels:
    monitor: 'monitoring-hub'
scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['127.0.0.1:9090']
  - job_name: 'node'
    static_configs:
      - targets: ['127.0.0.1:9100']
        labels:
          host: 'monitoring-hub'

สร้างไฟล์ .env ที่เก็บรหัสผ่านผู้ดูแลระบบของ Grafana ใช้รหัสผ่านที่คาดเดายาก และอย่า commit ไฟล์นี้เข้า git

cat > ~/monitoring/.env <<'EOF'
GRAFANA_ADMIN_PASSWORD='replace-with-a-strong-password'
EOF
chmod 600 ~/monitoring/.env

มีบางแฟล็กด้านบนที่ควรอธิบายสักหน่อย

• --web.listen-address=127.0.0.1:9090 ทำให้ Prometheus ฟังเฉพาะบนอินเทอร์เฟซ loopback ของโฮสต์ ซึ่งทำให้พอร์ต 9090 อยู่นอกเครือข่ายสาธารณะ แต่ Grafana และการดูแลระบบในเครื่องยังเข้าถึงได้
• --web.enable-lifecycle จะเปิดใช้งาน POST /-/reload ทำให้คุณนำการเปลี่ยนแปลงคอนฟิกของ Prometheus ไปใช้ได้โดยไม่ต้องรีสตาร์ตคอนเทนเนอร์
• pid: host, network_mode: host การ bind mount รากของโฮสต์ และ --path.rootfs=/host จะให้ Node Exporter ที่รันในคอนเทนเนอร์เห็นบริบทของโฮสต์ตามที่ต้องการ แทนที่จะมอนิเตอร์แค่สภาพแวดล้อมในคอนเทนเนอร์ของตัวเอง
• GF_USERS_ALLOW_SIGN_UP=false จะป้องกันไม่ให้ผู้เข้าชมสมัครบัญชี Grafana เอง แต่ไม่ได้ทำให้ Grafana เป็นระบบปิด หน้าเข้าสู่ระบบยังคงเข้าถึงได้จากภายนอกผ่าน Caddy

เคล็ดลับ: หากคุณอยากข้ามการติดตั้งด้วยมือ Cloudzy มีการติดตั้งแบบคลิกเดียวสำหรับ Grafana และ Prometheus การติดตั้ง Prometheus ยังสามารถติดตั้ง Node Exporter ให้ด้วยได้

ขั้นตอนที่ 3: เริ่มรันครั้งแรกและตรวจสอบ

สั่งให้สแตกทำงาน

cd ~/monitoring
docker compose up -d

รอสักครู่ แล้วตรวจสอบว่าคอนเทนเนอร์ทั้งสามตัวกำลังทำงานอยู่

docker compose ps

บริการทั้งสามควรแสดงสถานะกำลังทำงาน

เปิดอุโมงค์ SSH จากเครื่องแล็ปท็อปของคุณเพื่อตรวจสอบหน้า targets ของ Prometheus

ssh -L 9090:localhost:9090 your-user@your-vps-ip

จากนั้นเปิด http://localhost:9090/targets ในเบราว์เซอร์ คุณควรเห็นเป้าหมายสองรายการที่มีสถานะ UP ทั้งคู่:

prometheus            UP    http://127.0.0.1:9090/metrics
node                  UP    http://127.0.0.1:9100/metrics

หากมีตัวใดขึ้นสถานะ DOWN ให้ข้ามไปที่หัวข้อปัญหาที่พบบ่อย และอย่าเพิ่งทำขั้นตอนถัดไปจนกว่าทั้งสองจะเป็น UP

ปิดอุโมงค์เมื่อตรวจสอบเป้าหมายเสร็จแล้ว จากภายนอก VPS นั้น Prometheus จะเข้าถึงได้ผ่านอุโมงค์ SSH นี้เท่านั้น ส่วนขั้นตอนถัดไปจะเปิด Grafana ผ่าน HTTPS

ขั้นตอนที่ 4: รีเวิร์สพร็อกซีพร้อม HTTPS ด้วย Caddy

Caddy เป็นไบนารีไฟล์เดียวและจัดการ HTTPS ให้อัตโนมัติ สำหรับรีเวิร์สพร็อกซีที่มีเว็บไซต์เดียว คอนฟิกของมันสั้นกว่าบล็อกของ Nginx ที่ทำงานเทียบเท่ากัน

ติดตั้ง Caddy จากรีโพซิทอรีอย่างเป็นทางการ

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | \
  sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | \
  sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo chmod o+r /usr/share/keyrings/caddy-stable-archive-keyring.gpg
sudo chmod o+r /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install -y caddy

ก่อนไปขั้นตอนถัดไป ให้ยืนยันว่าเรคคอร์ด DNS แบบ A ของ grafana.example.com ชี้ไปยัง IP สาธารณะของ VPS แล้ว มิฉะนั้นการยืนยันแบบ ACME จะล้มเหลว

dig +short grafana.example.com
# Should print the VPS public IP

แก้ไขไฟล์ Caddyfile

# /etc/caddy/Caddyfile
grafana.example.com {
    reverse_proxy 127.0.0.1:3000
    encode gzip
}

รีโหลด Caddy

sudo systemctl reload caddy

เมื่อโดเมนชี้มายังเซิร์ฟเวอร์ของคุณและพอร์ต 80 กับ 443 เข้าถึงได้แล้ว Caddy จะขอและต่ออายุใบรับรอง TLS ที่เชื่อถือได้แบบสาธารณะผ่าน ACME ให้อัตโนมัติ ลองเปิด https://grafana.example.com ในเบราว์เซอร์ คุณควรเห็นหน้าเข้าสู่ระบบของ Grafana บนการเชื่อมต่อ HTTPS ที่ถูกต้อง จากนั้นเข้าสู่ระบบด้วยผู้ใช้ admin และรหัสผ่านจากไฟล์ .env ของคุณ

ขั้นตอนที่ 5: เพิ่ม Prometheus เป็นแหล่งข้อมูลและนำเข้าแดชบอร์ด 1860

ในหน้าจอ Grafana ให้ไปที่ การเชื่อมต่อ > แหล่งข้อมูล > เพิ่มแหล่งข้อมูล แล้วเลือก Prometheus.

ตั้งค่า URL เป็น:

http://127.0.0.1:9090

ในการติดตั้งแบบนี้ Grafana และ Prometheus ใช้เครือข่ายของโฮสต์ร่วมกัน ขณะที่ Prometheus ฟังเฉพาะบน loopback เท่านั้น จากนั้นคลิก Save & test แล้วยืนยันว่า Grafana เรียกใช้ API ของ Prometheus ได้ คุณควรเห็นข้อความ "Successfully queried the Prometheus API"

ตอนนี้มานำเข้าแดชบอร์ดกัน Node Exporter Full (ID 1860 โดย rfmoz) เป็นแดชบอร์ดจากชุมชนที่นิยมใช้กันมากสำหรับเมตริกของ Node Exporter ครอบคลุมทั้ง CPU หน่วยความจำ ดิสก์ I/O เครือข่าย file descriptor และอุณหภูมิฮาร์ดแวร์ในกรณีที่โฮสต์เปิดเผยข้อมูลนั้น อีกทั้งยังมีตัวแปรสำหรับ job และ instance จึงใช้กับรูปแบบฮับและสโป๊กได้เลยโดยไม่ต้องแก้อะไร

ไปที่ แดชบอร์ด > ใหม่ > นำเข้าแดชบอร์ด ใส่รหัสแดชบอร์ด 1860 เลือกแหล่งข้อมูล Prometheus ของคุณ แล้วสั่งนำเข้า

แดชบอร์ดควรเริ่มมีข้อมูลทันทีที่เป้าหมาย Node Exporter ของคุณอยู่ในสถานะ UP ทั้งนี้แดชบอร์ด 1860 ยังใช้เมตริกจากคอลเลกเตอร์เสริมอย่าง systemd และ processes ในบางแผงด้วย ดังนั้นการที่แผงใดแผงหนึ่งว่างเปล่าจึงไม่ได้แปลว่าเป้าหมายมีปัญหาเสมอไป

ขั้นตอนที่ 6: เพิ่ม VPS เครื่องที่สอง (รูปแบบฮับและสโป๊ก)

ก่อนเริ่มรัน Node Exporter ให้แน่ใจว่า IP ส่วนตัวที่คุณจะผูกไว้นั้นมีอยู่บน VPS เครื่องที่สองแล้วจริง ๆ หากคุณใช้ WireGuard ให้ตั้งค่า WireGuard ให้เสร็จก่อน

บน VPS เครื่องที่สอง ให้ติดตั้ง Docker โดยทำตามส่วนติดตั้ง Docker ในขั้นตอนที่ 1 แต่อย่าเปิดพอร์ต 80 หรือ 443 เพียงเพื่อการมอนิเตอร์ จากนั้นรันเฉพาะ Node Exporter

mkdir -p ~/node-exporter
cd ~/node-exporter

cat > docker-compose.yml <<'EOF'
services:
  node-exporter:
    image: prom/node-exporter:v1.12.1
    container_name: node-exporter
    restart: unless-stopped
    pid: host
    command:
      - '--path.rootfs=/host'
      - '--web.listen-address=10.10.0.2:9100'  # bind to the private monitoring IP, never 0.0.0.0
    volumes:
      - '/:/host:ro,rslave'
    network_mode: host
EOF

docker compose up -d

แทนที่ 10.10.0.2 ด้วย IP ส่วนตัวสำหรับมอนิเตอร์ของเซิร์ฟเวอร์เครื่องนี้ หากคุณใช้ WireGuard ให้ใช้ IP ของ WireGuard และหากใช้เครือข่ายส่วนตัวของ Cloudzy ให้ใช้ IP ของอินเทอร์เฟซส่วนตัวของ VPS หาก UFW เปิดใช้งานอยู่แล้วบน VPS เครื่องนี้ ให้อนุญาตเฉพาะเครื่องฮับเท่านั้นที่เข้าถึง Node Exporter ได้ ตัวอย่างเช่น หาก IP ส่วนตัวของฮับคือ 10.10.0.1:

sudo ufw allow proto tcp from 10.10.0.1 to any port 9100
sudo ufw status

แทนที่ 10.10.0.1 ด้วย IP ส่วนตัวจริงของเครื่องฮับ หาก UFW ไม่ได้เปิดใช้งาน การระบุ --web.listen-address ยังคงทำให้ Node Exporter ไม่อยู่บนอินเทอร์เฟซสาธารณะ แต่เครื่องอื่นที่เข้าถึงเครือข่ายส่วนตัวนั้นได้ก็อาจเข้าถึงพอร์ต 9100 ได้เช่นกัน

สองทางเลือกที่ดีสำหรับเส้นทางเครือข่ายระหว่างฮับกับเครื่องปลายทาง:

1. เครือข่าย WireGuard ให้ VPS ทุกเครื่องเข้าร่วมเครือข่าย WireGuard แล้ว Prometheus ก็ดึงเมตริกผ่าน IP ส่วนตัว นี่คือทางเลือกที่ปลอดภัยที่สุดหลังจากตั้งค่า WireGuard ครั้งแรกเสร็จ เรามีบริการ WireGuard แบบติดตั้งคลิกเดียว และยังมี บทแนะนำการติดตั้ง สำหรับเรื่องนี้อยู่แล้ว
2. เครือข่ายส่วนตัวของ Cloudzy อินสแตนซ์ VPS ของ Cloudzy ที่อยู่ในภูมิภาคเดียวกันจะได้อินเทอร์เฟซส่วนตัวสำหรับทราฟฟิกระหว่างเซิร์ฟเวอร์ ดังนั้นคุณจึงดึงเมตริกจากที่อยู่นั้นได้เลยโดยไม่ต้องสร้างอุโมงค์ WireGuard แยกต่างหาก

อ่าน

วิธีติดตั้ง WireGuard VPN บน VPS | คู่มือ Ubuntu

เมื่อ Node Exporter ทำงานอยู่บน VPS เครื่องที่สองและเข้าถึงได้ผ่าน IP ส่วนตัวแล้ว ให้แทนที่ job ชื่อ node เดิมในไฟล์ prometheus.yml บนเครื่องฮับ ด้วยบล็อกด้านล่างนี้

# Update the existing 'node' job in ~/monitoring/prometheus/prometheus.yml
  - job_name: 'node'
    static_configs:
      - targets: ['127.0.0.1:9100']
        labels:
          host: 'monitoring-hub'
      - targets: ['10.10.0.2:9100']
        labels:
          host: 'app-vps-1'
          tier: 'production'

รีโหลด Prometheus โดยไม่ต้องรีสตาร์ตคอนเทนเนอร์

curl -X POST http://localhost:9090/-/reload

เปิดอุโมงค์ SSH จากขั้นตอนที่ 3 อีกครั้ง แล้วเข้าไปที่ http://localhost:9090/targets เป้าหมายใหม่ควรแสดงสถานะ UP จากนั้นเปิดแดชบอร์ด Node Exporter Full เปลี่ยนตัวแปร instance ด้านบนให้เป็นเซิร์ฟเวอร์เครื่องใหม่ แล้วคุณก็จะเห็นกราฟของเครื่องนั้น

การใช้ทรัพยากรและควรอัปเกรดเมื่อใด

ตัวเลขเหล่านี้มาจากการทดสอบครั้งแรกเมื่อเดือนเมษายน 2026 บน VPS ที่รัน Ubuntu ขนาด 2 GB และมอนิเตอร์อยู่ห้าโฮสต์ ให้ถือเป็นค่าอ้างอิงสำหรับภาระงานลักษณะนี้ ไม่ใช่การรับประกันขนาดเครื่องสำหรับเวอร์ชันที่ใหม่กว่า

ควรอัปเกรดเมื่อเครื่องฮับเริ่มมีหน่วยความจำหรือพื้นที่ดิสก์เหลือน้อย การดูแค่จำนวนโฮสต์เป็นเกณฑ์ที่ไม่ดีนัก เพราะจำนวนซีรีส์ คอลเลกเตอร์ที่เปิดใช้ ช่วงเวลาการเก็บ และระยะเวลาที่เก็บข้อมูล ล้วนทำให้การใช้ทรัพยากรเปลี่ยนไป หากต้องการเก็บข้อมูลรวมศูนย์ในระยะยาว Prometheus รองรับการเชื่อมต่อกับที่จัดเก็บระยะไกล และ VictoriaMetrics ก็เป็นหนึ่งในตัวเลือกที่เข้ากันได้กับ Prometheus

ปัญหาที่พบบ่อย

เจ็ดปัญหาที่พบบ่อยที่สุด พร้อมวิธีแก้

1. Prometheus เข้าถึงได้จากอินเทอร์เน็ตสาธารณะ การแมปพอร์ตแบบ 9090:9090 ตรง ๆ จะทำให้ Prometheus เปิดสู่คนทั้งโลก วิธีแก้คือคงค่า --web.listen-address=127.0.0.1:9090 ไว้ในคำสั่งของ Prometheus ตามที่แสดงไว้ด้านบน ซึ่งจะทำให้ Prometheus ฟังเฉพาะบนอินเทอร์เฟซ loopback ของโฮสต์เท่านั้น
2. แหล่งข้อมูลใน Grafana ติดต่อ Prometheus ไม่ได้ สแตกนี้ใช้เครือข่ายของโฮสต์ ดังนั้น Grafana จึงติดต่อ Prometheus ได้ที่ http://127.0.0.1:9090 ให้ตรวจสอบว่า Prometheus ยังทำงานอยู่และยังฟังบน loopback
3. แดชบอร์ด Node Exporter ขึ้นว่า "No data" มีสาเหตุที่พบบ่อยสามอย่าง (ก) Prometheus ไม่ได้ดึงข้อมูลจากเป้าหมาย ให้ตรวจสอบที่ /targets (ข) ป้าย job ในตัวแปรของแดชบอร์ดไม่ตรงกับ job_name ในคอนฟิกการดึงข้อมูล (ค) ไฟร์วอลล์บล็อกพอร์ต 9100 ระหว่างฮับกับเป้าหมาย
4. รหัสผ่านผู้ดูแลระบบของ Grafana ยังเป็น admin/admin อยู่ในระบบที่ใช้งานจริง ตั้งค่า GF_SECURITY_ADMIN_PASSWORD จากไฟล์ .env ก่อนเริ่มรันครั้งแรก หากพลาดไปแล้ว ให้เปลี่ยนรหัสผ่านตอนเข้าสู่ระบบครั้งแรกและปิดการสมัครสมาชิก
5. Caddy แจ้งว่า "ACME challenge failed" เรคคอร์ด DNS แบบ A ยังกระจายไม่ทั่ว หรือพอร์ต 80 ถูกบล็อก ให้รัน ufw allow 80,443/tcp รอให้ DNS กระจายเสร็จ แล้วรัน sudo systemctl reload caddy และใช้ dig +short เพื่อยืนยันว่ากระจายเรียบร้อยแล้ว
6. ดิสก์ของ Prometheus เต็ม ป้ายกำกับที่มีความหลากหลายสูง หรือช่วงเวลาการดึงข้อมูลที่สั้นเกินไปเมื่อมีโฮสต์จำนวนมาก อาจทำให้พื้นที่เต็มได้เร็ว ให้คอยจับตาดู prometheus_tsdb_head_series และขนาดของวอลุ่ม วิธีบรรเทาคือ ปิดคอลเลกเตอร์ของ Node Exporter ที่ไม่ได้ใช้ ขยาย scrape_interval เป็น 30s หรือลดระยะเวลาเก็บข้อมูลลง
7. ข้อผิดพลาดเรื่องสิทธิ์ของ bind mount หากคุณเมานต์ไดเรกทอรีของโฮสต์แทนการใช้ named volume ตัว UID ของคอนเทนเนอร์ (65534 สำหรับ Prometheus และ 472 สำหรับ Grafana) จะต้องมีสิทธิ์เขียน ส่วน named volume อย่างที่ใช้ในไฟล์ Compose ด้านบนจะช่วยเลี่ยงปัญหานี้ไปได้

เมื่อสแตกนี้เกินความจำเป็น

หากสิ่งที่คุณต้องการมีแค่การแจ้งเตือนเมื่อ URL ไม่ตอบสนอง สแตกนี้ก็เกินความจำเป็นไปมาก Uptime Kuma เป็นตัวเลือกที่เบากว่ามาก หากคุณต้องการแค่การตรวจสอบสถานะออนไลน์พื้นฐาน

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

Prometheus กับ Grafana ต่างกันอย่างไร

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

การติดตั้ง Prometheus + Grafana ต้องใช้ RAM เท่าไร

เครื่องฮับที่รัน Prometheus, Grafana, Node Exporter และรีเวิร์สพร็อกซีอยู่บน VPS เครื่องเดียว จะใช้ RAM ราว 300 MB ขณะว่าง และ 530 ถึง 650 MB เมื่อกำลังดึงเมตริกจากห้าโฮสต์ทุก ๆ 15 วินาที

ใช้ Grafana ตัวเดียวมอนิเตอร์หลายเซิร์ฟเวอร์ได้ไหม

ได้ รูปแบบมาตรฐานคือฮับและสโป๊ก โดยมี Prometheus เพียงตัวเดียวบน VPS ที่เป็นฮับ คอยดึงข้อมูลจาก Node Exporter ที่รันอยู่บนเซิร์ฟเวอร์อื่น ๆ ทุกเครื่องที่คุณต้องการมอนิเตอร์ ส่วน Grafana บนฮับก็เรียกดูข้อมูลจาก Prometheus ตัวนั้นตัวเดียว และแดชบอร์ด Node Exporter Full (ID 1860) ก็รองรับตัวแปร instance ทำให้คุณสลับดูแต่ละเซิร์ฟเวอร์ได้จากแดชบอร์ดเดียว

แดชบอร์ด Grafana ตัวไหนดีที่สุดสำหรับ Node Exporter

สำหรับการติดตั้งแบบนี้ Node Exporter Full (แดชบอร์ด ID 1860 โดย rfmoz) เป็นตัวเลือกตั้งต้นที่ดีมาก มันครอบคลุมเมตริกหลักของโฮสต์จาก Node Exporter และรองรับตัวแปร job กับ instance สำหรับการมอนิเตอร์หลายเซิร์ฟเวอร์ ทั้งนี้บางแผงต้องอาศัยคอลเลกเตอร์เสริมของ Node Exporter ดังนั้นแผงเดี่ยว ๆ ที่ว่างอยู่จึงไม่ได้แปลว่าเป้าหมายมีปัญหาเสมอไป

จะเปิด Grafana ผ่าน HTTPS ได้อย่างไร

รัน Grafana โดยผูกไว้ที่ 127.0.0.1:3000 แล้ววางรีเวิร์สพร็อกซีไว้ด้านหน้าเพื่อจัดการ HTTPS ตัวเลือกที่ง่ายที่สุดคือ Caddy เพียงเขียน Caddyfile สี่บรรทัดที่มี reverse_proxy 127.0.0.1:3000 และบล็อกของโดเมน ก็จัดการได้ครบทั้งหมด รวมถึงการดูแลใบรับรอง TLS โดยอัตโนมัติ

Prometheus + Grafana ใช้เชิงพาณิชย์ได้ฟรีหรือไม่

Prometheus ใช้สัญญาอนุญาตแบบ Apache 2.0 ส่วน Grafana OSS ใช้ AGPLv3 การใช้งาน Grafana OSS ที่ไม่ได้ดัดแปลงทั้งภายในองค์กรและเชิงพาณิชย์นั้นทำได้ แต่การแก้ไข การแจกจ่าย หรือการให้บริการเวอร์ชันที่ดัดแปลงผ่านเครือข่าย อาจก่อให้เกิดภาระผูกพันเรื่องการเปิดเผยซอร์สโค้ดตาม AGPL ขณะที่ Grafana Enterprise และ Grafana Cloud อยู่ภายใต้เงื่อนไขเชิงพาณิชย์แยกต่างหาก

ควรย้ายจาก Prometheus ไป VictoriaMetrics เมื่อไร

ควรพิจารณา VictoriaMetrics เมื่อการเก็บข้อมูลนานขึ้น จำนวนซีรีส์ที่สูงมาก หรือการมี Prometheus หลายตัว ทำให้การดูแล TSDB ในเครื่องของ Prometheus ยากขึ้นภายใต้งบหน่วยความจำและดิสก์ของเซิร์ฟเวอร์คุณ VictoriaMetrics รับข้อมูลจาก Prometheus ได้ และเปิด API สำหรับค้นหาที่เข้ากันได้กับ Prometheus จึงทำหน้าที่เป็นที่จัดเก็บระยะยาวหรือเป็นแบ็กเอนด์เมตริกให้ Grafana ได้ ควรทดสอบกับภาระงานจริงของคุณเอง แทนที่จะย้ายเมื่อถึงเกณฑ์ RAM ที่ตายตัว