Grafana + InfluxDB: Dashboard Monitoring IoT Time-Series

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

[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()