Planka on VPS: installation, configuration, and maintenance

Installing, configuring, and maintaining Planka on a VPS involves deploying Docker containers, configuring a web server (Nginx or Caddy) for reverse proxy and HTTPS, and performing regular backups and updates to ensure the stable operation of a modern project management system.

In the context of dynamically evolving teams and projects, effective task management becomes critically important. Planka offers a powerful and flexible solution for organizing workflows, providing functionality similar to popular commercial products, but with the advantage of full control over data and infrastructure. Choosing Planka on a VPS not only ensures complete confidentiality but also allows you to customize the system to your team's specific needs, avoiding reliance on third-party cloud services. In this detailed guide, we will cover all stages: from understanding what Planka is and why it's needed, to step-by-step Planka installation on your server, its configuration, security, and subsequent maintenance.

What is Planka and why choose Planka on a VPS?

Planka is a modern, Planka self-hosted project management platform inspired by solutions like Trello and Jira. It provides an intuitive interface for organizing tasks using Kanban boards, lists, and cards. Key features include creating projects, managing tasks, assigning assignees, setting due dates, adding comments and attachments, and tracking change history. Planka is written in Node.js, uses PostgreSQL as its database, and offers a flexible API for integration with other systems.

Key advantages of Planka for your team

• Full data control: By hosting Planka on your server, you fully own your data, which is critical for companies with high security and privacy requirements.
• Cost savings: The absence of monthly per-user or per-project fees, typical of cloud solutions, significantly reduces operational costs as your team grows.
• Flexibility and customization: Planka's open-source nature allows you to adapt its functionality to your organization's unique business processes.
• Performance: Optimized hosting on your own VPS guarantees high operating speed without dependence on third-party providers.
• Easy deployment with Docker: Using Planka Docker significantly simplifies the application installation and management process, ensuring isolation and portability.

By choosing Planka on a VPS, you get a reliable, scalable, and fully controlled project management tool that will grow with your team.

Planka System Requirements: Which VPS to choose?

Before proceeding with Planka installation, it's important to determine the minimum and recommended system requirements for your VPS. These parameters depend on the anticipated load: the number of users, active projects, tasks, and the volume of stored attachments. Planka, being a Node.js application with PostgreSQL, is quite efficient but requires adequate resources for stable operation.

Minimum and Recommended VPS Specifications for Planka

For small teams (up to 10-15 users) and not very intensive work, basic configurations will suffice. For medium and large teams, as well as for active use with a large number of projects and tasks, more powerful resources will be required.

Parameter	Minimum (up to 10 users)	Recommended (up to 50 users)	For high loads (50+ users)
Operating System	Ubuntu 20.04+, Debian 11+, CentOS 8+	Ubuntu 22.04+, Debian 12+	Ubuntu 22.04+, Debian 12+
CPU	1 vCPU (2.0 GHz+)	2 vCPU (2.5 GHz+)	4+ vCPU (3.0 GHz+)
RAM	2 GB	4 GB	8+ GB
Disk (NVMe SSD)	25 GB (minimum)	50 GB (recommended)	100+ GB (for large attachments)
Bandwidth	100 Mbps	500 Mbps	1 Gbps
Additional	Docker and Docker Compose	Docker and Docker Compose, Nginx/Caddy	Docker and Docker Compose, Nginx/Caddy, monitoring system

Important note: Using NVMe SSD drives is critically important for database performance and overall application responsiveness. Traditional HDDs or SATA SSDs can significantly slow down Planka's operation.

Why Valebyte.com is the best choice for Planka VPS?

At Valebyte.com, we offer high-performance VPS with NVMe SSDs and powerful processors, ideally suited for hosting Planka on your server. Our plans are designed to meet various needs, from small teams to large enterprises, ensuring stable operation of your Planka instance. You can easily scale resources as your team grows and load increases, ensuring uninterrupted project operation.

Preparing your VPS for Planka Docker Installation

Before deploying Planka, you need to prepare your VPS. This stage includes updating the system, installing Docker and Docker Compose – tools that will significantly simplify Planka installation and its subsequent management.

System update and installation of necessary utilities

Connect to your VPS via SSH and execute the following commands to update the system and install basic packages:

sudo apt update
sudo apt upgrade -y
sudo apt install -y curl git nano

For CentOS/RHEL, use:

sudo yum update -y
sudo yum install -y curl git nano

Installing Docker and Docker Compose

Planka Docker is the preferred deployment method as it provides application isolation and its dependencies. Let's install Docker Engine and Docker Compose. For Ubuntu/Debian:

# Install Docker
sudo apt install -y ca-certificates curl gnupg
sudo install -m 0755 -d /etc/apt/keyrings
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /etc/apt/keyrings/docker.gpg
sudo chmod a+r /etc/apt/keyrings/docker.gpg
echo \
  "deb [arch="$(dpkg --print-architecture)" signed-by=/etc/apt/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  "$(. /etc/os-release && echo "$VERSION_CODENAME")" 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 docker-buildx-plugin docker-compose-plugin

# Add current user to the docker group (to avoid using sudo with docker commands)
sudo usermod -aG docker $USER
newgrp docker

For CentOS/RHEL:

# Install Docker
sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
sudo yum install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo systemctl start docker
sudo systemctl enable docker

# Add current user to the docker group
sudo usermod -aG docker $USER
newgrp docker

Check Docker installation:

docker run hello-world

If you see "Hello from Docker!", then Docker is installed and working correctly. Now your VPS is ready for Planka installation.

Step-by-step Planka Installation on VPS with Docker Compose

Deploying Planka using Docker Compose is the simplest and recommended method. It allows you to define all services (Planka, PostgreSQL) and their dependencies in a single file, simplifying management. Follow these steps for Planka installation on your VPS.

Creating the docker-compose.yml file

Create a directory for Planka and navigate into it:

mkdir ~/planka
cd ~/planka

Create a docker-compose.yml file using your favorite text editor (e.g., nano):

nano docker-compose.yml

Paste the following content. Make sure to replace YOUR_SECRET_KEY with a long, random string (minimum 32 characters) and YOUR_POSTGRES_PASSWORD with a strong database password.

version: '3.8'

services:
  planka:
    image: ghcr.io/plankanban/planka:latest
    container_name: planka_app
    restart: always
    ports:
      - "1337:1337"
    environment:
      - DATABASE_URL=postgresql://planka:${YOUR_POSTGRES_PASSWORD}@db:5432/planka
      - SECRET_KEY=${YOUR_SECRET_KEY}
      - ROOT_URL=http://localhost:1337 # Will be changed when configuring the domain
      - TRUST_PROXY=1 # Important when using a reverse proxy
    depends_on:
      - db
    volumes:
      - ./uploads:/app/uploads # Persist uploaded files
      - ./data:/app/data # Other Planka data

  db:
    image: postgres:15-alpine
    container_name: planka_db
    restart: always
    environment:
      - POSTGRES_DB=planka
      - POSTGRES_USER=planka
      - POSTGRES_PASSWORD=${YOUR_POSTGRES_PASSWORD}
    volumes:
      - ./db_data:/var/lib/postgresql/data # Persist database data

volumes:
  uploads:
  data:
  db_data:

File explanations:

• planka: Service for the Planka application itself. Uses the official Docker image.
• ports: - "1337:1337": Maps container port 1337 to host port 1337. This is Planka's internal port.
• DATABASE_URL: Connection string for the PostgreSQL database.
• SECRET_KEY: Unique secret key for encrypting session data. Must be changed!
• ROOT_URL: Base URL of your application. Currently set to localhost, but will be changed later for domain access.
• TRUST_PROXY=1: An important variable that tells Planka to trust proxy server headers (e.g., Nginx or Caddy) for correct client IP address and HTTPS protocol detection.
• volumes: Mounts host directories to containers to persist data (files, database) even after containers are removed. This is critically important for data persistence and backup.
• db: Service for the PostgreSQL database. Uses the official image.
• POSTGRES_PASSWORD: Password for the Planka database user. Must be changed!

Save the file (Ctrl+X, Y, Enter for nano).

Starting Planka with Docker Compose

Now that the docker-compose.yml file is ready, you can start Planka:

docker compose up -d

The -d flag runs the containers in detached mode. Docker Compose will download the necessary images, create the containers, and start them. This process may take several minutes on the first run.

You can check the status of the containers with the command:

docker compose ps

You should see that the planka_app and planka_db containers are in the "Up" state.

At this stage, Planka on your VPS is already running and accessible via your server's IP address on port 1337 (e.g., http://YOUR_IP:1337). However, for full use and security, you need to configure a reverse proxy and HTTPS.

Configuring Reverse Proxy and HTTPS for Planka

Direct access to Planka via IP address and port 1337 is neither secure nor convenient. Configuring a reverse proxy (Nginx or Caddy) with HTTPS (SSL/TLS certificate from Let's Encrypt) will allow you to access Planka via a domain name, ensure traffic encryption, and enhance overall security. This is a key step for any Planka self-hosted installation.

Before you begin, ensure you have a domain name pointing to your VPS's IP address.

Option 1: Configuring Nginx as a Reverse Proxy with HTTPS

Nginx is a powerful and popular web server, perfectly suited for the role of a reverse proxy.

Installing Nginx and Certbot

sudo apt install -y nginx certbot python3-certbot-nginx

For CentOS/RHEL:

sudo yum install -y nginx epel-release
sudo yum install -y certbot python3-certbot-nginx

Nginx Configuration

Create a new Nginx configuration file for your domain (replace your_domain.com with your actual domain):

sudo nano /etc/nginx/sites-available/planka.conf

Paste the following content:

server {
    listen 80;
    listen [::]:80;
    server_name your_domain.com www.your_domain.com;

    location / {
        proxy_pass http://localhost:1337; # Planka Port
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;
        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;
    }
}

Activate the configuration by creating a symbolic link and reloading Nginx:

sudo ln -s /etc/nginx/sites-available/planka.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo systemctl restart nginx

Obtaining an SSL Certificate with Certbot

Now, get a free SSL certificate from Let's Encrypt using Certbot:

sudo certbot --nginx -d your_domain.com -d www.your_domain.com

Follow Certbot's instructions. It will automatically update the Nginx configuration to use HTTPS and set up automatic certificate renewal.

Updating ROOT_URL in Docker Compose

Go back to the docker-compose.yml file and update the ROOT_URL variable to use your domain name with HTTPS:

nano ~/planka/docker-compose.yml

Change the line:

      - ROOT_URL=http://localhost:1337

To:

      - ROOT_URL=https://your_domain.com

Save the file and restart the Planka containers for the changes to take effect:

cd ~/planka
docker compose down
docker compose up -d

Now your Planka on VPS is accessible at https://your_domain.com with a secure connection.

Option 2: Configuring Caddy as a Reverse Proxy with HTTPS

Caddy is a modern web server that automatically manages Let's Encrypt SSL certificates, making it very easy to set up.

Installing Caddy

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

For CentOS/RHEL:

sudo yum install -y yum-utils
sudo yum-config-manager --add-repo https://dl.cloudsmith.io/public/caddy/stable/rpm/caddy-stable.repo
sudo yum install -y caddy

Caddyfile Configuration

Create or edit the Caddyfile:

sudo nano /etc/caddy/Caddyfile

Remove all existing content and paste the following (replace your_domain.com with your actual domain):

your_domain.com {
    reverse_proxy localhost:1337 # Planka Port
}

Caddy will automatically obtain and configure an SSL certificate for your_domain.com. Restart Caddy:

sudo systemctl restart caddy

Updating ROOT_URL in Docker Compose

As with Nginx, update the ROOT_URL variable in your docker-compose.yml file:

nano ~/planka/docker-compose.yml

Change the line:

      - ROOT_URL=http://localhost:1337

To:

      - ROOT_URL=https://your_domain.com

Save the file and restart the Planka containers:

cd ~/planka
docker compose down
docker compose up -d

Now your Planka on your server is accessible at https://your_domain.com with automatic HTTPS.

Planka Maintenance: Backups, Updates, and Monitoring

After successfully installing Planka on your VPS, it's important to ensure its stable and secure operation through regular maintenance. This includes data backup, timely updates, and performance monitoring.

Planka Data Backup Strategies

Backup is a critically important aspect for any Planka self-hosted installation. Data loss can lead to serious consequences. Since we are using Docker Compose with persistent volumes, the backup process is relatively simple.

Planka's main data is stored in two locations:

1. PostgreSQL database (./db_data in our docker-compose.yml).
2. Uploaded files (./uploads in our docker-compose.yml).

Manual backup:

You can create an archive of these directories:

cd ~/planka
docker compose stop planka_app # Stop the Planka application before backing up the DB for consistency
pg_dump -h localhost -p 5432 -U planka planka > db_backup_$(date +%Y%m%d%H%M%S).sql # If PostgreSQL is directly accessible
# OR, if only via Docker:
docker exec planka_db pg_dump -U planka planka > db_backup_$(date +%Y%m%d%H%M%S).sql
tar -czvf uploads_backup_$(date +%Y%m%d%H%M%S).tar.gz uploads
docker compose start planka_app

Automated backup:

For automation, you can use cron and scripts that will execute these commands regularly. It is recommended to use specialized backup tools such as Restic or BorgBackup, which support incremental backups and encryption. Store backups on remote storage (S3, Backblaze B2, etc.), not on the same VPS.

Updating Planka and Docker Images

Regular Planka updates are important for new features, bug fixes, and security vulnerability patches.

To update Planka Docker, simply execute the following commands in the ~/planka directory:

cd ~/planka
docker compose pull # Downloads the latest versions of images
docker compose down # Stops current containers
docker compose up -d # Starts new containers with updated images

Always make a backup before updating.

Performance and Log Monitoring

To maintain the health of your Planka on your server, monitor its status:

• Container logs: Check Planka and PostgreSQL logs for errors:

  docker compose logs planka_app
  docker compose logs planka_db

• Resource usage: Use htop, free -h, df -h commands on your VPS to monitor CPU, RAM, and disk space.
• Monitoring systems: For more complex scenarios, consider using Prometheus + Grafana to collect and visualize metrics for your VPS and Docker containers.

Regular maintenance and monitoring will ensure the long-term stability and security of your Planka installation.

Choosing the Optimal VPS Configuration for Real Planka Workload

Choosing the right VPS configuration for Planka on a VPS is a key factor in ensuring performance and scalability. While we've already covered general recommendations, let's delve into the details, considering various usage scenarios and real-world workloads. The right choice will help avoid bottlenecks and ensure a comfortable working experience for your team.

Factors influencing configuration choice

1. Number of active users: The more users simultaneously working with Planka, the higher the CPU and RAM requirements. Each active user generates requests to the database and the application API.
2. Intensity of use: A team that actively creates, moves, and comments on hundreds of tasks daily will generate significantly more load than one that uses Planka for only a dozen tasks a week.
3. Volume of stored attachments: Planka allows attaching files to tasks. If your team plans to store large volumes of files (images, documents, archives), you will need more disk space.
4. Other applications on the VPS: If your VPS is used not only for Planka but also for other services (e.g., Vikunja, Git server, file storage Filebrowser), you must consider their requirements when planning resources.

VPS Configuration Recommendations from Valebyte.com

Based on our experience, we offer the following Valebyte.com VPS configurations, optimized for Planka on your server:

• For small teams (up to 10-15 active users):
  • CPU: 2 vCPU (2.5 GHz+)
  • RAM: 4 GB
  • Disk: 50 GB NVMe SSD
  • Bandwidth: 500 Mbps
  • Approximate monthly budget: from $15-$25
  • Justification: This will provide sufficient performance for the database and the application itself, as well as a small reserve for peak loads. NVMe SSD ensures fast data access.
• For medium teams (15-50 active users):
  • CPU: 4 vCPU (2.8 GHz+)
  • RAM: 8 GB
  • Disk: 100 GB NVMe SSD
  • Bandwidth: 1 Gbps
  • Approximate monthly budget: from $30-$60
  • Justification: Increased CPU and RAM resources will efficiently handle a larger number of simultaneous requests and background tasks. A larger disk will be needed for the growing volume of attachments and logs.
• For large teams and high loads (50+ active users):
  • CPU: 6-8+ vCPU (3.0 GHz+)
  • RAM: 16+ GB
  • Disk: 200+ GB NVMe SSD
  • Bandwidth: 1 Gbps+
  • Approximate monthly budget: from $70-$150+
  • Justification: This configuration will provide a significant performance reserve for handling a large number of requests, complex database operations, and supporting a large number of simultaneous users. It may be worth considering separating the database to a dedicated server or using clustered solutions if the load is extremely high.

Our VPS plans at Valebyte.com are flexibly configurable, allowing you to precisely match resources to your needs. You can always start with a more modest plan and scale it as your team and project grow, minimizing initial costs and optimizing infrastructure expenses for your Planka self-hosted instance.

Conclusion

Deploying Planka on a VPS provides your team with a powerful, flexible, and fully controlled project management tool. By following the step-by-step instructions for Planka installation via Docker Compose, configuring a reverse proxy with HTTPS, and adhering to maintenance recommendations, you can create a reliable and secure working environment. For optimal performance and scalability, choose high-performance VPS servers with NVMe SSDs from Valebyte.com, which will ensure stable operation of your Planka Docker installation even under significant load.