Grafana + InfluxDB IoT Monitoring: Complete Production Setup Guide

For industrial IoT monitoring, Grafana + InfluxDB is the reference stack. InfluxDB stores time-series telemetry with automatic retention and fast aggregations. Grafana visualizes it with 50+ panel types, threshold alerting, and multi-team access control — all without writing a single line of frontend code.

This guide takes you from a blank server to a production monitoring stack with MQTT ingestion, Flux queries, alerting, and secure team access.

Architecture

IoT Devices → MQTT Broker (Mosquitto / AWS IoT)
                    ↓ Telegraf (MQTT input plugin)
              InfluxDB 2.x (time-series storage)
                    ↓ Flux queries
              Grafana (dashboards + alerting)
                    ↓
              PagerDuty / Slack / Email (alerts)

Step 1: Docker Compose Stack

docker-compose.yml
version: '3.8'
services:
  mosquitto:
    image: eclipse-mosquitto:2
    ports:
      - "1883:1883"
      - "8883:8883"
    volumes:
      - ./mosquitto/config:/mosquitto/config
      - ./mosquitto/data:/mosquitto/data
  influxdb:
    image: influxdb:2.7
    ports:
      - "8086:8086"
    volumes:
      - influxdb_data:/var/lib/influxdb2
    environment:
      DOCKER_INFLUXDB_INIT_MODE:     setup
      DOCKER_INFLUXDB_INIT_USERNAME: admin
      DOCKER_INFLUXDB_INIT_PASSWORD: ${INFLUX_PASSWORD}
      DOCKER_INFLUXDB_INIT_ORG:      codecaracal
      DOCKER_INFLUXDB_INIT_BUCKET:   iot_telemetry
      DOCKER_INFLUXDB_INIT_RETENTION: 30d
  telegraf:
    image: telegraf:1.31
    volumes:
      - ./telegraf/telegraf.conf:/etc/telegraf/telegraf.conf:ro
    environment:
      INFLUX_TOKEN: ${INFLUX_TOKEN}
    depends_on:
      - influxdb
      - mosquitto
  grafana:
    image: grafana/grafana:10.4.0
    ports:
      - "3000:3000"
    volumes:
      - grafana_data:/var/lib/grafana
      - ./grafana/provisioning:/etc/grafana/provisioning
    environment:
      GF_SECURITY_ADMIN_PASSWORD:     ${GRAFANA_PASSWORD}
      GF_AUTH_ANONYMOUS_ENABLED:      false
      GF_SMTP_ENABLED:                true
      GF_SMTP_HOST:                   smtp.sendgrid.net:587
      GF_SMTP_USER:                   apikey
      GF_SMTP_PASSWORD:               ${SENDGRID_KEY}
    depends_on:
      - influxdb
volumes:
  influxdb_data:
  grafana_data:

Step 2: Telegraf MQTT Input

telegraf/telegraf.conf
[agent]
  interval = "10s"
  flush_interval = "10s"
[[inputs.mqtt_consumer]]
  servers = ["tcp://mosquitto:1883"]
  topics  = ["devices/+/telemetry"]
  qos     = 1
  data_format = "json"
  # Extract device ID from topic (devices/{deviceId}/telemetry)
  [[inputs.mqtt_consumer.topic_parsing]]
    topic  = "devices/+/telemetry"
    tags   = "_/device_id/_"
    fields = ""
  # Tag each measurement with the device ID
  [inputs.mqtt_consumer.tags]
    measurement = "device_telemetry"
[[outputs.influxdb_v2]]
  urls         = ["http://influxdb:8086"]
  token        = "${INFLUX_TOKEN}"
  organization = "codecaracal"
  bucket       = "iot_telemetry"

Telegraf reads MQTT messages, parses JSON payloads, extracts the device_id from the topic, and writes tagged measurements to InfluxDB. No code required.

Step 3: Flux Queries for Grafana

Flux is InfluxDB's query language. Key queries for IoT dashboards:

Current value (for stat panels / gauges):

from(bucket: "iot_telemetry")
  |> range(start: -1h)
  |> filter(fn: (r) => r._measurement == "device_telemetry")
  |> filter(fn: (r) => r._field == "temperature")
  |> filter(fn: (r) => r.device_id == v.device_id)  // Dashboard variable
  |> last()

Time-series for a chart:

from(bucket: "iot_telemetry")
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  |> filter(fn: (r) => r._measurement == "device_telemetry")
  |> filter(fn: (r) => r._field == "temperature" or r._field == "humidity")
  |> filter(fn: (r) => r.device_id =~ /${device_id:regex}/)
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  |> pivot(rowKey: ["_time"], columnKey: ["_field"], valueColumn: "_value")

Fleet overview (all devices, latest value):

from(bucket: "iot_telemetry")
  |> range(start: -5m)
  |> filter(fn: (r) => r._measurement == "device_telemetry")
  |> filter(fn: (r) => r._field == "temperature")
  |> group(columns: ["device_id"])
  |> last()
  |> group()
  |> sort(columns: ["device_id"])

Step 4: Grafana Dashboard Variables

Create a device_id variable to make dashboards dynamic:

import "influxdata/influxdb/schema"
schema.tagValues(bucket: "iot_telemetry", tag: "device_id")

This creates a dropdown at the top of the dashboard — select one device or all, and every panel updates automatically.

Step 5: Alerting Rules

Grafana's unified alerting fires on Flux query results:

grafana/provisioning/alerting/rules.yaml
apiVersion: 1
groups:
  - orgId: 1
    name: IoT Alerts
    interval: 1m
    rules:
      - uid: temperature-high
        title: Temperature Above Threshold
        condition: C
        data:
          - refId: A
            datasourceUid: influxdb
            model:
              query: |
                from(bucket: "iot_telemetry")
                  |> range(start: -5m)
                  |> filter(fn: (r) => r._field == "temperature")
                  |> last()
          - refId: B
            datasourceUid: "-100"
            model:
              type: reduce
              reducer: last
          - refId: C
            datasourceUid: "-100"
            model:
              type: threshold
              conditions:
                - evaluator: { type: "gt", params: [80] }
        for: 2m
        labels:
          severity: critical
        annotations:
          summary: "{{ $labels.device_id }} temperature {{ $values.B.Value }}°C"

Step 6: Panel Types for IoT

| Measurement | Grafana Panel | Config | |-------------|---------------|--------| | Live temperature | Time series | Line, 1h window | | Current value | Stat | Single color threshold | | Battery level | Gauge | 0–100%, red below 20% | | Device online/offline | State timeline | green/red | | Fleet overview | Table | All devices, last value | | Geolocation | Geomap | Lat/lon tags from devices |

Role-Based Access Control

grafana/provisioning/access-control/roles.yaml
apiVersion: 1
roles:
  - name: IoT Operator
    global: true
    permissions:
      - action: dashboards:read
        scope: "dashboards:*"
      - action: alert.instances:read
        scope: "global:*"

Clients get Viewer access — they can see dashboards and receive alerts but cannot edit. Your team gets Editor. Only platform admins get Admin.

The Grafana + InfluxDB stack handles 10,000+ data points per second on modest hardware ($200/month AWS) and scales further with InfluxDB clustering. [Contact Code Caracal](/contact) to set this up for your IoT fleet.