Tech Setup
IoT

Monitor IoT Data on Windows with Grafana & InfluxDB

Tech Setup6 min read
TS

Tech Setup

Reviewed July 31, 2026

Monitor IoT Data on Windows with Grafana & InfluxDB

Introduction

Building a local telemetry pipeline for Internet of Things (IoT) devices on a Windows workstation requires a high-performance time-series database and an extensible visualization layer. For developers prototyping embedded systems, industrial IoT gateways, or smart-home networks, InfluxDB and Grafana form the industry-standard open-source stack.

InfluxDB is purpose-built to handle high write-and-query loads of timestamped metrics, while Grafana connects natively to InfluxDB to render real-time dashboards with low latency.

This guide walks through setting up InfluxDB (v2.x) and Grafana natively on Windows, ingesting simulated IoT sensor data via Python, and configuring a production-ready dashboard.

Prerequisites and Architecture Overview

Before running binaries or scripts, ensure your Windows environment meets the following requirements:

  • Operating System: Windows 10/11 Pro/Enterprise or Windows Server 2019/2022 (WSL2 is optional; this guide uses native Windows binaries).
  • Permissions: Administrator access to manage Windows Services and firewall rules.
  • Development Tools: Python 3.10+ installed and added to the system PATH.

The Data Flow

  1. IoT Sensors / Simulators: Push JSON payloads containing metrics (e.g., temperature, humidity, vibration) over HTTP to InfluxDB.
  2. InfluxDB: Receives, indexes, and stores time-series data using its proprietary TSBS engine.
  3. Grafana: Queries InfluxDB using Flux or InfluxQL and renders dynamic panels.

Installing and Configuring InfluxDB on Windows

InfluxDB v2 decouples storage from management and introduces a built-in UI, task engine, and native security model.

1. Download and Extract

  1. Navigate to the official InfluxData downloads page and grab the Windows binary for InfluxDB v2.x (e.g., influxdb2-x.x.x_windows_amd64.zip).
  2. Extract the contents to C:\Program Files\InfluxData\InfluxDB.

2. Run InfluxDB as a Windows Service

While you can run influxd.exe directly in a terminal, production workflows require it to run as a background service. We will use NSSM (Non-Sucking Service Manager) or the native PowerShell service registration.

Open PowerShell as Administrator and run the following commands to create a data directory and start the service:

# Create data directories
New-Item -ItemType Directory -Force -Path "C:\ProgramData\InfluxDB\data"
New-Item -ItemType Directory -Force -Path "C:\ProgramData\InfluxDB\engine"

# Start the InfluxDB server directly to initialize
Start-Process -FilePath "C:\Program Files\InfluxData\InfluxDB\influxd.exe"

By default, InfluxDB binds to port 8086. Open your browser and navigate to http://localhost:8086.

3. Initial Setup via UI

  1. Click Get Started.
  2. Fill in the initial credentials:
    • Username: admin
    • Password: Use a secure, high-entropy password.
    • Initial Organization Name: iot-workspace
    • Initial Bucket Name: sensor-data
  3. Click Continue. Copy your generated API Token and save it securely; you will need it for the Python ingestion script.

Installing and Configuring Grafana on Windows

Grafana handles the presentation layer.

1. Installation

  1. Download the Grafana Windows installer (OSS edition) from the official website.
  2. Run the installer, accepting the default paths (C:\Program Files\GrafanaLabs\grafana).
  3. During installation, choose to install Grafana as a Windows Service.

2. Verify the Service

Open PowerShell and check the status of the Grafana service:

Get-Service -Name "Grafana"

If it is not running, start it manually:

Start-Service -Name "Grafana"

Grafana listens on port 3000 by default. Open http://localhost:3000 in your browser and log in with the default credentials (admin / admin). You will be prompted to update the password immediately.

Ingesting IoT Sensor Data via Python

To simulate real-world IoT devices (like an ESP32 or Raspberry Pi running MicroPython), we will write a Python script that pushes randomized temperature, humidity, and pressure telemetry to InfluxDB at regular intervals.

1. Install Dependencies

Open a terminal and install the official InfluxDB client library:

pip install influxdb-client

2. Write the Simulation Script

Create a file named iot_simulator.py:

import time
import random
from datetime import datetime
from influxdb_client import InfluxDBClient, Point, WritePrecision
from influxdb_client.client.write_api import SYNCHRONOUS

# Configuration
URL = "http://localhost:8086"
TOKEN = "YOUR_INFLUXDB_API_TOKEN_HERE"
ORG = "iot-workspace"
BUCKET = "sensor-data"

client = InfluxDBClient(url=URL, token=TOKEN, org=ORG)
write_api = client.write_api(write_options=SYNCHRONOUS)

def generate_sensor_payload():
    device_id = f"esp32-sensor-{random.randint(1, 3)}"
    temperature = round(20.0 + random.random() * 15.0, 2)
    humidity = round(40.0 + random.random() * 30.0, 2)
    pressure = round(1010.0 + random.random() * 10.0, 2)

    point = (
        Point("environmental_sensors")
        .tag("device_id", device_id)
        .tag("location", "factory_floor_a")
        .field("temperature", temperature)
        .field("humidity", humidity)
        .field("pressure", pressure)
        .time(datetime.utcnow(), WritePrecision.MS)
    )
    
    return point

if __name__ == "__main__":
    print("Starting IoT sensor data simulation. Press Ctrl+C to stop.")
    try:
        while True:
            sensor_point = generate_sensor_payload()
            write_api.write(bucket=BUCKET, org=ORG, record=sensor_point)
            print(f"[{datetime.utcnow().isoformat()}] Written data: {sensor_point.to_line_protocol()}")
            time.sleep(2)
    except KeyboardInterrupt:
        print("\nSimulation stopped by user. Closing connection.")
        client.close()

Replace YOUR_INFLUXDB_API_TOKEN_HERE with the token generated during the InfluxDB setup phase. Run the script:

python iot_simulator.py

You should see continuous output confirming data points are being written to the database. Leave this script running in the background.

Connecting Grafana to InfluxDB

Now that data is flowing into InfluxDB, we need to wire Grafana into the database.

1. Add Data Source

  1. Open Grafana at http://localhost:3000.
  2. In the left-hand navigation menu, hover over Connections and click Data sources.
  3. Click Add data source and select InfluxDB.

2. Configure Connection Parameters

Configure the InfluxDB data source with the following parameters:

  • Query Language: Flux (recommended for InfluxDB v2)
  • URL: http://localhost:8086
  • Access: Server (default)
  • Auth -> Basic Auth: Leave unchecked (we are using token auth).
  • InfluxDB Details:
    • Organization: iot-workspace
    • Token: Paste your InfluxDB API token.
    • Default Bucket: sensor-data

Scroll to the bottom and click Save & test. You should see a green success banner reading: "Data source is working. Database version found."

Building an IoT Monitoring Dashboard

With the data source connected, let's construct a monitoring dashboard to track our simulated hardware fleet.

1. Create a New Dashboard

  1. In Grafana, click the + icon in the top right and select Dashboard.
  2. Click Add visualization.
  3. Select your InfluxDB data source.

2. Querying Data with Flux

Grafana uses Flux to query InfluxDB v2. We will write a query to extract the average temperature per device over time.

In the Flux query editor, paste the following script:

from(bucket: "sensor-data")
  // Define time range
  |> range(start: v.timeRangeStart, stop: v.timeRangeStop)
  // Filter by measurement
  |> filter(fn: (r) => r["_measurement"] == "environmental_sensors")
  // Filter by field name
  |> filter(fn: (r) => r["_field"] == "temperature")
  // Aggregate data into windows
  |> aggregateWindow(every: v.windowPeriod, fn: mean, createEmpty: false)
  // Yield the results to Grafana
  |> yield(name: "mean")

3. Configuring Panel Settings

On the right-hand panel settings menu:

  • Panel title: Real-Time Temperature by Device
  • Visualization: Select Time series.
  • Standard options -> Unit: Select Temperature -> Celsius (°C).
  • Standard options -> Min/Max: Set appropriate display limits if needed.

Click Apply in the top right to save the panel to your dashboard.

4. Adding a Stat Panel for Fleet Health

Let's add a second panel to show the current humidity for the most recent data point.

  1. Click Add visualization at the top of the dashboard.
  2. Select your InfluxDB data source.
  3. Use the following Flux query:
from(bucket: "sensor-data")
  |> range(start: -5m)
  |> filter(fn: (r) => r["_measurement"] == "environmental_sensors")
  |> filter(fn: (r) => r["_field"] == "humidity")
  |> last()
  1. Set the visualization type to Stat.
  2. Set the panel title to Latest Humidity (%).
  3. Click Apply.

Save the entire dashboard by clicking the save icon in the top-right header and naming it IoT Fleet Diagnostics.

Production Best Practices for Windows Deployments

Running a telemetry stack on Windows requires attention to system-level configuration if you intend to scale beyond local development.

1. Windows Firewall Rules

If your IoT devices are communicating from external machines on your local network (e.g., physical microcontrollers on your LAN), you must open the inbound ports in Windows Defender Firewall.

Run PowerShell as Administrator:

# Allow InfluxDB port
New-NetFirewallRule -DisplayName "InfluxDB Inbound" -Direction Inbound -Protocol TCP -LocalPort 8086 -Action Allow

# Allow Grafana port
New-NetFirewallRule -DisplayName "Grafana Inbound" -Direction Inbound -Protocol TCP -LocalPort 3000 -Action Allow

2. Log Rotation and Storage Management

Time-series databases grow rapidly. Ensure your InfluxDB data and engine directories (C:\ProgramData\InfluxDB) reside on a drive with adequate disk space, preferably an NVMe SSD to handle high IOPS workloads during writes and downsampling queries.

Configure InfluxDB retention policies to automatically drop stale data and prevent disk exhaustion. You can manage retention policies directly in the InfluxDB UI under Data -> Buckets -> Configure.

3. Service Recovery Options

Configure Windows Services to automatically restart if they crash or if the server reboots:

sc.exe failure "InfluxDB" reset= 86400 actions= restart/60000/restart/60000/restart/60000
sc.exe failure "Grafana" reset= 86400 actions= restart/60000/restart/60000/restart/60000

Conclusion

You now have a fully functional local IoT monitoring stack running natively on Windows. InfluxDB ingests and indexes time-series metrics from edge devices with minimal overhead, while Grafana provides immediate visual feedback through robust Flux-backed dashboards.

From here, you can expand this architecture by adding alerting rules in Grafana (via webhooks to Slack, Discord, or PagerDuty), configuring InfluxDB tasks for automated downsampling, or swapping the Python simulation script for real firmware communicating via MQTT through an intermediary broker like EMQX or Mosquitto.

Related articles