Dashy on VPS: Installation, Configuration, and Maintenance

Installing Dashy on a VPS, especially using Docker, is an efficient way to create a personalized dashboard for quick access to your services, system monitoring, and link organization, ensuring full data control and high performance. This approach allows you to deploy Dashy—a modern, customizable self-hosted monitoring dashboard—on your own virtual server, providing flexibility and security unavailable in cloud solutions. In this article, we will detail how to install Dashy, configure it for optimal operation, and ensure reliable maintenance on a VPS.

Dashy is more than just a list of links. It's an interactive, responsive, and highly customizable dashboard that allows you to centralize the management of all your web applications, services, and resources. Track server status, view RSS feeds, receive notifications, and quickly navigate to your projects—all from one place. When you decide to host such a solution on a VPS, you gain full control over infrastructure, security, and performance.

What is Dashy and why do you need it on a VPS?

Dashy is a powerful, minimalistic, and easily configurable open-source dashboard designed to centralize access to your favorite applications and services. It's an ideal solution for anyone who wants a single entry point to all their self-hosted applications, cloud services, server monitoring, or simply frequently used websites. Key features of Dashy include:

• Intuitive Interface: Modern design, many themes (including dark mode), support for custom styles.
• Service Status Monitoring: Ability to add links with automatic availability checks, displaying "online" or "offline" status.
• Quick Search: Integrated search across all added items.
• Integrations: Support for widgets to display information from various sources (weather, RSS feeds, server load, etc.).
• Flexible Customization: Full control over layout, icons, colors, and behavior.
• Security: Support for authentication (basic auth, OIDC) to protect your dashboard.
• Multilingual: Support for multiple languages, including Russian.

Deploying Dashy on your own VPS (Virtual Private Server) gives you several significant advantages compared to using public cloud services or local solutions:

• Full Control and Privacy: Your data and configurations are stored on your server, under your full control. This is critical for sensitive information or when you simply value privacy.
• Performance and Stability: Dedicated VPS resources guarantee stable Dashy operation without interference from "neighbors" on shared hosting. You can choose a configuration that precisely matches your needs.
• 24/7 Availability: A VPS operates around the clock, providing constant access to your dashboard from anywhere in the world.
• Flexibility and Scalability: You can easily scale VPS resources as your needs grow, adding more CPU, RAM, or disk space.
• Integration with Other Self-Hosted Services: If you already use a VPS for other applications, such as Dozzle for Docker container monitoring or Coder for remote development, Dashy on the same server will perfectly complement your ecosystem.

Thus, Dashy self-hosted on a VPS is the optimal choice for those seeking a powerful, private, and customizable tool to organize their digital life.

System Requirements for Dashy: Which VPS to Choose?

Dashy, being a modern web application developed with Vue.js, is relatively undemanding on resources under typical usage. However, choosing the right VPS is important to ensure stability, speed, and scalability. The main system requirements are as follows:

Minimum Requirements for Personal Dashy Use

For a single user or a small group using Dashy as a personal dashboard with a few dozen links and basic monitoring, the following minimum specifications are suitable:

• Processor (CPU): 1 vCPU (virtual core). Dashy is not CPU-intensive, but it needs enough power for fast loading and request processing.
• Random Access Memory (RAM): 1 GB. This is sufficient to run the Dashy Docker container and a basic operating system. If you plan to run other containers or services on the same VPS, 2 GB is recommended.
• Disk Space: 10-20 GB NVMe SSD. Dashy itself takes up little space (a few hundred MB), but you'll need space for the operating system, Docker images, logs, and potential backups. Using NVMe SSD will significantly speed up container startup and overall file operations.
• Operating System: Ubuntu 20.04/22.04 LTS, Debian 10/11/12. These distributions are well-supported and have up-to-date Docker versions.
• Network Bandwidth: 100 Mbps. Dashy does not require high bandwidth, but a stable connection is important for quick access.

Recommended VPS Configurations for Dashy Under Real Load

If you plan to use Dashy for a team, with a large number of services, active monitoring, various widgets, or as a central hub for multiple users, you should consider more powerful configurations:

• Processor (CPU): 2 vCPU. This will provide better responsiveness for concurrent requests and background task processing.
• Random Access Memory (RAM): 2-4 GB. This will allow comfortable work with a large number of elements, use more widgets, and provide a buffer for peak loads. If other Docker containers (e.g., OpenProject, code-server, or databases) will run on the same VPS, 4 GB RAM would be a more reasonable choice.
• Disk Space: 30-50 GB NVMe SSD. Additional space for expansion, backups, logs, and other related tools. NVMe SSD remains critically important for performance.
• Operating System: Ubuntu 22.04 LTS or Debian 12.
• Network Bandwidth: 1 Gbps. Although Dashy is not a "heavy" network application, high bandwidth is always beneficial for overall server interaction and other services.

It's important to remember that these recommendations only account for Dashy. If other applications will run on your VPS, you need to increase resources accordingly.

Valebyte.com offers various VPS plans with NVMe SSD, which are ideal for deploying Dashy and other self-hosted solutions. The choice of the optimal plan depends on your specific needs and planned load.

Preparing your VPS for Dashy Installation: Docker and Docker Compose

The most convenient and recommended way to install Dashy is by using Docker and Docker Compose. Docker allows you to package an application with all its dependencies into an isolated container, simplifying deployment and management. Docker Compose helps define and run multi-container Docker applications. Before proceeding with Dashy installation, you need to prepare your VPS.

System Update and Docker Installation

First, connect to your VPS via SSH. It is recommended to use a user with sudo privileges, rather than root directly, for increased security.

ssh user@your_vps_ip

After connecting, update the package list and installed packages to the latest versions:

sudo apt update
sudo apt upgrade -y

Now, let's install Docker Engine. For Ubuntu/Debian, this is done as follows:

1. Install necessary packages to install Docker over HTTPS:

sudo apt install -y ca-certificates curl gnupg lsb-release

2. Add Docker's official GPG key:

sudo mkdir -p /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg

3. Add the Docker repository to APT sources:

echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

4. Update the package list again and install Docker Engine:

sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin

5. Add your user to the docker group so you don't need to use sudo for every Docker command:

sudo usermod -aG docker $USER
newgrp docker

Verify that Docker is installed correctly by running a test container:

docker run hello-world

You should see the message "Hello from Docker!".

Installing Docker Compose (if not installed as a plugin)

In modern Docker versions (starting from 20.10), Docker Compose comes as a docker compose plugin. If you installed docker-compose-plugin as described above, you already have docker compose. You can check this with the command:

docker compose version

If for some reason you need the older, standalone docker-compose version (which is invoked as docker-compose with a hyphen), you can install it as follows (this is a less preferred option, but it works):

sudo apt install -y docker-compose

Or manually:

sudo curl -L "https://github.com/docker/compose/releases/download/v2.24.5/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
sudo chmod +x /usr/local/bin/docker-compose
docker-compose --version

For the purposes of this article, we will use the new docker compose syntax (without a hyphen).

Installing Dashy with Docker Compose: A Step-by-Step Guide

Now that Docker and Docker Compose are ready, we can proceed with Dashy installation. We will create a docker-compose.yml file that defines how Docker should run Dashy.

1. Creating a Directory for Dashy

Create a new directory to store Dashy's configuration files and Docker Compose:

mkdir ~/dashy
cd ~/dashy

2. Creating the docker-compose.yml file

Inside this directory, create a docker-compose.yml file:

nano docker-compose.yml

Paste the following content. This file defines which Docker image to use, which ports to map, how to store data, and which environment variables to set. For Dashy Docker, this is the standard approach.

version: "3.8"
services:
  dashy:
    container_name: dashy
    image: lissy93/dashy:latest
    ports:
      - 8080:80 # Map container port 80 to host port 8080
    volumes:
      - ./data:/app/public/conf # Path for Dashy configuration storage
      - ./icons:/app/public/item-icons # Optional: for custom icons
    environment:
      # - NODE_ENV=production # Optional: for production mode, disables some debug logs
      - PUID=1000 # User ID under which the container will run
      - PGID=1000 # Group ID under which the container will run
      - TZ=Europe/Moscow # Set your timezone
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    healthcheck:
      test: ["CMD", "wget", "--quiet", "--tries=1", "--timeout=2", "http://localhost/healthz"]
      interval: 30s
      timeout: 10s
      retries: 3
    # networks:
    #   - web
# networks:
#   web:
#     external: true

File explanations:

• container_name: dashy: Assigns a name to the container for easier management.
• image: lissy93/dashy:latest: Instructs Docker to pull and use the latest stable Dashy image.
• ports: - 8080:80: Maps port 80 inside the container (where Dashy runs) to port 8080 of your VPS. You can choose any free port on the host.
• volumes: - ./data:/app/public/conf: This is a critically important line. It mounts the data directory on your host (VPS) to the /app/public/conf directory inside the container. All your Dashy settings (conf.yml file) will be stored in this directory. This allows you to preserve your configuration even when recreating the container.
• environment:: Sets environment variables.
  • PUID and PGID: User and group IDs on the host under which files will be created in the mounted volumes. This is usually 1000 for the first user, but you can check your IDs with id $USER.
  • TZ: Sets the container's timezone.
• restart: unless-stopped: Ensures that the container will automatically restart after failures or VPS reboots, unless you stop it manually.
• security_opt: - no-new-privileges:true: Improves security by preventing the container from gaining new privileges.
• healthcheck:: Defines a health check for the container, which is useful for monitoring.
• networks: (commented out): If you use advanced Docker network settings (e.g., for Nginx Proxy Manager or Traefik), you can uncomment these lines and connect Dashy to an existing network.

3. Starting Dashy

Save the file (Ctrl+O, Enter, Ctrl+X in nano) and start the Dashy container:

docker compose up -d

The up -d command starts the containers in the background (detached mode). Docker will download the Dashy image (if not already present), create the container, and start it.

4. Verifying Dashy's Operation

After a few seconds, Dashy should be accessible. You can check the container status:

docker compose ps

You should see that the dashy container is in "Up" status.

Now you can open Dashy in your browser by navigating to http://your_vps_ip:8080. You will see Dashy's welcome page with a basic configuration. At this point, Dashy on the server is already running, but it is accessed via an IP address and a non-standard port, without HTTPS.

Configuring Dashy Access via Reverse Proxy (Nginx/Caddy) and HTTPS

For secure and convenient access to Dashy via a domain name (e.g., dashy.yourdomain.com) and using HTTPS, you need to configure a reverse proxy. We will cover two popular options: Nginx and Caddy. Both options will use Let's Encrypt for automatic SSL certificate acquisition and renewal.

Before you begin, ensure that your domain or subdomain (e.g., dashy.yourdomain.com) points to your VPS's IP address in your DNS records (A-record).

Option 1: Nginx with Certbot

Nginx is a powerful and widely used web server and reverse proxy. It will also require Certbot for managing Let's Encrypt SSL certificates.

1. Installing Nginx

sudo apt update
sudo apt install -y nginx

2. Creating Nginx Configuration for Dashy

Create a new configuration file for your domain:

sudo nano /etc/nginx/sites-available/dashy.yourdomain.com

Paste the following content, replacing dashy.yourdomain.com with your actual domain:

server {
    listen 80;
    listen [::]:80;
    server_name dashy.yourdomain.com;

    location / {
        proxy_pass http://localhost:8080; # Or IP_address_of_VPS:8080 if Dashy is not on the same host
        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_read_timeout 900;
        proxy_send_timeout 900;
    }
}

Save the file. Then create a symbolic link to this file in sites-enabled for Nginx to use it:

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

Check Nginx configuration syntax and reload it:

sudo nginx -t
sudo systemctl reload nginx

Now Dashy should be accessible via http://dashy.yourdomain.com (without HTTPS).

3. Installing Certbot and Obtaining an SSL Certificate

sudo apt install -y certbot python3-certbot-nginx

Run Certbot to obtain a certificate and automatically configure Nginx:

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

Certbot will ask a few questions (email, agreement to terms). Upon successful completion, it will automatically update your Nginx configuration, adding HTTPS settings and redirecting from HTTP to HTTPS. It will also set up automatic certificate renewal.

Verify that Nginx has reloaded, and your Dashy is now accessible via https://dashy.yourdomain.com.

Option 2: Caddy (simpler HTTPS setup)

Caddy is a modern web server with automatic HTTPS, which significantly simplifies SSL configuration.

1. Installing Caddy

Add the Caddy repository and install it:

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 -y caddy

2. Creating a Caddyfile for Dashy

Create or edit the Caddy configuration file (Caddyfile):

sudo nano /etc/caddy/Caddyfile

Remove existing content and paste the following, replacing dashy.yourdomain.com with your domain:

dashy.yourdomain.com {
    reverse_proxy localhost:8080 # Or IP_address_of_VPS:8080
    
    # Optional: enable compression
    encode gzip zstd

    # Optional: enable basic authentication
    # basicauth / {
    #     username your_username
    #     password your_hashed_password # Use caddy hash-password to generate hash
    # }
}

Save the file. Caddy will automatically obtain and renew SSL certificates for your domain.

3. Checking and Starting Caddy

Check the Caddyfile syntax:

sudo caddy validate --config /etc/caddy/Caddyfile

Restart the Caddy service to apply changes:

sudo systemctl reload caddy

Now your Dashy on the server should be accessible via https://dashy.yourdomain.com with automatically configured HTTPS.

Customizing Dashy: Configuration and Personalization

Dashy allows deep customization of its appearance and functionality through the conf.yml configuration file. This file is located in the directory we mounted into the Docker container (in our case, ~/dashy/data/conf.yml).

Editing the Configuration File (conf.yml)

By default, Dashy creates a basic conf.yml on first launch. You can edit it directly on your VPS:

nano ~/dashy/data/conf.yml

Here's an example of the conf.yml file structure with some common settings:

# Main settings
appConfig:
  title: My Valebyte Dashboard
  description: All important links in one place
  navLinks: # Header links
    - title: GitHub
      path: https://github.com/Lissy93/dashy
    - title: Valebyte
      path: https://valebyte.com/ru/blog/
  theme: auto # light, dark, auto, nord, matrix, cyberpunk, material-dark, etc.
  primaryColor: '#007bff' # Primary color
  favicon: 'https://valebyte.com/favicon.ico' # Custom tab icon

# Authentication settings (optional)
auth:
  enable: false # Whether to enable authentication
  users:
    - user: admin
      hash: $2b$10$XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX # Generated password hash
      type: admin # admin or guest
  # Other authentication methods: OIDC, Keycloak, etc.

# Sections with items
sections:
  - name: My Services
    icon: fas fa-server
    items:
      - title: Dozzle
        description: Docker log monitoring
        icon: https://dozzle.space/logo.svg
        url: https://dozzle.yourdomain.com # Link to Dozzle
        statusCheck: true # Check availability status
      - title: Code-Server
        description: VS Code in the browser
        icon: https://valebyte.com/img/blog/code-server.png
        url: https://code.yourdomain.com
        statusCheck: true
      - title: Nextcloud
        description: Cloud storage
        icon: https://nextcloud.com/wp-content/themes/nextcloud-homepage/assets/img/nextcloud-logo-white.svg
        url: https://nextcloud.yourdomain.com

  - name: Useful Tools
    icon: fas fa-tools
    items:
      - title: Google
        description: Search engine
        icon: https://www.google.com/favicon.ico
        url: https://www.google.com
      - title: YouTube
        description: Video hosting
        icon: https://www.youtube.com/favicon.ico
        url: https://www.youtube.com
      - title: Telegram
        description: Messenger
        icon: https://telegram.org/favicon.ico
        url: https://web.telegram.org

# Widgets (optional)
widgets:
  - type: weather
    options:
      city: Moscow
      units: metric
      apiKey: YOUR_OPENWEATHERMAP_API_KEY
  - type: rss
    options:
      title: Valebyte News
      url: https://valebyte.com/ru/blog/feed.xml
      count: 5

# Other settings
pageInfo:
  poweredBy: false # Hide "Powered by Dashy"
  footer: '© 2024 Valebyte.com' # Custom footer

Main customization parameters:

• appConfig: General application settings, such as title, description, navigation links, theme, primary color.
• auth: Authentication settings. You can enable basic authentication by specifying a username and password hash. The hash can be generated online or using a utility.
• sections: This is the main block where you define categories (sections) and items (links) within them. Each item can have a title, description, URL, icon (local or remote), and a statusCheck: true flag for availability checking.
• widgets: Add various widgets, such as weather, RSS feeds, system information, etc. Some widgets may require API keys.
• pageInfo: Page information settings, e.g., a custom footer.

After each change to the conf.yml file, you need to restart the Dashy container for the changes to take effect:

cd ~/dashy
docker compose restart dashy

Or, if you just want to update the configuration without restarting the entire container, Dashy supports dynamic reloading: simply open the settings in the web interface and click "Reload Config".

Detailed documentation on all configuration options can be found on the official Dashy website.

Dashy Maintenance: Backups, Updates, and Monitoring

Proper maintenance of Dashy on a VPS includes regular backups, timely updates, and basic monitoring to ensure stable and secure operation of your dashboard.

Backups

Backing up your Dashy configuration is a simple but critically important task. Since we used Docker volumes, all important data is stored on the host.

What needs to be backed up:

• Dashy configuration file: ~/dashy/data/conf.yml
• Custom icons (if you use them): ~/dashy/icons/

Simple way to create a backup:

You can simply copy the entire Dashy directory into an archive:

cd ~/dashy
tar -czvf dashy_backup_$(date +%Y%m%d_%H%M%S).tar.gz data icons docker-compose.yml

This command will create a .tar.gz archive with the current date and time in its name, containing your configuration, icons, and the docker-compose.yml file. Store this archive in a safe place, preferably on another server or in cloud storage.

Automating backups:

You can set up a Cron job to automatically perform backups. Open crontab for editing:

crontab -e

Add a line for daily backup (e.g., at 3:00 AM):

0 3 * * * cd /home/user/dashy && tar -czvf /home/user/backups/dashy_backup_$(date +\%Y\%m\%d).tar.gz data icons docker-compose.yml > /dev/null 2>&1

Ensure that the /home/user/backups/ directory exists and has the correct permissions. Replace /home/user/ with your actual home directory.

Updating Dashy

Updating Dashy running in Docker is also very simple. You should regularly update the Docker image to get new features, bug fixes, and security improvements.

1. Navigate to the directory containing the docker-compose.yml file:

cd ~/dashy

2. Stop the current Dashy container:

docker compose down

3. Pull the new Dashy image:

docker compose pull dashy

This command will download the latest version of the lissy93/dashy:latest image.

4. Start Dashy with the new image:

docker compose up -d

Docker Compose will detect that the image has been updated and will recreate the container with the new version, while your data (stored in the ./data volume) will remain untouched.

Monitoring Dashy

Although Dashy is not a mission-critical service like a database, basic monitoring will help ensure it is always available and functioning correctly.

• Checking container status:

  docker compose ps

  Ensure that the dashy container status is "Up".

• Viewing logs:

  docker compose logs dashy

  Use -f to view logs in real time: docker compose logs -f dashy.

• Using healthcheck: We already added a healthcheck to docker-compose.yml. You can check its status:

  docker inspect --format='{{json .State.Health}}' dashy

• External monitoring: Consider using external monitoring services (e.g., UptimeRobot, Healthchecks.io) to check the availability of your Dashy domain.

By following these recommendations, you will ensure stable, secure, and up-to-date operation of your Dashy on VPS.

Choosing the Optimal VPS for Dashy: Valebyte.com Recommendations

Choosing the right VPS for Dashy depends on your current and future needs. Valebyte.com offers flexible plans that are ideal for hosting self-hosted applications, including Dashy. When choosing, consider the following factors:

Factors Influencing VPS Choice for Dashy

• Number of users: Personal use or a large team? The more users and active sessions, the more RAM and CPU will be required.
• Number of items and widgets: A dashboard with dozens of links and several widgets consumes more resources than a simple page with 5-10 links.
• Other services on the VPS: If other Docker containers (e.g., databases, other web applications) will run on the same VPS, their resource requirements will sum up.
• Disk type: NVMe SSD significantly outperforms HDD and SATA SSD in read/write speed, which is critical for fast application loading and file operations.
• Budget: Determine how much you are willing to spend monthly on a VPS.

Table of VPS Configurations Comparison for Dashy

Below is a table with recommended VPS configurations from Valebyte.com for various Dashy usage scenarios. Prices are approximate and may vary.

Usage Scenario	CPU	RAM	Disk (NVMe SSD)	Bandwidth	Approximate Valebyte.com Plan	Approximate Monthly Price ($)
Personal Dashboard (1-2 users, up to 50 links, basic widgets)	1 vCPU	1-2 GB	20-30 GB	100 Mbps	VPS-Start	from $5-$7
Small Team/Family (2-5 users, up to 100 links, several widgets)	2 vCPU	2-4 GB	40-60 GB	500 Mbps	VPS-Standard	from $10-$15
Medium Team/Department (5-15 users, 100+ links, active monitoring, many widgets)	2-4 vCPU	4-8 GB	80-120 GB	1 Gbps	VPS-Pro	from $20-$35
Large Organization/Development (15+ users, many services, other applications on VPS)	4+ vCPU	8+ GB	160+ GB	1 Gbps	VPS-Enterprise	from $40+

Valebyte.com Recommendations

1. Start small: For most Dashy users, especially for personal use, a plan with 1 vCPU and 2 GB RAM will be more than sufficient. This will allow you to comfortably get started with Dashy installation and configuration.
2. Prioritize NVMe SSD: Always choose a VPS with NVMe SSD. This will significantly improve Dashy's responsiveness, loading speed, and overall system performance.
3. Scaling flexibility: Choose a provider that allows easy scaling of VPS resources up (and down). Valebyte.com offers this capability, so you can start with a small plan and increase it as your needs grow.
4. Proximity to users: If you have the option to choose a data center, select one that is geographically closer to your primary audience or yourself to minimize latency.
5. Use Docker: Always use Dashy Docker for deployment. This simplifies management, updates, and migration.

By choosing a suitable VPS from Valebyte.com, you will get a reliable foundation for your Dashy dashboard, ensuring its stable operation and high availability.

Conclusion

Dashy is a powerful, flexible, and convenient tool for organizing your digital environment, and deploying it on a VPS using Docker provides full control, security, and performance. By following our step-by-step guide, you can perform Dashy installation, configure secure access via a reverse proxy with HTTPS, and ensure its reliable maintenance. For optimal Dashy performance and other self-hosted solutions, choose a VPS with NVMe SSD and sufficient RAM from Valebyte.com to ensure your dashboard always runs fast and stably.