A Python-based network infrastructure monitoring platform for real-time device availability, latency and system health monitoring.
The Intelligent Network Health Dashboard - Version 1 is a Linux-hosted network monitoring application developed to provide centralized visibility into the availability and basic health of network infrastructure.
The system monitors configured routers, switches, servers and other IP-enabled devices using ICMP-based reachability checks. Monitoring results are processed through a Python backend and displayed through a web-based dashboard, allowing administrators to quickly identify healthy and unreachable devices.
Version 1 establishes the core monitoring foundation for future enhancements including automatic network discovery, DHCP-aware device tracking, SNMP resource monitoring, SSH-based configuration backup, alerting and AI-assisted network diagnostics.
- Centralize monitoring of network infrastructure devices.
- Monitor device availability using ICMP health checks.
- Measure network response time and latency.
- Maintain device inventory and monitoring history.
- Provide a centralized dashboard for infrastructure visibility.
- Demonstrate practical integration of Networking, Linux, Python, Database and Web technologies.
The application follows a modular monitoring architecture that separates the web interface, monitoring engine, scheduler, database and network devices.
Network Administrator
|
v
Web Dashboard
|
v
Flask Application
|
+--------------+--------------+
| | |
v v v
Device API Monitoring Scheduler
| | |
| v |
| ICMP Engine <-------+
| |
v v
Database Network Devices
| / | \
| Router Switch Server
|
v
Monitoring History
Device Configuration
↓
IP Address Retrieved
↓
ICMP Health Check
↓
Response Evaluated
↓
Latency Calculated
↓
Device Status Updated
↓
Result Stored in Database
↓
Dashboard Updated
The system monitors configured infrastructure devices using their IP addresses.
Supported device categories include:
- Routers
- Switches
- Linux servers
- Windows systems
- Network appliances
- Other ICMP-enabled devices
The monitoring engine periodically sends ICMP echo requests to configured devices.
Monitoring Server
|
| ICMP Echo Request
v
Network Device
|
| ICMP Echo Reply
v
Monitoring Server
The device status is determined based on the received response.
Healthy
The device responds successfully.
Critical
The device fails to respond within the configured timeout.
The system records ICMP response time to provide visibility into network latency.
Example:
Device : Router-01
IP Address : 192.168.1.1
Status : Healthy
Latency : 2.4 ms
The application maintains device information including:
- Device name
- IP address
- Device type
- Monitoring status
- Current health status
- Last successful check
- Monitoring history
APScheduler executes monitoring tasks at configured intervals without requiring manual execution.
Scheduler
|
+----> Router
|
+----> Switch
|
+----> Linux Server
|
+----> Network Device
The dashboard provides centralized visibility into:
- Total monitored devices
- Healthy devices
- Critical devices
- Device availability
- Network latency
- Monitoring history
- Linux system health
The monitoring server's own system resources are collected using psutil.
Metrics include:
- CPU utilization
- Memory utilization
- System health information
Monitoring and application activities are recorded through structured log files.
Logging covers:
- Monitoring events
- Scheduler events
- Application events
- Errors and exceptions
- Troubleshooting information
The following screenshots demonstrate the major capabilities of Version 1.
Note: Store all screenshots inside the
screenshots/directory using the filenames shown below.
Centralized dashboard displaying the overall health of the monitored infrastructure.
Displays configured routers, switches, servers and other monitored network devices.
Provides detailed information about an individual monitored device, including IP address, status, latency and monitoring information.
Displays historical latency information collected from monitored devices.
Displays the Health of the API and Linux monitoring server.
Demonstrates the system detecting an unreachable network device and changing its status to Critical.
Shows the monitoring application running on the Ubuntu Linux server.
| Category | Technology |
|---|---|
| Operating System | Ubuntu 26.04 LTS |
| Programming Language | Python |
| Web Framework | Flask |
| Database | SQLite |
| ORM | Flask-SQLAlchemy |
| Network Monitoring | ICMP / Ping |
| System Monitoring | psutil |
| Task Scheduling | APScheduler |
| Frontend | HTML, CSS, Bootstrap |
| Visualization | Chart.js |
| Version Control | Git / GitHub |
linux_automation/
│
├── backend/
│ ├── app/
│ │ ├── models/
│ │ ├── monitoring/
│ │ ├── routes/
│ │ ├── scheduler/
│ │ ├── static/
│ │ ├── templates/
│ │ └── utils/
│ │
│ ├── logs/
│ └── tests/
│
├── logs/
│
├── screenshots/
│ ├── dashboard-overview.png
│ ├── device-inventory.png
│ ├── device-details.png
│ ├── latency-monitoring.png
│ ├── system-health.png
│ ├── critical-device.png
│ └── linux-deployment.png
│
├── requirements.txt
└── README.md
- Ubuntu 26.04 LTS
- Python 3.10+
- SQLite 3
- Git
- ICMP connectivity to monitored devices
sudo apt update
sudo apt upgrade -ysudo apt install -y python3 python3-venv python3-pip git sqlite3 iputils-pingVerify:
python3 --version
git --version
sqlite3 --version
ping -Vgit clone https://github.com/GD-125/linux_automation.gitNavigate to the project:
cd linux_automationpython3 -m venv .venvActivate it:
source .venv/bin/activatepip install --upgrade pip
pip install -r requirements.txtVersion 1 uses SQLite as the default database.
The application creates the required database structure according to the configured Flask application.
Environment variables can be configured as required:
export FLASK_APP=backend.app
export FLASK_ENV=developmentFor production environments, sensitive configuration values should be stored through environment variables or a dedicated secrets-management solution.
Start the Flask application:
python -m flask --app backend.app run --host 0.0.0.0 --port 5000Open the dashboard locally:
http://localhost:5000
To access it from another system on the same network:
http://<SERVER-IP>:5000
Example:
http://192.168.1.10:5000
Before adding a device to the dashboard, verify connectivity from the monitoring server.
Example:
ping 192.168.1.1Successful response:
64 bytes from 192.168.1.1
The reachable device can then be added to the monitoring inventory.
LAN
|
+--------+--------+
| |
Router-01 Switch-01
192.168.1.1 192.168.1.2
| |
+--------+--------+
|
Ubuntu Server
192.168.1.10
|
v
Monitoring System
|
v
Web Dashboard
Example dashboard data:
Device IP Address Status Latency
----------------------------------------------------
Router-01 192.168.1.1 Healthy 1.8 ms
Switch-01 192.168.1.2 Healthy 2.1 ms
Server-01 192.168.1.20 Critical Timeout
| Capability | Status |
|---|---|
| Manual device registration | ✅ |
| IP-based monitoring | ✅ |
| ICMP availability checks | ✅ |
| Healthy/Critical status | ✅ |
| Latency monitoring | ✅ |
| Device inventory | ✅ |
| Monitoring history | ✅ |
| Linux system metrics | ✅ |
| Background monitoring | ✅ |
| Centralized logging | ✅ |
| Web dashboard | ✅ |
Version 1 intentionally uses an IP-based device monitoring model.
If a monitored device receives its address dynamically through DHCP and its IP changes, the application may no longer be able to associate the new address with the original device.
Version 1 also focuses on basic availability and health monitoring. Detailed infrastructure metrics such as router/switch CPU, memory, interface statistics, bandwidth, temperature and uptime are planned for future versions through SNMP.
Planned:
- Automatic network discovery
- DHCP-aware device tracking
- Hostname resolution
- MAC address tracking
- Automatic inventory updates
- Network range scanning
- Discovery history
Planned:
- SNMP monitoring
- CPU utilization
- Memory utilization
- Interface statistics
- Bandwidth utilization
- Device uptime
- Historical performance analysis
Planned:
- SSH configuration backup
- Configuration versioning
- Configuration comparison
- Automated alerts
- Email notifications
- Scheduled backups
- Configuration recovery workflows
Planned:
- AI network assistant
- Natural-language network queries
- Root-cause analysis suggestions
- Historical incident analysis
- Capacity planning
- Predictive alerts
- Intelligent troubleshooting recommendations
AI-generated recommendations will follow a human-in-the-loop approach, requiring administrator review before configuration changes are executed.
Before using the project in a production environment:
- Never hard-code device credentials.
- Use environment variables or secure secret storage.
- Restrict access to monitoring interfaces.
- Implement authentication and role-based access control.
- Validate all device information.
- Maintain configuration backups before automated changes.
- Log administrative activities.
- Use HTTPS for production deployments.
- Follow least-privilege principles.
- IP addressing
- ICMP
- Network reachability
- Latency monitoring
- Network device monitoring
- Infrastructure troubleshooting
- Ubuntu administration
- Command-line operations
- Package management
- Process and resource monitoring
- Log management
- Flask
- Network monitoring automation
- Background scheduling
- Database integration
- Exception handling
- Modular application design
- Device inventory
- Availability monitoring
- Infrastructure health monitoring
- Centralized logging
- Operational visibility
This project was developed to demonstrate practical Network Engineering, Linux Administration, Python Automation and Infrastructure Monitoring skills.
Version 1 establishes the foundation for a progressively enhanced Network Management System. Future versions will extend the platform from basic availability monitoring toward automatic discovery, SNMP-based infrastructure monitoring, network automation and AI-assisted network operations.
This project is intended for educational, learning and portfolio purposes.
This project uses the following open-source technologies:
- Python
- Flask
- Flask-SQLAlchemy
- APScheduler
- psutil
- Bootstrap
- Chart.js
- SQLite
- Ubuntu Linux