Kanboard on VPS: installation, configuration, and maintenance

Kanboard on a VPS is an effective solution for Kanban project management, providing full data control and high performance. Installing Kanboard on a VPS involves deployment via Docker, web server configuration (Nginx/Caddy), and regular maintenance for stable operation. This approach allows you to obtain a flexible, secure, and scalable platform for teams of any size, avoiding the limitations of cloud services and ensuring complete confidentiality of your data.

In a world where efficiency and transparency of the workflow are critically important, project management systems play a key role. Kanboard stands out for its simplicity, speed, and open-source nature, offering a clean Kanban board without unnecessary features. Deploying Kanboard on your own Virtual Private Server (VPS) from Valebyte.com gives you unique advantages: from full control over the infrastructure to fine-tuning performance and security. In this article, we will detail how to perform a Kanboard installation, configure it for optimal operation, and ensure long-term maintenance.

What is Kanboard and why is self-hosted Kanboard on a VPS the optimal choice?

Kanboard is free and open-source project management software that strictly adheres to Kanban principles. Its core philosophy is to minimize complexity and maximize focus on workflow visualization. Unlike many other tools, Kanboard is not overloaded with features, offering only the essentials: boards, tasks, subtasks, comments, attachments, WIP (Work In Progress) limits, and reports.

Choosing self-hosted Kanboard on a VPS from Valebyte.com offers several significant advantages:

• Full Data Control: Your data is stored on your server, not on third-party cloud platforms. This is critically important for companies dealing with confidential information or subject to strict regulatory requirements.
• Flexibility and Customization: You can configure the server environment and Kanboard itself to meet your unique needs. This includes integration with other internal systems, installation of custom plugins and themes.
• Performance: With proper configuration and the right VPS, Kanboard will run faster than many cloud counterparts, especially if you have a stable internet connection to the server. You are not dependent on the overall load on the provider's cloud servers.
• Cost Savings: In the long run, hosting Kanboard on your own VPS can be significantly cheaper than subscribing to commercial SaaS solutions, especially for growing teams.
• Security: You have full control over server security, implementing your own security policies, firewalls, and monitoring systems.

For those already familiar with other project management tools such as Focalboard, Planka, or Vikunja, Kanboard offers a more minimalistic yet equally powerful approach to task management.

Key Features of Kanboard for Effective Management

• Visual Kanban Boards: The central element of Kanboard, allowing visual tracking of task progress.
• Simple Tasks: Create and manage tasks with descriptions, subtasks, due dates, and priorities.
• Automated Actions: Set up rules for automatic task movement, sending notifications, etc.
• Reports and Analytics: Basic reports for analyzing task completion times (Lead and Cycle Time), task distribution, and other metrics.
• Plugin Support: Extend Kanboard's functionality with third-party plugins or by creating your own.

Kanboard System Requirements: Which VPS to Choose for Stable Operation?

Kanboard is known for its lightweight nature and low resource requirements, making it an excellent candidate for deployment even on inexpensive VPS. However, to ensure stable operation and scalability, especially with team growth and an increasing number of projects, it's important to choose the right configuration.

Minimum and Recommended VPS Requirements

For a Kanboard installation, you will need a Linux-based operating system. Ubuntu Server or Debian are excellent choices due to their stability and broad community support.

• Operating System: Ubuntu 20.04+, Debian 10+, CentOS 7+.
• Processor (CPU):
  • Minimum: 1 vCPU (virtual core) at 2.0 GHz.
  • Recommended: 2 vCPU at 2.5 GHz+ for better performance with multiple concurrent users.
• Random Access Memory (RAM):
  • Minimum: 1 GB RAM (if using SQLite and a small amount of data).
  • Recommended: 2 GB RAM or more. If you plan to use MySQL/PostgreSQL and Kanboard on the server will serve 10+ users, 4 GB RAM will be the optimal choice.
• Disk Space:
  • Minimum: 10 GB NVMe SSD. Kanboard itself takes up little space, but you need to account for the OS, database, logs, and future attachments.
  • Recommended: 25-50 GB NVMe SSD. Using NVMe drives significantly increases database speed and overall system responsiveness.
• Database:
  • SQLite (default, for small installations).
  • MySQL 5.7+ / MariaDB 10.2+ or PostgreSQL 9.5+ (for larger installations and better performance).
• Web Server: Nginx or Apache (we will use Nginx in conjunction with PHP-FPM).
• PHP: PHP 7.4+ with extensions php-fpm, php-sqlite3 (or php-mysql/php-pgsql), php-gd, php-mbstring, php-xml, php-json.

For small teams (up to 5-10 people), a basic VPS plan from Valebyte.com with 2 vCPU, 2 GB RAM, and 25 GB NVMe SSD will be quite sufficient. If you plan to use Kanboard in a large company or for handling a large number of projects and tasks, consider more powerful configurations. Using Kanboard Docker simplifies dependency management, as all components will be isolated in containers.

Step-by-Step Kanboard Installation on a VPS using Docker Compose

The simplest and most reliable way to deploy Kanboard on a VPS is by using Docker and Docker Compose. This approach ensures that all dependencies are correctly installed and isolated, and it significantly simplifies scaling and updating. We will show you how to perform a Kanboard installation with Nginx and PostgreSQL.

VPS Prerequisites

1. Update the system:

sudo apt update && sudo apt upgrade -y

2. Install Docker:

sudo apt install -y apt-transport-https ca-certificates curl gnupg lsb-release
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io

3. Install Docker Compose (if not installed as a Docker plugin):

sudo apt install -y docker-compose-plugin # For new Docker versions
# Or for older versions (before Docker Compose v2):
# sudo curl -L "https://github.com/docker/compose/releases/download/v2.20.2/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose
# sudo chmod +x /usr/local/bin/docker-compose

4. Add your user to the docker group (to avoid using sudo with docker commands):

sudo usermod -aG docker $USER
newgrp docker # Apply changes immediately or reconnect to SSH

Creating the docker-compose.yml file for Kanboard

Create a directory for Kanboard and navigate into it:

mkdir -p ~/kanboard
cd ~/kanboard

Create the docker-compose.yml file:

nano docker-compose.yml

Insert the following content:

version: '3.8'

services:
  kanboard-app:
    image: kanboard/kanboard:latest
    container_name: kanboard_app
    restart: unless-stopped
    depends_on:
      - kanboard-db
    environment:
      # PostgreSQL database settings
      - DB_DRIVER=pgsql
      - DB_HOSTNAME=kanboard-db
      - DB_NAME=kanboard_db
      - DB_USERNAME=kanboard_user
      - DB_PASSWORD=your_strong_db_password # Replace with a strong password
      # Timezone settings (example: Europe/Moscow)
      - TZ=Europe/Moscow
      # URL for Kanboard (will be configured by Nginx later)
      - APPLICATION_URL=https://your-kanboard-domain.com/ # Replace with your domain
    volumes:
      - kanboard_data:/var/www/app/data
      - kanboard_plugins:/var/www/app/plugins
      - kanboard_assets:/var/www/app/assets

  kanboard-db:
    image: postgres:13
    container_name: kanboard_db
    restart: unless-stopped
    environment:
      - POSTGRES_DB=kanboard_db
      - POSTGRES_USER=kanboard_user
      - POSTGRES_PASSWORD=your_strong_db_password # Must match DB_PASSWORD above
    volumes:
      - kanboard_db_data:/var/lib/postgresql/data

  kanboard-nginx:
    image: nginx:stable-alpine
    container_name: kanboard_nginx
    restart: unless-stopped
    depends_on:
      - kanboard-app
    ports:
      - "80:80" # For HTTP, will be redirected to HTTPS
      - "443:443" # For HTTPS
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/conf.d/default.conf:ro
      - kanboard_data:/var/www/app/data:ro # Only for static files, if Kanboard generates them
      - kanboard_plugins:/var/www/app/plugins:ro
      - kanboard_assets:/var/www/app/assets:ro
      # For Let's Encrypt certificates (Certbot)
      - ./certbot/conf:/etc/letsencrypt
      - ./certbot/www:/var/www/certbot

volumes:
  kanboard_data:
  kanboard_plugins:
  kanboard_assets:
  kanboard_db_data:

Important notes:

• Replace your_strong_db_password with a strong password.
• Replace your-kanboard-domain.com with your actual domain.
• kanboard_data, kanboard_plugins, kanboard_assets, and kanboard_db_data are Docker volumes that ensure data persistence even if containers are removed or recreated.

Configuring Nginx for Kanboard

Create a directory for Nginx configuration:

mkdir -p ~/kanboard/nginx

Create the nginx/nginx.conf file:

nano ~/kanboard/nginx/nginx.conf

Insert the following content:

server {
    listen 80;
    server_name your-kanboard-domain.com www.your-kanboard-domain.com; # Replace with your domain

    location /.well-known/acme-challenge/ {
        root /var/www/certbot;
    }

    location / {
        return 301 https://$host$request_uri;
    }
}

server {
    listen 443 ssl http2;
    server_name your-kanboard-domain.com www.your-kanboard-domain.com; # Replace with your domain

    ssl_certificate /etc/letsencrypt/live/your-kanboard-domain.com/fullchain.pem; # Replace with your domain
    ssl_certificate_key /etc/letsencrypt/live/your-kanboard-domain.com/privkey.pem; # Replace with your domain
    ssl_trusted_certificate /etc/letsencrypt/live/your-kanboard-domain.com/chain.pem;

    include /etc/letsencrypt/options-ssl-nginx.conf;
    ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem; # Will be created by Certbot

    root /var/www/app/public; # Kanboard root directory

    index index.php;

    client_max_body_size 20M; # Increase if you plan to upload large files

    location / {
        try_files $uri $uri/ /index.php?$query_string;
    }

    location ~ \.php$ {
        try_files $uri =404;
        fastcgi_split_path_info ^(.+\.php)(/.+)$;
        fastcgi_pass kanboard-app:9000; # PHP-FPM service name in Docker Compose
        fastcgi_index index.php;
        include fastcgi_params;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
        fastcgi_param PATH_INFO $fastcgi_path_info;
        fastcgi_buffers 16 16k;
        fastcgi_buffer_size 32k;
    }

    location ~ /\.ht {
        deny all;
    }
}

Important notes:

• Replace your-kanboard-domain.com with your actual domain in all places.
• This Nginx config assumes Kanboard will be accessible via HTTPS.

Starting Kanboard Docker Containers

Now that all files are configured, start the containers:

docker compose up -d

Check the status of the containers:

docker compose ps

You should see that all containers are running (Up).

Configuring Reverse Proxy and HTTPS for Kanboard on the Server

To ensure the security and accessibility of Kanboard on the server via a domain name, you need to configure a reverse proxy (Nginx in our case) and HTTPS using Let's Encrypt certificates. This will allow you to use Kanboard over a secure connection (https://your-kanboard-domain.com).

Obtaining SSL Certificates with Certbot

Before obtaining certificates, ensure that your domain (your-kanboard-domain.com) points to your VPS's IP address.

docker compose stop kanboard-nginx

docker run -it --rm \
  -v ~/kanboard/certbot/conf:/etc/letsencrypt \
  -v ~/kanboard/certbot/www:/var/www/certbot \
  certbot/certbot \
  certonly --webroot -w /var/www/certbot \
  --email [email protected] \
  -d your-kanboard-domain.com \
  --agree-tos --no-eff-email

Replace [email protected] with your email address and your-kanboard-domain.com with your domain.

docker compose start kanboard-nginx

Your Kanboard should now be accessible at https://your-kanboard-domain.com. Initial login: admin / admin. Be sure to change the password immediately after logging in!

Alternative: Caddy for Automatic HTTPS

If you are looking for a simpler reverse proxy solution with automatic HTTPS, Caddy is an excellent choice. Caddy automatically obtains and renews Let's Encrypt certificates. To use it, you will need to replace the kanboard-nginx service in docker-compose.yml with kanboard-caddy.

Example Caddy service in docker-compose.yml:

  kanboard-caddy:
    image: caddy:2-alpine
    container_name: kanboard_caddy
    restart: unless-stopped
    depends_on:
      - kanboard-app
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data # For storing Caddy certificates
    environment:
      - DOMAIN=your-kanboard-domain.com # Replace with your domain

volumes:
  # ... existing volumes ...
  caddy_data:

Create a Caddyfile in the ~/kanboard/ directory:

nano ~/kanboard/Caddyfile

Insert the following content:

{$DOMAIN} {
    reverse_proxy kanboard-app:80
    
    # Additional security headers (optional)
    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
        X-Frame-Options "DENY"
        X-Content-Type-Options "nosniff"
        X-XSS-Protection "1; mode=block"
        Referrer-Policy "strict-origin-when-cross-origin"
    }
}

Then recreate the containers with docker compose up -d. Caddy will automatically configure HTTPS for your domain.

Kanboard Maintenance: Backups, Updates, and Monitoring for Kanboard on the Server

Regular maintenance is critically important for any system running in production. For Kanboard on the server, this includes backup strategies, update procedures, and basic monitoring. Neglecting these aspects can lead to data loss or security vulnerabilities.

Kanboard Data Backup

Your Kanboard data consists of two main parts: the database (PostgreSQL) and files (attachments, plugins). Since we use Docker volumes, they are easy to back up.

1. PostgreSQL Database Backup:

   You can create a database dump directly from the PostgreSQL container:

   docker exec kanboard_db pg_dump -U kanboard_user kanboard_db > ~/kanboard_backup/kanboard_db_$(date +%Y%m%d%H%M%S).sql

   Replace kanboard_user and kanboard_db with those specified in your docker-compose.yml.

2. Kanboard File Backup:

   Files are stored in Docker volumes kanboard_data, kanboard_plugins, and kanboard_assets. You can copy their contents to the host system.

   # Create a directory for backups
   mkdir -p ~/kanboard_backup/files_$(date +%Y%m%d%H%M%S)
   
   # Copy data from volumes
   docker run --rm -v kanboard_data:/data -v ~/kanboard_backup/files_$(date +%Y%m%d%H%M%S)/data:/backup_target alpine cp -r /data/. /backup_target
   docker run --rm -v kanboard_plugins:/data -v ~/kanboard_backup/files_$(date +%Y%m%d%H%M%S)/plugins:/backup_target alpine cp -r /data/. /backup_target
   docker run --rm -v kanboard_assets:/data -v ~/kanboard_backup/files_$(date +%Y%m%d%H%M%S)/assets:/backup_target alpine cp -r /data/. /backup_target

It is recommended to automate these backups using cron jobs and save them to remote storage. Consider using tools like Restic for incremental and encrypted backups to S3-compatible storage or other cloud services.

Updating Kanboard and Docker Containers

Updating Kanboard when deployed via Docker is relatively simple:

1. Create a backup (see above) — this is the most important step before any update.
2. Download new Docker images:

   cd ~/kanboard
   docker compose pull

3. Recreate containers with new images:

   docker compose up -d

   Docker Compose will stop the old containers, remove them, and start new ones using the freshly downloaded images, while preserving your data in volumes.

4. Update Certbot (if used):

   docker run -it --rm \
     -v ~/kanboard/certbot/conf:/etc/letsencrypt \
     -v ~/kanboard/certbot/www:/var/www/certbot \
     certbot/certbot \
     renew --dry-run # For testing

   If the dry run is successful, run without --dry-run. It's better to set up automatic certificate renewal using cron.

5. Update the host system: Regularly update your OS:

sudo apt update && sudo apt upgrade -y

Performance and Availability Monitoring

For Kanboard on a VPS, it's important to monitor:

• Availability: Ensure your Kanboard is accessible 24/7. Use external monitoring services (e.g., UptimeRobot).
• Resource Usage: Track the CPU, RAM, and disk load of your VPS. If resources are consistently at their limit, it might be time to upgrade your Valebyte.com plan.
• Container Logs: Check Kanboard, Nginx, and database logs for errors:

  docker compose logs -f kanboard_app
  docker compose logs -f kanboard_nginx
  docker compose logs -f kanboard_db

Using tools like Filebrowser can simplify file management on the server, although this is less relevant for Docker containers.

Optimal VPS Config for Kanboard under Real-World Load

Choosing the right VPS configuration is critical to ensure smooth Kanboard operation as your team and projects grow. Valebyte.com offers a wide range of VPS plans that can be adapted to various usage scenarios.

Recommendations for Choosing a VPS Plan

Below are recommendations for VPS configurations for Kanboard, based on team size and expected load:

1. For Small Teams (up to 5-10 users, several active projects):
   • CPU: 2 vCPU @ 2.5 GHz+
   • RAM: 2 GB
   • Disk: 25 GB NVMe SSD
   • Bandwidth: 500 Mbps
   • Estimated Cost: $5-10/month
   • Note: This configuration will be sufficient for most startups and small departments. SQLite database can also be considered for simplicity, but PostgreSQL is preferred.
2. For Medium Teams (10-30 users, up to 20 active projects):
   • CPU: 4 vCPU @ 2.8 GHz+
   • RAM: 4 GB
   • Disk: 50 GB NVMe SSD
   • Bandwidth: 1 Gbps
   • Estimated Cost: $15-25/month
   • Note: This configuration will ensure comfortable operation under higher load, with more concurrent users and active use of attachments. PostgreSQL is mandatory.
3. For Large Teams or Intensive Use (30+ users, many projects and tasks):
   • CPU: 6-8 vCPU @ 3.0 GHz+
   • RAM: 8-16 GB
   • Disk: 100-200 GB NVMe SSD
   • Bandwidth: 1-2 Gbps
   • Estimated Cost: $30-60+/month
   • Note: In this case, it is recommended to consider a dedicated server or a more powerful VPS with guaranteed resources. This will ensure maximum performance and stability even during peak loads.

Comparison Table of VPS Configurations for Kanboard

It is important to remember that these figures are approximate. Actual resource requirements may vary depending on usage intensity, the number of concurrent users, the volume of stored attachments, and the use of additional Kanboard plugins.

Conclusion

Deploying Kanboard on a VPS from Valebyte.com provides teams with a powerful, flexible, and secure tool for Kanban project management. By following the detailed instructions for Kanboard installation via Docker Compose, configuring Nginx and HTTPS, and paying attention to regular maintenance, you will be able to create a reliable and high-performance working environment. Choose the optimal VPS plan that matches your team's size to ensure stable Kanboard operation and full control over your data.