Mastering System Monitoring: Integrating Glances with Home Assistant

A reliable smart home ecosystem isn't just about automating lights and sensors; it's also about ensuring the foundation upon which it runs is stable and healthy. For many Home Assistant users, this means monitoring the performance and resources of the server running HA, whether it's a Raspberry Pi, a mini PC, a NAS, or a virtual machine. But monitoring goes beyond just the HA host – you might want to keep an eye on other critical systems in your home network.

Why Monitor Your System?

Ignoring system health can lead to unexpected outages, slow performance, data loss (if a disk fails), or missed automations. Monitoring key metrics like CPU load, memory usage, disk space, temperature, and network activity allows you to:

• Identify bottlenecks causing performance issues.
• Receive alerts before critical resources (like disk space) run out.
• Track temperatures to prevent overheating and potential hardware damage.
• Monitor network traffic to spot anomalies or understand usage patterns.
• Ensure essential services are running.

Integrating this data into Home Assistant puts it right where you manage your smart home, enabling powerful automations based on system state.

What is Glances?

Glances is a free, open-source, cross-platform monitoring tool that presents a large amount of system information through a curses or Web based interface. It can collect data from various sensors and APIs and display information about CPU, memory, disk I/O, file system, network interfaces, processes, battery, sensors (temperature, fan speed, voltages), and much more. Crucially for our purpose, Glances has a robust API that Home Assistant can connect to.

Prerequisites

• A running Home Assistant instance.
• Access to the system(s) you want to monitor (e.g., SSH access).
• Python installed on the target system(s) (usually comes pre-installed on Linux/macOS).
• Basic command-line familiarity.

Step 1: Installing and Configuring Glances

Glances is typically installed using Python's package manager, pip.

Installation

Connect to the system you want to monitor via SSH or terminal. Run the following command:

pip install glances[web]

The [web] part includes dependencies needed for the web server and API. You might need to use pip3 instead of pip depending on your system's Python setup. You might also need to use sudo if installing system-wide:

sudo pip install glances[web]

Wait for the installation to complete.

Running Glances with Web/API Mode

To make Glances' data available to Home Assistant, you need to run it in server mode with the WebUI/API enabled. The default port is 61208.

glances -w

This command starts Glances in web server mode. You can access the WebUI by navigating to http://[target_system_ip]:61208 in your web browser. This also enables the JSON API on the same port at http://[target_system_ip]:61208/api/3/.

For a more permanent solution, you might want to run Glances as a service using tools like systemd. A basic systemd service file (e.g., /etc/systemd/system/glances.service) might look like this (adjust paths as necessary):

[Unit]
Description=Glances System Monitor
After=network.target

[Service]
ExecStart=/usr/local/bin/glances -w
Restart=always
User=glances # Create a dedicated user or use root if necessary (less secure)

[Install]
WantedBy=multi-user.target

After creating the service file, reload the systemd daemon and start the service:

sudo systemctl daemon-reload
sudo systemctl start glances
sudo systemctl enable glances # To start on boot

Verify Glances is running and accessible from your Home Assistant server's network before proceeding.

Step 2: Integrating with Home Assistant

Home Assistant has an official integration for Glances, making the setup straightforward.

1. In Home Assistant, go to Settings > Devices & Services.
2. Click the '+ Add Integration' button in the bottom right.
3. Search for 'Glances'.
4. Select the Glances integration.

5. A configuration dialog will appear:

   • Host: Enter the IP address or hostname of the system running Glances (e.g., 192.168.1.100).
   • Port: The port Glances is running on (default is 61208).
   • Username/Password (Optional): If you configured Glances with API authentication (highly recommended for security), enter the credentials here.
6. Submit the form. Home Assistant will attempt to connect to Glances.
7. If successful, it will discover the available sensors. You can select which sensors you want to enable immediately or do this later via the entity registry.
8. Click 'Finish'.

Home Assistant will now create a device representing your monitored system, with entities for each enabled sensor (CPU usage, Memory Free, Disk Usage /, etc.).

Understanding Glances Entities in Home Assistant

The Glances integration exposes various sensors based on the data available from the Glances API. Entity naming usually follows a pattern like sensor.[system_name]_[metric] (e.g., sensor.server_cpu_total, sensor.server_memory_free, sensor.server_disk_use).

Common entity types you'll see include:

• sensor.*_cpu_total: Overall CPU usage percentage.
• sensor.*_memory_use: Used memory percentage.
• sensor.*_memory_free: Free memory in MB or GB.
• sensor.*_swap_use: Used swap percentage.
• sensor.*_disk_use_root (or similar): Disk usage percentage for specific mount points.
• sensor.*_network_rx / sensor.*_network_tx: Network received/transmitted data rates.
• sensor.*_temperature_cpu (or similar): CPU temperature from available sensors.
• sensor.*_process_count: Total number of running processes.
• sensor.*_load_avg_1min / 5min / 15min: System load averages.

The available entities will depend on the hardware and operating system of the monitored system, as well as what Glances can detect.

Device Integration Tips and Advanced Usage

Monitoring Multiple Machines

Simply repeat Step 2 for each system you want to monitor, ensuring Glances is running on each with its API accessible from Home Assistant. Each system will show up as a separate device in Home Assistant.

Filtering Data / Specific Processes

By default, Glances provides overall system stats. If you need to monitor metrics for a specific process (e.g., the Home Assistant process itself if HA isn't running in a constrained environment), Glances can be configured to expose this via its API using command-line flags or configuration files. Refer to the Glances documentation for advanced process monitoring configurations.

Using Templates

Sometimes, the raw data isn't exactly what you need. For example, if you want disk usage in TB or need to combine multiple sensors, you can use Home Assistant Template Sensors to transform the data.

Example: Convert free memory from MB to GB:

# In your configuration.yaml or a dedicated templates file
template:
  - sensor:
      - name: "Server Memory Free GB"
        unit_of_measurement: "GB"
        state:
          "{{ (states('sensor.server_memory_free') | float / 1024) | round(2) }}"
        availability:
          "{{ states('sensor.server_memory_free') not in ('unknown', 'unavailable') }}"

Best Practices for a Reliable Monitoring Setup

Security: Protecting the Glances API

Running Glances with the -w flag opens a web server and API endpoint on your network. If this port is exposed outside your local network, it's a significant security risk. Even within your local network, it's good practice to secure it.

Glances supports API password protection. You can set this up via a configuration file or environment variables. Consult the Glances documentation for details on setting up authentication.

Alternatively, or in addition, use a firewall on the monitored system to restrict access to port 61208 only to the IP address of your Home Assistant server.

Leveraging Monitoring Data in Dashboards

Add your Glances sensors to your Home Assistant dashboards. Use cards like the 'Entities' card, 'History Graph', 'Gauge', or 'Statistics Graph' to visualize key metrics over time. This gives you an at-a-glance view of your systems' health.

The standard 'System Monitor' card in Lovelace can be configured to show these Glances entities in a clean format.

Setting Up Critical Alerts

This is where monitoring becomes proactive. Use Home Assistant automations to send notifications when metrics cross critical thresholds.

Example Automation: Alert when disk space on the root partition goes below 10%.

automation:
  - alias: 'Alert Low Disk Space Server'
    description: 'Notify when server root disk usage is high'
    trigger:
      - platform: numeric_state
        entity_id: sensor.server_disk_use_root # Adjust entity ID
        above: 90
        for: # Optional: only trigger if above 90% for 5 minutes
          minutes: 5
    condition: [] # No conditions needed here usually
    action:
      - service: persistent_notification.create # Or use your preferred notification service (Telegram, Pushover, Mobile App, etc.)
        data:
          title: "🏡 Home Assistant Server Alert"
          message: "Warning: Disk usage on server root partition is {{ states('sensor.server_disk_use_root') }}%!
                     System performance may be impacted or fail soon. Free up space!"
    mode: single

Set up similar alerts for high CPU usage, low free memory, critical temperatures, etc.

Performance Impact

The Glances integration polls the Glances API periodically (default is every 60 seconds). While typically light on resources, monitoring a large number of systems or having very frequent polling intervals could add slight load to both the monitored system and the Home Assistant server. For most home setups, the default polling interval is sufficient.

Conclusion

Integrating Glances with Home Assistant provides invaluable insight into the health and performance of your critical systems. By setting up monitoring, visualizing data, and configuring proactive alerts, you move from reacting to problems to preventing them, ensuring your Home Assistant instance and the services it relies upon remain stable and reliable. This is a fundamental step towards a truly robust smart home ecosystem.