Skip to content
BranchesTags

Repository files navigation

Large Public Venue Dashboard

A comprehensive, dockerized monitoring solution for Central that visualizes network performance, device health, and client experience data in real-time. This project provides two powerful dashboards (Grafana and a custom Next.js dashboard) connected to an InfluxDB time-series database for historical data analysis.

Table of Contents

Overview

This solution automatically collects network monitoring data from HPE Aruba Central and displays it across two complementary dashboards:

  • Grafana Dashboard (localhost:3000): Advanced visualizations with customizable panels for network metrics, device health, client experience, and radio performance
  • Next.js Custom Dashboard (localhost:3001): Real-time overview dashboard with device counts, health statistics, and alerts
  • InfluxDB Web Interface (localhost:8086): Time-series database interface for advanced data queries and management

All data is stored in InfluxDB, a time-series database optimized for monitoring and analytics workloads.

What You'll Get

  • 5 pre-configured Grafana dashboards (Home, Network, Access Points, Switches, Gateways)
  • Real-time data collection from Central APIs
  • Automatic dashboard provisioning and setup
  • Persistent data storage across container restarts

System Requirements

Minimum Requirements (Lab Environment)

  • Operating System: Linux (Ubuntu 20.04+ recommended), macOS, or Windows with WSL2
  • CPU: 4 cores
  • RAM: 8 GB
  • Storage: 50 GB free disk space (standard HDD acceptable, SSD recommended for better performance)
  • Network: Stable internet connection for API calls to HPE Aruba Central

Recommended Requirements (Production/Extended Use)

  • CPU: 8+ cores
  • RAM: 16 GB
  • Storage: 100+ GB (InfluxDB data can grow to ~25 GB for several hours of continuous collection)

Note: Storage requirements scale with the number of monitored devices and data retention period.

Prerequisites

1. Docker Installation

You need Docker Desktop (recommended) or Docker Engine with Docker Compose.

Docker Desktop (Easiest Option - Recommended)

Download and install Docker Desktop for your operating system:

Docker Desktop includes both Docker Engine and Docker Compose, so you're ready to go after installation.

Docker Engine + Docker Compose (Linux Alternative)

If you prefer a lightweight installation without Docker Desktop:

Ubuntu/Debian:

Note: The docker-compose-plugin package is not available in the default Ubuntu repositories. You must first add Docker's official repository as shown below.

# Add Docker's official GPG key:
sudo apt update
sudo apt install ca-certificates curl
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc

# Add the repository to Apt sources:
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF

sudo apt update

# Install Docker Engine and Docker Compose plugin
sudo apt install docker-ce docker-ce-cli containerd.io docker-compose-plugin

# Allow running docker commands without sudo
sudo usermod -aG docker $USER

# Verify installation (log out and back in for the group change to take effect)
docker --version
docker compose version

macOS (using Homebrew):

# Install Homebrew if not already installed
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# Install Docker
brew install docker docker-compose

# Install Docker Machine (required for Docker Engine without Docker Desktop)
brew install docker-machine

# Verify installation
docker --version
docker-compose --version

Note for macOS: Docker Desktop is strongly recommended over the Homebrew installation for ease of use.

Other Linux Distributions: Follow the official installation guide: https://docs.docker.com/engine/install/

2. Docker Compose Version Requirements

  • Minimum: Docker Compose v1.29+
  • Recommended: Docker Compose v2.0+ (included in Docker Desktop)

To check your version:

docker-compose --version    # For V1
docker compose version      # For V2

If using Docker Compose V2, use docker compose (without hyphen) instead of docker-compose in all commands.

3. Git (for cloning the repository)

# Verify Git is installed
git --version

# If not installed:
# Ubuntu/Debian: sudo apt install git
# macOS: brew install git
# Windows: Download from https://git-scm.com/

4. Central API Credentials

You'll need API access to your Central instance. If you don't have credentials yet, follow this guide to generate them:

How to Generate Central API Credentials

You will need:

  • Client ID
  • Client Secret
  • Base URL (your Central instance URL based on your region - see Base URL Reference)

Keep these credentials handy, as you'll use them in the next section.

Initial Setup

Step 1: Open Your Command Line Interface

First, open the command line interface for your operating system:

Windows:

  • Press Windows Key + R
  • Type cmd or powershell and press Enter
  • Or search for "Command Prompt" or "PowerShell" in the Start menu

macOS:

  • Press Command + Space to open Spotlight
  • Type terminal and press Enter
  • Or go to Applications → Utilities → Terminal

Linux:

  • Press Ctrl + Alt + T
  • Or search for "Terminal" in your applications menu

Step 2: Create a Project Folder on Your Desktop

Navigate to your Desktop and create a new folder for the project:

Windows (Command Prompt):

cd %USERPROFILE%\Desktop
mkdir monitoring-dashboard
cd monitoring-dashboard

Windows (PowerShell):

cd $HOME\Desktop
mkdir monitoring-dashboard
cd monitoring-dashboard

macOS/Linux:

cd ~/Desktop
mkdir monitoring-dashboard
cd monitoring-dashboard

You should now be inside a new folder called monitoring-dashboard on your Desktop.

Step 3: Clone the Repository

git clone https://github.com/aruba/central-large-campus-monitoring-dashboard.git
cd central-large-campus-monitoring-dashboard

Step 4: Create Required Credential Files

Before running the application, you need to set up your Central API credentials. Sample files are included in the repository as a template.

Central API Credentials

Copy the sample file and fill in your credentials in the following location:

cp influx/account_credentials.sample.yaml influx/account_credentials.yaml

Edit influx/account_credentials.yaml with your Central API credentials:

new_central:
  base_url: https://YOUR_CENTRAL_BASE_URL
  client_id: YOUR_CLIENT_ID_HERE
  client_secret: YOUR_CLIENT_SECRET_HERE
  • Replace YOUR_CENTRAL_BASE_URL with your Central instance URL based on your region (see Base URL Reference)
  • Replace YOUR_CLIENT_ID_HERE and YOUR_CLIENT_SECRET_HERE with your actual API credentials
  • Do not commit this file to version control — it is already in .gitignore

Note: The Next.js dashboard also requires these credentials (for floor plan image retrieval). At runtime, Docker automatically maps influx/account_credentials.yaml into the Next.js container, so you only need to create this one file.

InfluxDB Connection Settings

The file influx/influx_credentials.yaml is pre-configured with defaults that match the Docker Compose configuration. No changes are needed unless you customize the InfluxDB token in docker-compose.yml.

If you do change the InfluxDB token, update it in influx/influx_credentials.yaml to match.

Configuration

Default Configuration

The application comes pre-configured with sensible defaults:

Service Port Default Credentials
Grafana 3000 Username: admin
Password: admin
Next.js Dashboard 3001 No authentication
InfluxDB 8086 Username: admin
Password: password

Customizing Configuration (Optional)

If you want to change default passwords or settings, edit docker-compose.yml:

Change Grafana Credentials:

grafana:
  environment:
    - GF_SECURITY_ADMIN_USER=your_username
    - GF_SECURITY_ADMIN_PASSWORD=your_password

Change InfluxDB Credentials:

influxdb:
  environment:
    - DOCKER_INFLUXDB_INIT_USERNAME=your_username
    - DOCKER_INFLUXDB_INIT_PASSWORD=your_password
    - DOCKER_INFLUXDB_INIT_ADMIN_TOKEN=your-secure-token-here

Important: If you change the InfluxDB token, update it in influx/influx_credentials.yaml as well.

Data Collection Interval

By default, the system refreshes data every 10 minutes. To change this, edit influx/fetch.py:

File Location:

  • Windows: %USERPROFILE%\Desktop\monitoring-dashboard\central-large-campus-monitoring-dashboard\influx\fetch.py
  • macOS/Linux: ~/Desktop/monitoring-dashboard/central-large-campus-monitoring-dashboard/influx/fetch.py
REFRESH_INTERVAL_MINUTES = 10  # Change to desired interval in minutes

Running the Application

Start All Services

From the project root directory, run:

docker-compose up --build

What happens:

  1. InfluxDB starts and initializes the database
  2. The data collection service connects to HPE Aruba Central and begins collecting metrics
  3. Grafana starts and automatically imports the 5 pre-configured dashboards
  4. The Next.js custom dashboard builds and starts

First-time startup takes 2-5 minutes as Docker downloads images and builds containers.

Run in Background (Detached Mode)

To run the services in the background:

docker-compose up --build -d

Check logs at any time:

docker-compose logs -f

Verify Services are Running

docker-compose ps

You should see 5 services running:

  • influxdb
  • influx-service (data collector)
  • grafana
  • next-dashboard
  • dashboard-importer (runs once and exits)

Accessing the Dashboards

Grafana Dashboard (Primary Visualization Platform)

Open your browser and navigate to: http://localhost:3000

Login Credentials:

  • Username: admin
  • Password: admin

Available Dashboards:

  1. Home Dashboard: Overview of all sites, devices, and network health
  2. Network Dashboard: Comprehensive network metrics and client data
  3. Access Points Dashboard: AP-specific metrics (CPU, memory, power, radio performance)
  4. Switches Dashboard: Switch health, hardware status, and port metrics
  5. Gateways Dashboard: Gateway status and performance

First-time Login: Grafana will prompt you to change the default password. You can skip this for lab environments.

Next.js Custom Dashboard

Open your browser and navigate to: http://localhost:3001

This dashboard provides:

  • Real-time device counts (APs, Switches, Gateways)
  • Device health statistics (Good/Fair/Poor)
  • Total alerts and critical alerts
  • System status overview

InfluxDB Web Interface (Advanced Users)

Open your browser and navigate to: http://localhost:8086

Login Credentials:

  • Username: admin
  • Password: password

Use this interface to:

  • Query raw data using Flux query language
  • View data buckets and measurements
  • Monitor database performance

Troubleshooting

Services Won't Start

Check Docker is running:

docker --version
docker-compose --version

Check if ports are already in use:

# Linux/macOS
lsof -i :3000
lsof -i :3001
lsof -i :8086

# Windows
netstat -ano | findstr :3000

Solution: Stop any services using these ports or change the ports in docker-compose.yml.

No Data Appearing in Dashboards

Verify credentials are correct:

Check data collection logs:

docker-compose logs influx-service

Look for successful API calls and data writes. Common issues:

  • Invalid credentials
  • Network connectivity problems
  • API rate limiting

Wait for initial data collection: The first data collection cycle takes 2-5 minutes. Refresh dashboards after waiting.

Grafana Shows "No Data"

Verify InfluxDB connection:

  1. Go to Grafana → Configuration → Data Sources
  2. Click on "InfluxDB"
  3. Click "Save & Test"
  4. Should show "Data source is working"

Check if data exists in InfluxDB:

docker exec -it $(docker ps -qf "name=influxdb") influx query 'from(bucket:"venue_data") |> range(start: -1h) |> limit(n:10)'

Docker Compose Version Errors

If you see errors about unsupported syntax or version:

Update Docker Compose:

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

# For Docker Compose V2 (recommended)
sudo apt install docker-compose-plugin

Then use docker compose (no hyphen) instead of docker-compose.

Container Crashes or Restarts

Check container logs:

docker-compose logs [service-name]

# Examples:
docker-compose logs influx-service
docker-compose logs grafana
docker-compose logs next-dashboard

Common fixes:

  • Insufficient memory: Increase Docker memory limit in Docker Desktop settings
  • Permission issues: Ensure Docker has access to the project directory

Can't Access Dashboards from Another Computer

By default, services only listen on localhost. To access from another machine:

  1. Find your host machine's IP address
  2. Update docker-compose.yml port bindings: 
    ports:
  - "0.0.0.0:3000:3000"  # Makes Grafana accessible on all network interfaces
  3. Restart services: docker-compose down && docker-compose up -d
  4. Access via http://YOUR_IP:3000

Security Warning: Only expose services on trusted networks.

Data Collection Details

What Data is Collected?

The system automatically collects the following metrics from Central:

Network Infrastructure:

  • Site health and location data
  • Device inventory (APs, Switches, Gateways)
  • Device status and uptime

Access Points:

  • CPU and memory utilization
  • Power consumption
  • Radio metrics (channel quality, utilization, interference)
  • Tunnel statistics (MOS, throughput, latency, packet loss)
  • WLAN throughput trends

Switches:

  • Health status and hardware metrics
  • CPU, memory, temperature
  • Fan and power supply status
  • Port statistics

Gateways:

  • Status and uptime
  • Configuration synchronization
  • Cluster information

Clients:

  • Client counts and locations
  • Connection quality and experience scores
  • Web application usage

Data Retention

  • Default retention: Unlimited (data persists until manually deleted)
  • To configure retention policies, access InfluxDB UI at http://localhost:8086
  • Average data growth: ~25 GB for several hours of continuous collection (varies by network size)

Collection Frequency

  • Default: Every 10 minutes
  • Configurable in influx/fetch.py by changing REFRESH_INTERVAL_MINUTES

Stopping and Cleaning Up

Stop All Services (Preserve Data)

docker-compose down

This stops all containers but keeps data volumes intact. Next time you run docker-compose up, your historical data will still be there.

Stop and Remove All Data

Warning: This deletes all collected data and configurations.

docker-compose down -v

The -v flag removes Docker volumes (InfluxDB and Grafana data).

Clean Up Docker System

To free up disk space by removing unused Docker resources:

docker system prune -a

Warning: This removes all unused images, containers, and networks. Only run this if you want to completely clean your Docker environment.

Restart Services

docker-compose restart

Or restart a specific service:

docker-compose restart influx-service

Additional Notes

Security Best Practices

For production deployments:

  1. Change default passwords in docker-compose.yml
  2. Protect credential files: Never commit account_credentials.yaml to version control
  3. Use HTTPS: Configure reverse proxy (nginx/Apache) with SSL certificates
  4. Enable authentication: Configure Grafana authentication (LDAP, OAuth, SAML)
  5. Network isolation: Use Docker networks to isolate services
  6. Regular updates: Keep Docker images updated with security patches

Performance Optimization

For large-scale deployments (100+ devices):

  1. Increase Docker resources: Allocate more CPU and RAM in Docker Desktop settings
  2. Use SSDs: Significantly improves InfluxDB query performance
  3. Adjust collection interval: Reduce frequency for fewer devices, increase for more
  4. Configure data retention: Set up InfluxDB retention policies to manage storage
  5. Scale horizontally: Run multiple instances with load balancing

Getting Help

Happy Monitoring!

About

A comprehensive, dockerized monitoring solution for Central that visualizes network performance, device health, and client experience data in real-time. This project provides two powerful dashboards (Grafana and a custom Next.js dashboard) connected to an InfluxDB time-series database for historical data analysis.

Resources

Readme
Activity
Custom properties

Stars

2 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages