Grafana + InfluxDB: Dashboard Monitoring IoT Time-Series

docker run -d \
  --name influxdb \
  -p 8086:8086 \
  -v influxdb-data:/var/lib/influxdb2 \
  -v influxdb-config:/etc/influxdb2 \
  -e DOCKER_INFLUXDB_INIT_MODE=setup \
  -e DOCKER_INFLUXDB_INIT_USERNAME=admin \
  -e DOCKER_INFLUXDB_INIT_PASSWORD=influxdb12345 \
  -e DOCKER_INFLUXDB_INIT_ORG=my-org \
  -e DOCKER_INFLUXDB_INIT_BUCKET=iot-data \
  -e DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=my-super-secret-token \
  influxdb:2.7

# Cek log InfluxDB
docker logs influxdb

# Cek status container
docker ps | grep influxdb

# Output yang diharapkan:
# CONTAINER ID  IMAGE         STATUS         PORTS
# a1b2c3d4e5f6  influxdb:2.7  Up 2 minutes   0.0.0.0:8086->8086/tcp

# 1. Tambah repository InfluxDB
curl --silent --location -O https://repos.influxdata.com/influxdata-archive.key
echo "943666881a1b8d9b849b74caebf02d3465d6beb716510d86a39f6c8dc8267464  influxdata-archive.key" | sha256sum --check - && cat influxdata-archive.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive.gpg > /dev/null
echo "deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive.gpg] https://repos.influxdata.com/debian stable main" | sudo tee /etc/apt/sources.list.d/influxdata.list

# 2. Instalasi
sudo apt-get update && sudo apt-get install influxdb2

# 3. Jalankan service
sudo systemctl enable influxdb
sudo systemctl start influxdb

# 4. Setup awal via CLI
influx setup \
  --username admin \
  --password influxdb12345 \
  --org my-org \
  --bucket iot-data \
  --retention 0 \
  --force

docker run -d \
  --name grafana \
  -p 3000:3000 \
  -v grafana-data:/var/lib/grafana \
  -e "GF_SECURITY_ADMIN_USER=admin" \
  -e "GF_SECURITY_ADMIN_PASSWORD=grafana12345" \
  -e "GF_INSTALL_PLUGINS=grafana-clock-panel,grafana-piechart-panel" \
  grafana/grafana:latest

# 1. Tambah GPG key dan repository
curl -fsSL https://apt.grafana.com/gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/grafana.gpg
echo "deb [signed-by=/etc/apt/keyrings/grafana.gpg] https://apt.grafana.com stable main" | sudo tee /etc/apt/sources.list.d/grafana.list

# 2. Instalasi
sudo apt-get update
sudo apt-get install -y grafana

# 3. Jalankan service
sudo systemctl enable grafana-server
sudo systemctl start grafana-server

# 4. Cek status
sudo systemctl status grafana-server

[server]
http_port = 3000
root_url = https://monitoring.example.com

[security]
admin_user = admin
admin_password = ganti_dengan_password_kuat

[auth.anonymous]
enabled = false

version: "3.8"

services:
  influxdb:
    image: influxdb:2.7
    container_name: influxdb
    ports:
      - "8086:8086"
    volumes:
      - influxdb-data:/var/lib/influxdb2
      - influxdb-config:/etc/influxdb2
    environment:
      - DOCKER_INFLUXDB_INIT_MODE=setup
      - DOCKER_INFLUXDB_INIT_USERNAME=admin
      - DOCKER_INFLUXDB_INIT_PASSWORD=influxdb12345
      - DOCKER_INFLUXDB_INIT_ORG=my-org
      - DOCKER_INFLUXDB_INIT_BUCKET=iot-data
      - DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=my-super-secret-token
    restart: unless-stopped

  grafana:
    image: grafana/grafana:latest
    container_name: grafana
    ports:
      - "3000:3000"
    volumes:
      - grafana-data:/var/lib/grafana
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=grafana12345
      - GF_INSTALL_PLUGINS=grafana-clock-panel
    depends_on:
      - influxdb
    restart: unless-stopped

volumes:
  influxdb-data:
  influxdb-config:
  grafana-data:

networks:
  default:
    name: iot-monitoring

# Jalankan semua service
docker compose up -d

# Cek status
docker compose ps

# Output:
# NAME       IMAGE                  STATUS         PORTS
# grafana    grafana/grafana:latest Up 5 seconds   0.0.0.0:3000->3000/tcp
# influxdb   influxdb:2.7           Up 5 seconds   0.0.0.0:8086->8086/tcp

# Buat jaringan bersama
docker network create iot-monitoring

# Hubungkan container ke jaringan yang sama
docker network connect iot-monitoring influxdb
docker network connect iot-monitoring grafana

from(bucket: "iot-data")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> aggregateWindow(every: 1m, fn: mean, createEmpty: false)
  |> yield(name: "suhu_realtime")

from(bucket: "iot-data")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> last()
  |> yield(name: "suhu_sekarang")

// 1. Rata-rata suhu per jam
from(bucket: "iot-data")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> aggregateWindow(every: 1h, fn: mean)
  |> yield(name: "rata_rata_per_jam")

// 2. Suhu maksimum hari ini
from(bucket: "iot-data")
  |> range(start: today())
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> max()
  |> yield(name: "suhu_maks_hari_ini")

// 3. Nilai terakhir dari semua field
from(bucket: "iot-data")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> last()
  |> yield(name: "nilai_terakhir")

// 4. Suhu rata-rata per lokasi
from(bucket: "iot-data")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> group(columns: ["location"])
  |> mean()
  |> yield(name: "rata_rata_per_lokasi")

// 5. Batasi jumlah hasil (top 10)
from(bucket: "iot-data")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> sort(columns: ["_value"], desc: true)
  |> limit(n: 10)
  |> yield(name: "top_10_suhu")

// 6. Agregasi bergerak (moving average 5 data terakhir)
from(bucket: "iot-data")
  |> range(start: -6h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> movingAverage(n: 5)
  |> yield(name: "moving_average")

// 7. Transformasi ke Fahrenheit
from(bucket: "iot-data")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> map(fn: (r) => ({ r with _value: r._value * 1.8 + 32.0 }))
  |> yield(name: "suhu_fahrenheit")

|> aggregateWindow(every: 1m, fn: mean)   // Rata-rata per menit
|> aggregateWindow(every: 5m, fn: mean)   // Rata-rata per 5 menit
|> aggregateWindow(every: 1h, fn: mean)   // Rata-rata per jam
|> aggregateWindow(every: 1d, fn: mean)   // Rata-rata per hari

[smtp]
enabled = true
host = smtp.gmail.com:587
user = alert@kamu.com
password = app-password-gmail
from_address = alert@kamu.com
from_name = IoT Monitoring

Integration: Telegram
Bot Token: 1234567890:ABCdefGHIjklMNOpqrsTUVwxyz
Chat ID: 123456789

from(bucket: "iot-data")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> last()

// IoT Temperature Monitor - ESP32 + DHT22 + InfluxDB
// BeebaneLabs - https://beebanelabs.pages.dev

#include <WiFi.h>
#include <HTTPClient.h>
#include <DHT.h>

// === KONFIGURASI WIFI ===
const char* WIFI_SSID = "NamaWiFi";
const char* WIFI_PASS = "PasswordWiFi";

// === KONFIGURASI INFLUXDB ===
const char* INFLUXDB_URL = "http://192.168.1.100:8086/api/v2/write";
const char* INFLUXDB_ORG = "my-org";
const char* INFLUXDB_BUCKET = "iot-data";
const char* INFLUXDB_TOKEN = "my-super-secret-token";

// === KONFIGURASI SENSOR ===
#define DHT_PIN 4
#define DHT_TYPE DHT22
#define SENSOR_LOCATION "server-room-1"
#define DEVICE_ID "esp32-001"

DHT dht(DHT_PIN, DHT_TYPE);

// Setup WiFi
void connectWiFi() {
  Serial.print("Menghubungkan WiFi: ");
  Serial.println(WIFI_SSID);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("WiFi terhubung! IP: ");
  Serial.println(WiFi.localIP());
}

// Kirim data ke InfluxDB
void kirimKeInfluxDB(float suhu, float kelembaban) {
  if (WiFi.status() != WL_CONNECTED) {
    Serial.println("[ERROR] WiFi terputus, mencoba reconnect...");
    connectWiFi();
    return;
  }

  HTTPClient http;
  String url = String(INFLUXDB_URL) + "?org=" + INFLUXDB_ORG 
             + "&bucket=" + INFLUXDB_BUCKET + "&precision=s";

  http.begin(url);
  http.addHeader("Authorization", "Token " + String(INFLUXDB_TOKEN));
  http.addHeader("Content-Type", "text/plain");

  // Format InfluxDB Line Protocol
  // measurement,tag=value field=value timestamp
  String payload = "suhu_ruang,location=" + String(SENSOR_LOCATION) 
                 + ",device=" + String(DEVICE_ID) 
                 + " suhu=" + String(suhu, 1) 
                 + ",kelembaban=" + String(kelembaban, 1) 
                 + " " + String(millis());

  int httpCode = http.POST(payload);

  if (httpCode == 204 || httpCode == 200) {
    Serial.print("[OK] Data terkirim: suhu=");
    Serial.print(suhu);
    Serial.print("°C, kelembaban=");
    Serial.print(kelembaban);
    Serial.println("%");
  } else {
    Serial.print("[ERROR] HTTP ");
    Serial.println(httpCode);
    Serial.println(http.getString());
  }

  http.end();
}

void setup() {
  Serial.begin(115200);
  delay(1000);
  Serial.println("=== IoT Temp Monitor ===");

  dht.begin();
  connectWiFi();

  Serial.println("Siap mengirim data setiap 30 detik!");
}

void loop() {
  float suhu = dht.readTemperature();
  float kelembaban = dht.readHumidity();

  if (isnan(suhu) || isnan(kelembaban)) {
    Serial.println("[ERROR] Gagal membaca sensor!");
    delay(5000);
    return;
  }

  kirimKeInfluxDB(suhu, kelembaban);
  delay(30000);  // Kirim setiap 30 detik
}

// === PANEL 1: Suhu Saat Ini (Gauge) ===
from(bucket: "iot-data")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> last()

// === PANEL 2: Kelembaban Saat Ini (Gauge) ===
from(bucket: "iot-data")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "kelembaban")
  |> last()

// === PANEL 3: Tren Suhu 24 Jam (Time Series) ===
from(bucket: "iot-data")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> aggregateWindow(every: 5m, fn: mean, createEmpty: false)
  |> yield(name: "tren_suhu")

// === PANEL 4: Tren Kelembaban 24 Jam (Time Series) ===
from(bucket: "iot-data")
  |> range(start: -24h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "kelembaban")
  |> aggregateWindow(every: 5m, fn: mean, createEmpty: false)
  |> yield(name: "tren_kelembaban")

// === PANEL 5: Statistik Harian (Stat) ===
// Gunakan 3 query terpisah:
// Query A (min):
from(bucket: "iot-data")
  |> range(start: today())
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> min()
  |> yield(name: "min_suhu")

// Query B (max):
from(bucket: "iot-data")
  |> range(start: today())
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> max()
  |> yield(name: "max_suhu")

// Query C (mean):
from(bucket: "iot-data")
  |> range(start: today())
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> mean()
  |> yield(name: "mean_suhu")

// === PANEL 6: Log Data Terbaru (Table) ===
from(bucket: "iot-data")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu" or r._field == "kelembaban")
  |> pivot(rowKey: ["_time"], columnKey: ["_field"], valueColumn: "_value")
  |> sort(columns: ["_time"], desc: true)
  |> limit(n: 10)
  |> yield(name: "log_terbaru")

from(bucket: "iot-data")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "suhu_ruang")
  |> filter(fn: (r) => r._field == "suhu")
  |> aggregateWindow(every: 1m, fn: mean)
  |> last()