Discourse on a VPS: installation, configuration, and maintenance

Installing and configuring Discourse on a VPS involves choosing a suitable server, deploying the platform via the official Docker image, configuring the domain name, mail server, and HTTPS, as well as regular maintenance to ensure the stable and secure operation of your online community.

Discourse is a modern, powerful platform for creating online communities, forums, and discussion boards. Unlike outdated forum engines, it is designed with modern web standards and user needs in mind, offering an intuitive interface, responsive design, powerful moderation features, and integrations. Self-hosting Discourse on a Virtual Private Server (VPS) gives you full control over data, performance, and customization options, making it an ideal choice for companies, projects, and communities seeking independence and flexibility.

What is Discourse and why deploy it on a VPS?

Discourse is an open-source platform for organizing online discussions that redefines the traditional forum experience. It is designed as a single linear discussion where new replies load dynamically as you scroll, making interaction smoother and more modern. Discourse primarily focuses on user convenience, ease of moderation, and deep integration with various services.

Advantages of Discourse for a community

Discourse is not just a forum; it's a comprehensive tool for building and managing a community. Its key advantages include:

• Modern UX/UI: A clean, intuitive interface that works beautifully on all devices, from desktops to smartphones.
• Gamification: A system of badges, trust levels, and notifications encourages participants to be active and produce quality content.
• Powerful Moderation Tools: Built-in features for combating spam, quickly responding to violations, and managing content.
• Flexibility and Extensibility: Plugin and theme support allows Discourse to be adapted to any needs and branding.
• SEO Optimization: All topics and posts are automatically optimized for search engines, improving content indexing.
• Integrations: Easily integrates with SSO (Single Sign-On), Slack, GitHub, and other popular services.
• Open Source: Full transparency and the ability for self-modification.

Thanks to these qualities, Discourse is ideal for customer support, internal corporate discussions, educational platforms, fan communities, as well as for creating knowledge bases and Q&A sections. If you are looking for a platform for project and task management, you might be interested in the article about Redmine on VPS or OpenProject on VPS, which also provide powerful tools for teamwork.

Why VPS is the ideal choice for Discourse on a server?

Deploying Discourse on a Virtual Private Server (VPS) offers an optimal balance between cost, performance, and control compared to shared hosting or fully managed solutions.

• Full Control: You get root access to the server, allowing you to install any software, configure system parameters, and optimize performance for your needs.
• Scalability: As your community grows, you can easily scale VPS resources (CPU, RAM, storage) without needing to migrate to a new server.
• Isolated Resources: Unlike shared hosting, VPS resources are fully dedicated to you, ensuring stable performance and no impact from "neighbors" on the server.
• Security: You control all aspects of server security, can configure a firewall, SSH access, and other protection measures as you see fit.
• Cost-effectiveness: The cost of a VPS is significantly lower than that of dedicated servers, while providing sufficient power for most medium and large Discourse communities.
• Configuration Flexibility: You can configure the operating system, software versions, and network parameters exactly as needed for optimal Discourse operation.

Self-hosting Discourse on a VPS is especially relevant when data privacy, performance, and unique branding are paramount. You are not tied to the limitations of third-party services and can fully control your online home.

System requirements for Discourse installation

Discourse, being a resource-intensive application developed on Ruby on Rails using PostgreSQL and Redis, has certain minimum and recommended system requirements. It is important to consider these parameters when choosing a VPS plan to ensure stable and fast platform operation.

Minimum and recommended configurations for Discourse VPS

The choice of VPS configuration directly depends on the expected load and the size of your community. Insufficient resources will lead to slow performance, delays, and failures, while excessive resources will lead to unnecessary costs. Here are general recommendations:

Minimum requirements (for small communities up to 50 active users):

• Processor (CPU): 1-2 vCPU (virtual cores). The higher the clock speed, the better.
• Random Access Memory (RAM): 2 GB. This is an absolute minimum and may be insufficient for active use.
• Storage: 25 GB NVMe SSD. NVMe drives are significantly faster than traditional SSDs and HDDs, which is critical for database performance.
• Bandwidth: 100 Mbps or 1 Gbps port.

Recommended requirements (for medium communities 50-200 active users):

• Processor (CPU): 2-4 vCPU.
• Random Access Memory (RAM): 4 GB.
• Storage: 50 GB NVMe SSD.
• Bandwidth: 1 Gbps port.

Optimal requirements (for large communities 200+ active users or with many plugins):

• Processor (CPU): 4-8+ vCPU.
• Random Access Memory (RAM): 8 GB or more.
• Storage: 100 GB+ NVMe SSD.
• Bandwidth: 1 Gbps port.

Important note: Discourse actively uses PostgreSQL and Redis, which are sensitive to disk subsystem speed. Therefore, using NVMe SSD is highly desirable for any configuration, providing significantly better performance compared to regular SSDs or, moreover, HDDs.

Compatible operating systems

Discourse is designed to run in a Linux environment. The following distributions are officially supported and recommended:

• Ubuntu Server: Versions 20.04 LTS, 22.04 LTS (recommended).
• Debian: Versions 10, 11, 12.

These distributions provide stability, up-to-date packages, and good community support. It is strongly not recommended to use other distributions, such as CentOS/RHEL, due to potential dependency issues and lack of official support. All commands in this guide will be oriented towards Ubuntu/Debian.

Step-by-step Discourse installation on VPS with Docker

Discourse is officially distributed and recommended for Discourse installation via Docker. This approach significantly simplifies the deployment process, provides application isolation, and dependency management. We will use the official installation script, which automates most of the process.

VPS preparation: OS, domain, mail server

Before proceeding with the installation, ensure that your VPS meets the following conditions:

1. Operating System: A fresh installation of Ubuntu Server 22.04 LTS or Debian 12.
2. SSH Access: You have root access or user access with sudo privileges.
3. System Update: Update system packages to the latest versions:

   sudo apt update && sudo apt upgrade -y

4. Domain Name: You have a registered domain name (e.g., forum.example.com), and the A-record for this domain points to your VPS's IP address. This is critical for HTTPS and email to work.
5. Mail Server: Discourse actively uses email for user registration, password resets, notifications, and other functions. You will need to configure an external SMTP server. It is recommended to use third-party services such as Postmark, SendGrid, Mailgun, Amazon SES, or Gmail SMTP. Self-configuring a mail server for Discourse is complex and not recommended without deep knowledge in this area due to issues with email deliverability and spam filters.

Installing Docker and Docker Compose for Discourse Docker

The official Discourse installation script will automatically install Docker if it is not present. However, for a better understanding of the process and the possibility of self-debugging, let's look at the steps for installing Docker manually:

1. Remove old versions (if any):

   for pkg in docker.io docker-doc docker-compose docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras; do sudo apt remove $pkg; done

2. Install dependencies:

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

3. Add Docker's official GPG key:

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

4. 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

5. Update package list and install Docker Engine:

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

6. Verify Docker installation:

   sudo docker run hello-world

   The output should show a message about Docker running successfully.

Deploying Discourse: cloning the repository and configuration

Now that Docker is installed, you can proceed with deploying Discourse Docker:

1. Clone the official Discourse Docker repository:

   sudo -s # Switch to root user
   cd /var
   git clone https://github.com/discourse/discourse_docker.git /var/discourse
   cd /var/discourse

   We are cloning the repository into /var/discourse, which is the standard and recommended path.

2. Run the interactive setup script:

   ./discourse-setup

   This script will guide you through the setup process, asking necessary questions. Pay attention to your answers:

   • Hostname for your Discourse? Enter your domain name (e.g., forum.example.com).
   • Email address for admin account(s)? Enter your email address. This will be the Discourse administrator's address.
   • SMTP server address? Your SMTP server address (e.g., smtp.postmarkapp.com).
   • SMTP port? SMTP port (usually 587 for TLS or 465 for SSL).
   • SMTP username? Username for your SMTP server.
   • SMTP password? Password for your SMTP server.
   • Optional email address for Let's Encrypt notifications? Email address for Let's Encrypt notifications (recommended).

   The script will generate the configuration file containers/app.yml based on your answers. Example content of app.yml (abbreviated):

   # file: containers/app.yml
   templates:
     - "templates/cdk.yml"
     - "templates/web.template.yml"
     - "templates/web.ssl.template.yml"
     - "templates/web.ratelimited.template.yml"
   
   expose:
     - "80:80"   # http
     - "443:443" # https
   
   params:
     db_default_text_search_config: "pg_catalog.english"
   
   env:
     LANG: en_US.UTF-8
     TZ: Europe/Moscow # Set your timezone
     RUBY_GLOBAL_METHOD_CACHE_SIZE: 131072
     UNICORN_WORKERS: 2 # Number of Unicorn worker processes, configure for your CPU
     DISCOURSE_DEFAULT_LOCALE: ru # Set Russian as default language
     DISCOURSE_HOSTNAME: forum.example.com # Your domain
     DISCOURSE_DEVELOPER_EMAILS: '[email protected]'
     DISCOURSE_ENABLE_CORS: true
     DISCOURSE_FORCE_HTTPS: true
     DISCOURSE_REJECT_ADMIN_REGISTRATION_EMAILS: true
   
     # SMTP settings
     DISCOURSE_SMTP_ADDRESS: smtp.postmarkapp.com
     DISCOURSE_SMTP_PORT: 587
     DISCOURSE_SMTP_USER_NAME: your_postmark_username
     DISCOURSE_SMTP_PASSWORD: your_postmark_password
     DISCOURSE_SMTP_ENABLE_START_TLS: true
     DISCOURSE_SMTP_AUTHENTICATION: "plain"
   
     # Let's Encrypt
     LETSENCRYPT_ACCOUNT_EMAIL: '[email protected]'
   

Launching and initial Discourse setup

After the discourse-setup script has generated app.yml, it will automatically start the Docker container build and launch process. This process can take from 10 to 30 minutes depending on your VPS performance and internet connection speed. You will see a lot of output in the console, which is normal.

If the process completes successfully, you will see a message indicating that Discourse has started. Now you can open your domain (e.g., https://forum.example.com) in a web browser. You will be redirected to the first administrator registration page.

1. Administrator Registration: Enter the email address you provided during installation. An email will be sent to you with a link to confirm and create a password.
2. Complete Installation: Follow the on-screen instructions to create an administrator account, set a password, and complete the initial setup.
3. Initial Configuration: After logging in, Discourse will prompt you to go through the initial setup wizard, which will help you configure basic settings such as forum name, logo, categories, and rules.

At this stage, your Discourse should already be fully functional and accessible via HTTPS.

Configuring Reverse Proxy (Nginx/Caddy) and HTTPS for Discourse

Although Discourse can handle HTTPS on its own using Let's Encrypt by default, using an external reverse proxy like Nginx or Caddy offers several advantages, especially for advanced configurations or when hosting multiple web applications on a single VPS.

Advantages of using a reverse proxy

Integrating Discourse with a reverse proxy server provides the following benefits:

• Centralized HTTPS Management: You can manage SSL certificates for all your domains from one place.
• Load Balancing: For very large installations, a reverse proxy can distribute requests among multiple Discourse instances.
• Caching: A reverse proxy can cache static resources, reducing the load on Discourse and speeding up page loading.
• Additional Security: A reverse proxy can serve as the first line of defense, filtering malicious requests and hiding the internal server structure.
• Hosting Multiple Applications: You can use the same VPS for other web applications, such as Filebrowser on VPS or NocoDB on VPS, routing traffic to different domains or subdomains.
• Web Application Firewall (WAF): Ability to integrate with a WAF for enhanced protection.

To use a reverse proxy, you will need to modify the Discourse configuration so that it does not attempt to manage HTTPS itself and only listens on the HTTP port (usually 80). To do this, edit the /var/discourse/containers/app.yml file and comment out the lines related to SSL and Let's Encrypt, and also change the expose:

# Comment out or delete the following lines:
#  - "templates/web.ssl.template.yml"
#  - "templates/web.ratelimited.template.yml"

# Change expose to:
expose:
  - "80:80" # http

env:
  # Comment out or delete Let's Encrypt
  # LETSENCRYPT_ACCOUNT_EMAIL: '[email protected]'
  # DISCOURSE_FORCE_HTTPS: true # Comment out this line as well

After changing app.yml, rebuild the container:

cd /var/discourse
./launcher rebuild app

Nginx configuration for Discourse

Nginx is one of the most popular web servers and reverse proxies. To install and configure it:

1. Install Nginx:

   sudo apt install nginx -y

2. Create an Nginx configuration file for your domain:

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

   Paste the following content, replacing forum.example.com with your domain:

   server {
       listen 80;
       listen [::]:80;
       server_name forum.example.com;
   
       # Redirect HTTP to HTTPS
       return 301 https://$host$request_uri;
   }
   
   server {
       listen 443 ssl http2;
       listen [::]:443 ssl http2;
       server_name forum.example.com;
   
       # Paths to SSL certificates (will be obtained later with Certbot)
       ssl_certificate /etc/letsencrypt/live/forum.example.com/fullchain.pem;
       ssl_certificate_key /etc/letsencrypt/live/forum.example.com/privkey.pem;
   
       ssl_session_timeout 1d;
       ssl_session_cache shared:SSL:10m;
       ssl_session_tickets off;
   
       ssl_protocols TLSv1.2 TLSv1.3;
       ssl_ciphers 'ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384';
       ssl_prefer_server_ciphers off;
   
       # HSTS (enable after successful HTTPS verification)
       # add_header Strict-Transport-Security "max-age=63072000" always;
   
       # Proxy requests to Discourse
       location / {
           proxy_pass http://127.0.0.1:80; # Discourse listens on port 80 inside Docker
           proxy_set_header Host $host;
           proxy_set_header X-Real-IP $remote_addr;
           proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
           proxy_set_header X-Forwarded-Proto $scheme;
           proxy_http_version 1.1;
           proxy_buffering off;
           proxy_set_header Upgrade $http_upgrade;
           proxy_set_header Connection "upgrade";
           proxy_read_timeout 900; # Increase timeout for long operations
       }
   
       # For static files, if you decide to serve them via Nginx
       # location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg)$ {
       #     expires 30d;
       #     add_header Cache-Control "public, no-transform";
       #     proxy_pass http://127.0.0.1:80;
       # }
   }
   

3. Activate configuration:

   sudo ln -s /etc/nginx/sites-available/discourse.conf /etc/nginx/sites-enabled/
   sudo nginx -t # Check syntax
   sudo systemctl restart nginx

4. Obtain an SSL certificate with Let's Encrypt using Certbot:

   sudo apt install certbot python3-certbot-nginx -y
   sudo certbot --nginx -d forum.example.com

   Certbot will automatically configure Nginx to use HTTPS and add rules for automatic certificate renewal.

Caddy configuration for Discourse

Caddy is a modern web server that simplifies HTTPS setup thanks to its built-in automatic integration with Let's Encrypt. This makes it an excellent choice for Discourse.

1. Install 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 caddy -y

2. Create a Caddyfile:

   sudo nano /etc/caddy/Caddyfile

   Remove existing content and paste the following, replacing forum.example.com with your domain:

   forum.example.com {
       reverse_proxy 127.0.0.1:80 {
           header_up Host {host}
           header_up X-Real-IP {remote_ip}
           header_up X-Forwarded-For {remote_ip}
           header_up X-Forwarded-Proto {scheme}
           header_up Upgrade {http.request.header.Upgrade}
           header_up Connection {http.request.header.Connection}
       }
   
       # Optional: Enable Gzip compression
       # encode gzip
   
       # Optional: Log requests
       # log {
       #     output file /var/log/caddy/discourse_access.log
       # }
   }
   

   Caddy will automatically obtain and renew SSL certificates for forum.example.com.

3. Restart Caddy:

   sudo systemctl reload caddy

After configuring Nginx or Caddy, your Discourse will be accessible via HTTPS through the chosen reverse proxy.

Maintaining Discourse self-hosted: backups, updates, and monitoring

Deploying Discourse on a VPS is only half the battle. Long-term stability, security, and platform relevance require regular maintenance. This includes data backup, timely updates, and performance monitoring.

Backup and recovery strategies

Backup is the most important aspect of maintaining any online service. Loss of community data can be catastrophic. Discourse offers built-in backup mechanisms, which are complemented by external strategies.

Built-in Discourse backups:

Discourse has a convenient built-in backup feature, accessible via the admin panel (/admin/backups). These backups include the database, uploaded files, and configuration. You can:

• Create backups manually.
• Set up an automatic backup schedule (e.g., daily or weekly).
• Configure automatic upload of backups to cloud storage (S3, Dropbox) for added security.
• Set the maximum number of stored backups to avoid disk overflow.

Recommendations:

1. Always set up automatic backups.
2. Use the option to upload backups to S3-compatible storage (e.g., Amazon S3, DigitalOcean Spaces) or an FTP server. This ensures that your backups are stored separately from the main server.
3. Regularly check the integrity of backups by attempting to restore them on a test server.

External VPS backup strategies:

In addition to built-in Discourse backups, it is recommended to use system-level backups of the entire VPS. This can be:

• VPS snapshots: Many hosting providers offer a VPS snapshot feature. This is a quick way to save the entire server's state.
• Rsync or rclone: Use these utilities for incremental copying of the /var/discourse directory (which contains all Discourse data) to remote storage. For example, you can configure Restic on VPS for encrypted and deduplicated backups.

Example command for manual Discourse backup:

cd /var/discourse
./launcher enter app
rake backups:create

After creation, the backup will be available in the /var/discourse/shared/standalone/backups/default/ folder on your VPS.

Discourse update process

Discourse releases updates regularly, often several times a month, containing bug fixes, security enhancements, and new features. Timely updates are crucial.

Update process via web interface:

The easiest way to update Discourse is through the admin panel: /admin/upgrade. If updates are available, you will see a corresponding notification. Click the "Upgrade" button and follow the instructions. Discourse will automatically update Docker images and rebuild the container.

Important: Discourse will be unavailable during the update. The process can take from 5 to 20 minutes depending on the size of your forum and VPS speed.

Update via command line (for more complex cases or automation):

1. Navigate to the Discourse directory:

   cd /var/discourse

2. Update the Docker configuration repository:

   git pull

3. Rebuild the container:

   ./launcher rebuild app

   This command will download the latest versions of Discourse Docker images, recreate the container with the new version, and restart it. The entire process will be logged to the console.

It is recommended to create a backup before each major update.

Monitoring VPS performance and resources

Monitoring your VPS resources helps to timely identify performance issues, bottlenecks, and potential threats.

• CPU and RAM usage:

  htop

  This utility provides an interactive overview of CPU, RAM usage, and running processes.

• Disk usage:

  df -h

  Shows disk space usage. It is important to ensure that the disk does not fill up, especially due to backups.

• Docker logs:

  docker logs -f app

  Viewing Discourse container (app) logs can help in debugging issues.

• Built-in Discourse monitoring:

  Discourse has an /admin/dashboard section that shows general statistics, as well as /admin/logs for viewing system logs and errors.

• External monitoring systems: For deeper analysis, consider using Grafana/Prometheus, Zabbix, or cloud monitoring services that provide more detailed metrics and alerts.

Regular monitoring will allow you to promptly respond to any anomalies and ensure the uninterrupted operation of your community.

Choosing a VPS configuration for Discourse under real load

The correct choice of VPS configuration is critically important for the long-term successful operation of your Discourse community. Insufficient resources will lead to slow performance, failures, and a poor user experience, while excessive resources will lead to overpayment.

Assessing needs: number of users, activity, plugins

When choosing a VPS, several key factors influencing resource consumption must be considered:

1. Number of active users: This is the primary factor. An "active user" is not just a registered account, but one who regularly views, posts messages, likes, and interacts with the platform.
   • Up to 50 active users: Small personal blogs, startups, internal teams.
   • 50-200 active users: Medium communities, small companies, educational projects.
   • 200-500 active users: Large communities, active forums, growing projects.
   • 500+ active users: Very large communities requiring scalable solutions.
2. Community activity: The number of topics created, messages, uploaded files, as well as the frequency of peak loads (e.g., during webinars or promotions). High activity requires more CPU and RAM.
3. Number and type of plugins: Each installed plugin adds load to the system. Some plugins can be quite resource-intensive (e.g., integrations with external services, complex customizations).
4. Database size and uploaded files: Over time, the database and the folder with uploaded files (images, attachments) will grow, requiring more disk space. NVMe SSD is critically important for database performance.

General rule: It's better to start with a slightly more powerful VPS than the minimum to have a performance reserve and avoid problems at the start. You can always downgrade the plan if resources prove to be excessive.

Comparison table of Valebyte.com VPS plans for Discourse

The tariffs presented below are indicative and may vary. They are designed to help you choose the right VPS configuration for your Discourse community on Valebyte.com.

Valebyte.com Plan	vCPU	RAM (GB)	NVMe SSD (GB)	Approximate load (active users)	Estimated cost ($/month)
Micro Discourse	2	2	50	Up to 50	From 10-15
Basic Discourse	2-4	4	80	50-200	From 20-30
Standard Discourse	4	8	160	200-500	From 40-60
Pro Discourse	6-8	16	320+	500+ (with scalability option)	From 80-120+

Note: The prices indicated are approximate and depend on current promotions, server region, and additional services (e.g., managed backups, additional IP addresses). All plans assume the use of NVMe SSD for maximum performance.

Performance optimization and scaling

Even with a correctly chosen VPS, there are optimization methods to improve performance and prepare for scaling:

1. Configure the number of Unicorn/Puma workers: In the app.yml file, the UNICORN_WORKERS (or PUMA_WORKERS if you are using Puma) parameter should be configured according to the number of your CPU cores. Usually 1-2 workers per core.
2. Caching: Discourse actively uses caching. Make sure Redis is working efficiently. An external reverse proxy can also cache static resources.
3. CDN (Content Delivery Network): For communities with a large number of images and other media files, using a CDN will significantly speed up content loading for users worldwide and reduce the load on the VPS.
4. Database optimization: Regular cleanup of old post versions, removal of inactive users, and query optimization can improve PostgreSQL performance.
5. Monitoring and profiling: Use monitoring tools to identify bottlenecks. If CPU or RAM is constantly at its limit, it's a signal to upgrade the VPS.
6. Horizontal scaling: For very large communities, horizontal scaling can be considered, separating the database, Redis, and web server onto separate VPSs or using more advanced architectures with load balancers. However, this significantly complicates management.

Remember that Discourse is a living platform, and its needs may change over time. Regular monitoring and flexibility in changing the VPS configuration will help ensure the stable and fast operation of your community.

Conclusion

Deploying Discourse on your own VPS provides full control over your online community, ensuring flexibility, security, and scalability. Choosing the right VPS configuration, careful installation via Docker, and regular maintenance are key to the stable and efficient operation of the platform.