Monitoring Docker Container dengan Prometheus, Grafana, dan Loki di Ubuntu

Artikel ini akan menjelaskan cara membuat sistem monitoring lengkap untuk container Docker menggunakan stack monitoring modern: Prometheus untuk metrik, Grafana untuk visualisasi, dan Loki untuk log. Setup ini menggunakan dua server terpisah - satu untuk aplikasi Docker dan satu lagi khusus untuk monitoring.

Prasyarat

• 2 VPS Ubuntu:
  • VPS 1: Sudah menjalankan aplikasi Docker (WordPress, MySQL, dll.)
  • VPS 2: Akan digunakan sebagai server monitoring (rekomendasi: 1 vCPU, 2GB RAM, 40GB SSD)
• Akses SSH ke kedua server
• Port yang terbuka di firewall

Arsitektur Sistem

• VPS 1 (Server Aplikasi):
  • Node Exporter: Mengumpulkan metrik sistem
  • cAdvisor: Mengumpulkan metrik container
  • Promtail: Mengumpulkan log dan mengirimnya ke Loki
• VPS 2 (Server Monitoring):
  • Prometheus: Database untuk metrik dan time series
  • Grafana: Platform visualisasi
  • Loki: Sistem agregasi log

Langkah 1: Persiapan Server Monitoring (VPS 2)

Pertama, kita perlu mempersiapkan server monitoring dengan menginstal paket-paket dasar:

# Update dan upgrade sistem
sudo apt update && sudo apt upgrade -y

# Install paket yang diperlukan
sudo apt install -y apt-transport-https ca-certificates curl software-properties-common gnupg

# Buat direktori untuk konfigurasi
sudo mkdir -p /etc/prometheus
sudo mkdir -p /var/lib/prometheus

Langkah 2: Install Docker di Server Monitoring

# Download dan install Docker
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

# Tambahkan user ke grup docker
sudo usermod -aG docker $USER

# Aktifkan dan jalankan Docker
sudo systemctl enable docker
sudo systemctl start docker

# Install Docker Compose
sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose

Langkah 3: Siapkan Stack Monitoring dengan Docker Compose

Buat struktur direktori untuk konfigurasi:

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

Buat file Docker Compose:

cat > ~/docker-monitoring/docker-compose.yml << EOF
version: '3'

services:
  prometheus:
    image: prom/prometheus:latest
    container_name: prometheus
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - prometheus_data:/prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
      - '--storage.tsdb.path=/prometheus'
      - '--web.console.libraries=/usr/share/prometheus/console_libraries'
      - '--web.console.templates=/usr/share/prometheus/consoles'
      - '--web.enable-lifecycle'
    restart: always

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
    depends_on:
      - prometheus
    restart: always

  loki:
    image: grafana/loki:latest
    container_name: loki
    ports:
      - "3100:3100"
    volumes:
      - ./loki/local-config.yaml:/etc/loki/local-config.yaml
      - loki_data:/loki
      - loki_wal:/wal
    command:
      - "-config.file=/etc/loki/local-config.yaml"
    restart: always
    user: "0"

volumes:
  prometheus_data:
  grafana_data:
  loki_data:
  loki_wal:
EOF

Langkah 4: Konfigurasi Prometheus

Buat file konfigurasi Prometheus untuk mengumpulkan metrik:

cat > ~/docker-monitoring/prometheus/prometheus.yml << EOF
global:
  scrape_interval: 15s
  evaluation_interval: 15s

scrape_configs:
  - job_name: 'prometheus'
    static_configs:
      - targets: ['localhost:9090']

  - job_name: 'node_exporter_vps1'
    static_configs:
      - targets: ['IP_VPS_1:9100']

  - job_name: 'cadvisor_vps1'
    static_configs:
      - targets: ['IP_VPS_1:8081']
EOF

Pastikan untuk mengganti IP_VPS_1 dengan alamat IP server aplikasi Docker Anda.

Langkah 5: Konfigurasi Loki

Buat file konfigurasi Loki untuk agregasi log:

cat > ~/docker-monitoring/loki/local-config.yaml << EOF
auth_enabled: false

server:
  http_listen_port: 3100

ingester:
  lifecycler:
    address: 127.0.0.1
    ring:
      kvstore:
        store: inmemory
      replication_factor: 1
    final_sleep: 0s
  chunk_idle_period: 5m
  chunk_retain_period: 30s

schema_config:
  configs:
    - from: 2020-10-24
      store: boltdb
      object_store: filesystem
      schema: v11
      index:
        prefix: index_
        period: 24h

storage_config:
  boltdb:
    directory: /loki/index
  filesystem:
    directory: /loki/chunks

limits_config:
  reject_old_samples: true
  reject_old_samples_max_age: 168h
  allow_structured_metadata: false  # Nonaktifkan structured metadata

compactor:
  working_directory: /loki/compactor
EOF

Langkah 6: Setup Eksporter di Server Aplikasi (VPS 1)

Di server yang menjalankan aplikasi Docker, pasang eksporter untuk mengumpulkan metrik dan log:

# Install Node Exporter untuk metrik sistem
docker run -d \
  --name=node-exporter \
  --restart=always \
  --net="host" \
  --pid="host" \
  -v "/:/host:ro,rslave" \
  quay.io/prometheus/node-exporter:latest \
  --path.rootfs=/host

# Install cAdvisor untuk metrik Docker (menggunakan port 8081 karena 8080 mungkin sudah digunakan)
docker run -d \
  --name=cadvisor \
  --restart=always \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8081:8080 \
  --privileged \
  gcr.io/cadvisor/cadvisor:latest

Langkah 7: Setup Promtail untuk Pengumpulan Log

Masih di server aplikasi (VPS 1), kita perlu mengatur Promtail untuk mengumpulkan log dan mengirimkannya ke Loki:

# Buat direktori konfigurasi
mkdir -p ~/promtail

# Buat file konfigurasi Promtail
cat > ~/promtail/config.yml << EOF
server:
  http_listen_port: 9080
  grpc_listen_port: 0

positions:
  filename: /tmp/positions.yaml

clients:
  - url: http://IP_VPS_2:3100/loki/api/v1/push

scrape_configs:
  - job_name: system
    static_configs:
    - targets:
        - localhost
      labels:
        job: varlogs
        __path__: /var/log/*log

  - job_name: docker
    static_configs:
    - targets:
        - localhost
      labels:
        job: docker
        __path__: /var/lib/docker/containers/*/*-json.log
EOF

Ganti IP_VPS_2 dengan alamat IP server monitoring Anda.

Jalankan Promtail:

docker run -d \
  --name=promtail \
  --restart=always \
  --user=root \
  --volume=/var/log:/var/log \
  --volume=$HOME/promtail:/etc/promtail \
  --volume=/var/lib/docker/containers:/var/lib/docker/containers:ro \
  --publish=9080:9080 \
  grafana/promtail:latest \
  -config.file=/etc/promtail/config.yml

Buka port yang diperlukan di firewall:

sudo ufw allow 9100/tcp  # Node Exporter
sudo ufw allow 8081/tcp  # cAdvisor
sudo ufw allow 9080/tcp  # Promtail

Langkah 8: Jalankan Stack Monitoring

Kembali ke server monitoring (VPS 2), jalankan stack monitoring:

cd ~/docker-monitoring
docker-compose up -d

Buka port yang diperlukan:

sudo ufw allow 9090/tcp  # Prometheus
sudo ufw allow 3000/tcp  # Grafana
sudo ufw allow 3100/tcp  # Loki

Langkah 9: Konfigurasi Grafana

1. Buka Grafana di browser: http://IP_VPS_2:3000
2. Login dengan username: admin dan password: admin (Anda akan diminta untuk mengubah password)
3. Tambahkan Prometheus sebagai data source:
   • Klik menu "Configuration" (ikon roda gigi)
   • Pilih "Data Sources"
   • Klik "Add data source"
   • Pilih "Prometheus"
   • URL: http://prometheus:9090
   • Klik "Save & Test"
4. Tambahkan Loki sebagai data source:
   • Klik "Add data source" lagi
   • Pilih "Loki"
   • URL: http://loki:3100
   • Klik "Save & Test"
5. Import dashboard untuk monitoring:
   • Klik ikon "+" di sidebar kiri
   • Pilih "Import"
   • Import dashboard berikut:
     • 1860 atau 10242 - Node Exporter Full dashboard
     • 893 - Docker monitoring dashboard
     • 13639 - Loki logs dashboard

Langkah 10: Monitoring MySQL (Opsional)

Untuk monitoring database MySQL di server aplikasi:

# Jalankan MySQL Exporter (ganti password sesuai kebutuhan)
docker run -d \
  --name mysql-exporter \
  --restart=always \
  -p 9104:9104 \
  -e DATA_SOURCE_NAME="exporter:MYSQL_PASSWORD@(mysql:3306)/" \
  prom/mysqld-exporter

Tambahkan konfigurasi di file prometheus.yml pada server monitoring:

  - job_name: 'mysql_exporter'
    static_configs:
      - targets: ['IP_VPS_1:9104']

Reload konfigurasi Prometheus:

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

Mengubah Port (Mengatasi Konflik Port)

Jika Anda mengalami konflik port, berikut cara mengubah port pada berbagai komponen:

*sebelum melakukan perubahan port, pastikan benar benar terjadi konflik port dengan menjalankan cmd "docker ps -a" pada server anda, jika diantara salah satu atau beberapa aplikasi di atas tidak berjalan, artinya memang terjadi konflik port dan anda harus mengubahnya.

Mengubah Port di VPS 2 (Server Monitoring)

Edit file docker-compose.yml:

nano ~/docker-monitoring/docker-compose.yml

Ubah port pada layanan yang diinginkan:

prometheus:
  # konfigurasi lainnya...
  ports:
    - "9091:9090"  # Mengubah port host menjadi 9091

grafana:
  # konfigurasi lainnya...
  ports:
    - "3001:3000"  # Mengubah port host menjadi 3001

loki:
  # konfigurasi lainnya...
  ports:
    - "3101:3100"  # Mengubah port host menjadi 3101

Setelah perubahan, restart layanan:

cd ~/docker-monitoring
docker-compose down
docker-compose up -d

Mengubah Port di VPS 1 (Server Aplikasi)

Mengubah Port cAdvisor

# Hentikan dan hapus container yang ada
docker stop cadvisor
docker rm cadvisor

# Jalankan dengan port yang berbeda
docker run -d \
  --name=cadvisor \
  --restart=always \
  --volume=/:/rootfs:ro \
  --volume=/var/run:/var/run:ro \
  --volume=/sys:/sys:ro \
  --volume=/var/lib/docker/:/var/lib/docker:ro \
  --volume=/dev/disk/:/dev/disk:ro \
  --publish=8082:8080 \  # Mengubah port host menjadi 8082
  --privileged \
  gcr.io/cadvisor/cadvisor:latest

Mengubah Port Node Exporter

# Hentikan dan hapus container yang ada
docker stop node-exporter
docker rm node-exporter

# Jalankan dengan port yang berbeda
docker run -d \
  --name=node-exporter \
  --restart=always \
  --net="host" \
  --pid="host" \
  -v "/:/host:ro,rslave" \
  quay.io/prometheus/node-exporter:latest \
  --path.rootfs=/host \
  --web.listen-address=:9101  # Mengubah port menjadi 9101

Mengubah Port Promtail

# Hentikan dan hapus container yang ada
docker stop promtail
docker rm promtail

# Jalankan dengan port yang berbeda
docker run -d \
  --name=promtail \
  --restart=always \
  --user=root \
  --volume=/var/log:/var/log \
  --volume=$HOME/promtail:/etc/promtail \
  --volume=/var/lib/docker/containers:/var/lib/docker/containers:ro \
  --publish=9081:9080 \  # Mengubah port host menjadi 9081
  grafana/promtail:latest \
  -config.file=/etc/promtail/config.yml

Perubahan Konfigurasi Setelah Mengubah Port

Setelah mengubah port, Anda perlu memperbarui konfigurasi:

1. Update konfigurasi Prometheus di VPS 2:

nano ~/docker-monitoring/prometheus/prometheus.yml

Ubah target sesuai port baru:

scrape_configs:
  - job_name: 'node_exporter_vps1'
    static_configs:
      - targets: ['IP_VPS_1:9101']  # Port yang diubah

  - job_name: 'cadvisor_vps1'
    static_configs:
      - targets: ['IP_VPS_1:8082']  # Port yang diubah

2. Update konfigurasi Promtail di VPS 1 jika port Loki berubah:

nano ~/promtail/config.yml

clients:
  - url: http://IP_VPS_2:3101/loki/api/v1/push  # Port Loki yang diubah

3. Reload konfigurasi:

# Di VPS 2
curl -X POST http://localhost:9091//-/reload  # Port Prometheus yang diubah

# Di VPS 1
docker restart promtail

4. Update firewall rule:

# Buka port baru
sudo ufw allow [port_baru]/tcp

# Opsional: tutup port lama
sudo ufw deny [port_lama]/tcp

Melihat Log di Grafana

Untuk melihat log yang dikumpulkan oleh Loki:

1. Di Grafana, klik "Explore" di sidebar kiri
2. Pilih "Loki" sebagai data source
3. Masukkan query sederhana:
   • {job="varlogs"} - untuk log sistem
   • {job="docker"} - untuk log container Docker
4. Pastikan rentang waktu di kanan atas sesuai (misalnya "Last 1 hour")

Jika tidak melihat data:

• Coba perluas rentang waktu
• Hapus semua filter dan gunakan query paling sederhana
• Periksa apakah Promtail berjalan dengan baik di server aplikasi

Troubleshooting Umum

1. Tidak Ada Data di Loki

Jika tidak ada log yang muncul di Loki, periksa:

• Koneksi Promtail ke Loki: curl IP_VPS_2:3100/ready seharusnya mengembalikan "ready"
• Log Promtail: docker logs promtail
• Izin file log: Pastikan Promtail memiliki akses ke file log
• Coba jalankan Promtail sebagai root: Tambahkan --user=root ke perintah docker run

2. cAdvisor Tidak Berjalan

Jika cAdvisor tidak muncul di docker ps, coba:

• Cek log: docker logs cadvisor
• Gunakan port alternatif jika port 8080 sudah digunakan
• Coba hapus parameter --device=/dev/kmsg jika ada masalah

3. Masalah Koneksi Data Source di Grafana

• Gunakan nama container sebagai host: http://prometheus:9090, http://loki:3100
• Jika itu tidak berhasil, coba gunakan localhost: http://localhost:9090, http://localhost:3100

4. Konektivitas Jaringan

• Semua layanan di VPS 2 (Prometheus, Grafana, Loki) secara otomatis berada pada jaringan Docker Compose yang sama, sehingga mereka dapat berkomunikasi menggunakan nama container sebagai hostname.
• Pastikan firewall mengizinkan koneksi antar VPS pada port yang diperlukan.

Uninstall dan Pembersihan

Jika Anda perlu menghapus setup monitoring, ikuti langkah-langkah berikut:

Uninstall di Server Monitoring (VPS 2)

# Hentikan dan hapus container
cd ~/docker-monitoring
docker-compose down -v

# Hapus direktori konfigurasi
rm -rf ~/docker-monitoring

# Hapus volume Docker (opsional, akan menghapus semua data)
docker volume rm docker-monitoring_prometheus_data docker-monitoring_grafana_data docker-monitoring_loki_data docker-monitoring_loki_wal

Uninstall di Server Aplikasi (VPS 1)

# Hentikan dan hapus container eksporter
docker stop node-exporter cadvisor promtail mysql-exporter
docker rm node-exporter cadvisor promtail mysql-exporter

# Hapus direktori konfigurasi
rm -rf ~/promtail

# Hapus plugin Docker Loki (jika diinstal)
docker plugin rm loki

Tutup Port yang Dibuka

# Di VPS 1
sudo ufw deny 9100/tcp
sudo ufw deny 8081/tcp
sudo ufw deny 9080/tcp
sudo ufw deny 9104/tcp

# Di VPS 2
sudo ufw deny 9090/tcp
sudo ufw deny 3000/tcp
sudo ufw deny 3100/tcp

Kesimpulan

Dengan mengikuti langkah-langkah di atas, Anda kini memiliki sistem monitoring Docker yang lengkap. Prometheus akan mengumpulkan metrik kinerja, Loki akan mengumpulkan log, dan Grafana memberikan visualisasi yang menarik untuk keduanya.

Setup ini memberi Anda visibilitas menyeluruh terhadap aplikasi Docker Anda, memungkinkan Anda untuk:

• Memantau penggunaan sumber daya (CPU, RAM, Disk)
• Menganalisis performa aplikasi
• Menelusuri log dari berbagai container secara terpusat
• Membuat alert untuk kondisi tertentu

Dengan sistem ini, Anda akan lebih mudah melakukan troubleshooting, deteksi masalah lebih awal, dan mengoptimalkan infrastruktur Docker Anda.

Artikel di atas adalah hasil generate prompt menggunakan clude ai disertai dengan praktek langsung menggunakan server ubuntu untuk membuktikan kebenaran informasinya, artikel di atas berisi informasi lengkap setelah melakukan berbagai prompt ulang saat mengalami error pada penerapannya hingga berhasil.