Home
AI
Android

Beszel Mobile: Monitor Servers from Your Phone

basanta sapkota

Monitoring your servers remotely has never been easier. With Beszel Mobile, a Flutter-based Android/iOS app, we can check server health and metrics on the go. I built this app as a companion to Beszel, a lightweight self-hosted monitoring hub. In this post, I’ll cover what Beszel Mobile does, how to set it up, and why mobile alerts and dashboards are handy for any sysadmin or DevOps engineer.

Key Takeaways

  • What it is: Beszel Mobile is a Flutter mobile client for the open-source Beszel monitoring platform. It runs on Android and iOS.
  • Features: Live dashboards with CPU/memory/disk stats, per-system charts, container and service views, alert configuration, and security (PIN/biometric).
  • Setup: You connect it to your Beszel server (running on PocketBase) using your account. The app stores tokens securely. You can install from APK/IPA or build from source with flutter build.
  • Why it matters: It brings server monitoring to your pocket. You get early warnings (e.g. CPU or disk alerts) and can troubleshoot anywhere, not just at your desktop.
  • Alternatives: Compared to the iOS-only Beszel Companion or generic monitoring apps, Beszel Mobile is open-source, cross-platform, and tightly integrated with Beszel’s features.
  • Best Practices: Track key metrics (CPU, RAM, disk, network) and use smart alerts to avoid noise. The app lets you set threshold alerts (CPU, memory, disk, etc.) and get push notifications on your phone.

By the end of this guide, you’ll have a clear overview of Beszel Mobile and how it fits into a robust monitoring strategy.

What is Beszel Mobile?

Beszel Mobile is a cross-platform Flutter app (Android & iOS) that connects to your Beszel server over the network. The Beszel server (hub) is a lightweight monitoring platform that collects system and Docker/Podman stats. Beszel itself uses PocketBase for its backend (database, authentication and real-time subscriptions).

When you fire up Beszel Mobile, it asks for your Beszel server URL and login. Once connected, the app subscribes to real-time metrics via WebSockets. In practice, you see a dashboard listing your servers with health indicators and metrics like CPU, RAM, and disk usage. Tapping a system drills down into detailed charts and gauges (per-core CPU, network throughput, disk I/O, etc.) for the last hour or day.

The app also lets you view containers and services on each system, track alert history, and manage alert thresholds. Overall, it mirrors many features of Beszel’s web UI but optimized for a small touchscreen.

Key Features

Beszel Mobile bundles a lot of functionality in a clean interface:

  • Real-time Dashboard: See all systems and their status (up/down), plus small inline bars for CPU/RAM/Disk. Filter or search systems easily.
  • Detailed System View: Tap into a system to see circular gauges for CPU, memory, disk, swap, and network I/O. Interactive time-series charts let you adjust the time range (e.g. last 1h to 30d).
  • Per-Core CPU & Network Stats: View each CPU core’s usage and live network throughput (upload/download) per interface.
  • Container Monitoring: See all running Docker or Podman containers per host, with their own CPU/memory usage and status (running, stopped, health).
  • Alerts & Notifications: View active alerts across systems and add new alert rules (e.g. CPU >80%, Memory >70%) directly in the app. You receive push notifications if thresholds are breached.
  • Security: Lock the app with a 4-digit PIN or biometric (fingerprint/FaceID) so your data stays private.
  • History & Trends: Check charts of historical metrics (up to 24h or more) for trend analysis. This helps spot issues like gradually filling disks or rising memory use.
  • Multi-OS Support: Beszel Mobile works on Android and iOS (iOS 12+). It even provides unsigned iOS builds for TrollStore users.

These match closely what the official Beszel documentation lists: “view servers at a glance with real-time status, CPU, memory, and disk usage” on the dashboard, plus detailed per-core and network insights. In short, Beszel Mobile brings the full power of your Beszel monitoring hub to your phone. It’s built with Flutter for native performance and uses PocketBase under the hood for live updates and auth.

Installation and Setup

Getting started is straightforward if you already have Beszel running. First, install or build the app:

  • Android: Download the latest APK from the GitHub releases or build from source: 

    flutter build apk --release

    This creates an app-release.apk which you can sideload onto your device.

  • iOS: Download the Beszel.ipa from releases. For regular installation, you’ll need to sign it with AltStore or Xcode. (Alternatively, use the built-in TrollStore support for unsigned IPA.) You can also build yourself: 

    flutter build ios --release

    Then open the Xcode workspace and archive/install.

  • Desktop/Web (optional): The project even supports Flutter desktop (macOS, Windows, Linux) and web, but the mobile UI is key.

After installing the app, you’ll configure it on first launch. Enter your Beszel Server URL (the address of your Beszel hub, e.g. https://beszel.example.com) and your Beszel login (email/password). The app will store an auth token securely. Once connected, the dashboard loads and you’ll see your systems list.

On the Beszel server side, ensure your Beszel instance is accessible from your phone’s network. If you deployed Beszel with Docker Compose, the default is http://localhost:8090 (you’ll need to use your server’s IP or domain). The Beszel documentation provides a quick-start example of using Docker Compose to run the hub and agent. In short, start the Beszel hub first (via binary or Docker) and create an admin user, then add your first system (agent) through the web UI, which generates a public key and token. Finally, run the agent on that system (point it at the hub URL, key, and token).

For example, a minimal Compose setup from the docs:

version: '3'
services:
  beszel:
    image: henrygd/beszel:latest
    environment:
      APP_URL: http://localhost:8090
    ports:
      - 8090:8090
    volumes:
      - ./beszel_data:/beszel_data

  beszel-agent:
    image: henrygd/beszel-agent:latest
    network_mode: host
    environment:
      HUB_URL: http://localhost:8090
      TOKEN: <your-token>
      KEY: "<your-key>"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./beszel_agent_data:/var/lib/beszel-agent

After running docker compose up -d, go to http://<server>:8090 in a browser to set up the admin account. Then use the Add System dialog in the web UI to configure a new host. Enter its name, host/IP (or use a Unix socket), and assign the public key/token. With the agent started, the host appears online on the dashboard.

Once your Beszel hub is feeding data, the mobile app will immediately display it. Use the servers list or dashboard to pick a system and see details. The transition from desk to phone is seamless.

Using Beszel Mobile in the Real World

In practice, Beszel Mobile helps me catch issues faster. For example, our team had an intermittent disk space problem on one server. Instead of SSHing every server, I got an alert on my phone when disk usage crossed 90%. Opening the app, I saw the offending server at a glance and jumped to its detail screen. The interactive chart showed the disk was filling up over time, not a sudden spike. We quickly cleaned up old logs and added an alert rule to notify before 95% usage.

Similarly, container failures are easier to monitor. The Containers view lists all Docker containers with their health status. If a container crashes, Beszel Mobile shows it as “down” and you can restart it from your phone or terminal immediately.

Beszel Mobile also supports offline caching. If you briefly lose connectivity, you can still scroll through the last loaded charts. When connection returns, live updates resume via the Beszel-PocketBase WebSocket.

Here’s a quick example of using the app’s features (Android UI shown):

# Example: Add Beszel server URL in app
Server URL: https://beszel.example.com

# Tap "Login", then go to dashboard when connected.
# Tap a system for details:
#   CPU usage: 23% (12 cores)
#   Memory: 45%
#   Disk: 60%
#   Network: 1.2 kB/s up, 3.4 kB/s down
# View charts for last 1h/24h. 
# Tap Containers to see running Docker containers.
# Tap Alerts to see or configure threshold alerts.

This kind of mobile-first monitoring complements your desktop setup. In my experience, having a phone alert and dashboard avoids the “silent failure” problem. Instead of only learning about issues when users complain, Beszel Mobile’s notifications and charts give us eyes on our servers 24/7.

Comparison with Other Mobile Monitoring Apps

Beszel Mobile is part of a small but growing ecosystem of mobile server monitors. For example, Beszel Companion is an iOS-only app (Swift) that also interfaces with Beszel. It offers widgets, OAuth auth, multi-hub support, and a polished iOS experience. However, it’s not available on Android. In contrast, Beszel Mobile is cross-platform (Android & iOS) and open-source (MIT license). This means anyone can contribute or audit the code.

General-purpose monitoring services like Datadog, Prometheus, or Grafana also have mobile apps or responsive UIs, but those systems are heavier to run and often proprietary. Beszel’s niche is simplicity and Docker integration, while still giving core metrics. The Beszel docs tout it as “lighter and less resource-intensive than leading solutions”. If you use Beszel for local monitoring, the Mobile app is the official (yet community-built) way to take it on the go.

In summary, Beszel Mobile stands out because:

  • It’s bespoke for Beszel: you get the exact same metrics and containers from your Beszel hub, with no middleman.
  • It supports both major mobile platforms (most alternatives are single-platform).
  • It’s free and open, with no vendor lock-in.
  • It directly implements best practices: real-time updates, threshold alerts, historical context.

Despite being quite full-featured, the app stays lightweight and focuses on essentials. I encourage you to compare it to any other mobile monitoring client, but chances are Beszel Mobile covers what you need for home lab or small fleet monitoring.

Best Practices: Why Mobile Alerts and Dashboards Help

Before wrapping up, let’s quickly touch on monitoring best practices that Beszel Mobile helps with. Monitoring is most useful when you focus on the right metrics and set smart alerts. For servers, key metrics include CPU load, memory usage, disk space, disk I/O, and network traffic. Beszel covers all of these by default.

However, raw data alone isn’t enough. Good monitoring means:

  • Real-time visibility: See what’s happening now, as Beszel Mobile does via WebSockets.
  • Historical context: Look at trends. A gradually rising memory graph can warn of a leak. Mobile charts allow that.
  • Alerts with thresholds: For example, trigger only if CPU >90% for X minutes, or if disk usage hits 95%. The app lets you configure these so you only get notified for real issues, reducing noise.
  • Incident response: When an alert fires, see details immediately. The mobile UI shows which server and metric tripped the alert, so you can act.

In practice, we avoid alert fatigue by tuning thresholds and grouping alerts. A mobile push on every tiny spike is noisy; we aim for alerts when something is really wrong. Beszel Mobile supports this by listing active alerts and letting us edit them per system.

It’s also wise to secure the app and communications. Beszel Mobile uses secure tokens and optional biometrics, and the Beszel hub supports TLS or reverse proxy setups. Always follow secure connection practices if exposing your hub (e.g. using HTTPS and a VPN for remote access).

By following these practices and using tools like Beszel (and its mobile client), teams can keep their infrastructure reliable. The UptimeRobot guide points out that continuous monitoring with smart alerts is key to catching issues early. With Beszel Mobile, that proactive monitoring is literally in your pocket.

Conclusion and Next Steps

To sum up, Beszel Mobile is an open-source way to keep tabs on your servers from anywhere. In this post we saw how it provides live dashboards, historical charts, and alert management on your phone. We covered the installation steps (getting the app, connecting to your hub) and compared it with other options. Most importantly, we saw why mobile monitoring matters: you get early warnings and can react faster to server issues.

If you’re already using Beszel, I encourage you to try the mobile app. Download the latest APK/IPA or build it yourself with Flutter. For more general monitoring tips, check out our Linux server monitoring guide which covers setting up agents and alerts.

Let me know what you think of Beszel Mobile! The source code is on GitHub if you want to contribute or raise issues. And if you have questions, feel free to leave a comment. Happy monitoring, and stay alert! 😊

Post a Comment