Netdata on VPS: installation, configuration, and maintenance

Netdata on VPS is a powerful real-time monitoring system that can be deployed on a virtual server to track the performance, health, and resources of your infrastructure with minimal cost and maximum detail.

What is Netdata and why do you need it on your VPS?

Netdata is a free, open-source, high-fidelity system and application health and performance monitoring tool. It collects thousands of metrics in real-time (per-second) from operating systems, applications, web servers, databases, and much more, visualizing them on an interactive web dashboard. Deploying Netdata on a VPS gives you full control over your virtual server, allowing you to identify bottlenecks, predict problems, and optimize performance.

Unlike traditional monitoring systems, which often require complex configurations and significant system resources, Netdata is designed for maximum efficiency. It uses a minimal amount of CPU and RAM, making it an ideal solution for installation on a VPS, where every megabyte and every CPU cycle matters. This allows even small VPS instances to gain deep insight into what's happening within the system without significantly impacting the performance of the main application.

Key Features and Benefits of Netdata

Netdata stands out from other solutions due to its unique approach to data collection and visualization. Here are the main advantages that make it an indispensable tool for any VPS administrator:

• Real-time Monitoring: Collects metrics with up to 1-second resolution, providing an instant picture of system status.
• Wide Range of Integrations: Supports data collection from hundreds of sources, including CPU, RAM, disks, network, processes, Apache, Nginx, MySQL, PostgreSQL, Docker, Kubernetes, and many more.
• Interactive Web Dashboard: A modern, intuitive interface makes it easy to explore data, scale graphs, and compare metrics.
• Efficient Resource Usage: Designed to run even on low-power systems, consuming minimal CPU and RAM.
• Alerting System: Built-in alerts with support for multiple notification channels (email, Slack, Telegram, PagerDuty, etc.) allow for prompt response to issues.
• Historical Data: Stores data locally, allowing you to analyze trends and retrospectively study system behavior.
• Self-learning Anomalies: Can use machine learning to detect anomalies in metric behavior.

Netdata Use Cases on VPS

Netdata on a server opens up many opportunities to improve the stability and performance of your projects:

• Web Server Performance Optimization: Monitor CPU load, RAM consumption, number of active connections, and bandwidth for Nginx or Apache to identify load peaks and prevent failures.
• Database Monitoring: Keep an eye on queries, connections, and cache usage for MySQL, PostgreSQL, MongoDB, Redis to ensure their stable operation.
• Application Debugging: If your application is running slowly, Netdata will help determine if the cause is a lack of resources (CPU, RAM, I/O) or a problem in the code itself.
• Resource Planning: By analyzing historical data, you can predict load growth and timely scale your VPS, upgrading to more powerful Valebyte.com plans.
• Docker Container Monitoring: Netdata integrates perfectly with Docker, allowing you to monitor each container individually, which is critical for modern microservices architectures.
• General System Diagnostics: Quickly determine why your VPS has become slow — perhaps the disk is full, the network is overloaded, or some process is consuming too many resources.

System Requirements for Installing Netdata on VPS

While Netdata is known for its lightweight nature, certain minimum and recommended system requirements must be considered for its effective operation on a VPS. The correct choice of VPS configuration will ensure stable collection and storage of metrics without affecting the performance of your main applications.

Minimum and Recommended Resources

Netdata is designed to run even on modest configurations, but for full monitoring and historical data storage, a little more resources will be needed. It's also worth noting that KVM VPS typically offers more predictable performance compared to OpenVZ.

Minimum Requirements for Netdata (monitoring 1-2 services, short data retention period):

• CPU: 1 vCPU (minimum 1 GHz)
• RAM: 512 MB (for Netdata itself, excluding OS and other applications)
• Disk: 5 GB free space (HDD or SSD, for metric storage)
• Network Bandwidth: 100 Mbps

Recommended Requirements for Netdata (monitoring 5-10 services, medium retention period, alerts):

• CPU: 2 vCPU (2+ GHz)
• RAM: 1 GB (for Netdata, excluding OS and other applications)
• Disk: 20-50 GB NVMe SSD (for high-speed metric write/read)
• Network Bandwidth: 500 Mbps - 1 Gbps

Important Notes:

• RAM: Netdata's RAM consumption is dynamic and depends on the number of metrics collected and the configured retention time. By default, Netdata stores data in RAM, flushing it to disk only for long-term storage.
• Disk: Using NVMe SSD significantly improves Netdata's performance, especially when writing large volumes of metrics and for long-term data storage on disk.
• CPU: Netdata is optimized for multi-core processors. More cores will allow faster processing and aggregation of metrics.

Supported Operating Systems

Netdata supports a wide range of Linux distributions. For installation via Docker or Docker Compose, almost any modern Linux distribution with a kernel capable of running Docker will work.

The most popular and recommended OS for installing Netdata on a VPS:

• Ubuntu Server (20.04 LTS, 22.04 LTS)
• Debian (10, 11, 12)
• CentOS Stream / AlmaLinux / Rocky Linux (8, 9)
• Fedora (latest versions)

Ensure your operating system is updated to the latest version to avoid dependency issues and ensure maximum security.

Step-by-Step Installation of Netdata on VPS using Docker and Docker Compose

Installing Netdata via Docker and Docker Compose is the most flexible and recommended method, especially for containerized environments on a VPS. It provides isolation, simplifies dependency management, updates, and migration.

Preparing Your VPS for Docker Installation

Before proceeding with Netdata Docker installation, ensure your VPS is updated and has the necessary utilities.

Connect to your VPS via SSH:

ssh user@your_vps_ip

Update system packages:

sudo apt update && sudo apt upgrade -y   # For Debian/Ubuntu
sudo dnf update -y                      # For CentOS/AlmaLinux/Rocky Linux/Fedora

Install necessary utilities (if not present):

sudo apt install -y curl git          # For Debian/Ubuntu
sudo dnf install -y curl git          # For CentOS/AlmaLinux/Rocky Linux/Fedora

Installing Docker and Docker Compose

The simplest and most reliable way to install Docker is to use the official installation script.

Install Docker Engine:

curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh

Add your user to the docker group to run Docker commands without sudo (requires re-login):

sudo usermod -aG docker $USER
newgrp docker

Verify Docker installation:

docker --version
docker run hello-world

Install Docker Compose:

Docker Compose is usually installed as a plugin to Docker Engine.

sudo apt install -y docker-compose-plugin # For Debian/Ubuntu
sudo dnf install -y docker-compose-plugin # For CentOS/AlmaLinux/Rocky Linux/Fedora

Or, if the plugin is not available, you can install it manually:

DOCKER_CONFIG=${DOCKER_CONFIG:-$HOME/.docker}
mkdir -p $DOCKER_CONFIG/cli-plugins
curl -SL https://github.com/docker/compose/releases/latest/download/docker-compose-linux-x86_64 -o $DOCKER_CONFIG/cli-plugins/docker-compose
chmod +x $DOCKER_CONFIG/cli-plugins/docker-compose

Verify Docker Compose installation:

docker compose version

Deploying Netdata via Docker Compose

Now that Docker and Docker Compose are installed, you can proceed with deploying Netdata self-hosted.

Create a directory for Netdata and navigate into it:

mkdir -p ~/netdata
cd ~/netdata

Create a docker-compose.yml file:

version: '3.8'
services:
  netdata:
    image: netdata/netdata
    container_name: netdata
    hostname: ${HOSTNAME:-netdata-vps} # Hostname for Netdata
    ports:
      - "19999:19999" # Netdata Port
    cap_add:
      - SYS_PTRACE
      - SYS_ADMIN # Required for collecting some metrics (e.g., cgroups)
    security_opt:
      - apparmor:unconfined # Disable AppArmor for full metric access
    volumes:
      - /etc/passwd:/etc/passwd:ro
      - /etc/group:/etc/group:ro
      - /proc:/host/proc:ro
      - /sys:/host/sys:ro
      - /etc/os-release:/host/etc/os-release:ro
      - /var/run/docker.sock:/var/run/docker.sock:ro # For Docker monitoring
      - /var/lib/netdata:/var/lib/netdata # For Netdata data storage
      - /etc/netdata:/etc/netdata # For Netdata configuration files
    restart: unless-stopped
    environment:
      - NETDATA_CLAIM_TOKEN=YOUR_CLAIM_TOKEN_HERE # Optional: for Netdata Cloud
      - NETDATA_CLAIM_URL=https://app.netdata.cloud # Optional: for Netdata Cloud
      # Other environment variables for configuration can be added
    labels:
      - "com.centurylinklabs.watchtower.enable=true" # For automatic Watchtower updates

Explanation of docker-compose.yml:

• image: netdata/netdata: Uses the official Netdata image.
• hostname: ${HOSTNAME:-netdata-vps}: Sets the hostname for the Netdata container. You can replace netdata-vps with something more meaningful.
• ports: - "19999:19999": Forwards port 19999 from the container to the host. The Netdata web interface will be accessible on this port.
• cap_add and security_opt: These parameters give Netdata the necessary privileges to access host system metrics. They are critical for full functionality.
• volumes: This is the most important part, allowing Netdata to access host system files (/proc, /sys) for metric collection, and to persistently store its data and configuration (/var/lib/netdata, /etc/netdata). /var/run/docker.sock is necessary for monitoring other Docker containers.
• restart: unless-stopped: Ensures that the Netdata container will automatically restart after failures or VPS reboots.
• environment: Here you can specify a token to connect to Netdata Cloud if you plan to use centralized management for multiple Netdata instances. If not, these lines can be removed or commented out.
• labels: An example label for automatic updates using Watchtower (installed separately).

Save the file and start the container:

docker compose up -d

Within a few seconds, Netdata will be running. You can access the web interface by navigating to http://your_vps_ip:19999 in your browser. Replace your_vps_ip with the actual IP address of your virtual server.

Configuring Reverse Proxy and HTTPS for Netdata: Nginx and Caddy

Accessing Netdata via an IP address with port 19999 is not an optimal solution for a production environment. Firstly, it's inconvenient, and secondly, it's insecure as traffic is not encrypted. Configuring a reverse proxy (Nginx or Caddy) with HTTPS will allow access to Netdata via a domain name, secured with an SSL/TLS certificate from Let's Encrypt.

Securing Netdata with Nginx and Let's Encrypt

To configure Nginx and Let's Encrypt, you will need a domain name pointing to your VPS.

1. Install Nginx:

sudo apt install -y nginx   # For Debian/Ubuntu
sudo dnf install -y nginx   # For CentOS/AlmaLinux/Rocky Linux/Fedora

Start Nginx and enable it to start on boot:

sudo systemctl start nginx
sudo systemctl enable nginx

2. Configure Nginx as a Reverse Proxy:

Create a new configuration file for your domain (e.g., netdata.yourdomain.com.conf):

sudo nano /etc/nginx/sites-available/netdata.yourdomain.com.conf

Insert the following configuration, replacing netdata.yourdomain.com with your actual domain:

server {
    listen 80;
    server_name netdata.yourdomain.com;

    location / {
        proxy_pass http://127.0.0.1:19999;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_http_version 1.1;
        proxy_buffering off;
        proxy_request_buffering off;
        proxy_cache_bypass $http_upgrade;
        proxy_read_timeout 3600s; # Increase timeout for long Netdata connections
    }
}

Create a symbolic link to this file in sites-enabled:

sudo ln -s /etc/nginx/sites-available/netdata.yourdomain.com.conf /etc/nginx/sites-enabled/

Test Nginx configuration and reload it:

sudo nginx -t
sudo systemctl reload nginx

Netdata should now be accessible at http://netdata.yourdomain.com.

3. Install Certbot and Obtain a Let's Encrypt SSL Certificate:

Install Certbot for your distribution (example for Ubuntu/Debian):

sudo apt install -y certbot python3-certbot-nginx

Obtain and install an SSL certificate for your domain:

sudo certbot --nginx -d netdata.yourdomain.com

Certbot will automatically modify the Nginx configuration, adding HTTPS and redirecting from HTTP to HTTPS. Follow Certbot's instructions. After completion, Netdata will be accessible at https://netdata.yourdomain.com.

Simplified Configuration with Caddy

Caddy is a modern web server that automatically manages Let's Encrypt SSL certificates, significantly simplifying HTTPS setup. This is an excellent choice for self-managed VPS.

1. Install Caddy:

The simplest way to install Caddy is to use the official script:

sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy

For other distributions, refer to the official Caddy documentation.

2. Configure Caddyfile:

Create or edit the /etc/caddy/Caddyfile file:

sudo nano /etc/caddy/Caddyfile

Insert the following configuration, replacing netdata.yourdomain.com with your actual domain:

netdata.yourdomain.com {
    reverse_proxy 127.0.0.1:19999 {
        # Netdata uses Server-Sent Events (SSE) for data updates
        # These options are important for correct SSE operation through a proxy
        header_up Connection {http.request.header.Connection}
        header_up Upgrade {http.request.header.Upgrade}
        flush_interval -1
    }
}

3. Reload Caddy:

sudo systemctl reload caddy

Caddy will automatically obtain an SSL certificate and configure HTTPS. Netdata will now be accessible at https://netdata.yourdomain.com.

Netdata Maintenance: Backups, Updates, and Health Monitoring

Regular maintenance of Netdata on a VPS is critically important to ensure its stable operation, security, and data integrity. This includes backing up configurations, timely updates, and monitoring the resources that Netdata itself consumes.

Netdata Data Backup Strategies

While Netdata primarily stores temporary data, configuration files and, potentially, historical archives (if long-term disk storage is configured) are valuable. If you use Netdata Cloud, your dashboards and alerts will also be stored there, but local configurations are still important.

What needs to be backed up:

• Configuration files: The /etc/netdata directory (or the /etc/netdata volume if you are using Docker Compose). All settings for collectors, plugins, alerts, etc., are stored here.
• Long-term storage data: The /var/lib/netdata directory (or the /var/lib/netdata volume). If you have configured Netdata to save historical data to disk, this data will be here.

Backup methods:

1. Manual backup:

   For a Docker container:

   docker compose stop netdata
   cp -r ~/netdata/etc_netdata /path/to/backup/netdata_config_$(date +%Y%m%d%H%M)
   cp -r ~/netdata/var_lib_netdata /path/to/backup/netdata_data_$(date +%Y%m%d%H%M)
   docker compose start netdata

   Where ~/netdata/etc_netdata and ~/netdata/var_lib_netdata are the host directories where the /etc/netdata and /var/lib/netdata volumes from your docker-compose.yml are mounted.

2. Automatic backup using scripts:

   Create a simple script that will execute these commands and run it via cron.

   #!/bin/bash
   BACKUP_DIR="/path/to/backup"
   NETDATA_CONFIG_SOURCE="~/netdata/etc_netdata" # Specify the path to the host volume
   NETDATA_DATA_SOURCE="~/netdata/var_lib_netdata" # Specify the path to the host volume
   TIMESTAMP=$(date +%Y%m%d%H%M%S)
   
   echo "Stopping Netdata container..."
   docker compose -f ~/netdata/docker-compose.yml stop netdata
   
   echo "Backing up Netdata configuration..."
   mkdir -p "$BACKUP_DIR/netdata_config"
   cp -r "$NETDATA_CONFIG_SOURCE" "$BACKUP_DIR/netdata_config/netdata_config_$TIMESTAMP"
   
   echo "Backing up Netdata data (if applicable)..."
   mkdir -p "$BACKUP_DIR/netdata_data"
   cp -r "$NETDATA_DATA_SOURCE" "$BACKUP_DIR/netdata_data/netdata_data_$TIMESTAMP"
   
   echo "Starting Netdata container..."
   docker compose -f ~/netdata/docker-compose.yml start netdata
   
   echo "Netdata backup complete."

   Configure cron to run this script, for example, once a day:

   crontab -e

   Add the line (replace /path/to/your_backup_script.sh with the actual path):

   0 3 * * * /path/to/your_backup_script.sh >> /var/log/netdata_backup.log 2>&1

3. External storage: Consider synchronizing backups with an external S3-compatible storage or another remote server for greater reliability.

Updating Netdata in Docker Containers

Updating Netdata deployed via Docker Compose is very simple and comes down to a few commands.

cd ~/netdata # Navigate to the directory with docker-compose.yml
docker compose pull # Download the latest Netdata image
docker compose down # Stop and remove the current container
docker compose up -d # Start a new container with the updated image

Automatic updates with Watchtower:

For fully automatic updates of Docker containers, you can use Watchtower. Add it to your docker-compose.yml:

version: '3.8'
services:
  netdata:
    # ... (existing Netdata configuration)
    labels:
      - "com.centurylinklabs.watchtower.enable=true" # Ensure this label is present

  watchtower:
    image: containrrr/watchtower
    container_name: watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 300 --cleanup # Check for updates every 300 seconds (5 minutes) and remove old images
    restart: unless-stopped
    labels:
      - "com.centurylinklabs.watchtower.enable=true" # Watchtower should also update itself

Start Watchtower:

docker compose up -d

Watchtower will automatically check for new Netdata images (and other containers with the watchtower.enable=true label) and update them, restarting the containers.

Monitoring Resources Consumed by Netdata

The irony is that Netdata, being a monitoring tool, itself consumes resources. It's important to ensure that it doesn't become a bottleneck for your VPS.

Fortunately, Netdata monitors itself by default! Open the Netdata dashboard and find the sections related to Netdata processes (netdata.service, netdata.health, etc.). You will be able to see the CPU, RAM, disk operations, and network traffic generated by Netdata itself.

If Netdata consumes too many resources, you can:

• Reduce data retention time: Edit the /etc/netdata/netdata.conf file (or the corresponding volume) and change the parameter history = 3600 (store for 1 hour) to a smaller value, for example, history = 1800 (30 minutes).
• Disable unnecessary plugins: Netdata collects data from hundreds of sources. Disable those you don't need by editing files in /etc/netdata/conf.d/ (e.g., python.d.conf, node.d.conf, etc.).
• Limit the number of stored metrics: In netdata.conf, you can configure memory mode = ram or memory mode = dbengine. dbengine stores data on disk, which can reduce RAM consumption but increase disk load.

Which VPS Configuration to Choose for Netdata under Real Load?

Choosing the optimal VPS configuration for Netdata depends on the scale of monitoring, the number of metrics collected, the duration of data retention, and the intensity of web interface usage. Requirements will differ drastically for a small personal project versus a large production system. Valebyte.com offers a wide range of VPS plans, allowing you to flexibly select resources.

Table of Recommended VPS Configurations for Netdata

This table will help you navigate when choosing a VPS configuration, considering typical Netdata usage scenarios.

Use Case	vCPU	RAM (GB)	Disk (NVMe SSD)	Bandwidth	Estimated VPS Cost (USD/month)
Minimal (personal project, 1-2 services)	1	1	10-20 GB	100 Mbps	$5 - $10
Small (several services, 5-10 containers)	2	2	20-40 GB	500 Mbps	$10 - $20
Medium (production, 10-20 services, alerts)	2-4	4	50-100 GB	1 Gbps	$20 - $40
Large (many services, long-term storage)	4-8	8-16+	100-200+ GB	1 Gbps+	$40 - $80+

Note: The prices indicated are approximate and may vary depending on the provider, location, and additional services (e.g., managed VPS, backups, DDoS protection).

Factors Influencing VPS Choice for Netdata

When choosing a VPS configuration for Netdata, consider the following factors:

1. Number of monitored sources: The more services (Nginx, MySQL, Redis, Docker containers) you want to monitor, the more CPU and RAM Netdata will require to collect and process metrics. Each plugin and each application instance adds load.
2. Metric collection frequency: Netdata collects metrics per second by default. If you reduce this frequency (which is not recommended, as accuracy is lost), resource consumption will decrease. However, for most tasks, the standard frequency is optimal.
3. Data retention duration: Netdata stores data in RAM by default. If you want to save metrics for a longer period (hours, days, weeks), Netdata will use more RAM or, if configured, write data to disk. For long-term data storage on disk, NVMe SSD is highly recommended due to its high read/write speed.
4. Web interface usage intensity: If many users simultaneously view Netdata dashboards or you frequently use it for deep analysis, this can increase CPU load.
5. Netdata Cloud usage: If you send metrics to Netdata Cloud, this adds a small amount of network traffic but reduces local requirements for historical data storage, as it is aggregated and stored in the cloud.
6. Other applications on the VPS: Remember that Netdata will run on the same VPS as your main applications. Allocate resources with a margin so that Netdata does not compete with your web server, database, or other services.
7. Disk type: NVMe SSD significantly outperforms regular SSDs and even HDDs in terms of I/O operations speed. For Netdata, which constantly writes and reads metrics, this is critically important.

Start with the minimum recommended configuration and scale resources as needed, monitoring Netdata's own performance through its dashboard.

Advanced Netdata Features and Integrations

Netdata is not just a pretty dashboard with graphs. It's a full-fledged monitoring platform that offers powerful tools for proactive infrastructure management. Utilizing its advanced features will allow you not only to see problems but also to react to them promptly.

Alerts and Notifications

One of Netdata's most valuable features is its built-in alerting system. It allows you to set up rules that will trigger when metrics reach certain thresholds or when anomalies are detected.

How alerts work:

• Rules: Alerts are defined in configuration files (e.g., /etc/netdata/health.d/*.conf). Each rule has a condition (e.g., "CPU usage above 90% for 5 minutes"), a severity level (warning, critical), a message, and a trigger frequency.
• Notification mechanisms: Netdata supports a wide range of notification mechanisms (notifiers):
  • Email
  • Slack
  • Telegram
  • Discord
  • PagerDuty
  • Webhook (for integration with arbitrary systems)
  • SMS (via gateways)
  • And many others

Example alert configuration (file /etc/netdata/health.d/cpu.conf):

template: cpu_usage
  on: system.cpu
  lookup: average -5s percentage
  units: %
  every: 10s
  warn: $this > 80
  crit: $this > 95
  info: average CPU utilization
  to: sysadmin # Notification group defined in alarm-notify.conf

To configure notifications, you need to edit the /etc/netdata/alarm-notify.conf file and specify your details (e.g., email address, Slack/Telegram token, etc.).

sudo nano /etc/netdata/alarm-notify.conf

Find the section corresponding to your preferred notification method (e.g., SEND_EMAIL, SLACK_WEBHOOK_URL) and uncomment/modify the relevant lines. After making changes, restart the Netdata container.

Integration with Other Monitoring Systems

Despite its self-sufficiency, Netdata can be integrated with other, more centralized monitoring systems or databases for long-term data storage and analysis.

• Prometheus: Netdata can export metrics in Prometheus format, allowing it to be used as a high-fidelity data collector (agent) for your Prometheus infrastructure. This is especially useful if you already have Grafana configured for Prometheus.
• Graphite: Netdata metrics can be sent to Graphite for centralized storage and visualization.
• InfluxDB: Netdata supports sending metrics to InfluxDB, which is a popular time-series database for monitoring.
• Elasticsearch / OpenSearch: Using plugins or custom scripts, Netdata data can be sent to ELK/ECK stacks for logging and analysis.

These integrations allow Netdata to collect real-time data and then transmit it to more powerful or existing analytical platforms for long-term storage, correlation with logs, and creation of complex reports.

To configure metric export to other systems, you will need to edit the corresponding configuration files in /etc/netdata/conf.d/, for example, exporting.conf or stream.conf, depending on the target system.

[exporting:prometheus]
    enabled = yes
    url = http://localhost:19999/api/v1/allmetrics?format=prometheus

[exporting:influxdb]
    enabled = no
    destination = localhost:8086
    db = netdata
    # ... other settings

Always restart the Netdata container after changing the configuration.

Conclusion

Netdata on a VPS is a powerful and efficient solution for real-time monitoring of your infrastructure's performance and health. Installation via Docker Compose provides flexibility and ease of management, while configuring a reverse proxy with HTTPS ensures secure access. For most projects, a VPS with 2-4 vCPU, 2-4 GB RAM, and NVMe SSD will be the optimal choice, allowing you to effectively track key metrics and respond promptly to potential issues.