Running Netdata: Real-Time Server Monitoring That Just Works

Most monitoring tools make you suffer through hours of configuration before you see a single metric. Netdata flips that on its head — install it, and within seconds you’re looking at hundreds of real-time charts covering every aspect of your system. No agents to configure, no dashboards to build, no query languages to learn.

What is Netdata?

Netdata is an open-source, real-time monitoring agent that collects thousands of metrics per second from your servers, containers, and applications. It comes with a built-in web dashboard that auto-discovers everything running on your system and visualizes it immediately.

Why Netdata Over Other Monitoring Tools?

• Zero configuration: Auto-discovers services, containers, and hardware
• Real-time: Per-second granularity, not the 15-second or 1-minute intervals most tools use
• Lightweight: Uses ~1% CPU and ~100MB RAM even while tracking 2000+ metrics
• Beautiful dashboard: Interactive charts out of the box — no Grafana required
• Smart alerts: Pre-configured alarms for common issues (disk full, RAM pressure, CPU spikes)
• Container-aware: Automatically monitors Docker and Kubernetes workloads
• No database required: Uses a custom time-series database that’s incredibly efficient

Prerequisites

Before starting, you’ll need:

• A Linux server (Ubuntu 22.04+ or Debian 12+ recommended)
• Docker and Docker Compose installed
• 512MB+ free RAM (Netdata is light but needs some headroom)
• A domain name (optional, for remote access)

Step 1: Create the Directory Structure

mkdir -p ~/netdata
cd ~/netdata

Step 2: Create the Docker Compose File

Create docker-compose.yml:

services:
  netdata:
    image: netdata/netdata:stable
    container_name: netdata
    hostname: ${HOSTNAME:-my-server}
    restart: unless-stopped
    ports:
      - "19999:19999"
    cap_add:
      - SYS_PTRACE
      - SYS_ADMIN
    security_opt:
      - apparmor:unconfined
    volumes:
      - netdataconfig:/etc/netdata
      - netdatalib:/var/lib/netdata
      - netdatacache:/var/cache/netdata
      - /etc/passwd:/host/etc/passwd:ro
      - /etc/group:/host/etc/group:ro
      - /etc/localtime:/etc/localtime:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
      - /var/log:/host/var/log:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro

volumes:
  netdataconfig:
  netdatalib:
  netdatacache:

A few things to note about this configuration:

• SYS_PTRACE and SYS_ADMIN capabilities let Netdata access detailed process and cgroup information
• The host filesystem mounts (/proc, /sys, /etc) give Netdata visibility into the host system from inside the container
• The Docker socket mount enables container monitoring
• Port 19999 is Netdata’s default dashboard port

Step 3: Launch Netdata

docker compose up -d

That’s it. Open http://your-server-ip:19999 in your browser and you’ll immediately see a full dashboard with hundreds of charts.

Step 4: Understanding the Dashboard

The Netdata dashboard is organized into sections:

• System Overview: CPU, RAM, disk I/O, network traffic at a glance
• CPU: Per-core utilization, frequency, thermals
• Memory: RAM usage, swap, page faults, kernel memory
• Disks: I/O bandwidth, operations, latency per device
• Network: Bandwidth, packets, errors, drops per interface
• Containers: Per-container CPU, memory, and network (auto-discovered)
• Applications: Per-process resource usage grouped by type
• Systemd Services: Resource usage per systemd unit

Everything updates every second by default. You can click and drag on any chart to zoom in, and all charts sync together — zoom one, and they all follow.

Step 5: Configure Alerts

Netdata ships with hundreds of pre-configured alerts, but you can customize them. First, access the config:

docker exec -it netdata bash
cd /etc/netdata
./edit-config health.d/cpu.conf

Example: Change the CPU alert threshold:

alarm: cpu_high_usage
on: system.cpu
lookup: average -5m unaligned of user,system,softirq,irq
units: %
every: 1m
warn: $this > 80
crit: $this > 95
info: Average CPU utilization over the last 5 minutes

To get alert notifications via email, Slack, Discord, or Telegram, edit the notification config:

docker exec -it netdata bash
cd /etc/netdata
./edit-config health_alarm_notify.conf

For Discord notifications, add:

SEND_DISCORD="YES"
DISCORD_WEBHOOK_URL="https://discord.com/api/webhooks/your-webhook-url"
DEFAULT_RECIPIENT_DISCORD="monitoring"

Restart Netdata after config changes:

docker compose restart

Step 6: Enable Netdata Cloud (Optional)

Netdata Cloud gives you a free centralized view if you’re monitoring multiple servers. It doesn’t store your metrics — your nodes stream data directly to your browser through Netdata’s infrastructure.

To connect your node:

1. Create a free account at app.netdata.cloud
2. Create a Space and a Room
3. Copy the claim command and run it:

docker exec -it netdata netdata-claim.sh -token=YOUR_TOKEN -rooms=YOUR_ROOM_ID -url=https://app.netdata.cloud

If you prefer to keep everything local, skip this step entirely — the local dashboard is fully featured on its own.

Step 7: Monitor Docker Containers

If you mounted the Docker socket (we did in our compose file), Netdata automatically discovers and monitors all running containers. You’ll see:

• Per-container CPU usage
• Memory consumption and limits
• Network I/O per container
• Disk I/O per container

No additional configuration needed. Spin up a new container and it appears in the dashboard within seconds.

Step 8: Data Retention

By default, Netdata stores metrics using its dbengine — a custom time-series database. The default retention depends on the number of metrics and available disk space, but you can configure it explicitly:

docker exec -it netdata bash
cd /etc/netdata
./edit-config netdata.conf

Under the [db] section:

[db]
    mode = dbengine
    storage tiers = 3
    dbengine multihost disk space MB = 1024
    dbengine tier 1 multihost disk space MB = 512
    dbengine tier 2 multihost disk space MB = 256

This gives you:

• Tier 0: Per-second data (1GB disk = ~2 days for 2000 metrics)
• Tier 1: Per-minute aggregates (512MB = ~2 months)
• Tier 2: Per-hour aggregates (256MB = ~2 years)

Step 9: Secure Your Dashboard

By default, Netdata’s dashboard is accessible to anyone who can reach port 19999. For production use, you should restrict access.

Option A: Bind to Localhost + Reverse Proxy

Update your docker-compose.yml to only expose locally:

ports:
  - "127.0.0.1:19999:19999"

Then put it behind Nginx Proxy Manager, Traefik, or Caddy with authentication.

Option B: Netdata’s Built-in Access Control

Edit the Netdata config:

docker exec -it netdata bash
cd /etc/netdata
./edit-config netdata.conf

Add under [web]:

[web]
    allow connections from = localhost 192.168.*
    allow dashboard from = localhost 192.168.*

Troubleshooting

Dashboard Shows “No Data”

Make sure the required volume mounts are correct. The most common issue is missing /proc or /sys mounts:

docker exec -it netdata ls /host/proc

If that returns nothing, check your volume mounts in the compose file.

Container Monitoring Not Working

Verify the Docker socket is accessible:

docker exec -it netdata ls -la /var/run/docker.sock

The Netdata process inside the container needs read access to the socket.

High Memory Usage

If Netdata is using more RAM than expected, reduce the number of collected metrics:

docker exec -it netdata bash
cd /etc/netdata
./edit-config netdata.conf

Add under [plugins]:

[plugins]
    proc = yes
    cgroups = yes
    apps = no  # Disable per-process monitoring to save RAM

Netdata vs. Alternatives

Netdata wins for single-server or small-cluster monitoring where you want instant visibility without an engineering project. For large-scale infrastructure with complex querying needs, Prometheus + Grafana is still the standard.

Wrapping Up

Netdata gives you production-grade monitoring with nearly zero setup. In the time it takes to write a Prometheus config file, you’ll have Netdata running with hundreds of metrics, pre-built alerts, and a dashboard that actually looks good.

For most self-hosters, this is all the monitoring you need. Install it on every server, optionally connect them through Netdata Cloud, and you’ll never wonder “what’s eating my CPU?” again.

Useful links:

• Netdata GitHub
• Netdata Documentation
• Netdata Cloud (free tier)