Redmine on VPS: installation, configuration, and maintenance

Redmine on VPS: installation, configuration, and maintenance — this is the process of deploying the popular project management system Redmine on a Virtual Private Server, including environment configuration, setting up web server access with HTTPS, and ensuring stable operation through backups and updates. Installing Redmine on a VPS allows for full control over data, customization of the system to specific team needs, and high performance, making it an ideal solution for companies that value flexibility and security of their project data.

What is Redmine and why is it ideal for a VPS?

Redmine is a powerful and flexible open-source web-based project management system, written on the Ruby on Rails framework. It provides a wide range of tools for effective organization of work for teams of any size: from small startups to large corporations. Key features of Redmine include an issue tracker, Gantt charts, calendars, wiki pages, forums, document management, time tracking, as well as support for multiple projects and user roles. Thanks to its extensibility through plugins, Redmine can be adapted to almost any workflow.

Choosing a VPS for deploying Redmine, or as it's often called, Redmine self-hosted, offers a number of undeniable advantages over cloud SaaS solutions or regular virtual hosting:

• Full control and data security: By hosting Redmine on your own VPS, you have complete control over project data, its storage, and security. This is critically important for companies with high confidentiality requirements.
• Flexibility and customization: You can install any plugins, modify the code, and configure the server environment according to your project's unique needs, which is not possible on standard SaaS platforms.
• Performance optimization: A VPS allows you to precisely configure server resources (CPU, RAM, disk) for Redmine's workload, ensuring optimal speed even with a large number of users and projects. You are not dependent on "neighbors" on shared hosting.
• Cost-effectiveness: For medium and large teams, a dedicated VPS with Redmine often proves more cost-effective in the long run compared to monthly subscriptions for commercial SaaS solutions, especially as the number of users grows.
• Integration: It's easier to integrate Redmine with other internal services, such as version control systems (Git, SVN), CI/CD pipelines, or monitoring systems.

Thus, Redmine on a VPS server is the choice for those who seek maximum flexibility, security, and performance, without overpaying for ready-made cloud solutions with limited functionality.

Key Features of Redmine for Project Management

• Task and bug management: A flexible task tracking system with customizable types, statuses, priorities, and assignees.
• Gantt charts and calendars: Visualization of project deadlines and task dependencies, resource planning.
• Wiki and forums: Centralized project knowledge base and discussion platform.
• Time tracking: Recording time spent on tasks, generating reports.
• File and document management: Storing and versioning documents, linking them to tasks and projects.
• Multi-project support: Ability to manage an unlimited number of projects with different settings and participants.
• Role-based access control: Detailed permission configuration for various user groups.
• Integration with version control systems: Linking commits to tasks, viewing repositories.
• Customizable fields and workflows: Adapting the system to specific project or company needs.

If you are looking for project management alternatives, also consider solutions like Vikunja on VPS or Kanboard on VPS, which offer their unique approaches to organizing work.

Redmine System Requirements: Which VPS to Choose?

For successful and stable operation of Redmine on a VPS, its system requirements must be considered. Redmine, being a Ruby on Rails application, has its own resource consumption characteristics. The correct choice of VPS configuration will ensure fast interface operation, prompt request processing, and comfortable work for all users.

Minimum and Recommended VPS Requirements

Minimum requirements are suitable for testing, personal use, or very small teams (up to 5 users) with low activity. For real production workloads, more powerful configurations are recommended.

• Operating System: Ubuntu Server (20.04 LTS or newer), Debian (11 or newer), CentOS Stream (8 or newer). These OSes support Docker well and have up-to-date packages.
• Processor (CPU):
  • Minimum: 1 vCPU (virtual core).
  • Recommended: 2 vCPUs for teams of 5-10 people, 4+ vCPUs for larger teams (20+ users) or high activity.
• Random Access Memory (RAM):
  • Minimum: 1 GB RAM (for Redmine without Docker, database only).
  • With Docker: 2 GB RAM (Redmine, PostgreSQL, Redis).
  • Recommended: 4 GB RAM for teams of 10-20 people, 8+ GB RAM for large teams or when using additional plugins, intensive report generation.
• Disk Space:
  • Minimum: 20 GB NVMe SSD. Redmine actively uses the database and stores attached files. NVMe SSD significantly speeds up disk operations compared to regular SSDs or HDDs.
  • Recommended: 50-100 GB NVMe SSD or more, depending on the volume of attached files, number of projects, and duration of use. The faster the disk, the more responsive Redmine will be.
• Database:
  • PostgreSQL (version 10+): The preferred choice for Redmine, as it generally shows better performance and reliability.
  • MySQL/MariaDB (version 5.7+/10.2+): Also supported, but PostgreSQL is more often recommended in the Redmine community.
• Redis: Recommended for caching and background tasks (Sidekiq) to improve Redmine performance.
• Network Interface: Stable network connection, preferably 1 Gbit/s.

When choosing a VPS, it's always better to opt for a configuration with a small reserve, especially for RAM and disk space, to avoid performance issues as the project grows and the number of users increases. Using NVMe SSD is practically mandatory for comfortable work with Redmine.

Preparing Your VPS for Redmine Installation: Basic Steps

Before proceeding with the actual Redmine installation, you need to prepare your VPS. These preparatory steps will ensure stability, security, and proper functioning of all components. We will use Docker and Docker Compose to simplify deployment, which is a modern and recommended approach for self-hosted Redmine.

Server Access, OS Update, and Docker Installation

First, connect to your VPS via SSH. To do this, use the command:

ssh root@YOUR_VPS_IP_ADDRESS

Replace YOUR_VPS_IP_ADDRESS with the actual IP address of your server. If you are using a user with limited privileges, replace root with your username.

After a successful connection, update the operating system packages to their latest state. This is important for security and compatibility:

sudo apt update
sudo apt upgrade -y
sudo apt dist-upgrade -y
sudo apt autoremove -y

For CentOS/RHEL-based systems, use sudo dnf update -y.

Reboot the server if recommended after a kernel or critical component update:

sudo reboot

After rebooting, reconnect via SSH.

Next, install Docker Engine and Docker Compose. This will allow you to easily deploy Redmine and its dependencies (database, Redis) in isolated containers.

# Install necessary packages
sudo apt install ca-certificates curl gnupg lsb-release -y

# 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

# Add Docker repository
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

# Update package index and install Docker Engine
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y

# Verify Docker installation
sudo docker run hello-world

If you don't want to use sudo for every Docker command, add your user to the docker group:

sudo usermod -aG docker $USER
newgrp docker

Log out and log back into your SSH session for the changes to take effect.

Firewall Configuration (UFW)

Firewall configuration is critically important for protecting your server. We will use UFW (Uncomplicated Firewall).

# Install UFW (if not already installed)
sudo apt install ufw -y

# Allow SSH (port 22)
sudo ufw allow ssh

# Allow HTTP (port 80) and HTTPS (port 443) for web access
sudo ufw allow http
sudo ufw allow https

# Enable UFW
sudo ufw enable

Confirm the action by pressing y. Check the firewall status:

sudo ufw status verbose

Your VPS is now ready for Redmine installation.

Installing Redmine on VPS with Docker Compose

Using Docker Compose significantly simplifies Redmine installation, allowing you to define all necessary services (Redmine, PostgreSQL, Redis) and their interconnections in a single file. This makes the process reproducible and easy to manage.

Creating the docker-compose.yml file for Redmine

First, create a directory for your Redmine project and navigate into it:

mkdir ~/redmine
cd ~/redmine

Now, create the docker-compose.yml file:

nano docker-compose.yml

Insert the following content into the file. This configuration defines three services: Redmine, PostgreSQL (database), and Redis (for caching and Sidekiq background tasks).

version: '3.8'

services:
  redmine:
    image: redmine:latest
    container_name: redmine_app
    restart: always
    ports:
      - "3000:3000" # Redmine port, will be available on host port 3000
    environment:
      REDMINE_DB_ADAPTER: postgresql
      REDMINE_DB_DATABASE: redmine_production
      REDMINE_DB_HOST: db
      REDMINE_DB_PORT: 5432
      REDMINE_DB_USERNAME: redmine_user
      REDMINE_DB_PASSWORD: YOUR_DB_PASSWORD # !!! Replace with a strong password !!!
      REDMINE_SECRET_KEY_BASE: YOUR_SECRET_KEY_BASE # !!! Replace with a random string !!!
      REDMINE_SECRETS_KEY_BASE: YOUR_SECRET_KEY_BASE # For compatibility with newer versions
      REDMINE_RAILS_ENV: production
      REDMINE_EMAIL_DELIVERY_METHOD: smtp
      REDMINE_SMTP_HOST: smtp.example.com # Replace with your SMTP server
      REDMINE_SMTP_PORT: 587
      REDMINE_SMTP_USER: [email protected] # Replace with your email address
      REDMINE_SMTP_PASSWORD: YOUR_EMAIL_PASSWORD # Replace with your email password
      REDMINE_SMTP_AUTHENTICATION: login
      REDMINE_SMTP_ENABLE_STARTTLS_AUTO: 'true'
      REDMINE_CACHE_STORE: redis_cache_store
      REDMINE_REDIS_URL: redis://redis:6379/1
    volumes:
      - redmine_data:/usr/src/redmine/files # For storing attached files
      - redmine_plugins:/usr/src/redmine/plugins # For plugins
      - redmine_themes:/usr/src/redmine/public/themes # For themes
    depends_on:
      - db
      - redis
    networks:
      - redmine_network

  db:
    image: postgres:13
    container_name: redmine_db
    restart: always
    environment:
      POSTGRES_DB: redmine_production
      POSTGRES_USER: redmine_user
      POSTGRES_PASSWORD: YOUR_DB_PASSWORD # !!! Must match REDMINE_DB_PASSWORD !!!
    volumes:
      - db_data:/var/lib/postgresql/data
    networks:
      - redmine_network

  redis:
    image: redis:latest
    container_name: redmine_redis
    restart: always
    networks:
      - redmine_network

volumes:
  redmine_data:
  redmine_plugins:
  redmine_themes:
  db_data:

networks:
  redmine_network:
    driver: bridge

Important points when editing docker-compose.yml:

• YOUR_DB_PASSWORD: Replace with a complex, unique password for the database. It must be the same for REDMINE_DB_PASSWORD and POSTGRES_PASSWORD.
• YOUR_SECRET_KEY_BASE: This is a critically important key for Redmine's security. Generate a random string, for example, using the rake secret command within the Redmine container or an online generator. For instance, openssl rand -hex 64.
• SMTP settings: Be sure to configure the SMTP section for sending email notifications. Replace smtp.example.com, [email protected], and YOUR_EMAIL_PASSWORD with your email provider's details.
• Port 3000:3000: Redmine will be accessible on port 3000 of your VPS. We will configure Nginx/Caddy as a reverse proxy for access via standard ports 80/443 later.

Save the file (Ctrl+O, then Enter, Ctrl+X).

Starting Redmine and Initializing the Database

Now that the docker-compose.yml file is ready, you can start Redmine. Execute the following command in the ~/redmine directory:

docker compose up -d

This command will download the necessary images, create containers, and run them in the background (-d). The process may take some time during the first launch.

After starting, you need to initialize the Redmine database. This is done from within the Redmine container. First, ensure that the containers are running:

docker compose ps

You should see an Up status for all three services. Then, perform database migrations and load default data (language, task statuses, etc.):

docker compose exec redmine bundle exec rake db:migrate RAILS_ENV=production
docker compose exec redmine bundle exec rake redmine:load_default_data RAILS_ENV=production

When prompted for the default language, enter ru for Russian.

After successfully executing these commands, your Redmine is ready for use. You can access it via your VPS's IP address and port 3000, for example, http://YOUR_VPS_IP_ADDRESS:3000. Default login: admin, password: admin. Be sure to change the password upon first login!

At this stage, Redmine installation on the server is complete. The next step is to configure secure access via a domain name and HTTPS.

Configuring Reverse Proxy and HTTPS for Redmine

Direct access to Redmine via an IP address and port 3000 is not a secure or convenient solution for a production environment. For this, a reverse proxy and HTTPS are used. A reverse proxy allows directing traffic from your domain name to Redmine's internal port, while HTTPS ensures data encryption between the user and the server.

We will consider two popular options: Nginx and Caddy. Both handle the task, but Caddy is often simpler to configure thanks to automatic management of Let's Encrypt HTTPS certificates.

Option 1: Nginx as Reverse Proxy with Certbot

If Nginx is not yet installed, install it:

sudo apt install nginx -y

Create a new configuration file for Redmine in Nginx:

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

Insert the following content, replacing your_domain.com with your domain name:

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

    location / {
        proxy_pass http://127.0.0.1:3000; # Proxy to Redmine's internal port
        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_redirect off;
    }
}

Create a symbolic link to this file in sites-enabled for Nginx to activate it:

sudo ln -s /etc/nginx/sites-available/redmine.conf /etc/nginx/sites-enabled/

Check the Nginx configuration for errors and reload it:

sudo nginx -t
sudo systemctl reload nginx

Now your Redmine should be accessible via HTTP at http://your_domain.com.

Configuring HTTPS with Certbot

Install Certbot to automatically obtain and renew Let's Encrypt SSL certificates:

sudo apt install certbot python3-certbot-nginx -y

Run Certbot for your domain:

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

Certbot will automatically modify the Nginx configuration, add the necessary entries for HTTPS, and set up automatic redirection from HTTP to HTTPS. Follow Certbot's instructions. Once completed, your Redmine will be accessible via HTTPS: https://your_domain.com.

Option 2: Caddy as Reverse Proxy with Automatic HTTPS

Caddy is a powerful web server that automatically obtains and renews Let's Encrypt SSL certificates, which greatly simplifies HTTPS configuration. If you prefer simplicity, Caddy is an excellent choice.

First, stop Nginx if it was installed and running, to avoid port conflicts:

sudo systemctl stop nginx
sudo systemctl disable nginx

Install Caddy. The simplest way is to use the official repository:

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

Create or edit the Caddy configuration file (Caddyfile):

sudo nano /etc/caddy/Caddyfile

Remove existing content and insert the following, replacing your_domain.com with your domain:

your_domain.com {
    reverse_proxy 127.0.0.1:3000
}

Save the file and reload Caddy:

sudo systemctl reload caddy

Caddy will automatically obtain an SSL certificate for your_domain.com and configure HTTPS. Your Redmine will be accessible via https://your_domain.com.

Regardless of the chosen reverse proxy, ensure that your domain's DNS records (A-record) point to your VPS's IP address.

Redmine Maintenance: Backups, Updates, and Monitoring

Regular maintenance of Redmine on a VPS is critically important to ensure its stable, secure, and up-to-date operation. This includes data backup, timely updates, and performance monitoring.

Redmine Data Backup Strategy

Backups are your insurance against data loss. For Redmine, two main parts need to be backed up: the database and files (attachments, plugins, themes).

PostgreSQL Database Backup

The database is the heart of Redmine. We will use pg_dump to create a database dump from within the PostgreSQL Docker container.

# Navigate to the directory with docker-compose.yml
cd ~/redmine

# Create a directory for backups (if it doesn't exist)
mkdir -p ./backups/db

# Perform database dump
docker compose exec db pg_dump -U redmine_user redmine_production > ./backups/db/redmine_db_$(date +%Y%m%d_%H%M%S).sql

Replace redmine_user and redmine_production with your values if they differ.

Redmine File Backup

Attached files, plugins, and themes are stored in Docker volumes. They also need to be backed up. You can use the docker cp command for this, or simply copy the contents of the volumes if they are mounted as directories on the host (which we did in docker-compose.yml).

# Create a directory for file backups
mkdir -p ./backups/files

# Copy Redmine files (attachments)
docker compose cp redmine_app:/usr/src/redmine/files ./backups/files/redmine_files_$(date +%Y%m%d_%H%M%S)

# Copy plugins
docker compose cp redmine_app:/usr/src/redmine/plugins ./backups/files/redmine_plugins_$(date +%Y%m%d_%H%M%S)

# Copy themes
docker compose cp redmine_app:/usr/src/redmine/public/themes ./backups/files/redmine_themes_$(date +%Y%m%d_%H%M%S)

To automate this process, you can create a shell script and add it to cron. For example, the script backup_redmine.sh:

#!/bin/bash

BACKUP_DIR="/home/$USER/redmine/backups"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)

# Backup database
docker compose exec db pg_dump -U redmine_user redmine_production > "$BACKUP_DIR/db/redmine_db_$TIMESTAMP.sql"

# Backup files
docker compose cp redmine_app:/usr/src/redmine/files "$BACKUP_DIR/files/redmine_files_$TIMESTAMP"
docker compose cp redmine_app:/usr/src/redmine/plugins "$BACKUP_DIR/files/redmine_plugins_$TIMESTAMP"
docker compose cp redmine_app:/usr/src/redmine/public/themes "$BACKUP_DIR/files/redmine_themes_$TIMESTAMP"

# Delete old backups (e.g., older than 7 days)
find "$BACKUP_DIR/db" -type f -name "*.sql" -mtime +7 -delete
find "$BACKUP_DIR/files" -maxdepth 1 -type d -name "redmine_files_*" -mtime +7 -exec rm -rf {} +
find "$BACKUP_DIR/files" -maxdepth 1 -type d -name "redmine_plugins_*" -mtime +7 -exec rm -rf {} +
find "$BACKUP_DIR/files" -maxdepth 1 -type d -name "redmine_themes_*" -mtime +7 -exec rm -rf {} +

echo "Redmine backup completed at $TIMESTAMP"

Make the script executable: chmod +x backup_redmine.sh. Add it to cron (crontab -e) for daily execution, for example, at 2 AM:

0 2 * * * /home/$USER/redmine/backup_redmine.sh >> /var/log/redmine_backup.log 2>&1

For more advanced backup solutions, consider using tools like Restic, which allows efficient management of incremental backups and sending them to cloud storage.

Updating Redmine and Docker Images

Regular updates of Redmine and its components are important for receiving new features, bug fixes, and security patches.

1. Updating Docker images:

   cd ~/redmine
   docker compose pull # Downloads new versions of images (redmine, postgres, redis)
   docker compose down # Stops current containers
   docker compose up -d # Starts containers with new images

2. Database migrations (if required): After updating the Redmine image, database migrations may be necessary. Always perform them:

   docker compose exec redmine bundle exec rake db:migrate RAILS_ENV=production

3. Updating plugins: If you use plugins, check their compatibility with the new Redmine version and update them manually, following the plugin developers' instructions. This often requires copying new plugin files to the plugins directory and performing migrations for plugins:

   docker compose exec redmine bundle exec rake redmine:plugins:migrate RAILS_ENV=production

4. Clearing cache: After updates, it is recommended to clear the Redmine cache:

   docker compose exec redmine bundle exec rake tmp:cache:clear RAILS_ENV=production
   docker compose exec redmine bundle exec rake tmp:sessions:clear RAILS_ENV=production

Always perform a full backup before starting the update process!

Performance and Status Monitoring

• Docker container status:

  docker compose ps
  docker stats

  docker stats will show CPU, RAM, I/O usage for each container.

• VPS resource usage:

  htop # Interactive process monitor
  free -h # RAM usage
  df -h # Disk space usage

• Redmine logs: Check Redmine logs for errors:

  docker compose logs redmine

Regular monitoring will help identify potential problems before they affect your team's work.

Choosing a VPS for Redmine under Real Load: Configurations and Prices

Choosing the optimal VPS configuration for Redmine directly depends on your team size, usage intensity, and the volume of stored data. Overpaying for excessive resources is just as undesirable as a lack of resources, which leads to slowdowns and failures.

Recommended VPS Configurations for Different Scenarios

Valebyte.com offers a wide range of VPS plans that are ideal for deploying Redmine. Below is a table with recommended configurations for various usage scenarios:

Usage Scenario	Number of Users	CPU (vCores)	RAM (GB)	Disk (NVMe SSD)	Approx. VPS Cost/Month (USD)
Personal / Test	1-3	1	2	30 GB	$5 - $8
Small Team	5-15	2	4	50 GB	$10 - $18
Medium Team	15-30	4	8	100 GB	$20 - $35
Large Team / High Load	30+	6-8+	16+	200 GB+	$40 - $70+

Table Explanations:

• CPU (vCores): Redmine does not always intensively use the processor, but with a large number of simultaneous requests or complex reports, additional cores significantly improve performance.
• RAM (GB): Random Access Memory is one of the most critical resources. Redmine, PostgreSQL, and Redis actively use RAM for caching. A lack of RAM leads to active swapping, which slows down the entire system. It's always better to have a small reserve.
• Disk (NVMe SSD): The presence of NVMe SSD is practically mandatory. The speed of disk operations directly affects Redmine's responsiveness, especially when working with the database and a large number of attached files. Regular SSDs or HDDs can become a bottleneck.
• Approx. Cost: Prices may vary among different providers but give a general idea of the budget. Valebyte.com offers competitive rates with high-performance NVMe SSDs.

Factors Influencing Configuration Choice

• Number of active users: The more people simultaneously working in Redmine, the higher the requirements for CPU and RAM.
• Usage intensity: If Redmine is only used for task tracking, requirements are lower. If Wiki, forums, large files, Gantt charts with many tasks, and time tracking are actively used, requirements increase.
• Number of projects and tasks: A large number of projects and tasks increases the database size and query complexity.
• Plugin usage: Some plugins can be resource-intensive and increase server load.
• Volume of stored files: Attached files occupy disk space. If users frequently upload large files, a larger disk volume is needed.

Start with a configuration that matches your current needs and be prepared to scale VPS resources as your team and project grow. Most providers, including Valebyte.com, allow easy upgrade of your plan without reinstalling the system.

Conclusion

Installing Redmine on a VPS using Docker Compose is a reliable and flexible way to get a powerful project management system under full control. This approach ensures high performance, data security, and the ability to fine-tune it to any team's needs, significantly surpassing SaaS solutions in terms of customization and long-term cost. Choosing an appropriate VPS plan with sufficient RAM and a fast NVMe disk guarantees stable and comfortable Redmine operation even under high load.