Skip to content
Klutch.sh Docs

Deploying a Flarum Forum

Introduction

Flarum is a modern, elegant, and fast forum software that makes online discussion fun again. Built with PHP and a powerful API, Flarum is designed from the ground up to be fast, simple, and beautiful. It’s the next generation of forum software that combines the simplicity of forum platforms with the engagement features of modern social media.

Flarum is renowned for:

  • Blazingly Fast: Lightweight and optimized for speed, providing near-instant page loads
  • Beautiful Design: Clean, responsive interface that looks great on all devices
  • Extensible: Rich extension ecosystem to customize and add features
  • Two-Pane Layout: Innovative discussion layout with fluid navigation
  • Mobile-First: Fully responsive design built for mobile devices
  • Real-Time: Live updates for new posts and discussions
  • SEO Optimized: Search engine friendly URLs and metadata
  • Modern Stack: Built with PHP 8+, Laravel components, and Mithril.js

Common use cases include community forums, support forums, project discussions, gaming communities, educational platforms, and customer engagement hubs.

This comprehensive guide walks you through deploying Flarum on Klutch.sh using Docker, including detailed installation steps, MySQL database configuration, persistent storage setup, and production-ready best practices for hosting a thriving online community.

Prerequisites

Before you begin, ensure you have the following:

Installation and Setup

Step 1: Create Your Project Directory

First, create a new directory for your Flarum deployment project:

Terminal window
mkdir flarum-klutch
cd flarum-klutch
git init

Step 2: Create the Dockerfile

Create a Dockerfile in your project root directory. This will define your Flarum container configuration with all necessary dependencies:

FROM php:8.2-apache


# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    zip \
    unzip \
    mariadb-client \
    && rm -rf /var/lib/apt/lists/*


# Install PHP extensions required by Flarum
RUN docker-php-ext-install \
    pdo_mysql \
    mysqli \
    mbstring \
    exif \
    pcntl \
    bcmath \
    gd \
    zip


# Enable Apache modules
RUN a2enmod rewrite headers


# Install Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer


# Set working directory
WORKDIR /var/www/html


# Download and install Flarum
# Note: Using --stability=beta to get the latest Flarum version
# For production, consider pinning to a specific stable version once released
RUN composer create-project flarum/flarum . --stability=beta && \
    chown -R www-data:www-data /var/www/html && \
    chmod -R 755 /var/www/html/storage


# Configure Apache DocumentRoot
ENV APACHE_DOCUMENT_ROOT=/var/www/html/public
RUN sed -ri -e 's!/var/www/html!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/sites-available/*.conf
RUN sed -ri -e 's!/var/www/!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/apache2.conf /etc/apache2/conf-available/*.conf


# Create custom Apache configuration for Flarum
RUN echo '<Directory /var/www/html/public>\n\
    Options Indexes FollowSymLinks\n\
    AllowOverride All\n\
    Require all granted\n\
</Directory>' > /etc/apache2/conf-available/flarum.conf && \
    a2enconf flarum


# Expose HTTP port
EXPOSE 80


# Start Apache in foreground
CMD ["apache2-foreground"]

Note: This Dockerfile uses PHP 8.2 with Apache, which is the recommended setup for Flarum. The configuration includes all required PHP extensions and properly configures Apache for Flarum’s URL structure. We use the beta stability flag as Flarum is currently in beta, but for production deployments, you should monitor for stable releases and pin to specific versions.

Step 3: Create Environment Configuration File

Create a .env.example file that documents the required environment variables:

Terminal window
# Database Configuration
DB_HOST=your-mysql-app.klutch.sh
DB_PORT=8000
DB_DATABASE=flarum
DB_USERNAME=flarum_user
DB_PASSWORD=secure_password_here
DB_PREFIX=flarum_


# Application Settings
FLARUM_URL=https://forum.example.com
FLARUM_DEBUG=false


# Admin User (for initial setup)
FLARUM_ADMIN_USERNAME=admin
FLARUM_ADMIN_PASSWORD=secure_admin_password
FLARUM_ADMIN_EMAIL=admin@example.com

Important: Never commit actual credentials to your repository. This file is for documentation only. Set actual values as environment variables in the Klutch.sh dashboard.

Step 4: Create Installation Script

Create a file named install-flarum.sh to handle the initial Flarum installation:

#!/bin/bash
set -e


echo "Waiting for MySQL to be ready..."
until mysql -h"$DB_HOST" -P"$DB_PORT" -u"$DB_USERNAME" -p"$DB_PASSWORD" -e "SELECT 1" >/dev/null 2>&1; do
    echo "MySQL is unavailable - sleeping"
    sleep 3
done


echo "MySQL is ready!"


# Check if Flarum is already installed
if [ ! -f "/var/www/html/config.php" ]; then
    echo "Installing Flarum..."


    # Run Flarum installation
    php flarum install \
        --defaults \
        --config-file=/dev/stdin <<EOF
{
    "debug": ${FLARUM_DEBUG:-false},
    "baseUrl": "${FLARUM_URL}",
    "databaseConfiguration": {
        "driver": "mysql",
        "host": "${DB_HOST}",
        "port": ${DB_PORT},
        "database": "${DB_DATABASE}",
        "username": "${DB_USERNAME}",
        "password": "${DB_PASSWORD}",
        "prefix": "${DB_PREFIX}"
    },
    "adminUser": {
        "username": "${FLARUM_ADMIN_USERNAME}",
        "password": "${FLARUM_ADMIN_PASSWORD}",
        "email": "${FLARUM_ADMIN_EMAIL}"
    },
    "settings": {
        "forum_title": "My Flarum Forum"
    }
}
EOF


    echo "Flarum installation complete!"
else
    echo "Flarum is already installed. Running migrations..."
    php flarum migrate
    php flarum cache:clear
fi


# Set proper permissions
chown -R www-data:www-data /var/www/html
chmod -R 755 /var/www/html/storage


echo "Starting Apache..."
exec apache2-foreground

Make the script executable:

Terminal window
chmod +x install-flarum.sh

Step 5: Update Dockerfile to Use Installation Script

Update your Dockerfile to include and use the installation script:

FROM php:8.2-apache


# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    zip \
    unzip \
    mariadb-client \
    && rm -rf /var/lib/apt/lists/*


# Install PHP extensions required by Flarum
RUN docker-php-ext-install \
    pdo_mysql \
    mysqli \
    mbstring \
    exif \
    pcntl \
    bcmath \
    gd \
    zip


# Enable Apache modules
RUN a2enmod rewrite headers


# Install Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer


# Set working directory
WORKDIR /var/www/html


# Download and install Flarum
# Note: Using --stability=beta to get the latest Flarum version
# For production, consider pinning to a specific stable version once released
RUN composer create-project flarum/flarum . --stability=beta && \
    chown -R www-data:www-data /var/www/html && \
    chmod -R 755 /var/www/html/storage


# Configure Apache DocumentRoot
ENV APACHE_DOCUMENT_ROOT=/var/www/html/public
RUN sed -ri -e 's!/var/www/html!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/sites-available/*.conf
RUN sed -ri -e 's!/var/www/!${APACHE_DOCUMENT_ROOT}!g' /etc/apache2/apache2.conf /etc/apache2/conf-available/*.conf


# Create custom Apache configuration for Flarum
RUN echo '<Directory /var/www/html/public>\n\
    Options Indexes FollowSymLinks\n\
    AllowOverride All\n\
    Require all granted\n\
</Directory>' > /etc/apache2/conf-available/flarum.conf && \
    a2enconf flarum


# Copy installation script
COPY install-flarum.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/install-flarum.sh


# Expose HTTP port
EXPOSE 80


# Use installation script as entrypoint
ENTRYPOINT ["/usr/local/bin/install-flarum.sh"]

Step 6: Create .gitignore File

Create a .gitignore file to exclude sensitive and generated files:

# Environment files
.env
.env.local


# Composer
vendor/
composer.lock


# Flarum
public/assets/*
storage/cache/*
storage/formatter-cache/*
storage/logs/*
storage/sessions/*
storage/tmp/*
storage/views/*


# Docker
.docker/


# OS
.DS_Store
Thumbs.db

Step 7: Test Locally (Optional)

Before deploying to Klutch.sh, you can test your Flarum setup locally using Docker:

Terminal window
# Build the Docker image
docker build -t my-flarum .


# Run a local MySQL container for testing
docker run -d \
  --name mysql-test \
  -e MYSQL_ROOT_PASSWORD=rootpass \
  -e MYSQL_DATABASE=flarum \
  -e MYSQL_USER=flarum_user \
  -e MYSQL_PASSWORD=testpass \
  -p 3306:3306 \
  mysql:8.0


# Wait for MySQL to initialize (about 30 seconds)
sleep 30


# Run the Flarum container
docker run -d \
  --name flarum-test \
  --link mysql-test:mysql \
  -p 8080:80 \
  -e DB_HOST=mysql-test \
  -e DB_PORT=3306 \
  -e DB_DATABASE=flarum \
  -e DB_USERNAME=flarum_user \
  -e DB_PASSWORD=testpass \
  -e DB_PREFIX=flarum_ \
  -e FLARUM_URL=http://localhost:8080 \
  -e FLARUM_DEBUG=true \
  -e FLARUM_ADMIN_USERNAME=admin \
  -e FLARUM_ADMIN_PASSWORD=adminpass123 \
  -e FLARUM_ADMIN_EMAIL=admin@localhost \
  my-flarum


# Check logs
docker logs -f flarum-test


# Once running, open http://localhost:8080 in your browser


# Cleanup when done testing
docker stop flarum-test mysql-test
docker rm flarum-test mysql-test

Step 8: Push to GitHub

Commit your files to your GitHub repository:

Terminal window
git add Dockerfile install-flarum.sh .env.example .gitignore
git commit -m "Add Flarum Dockerfile and installation script"
git remote add origin https://github.com/yourusername/flarum-klutch.git
git push -u origin main

Setting Up MySQL Database

Flarum requires a MySQL database to store forum data, users, posts, and configurations. You’ll need to deploy a MySQL database on Klutch.sh before deploying Flarum.

Database Deployment Steps

    1. Deploy MySQL on Klutch.sh

      Follow the comprehensive MySQL deployment guide to deploy a MySQL database on Klutch.sh.

    2. Create Flarum Database

      After your MySQL deployment is running, connect to it and create a dedicated database for Flarum:

      Terminal window
      mysql -h your-mysql-app.klutch.sh -P 8000 -u root -p

      Then run these SQL commands:

      CREATE DATABASE flarum CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
      CREATE USER 'flarum_user'@'%' IDENTIFIED BY 'your_secure_password';
      GRANT ALL PRIVILEGES ON flarum.* TO 'flarum_user'@'%';
      FLUSH PRIVILEGES;
      EXIT;

    3. Note Your Database Connection Details

      Save these details for use in your Flarum environment variables:

      • Database Host: your-mysql-app.klutch.sh
      • Database Port: 8000
      • Database Name: flarum
      • Database Username: flarum_user
      • Database Password: your_secure_password

Deploying to Klutch.sh

Now that your Flarum project is ready and your MySQL database is deployed, follow these steps to deploy Flarum on Klutch.sh.

Deployment Steps

    1. Log in to Klutch.sh

      Navigate to klutch.sh/app and sign in to your account.

    2. Create a New Project

      Go to Create Project and give your project a meaningful name (e.g., “Flarum Community Forum”).

    3. Create a New App

      Navigate to Create App and configure the following settings:

    4. Select Your Repository

      • Choose GitHub as your Git source
      • Select the repository containing your Dockerfile and installation script
      • Choose the branch you want to deploy (usually main or master)

    5. Configure Traffic Type

      • Traffic Type: Select HTTP (Flarum is a web application)
      • Internal Port: Set to 80 (the port Apache listens on inside the container)

    6. Set Environment Variables

      Add the following environment variables for your Flarum configuration:

      Database Configuration:

      • DB_HOST: Your MySQL app URL (e.g., your-mysql-app.klutch.sh)
      • DB_PORT: 8000 (Klutch.sh’s TCP routing port)
      • DB_DATABASE: flarum
      • DB_USERNAME: flarum_user
      • DB_PASSWORD: Your secure database password
      • DB_PREFIX: flarum_ (table prefix for organization)

      Flarum Application Settings:

      • FLARUM_URL: Your forum’s public URL (e.g., https://forum.example.com or use the Klutch.sh provided URL)
      • FLARUM_DEBUG: false (set to true only for troubleshooting)

      Admin User (for initial setup):

      • FLARUM_ADMIN_USERNAME: admin (or your preferred admin username)
      • FLARUM_ADMIN_PASSWORD: A strong, unique password for the admin account
      • FLARUM_ADMIN_EMAIL: Your admin email address

      Security Note: Always use strong, unique passwords. Never commit passwords to your repository.

    7. Attach Persistent Volumes

      Flarum stores uploaded assets, avatars, and cached data that need to persist across deployments:

      Volume 1 - Assets & Storage:

      • Mount Path: /var/www/html/public/assets
      • Size: 5GB (adjust based on expected media uploads)

      Volume 2 - Storage Directory:

      • Mount Path: /var/www/html/storage
      • Size: 2GB (for logs, cache, and sessions)

      Important: These volumes ensure your forum’s uploaded content and cached data persist across container restarts and redeployments.

    8. Configure Additional Settings

      • Region: Select the region closest to your target audience for optimal latency
      • Compute Resources: Choose CPU and memory based on expected traffic:
        • Small forum (< 1000 users): 512MB RAM, 0.5 CPU
        • Medium forum (1000-10000 users): 1GB RAM, 1 CPU
        • Large forum (> 10000 users): 2GB+ RAM, 2+ CPUs
      • Instances: Start with 1 instance and scale horizontally as needed

    9. Deploy Your Forum

      Click “Create” to start the deployment. Klutch.sh will:

      • Automatically detect your Dockerfile in the repository root
      • Build the Docker image with all Flarum dependencies
      • Attach the persistent volumes
      • Start your Flarum container
      • Run the installation script to set up Flarum
      • Connect to your MySQL database and create the schema
      • Create your admin user
      • Assign a URL for public access

    10. Access Your Forum

      Once deployment is complete, you’ll receive a URL like example-app.klutch.sh. Visit this URL in your browser to see your Flarum forum!

      You can immediately log in using your admin credentials to start customizing your forum.

Post-Deployment Configuration

After your Flarum forum is deployed, there are several important configuration steps to optimize your forum.

Initial Setup

  1. Log in as Admin

    Visit your forum URL and log in with your admin credentials.

  2. Configure Forum Settings

    • Navigate to the admin dashboard (click your username → Administration)
    • Under Basics, configure:
      • Forum title and description
      • Welcome banner
      • Default homepage
      • Forum language

  3. Set Up Email

    Configure email settings for notifications and user verification:

    • Go to Administration → Email
    • Choose your email driver (SMTP recommended)
    • Enter your SMTP credentials

    Or set these as environment variables and redeploy:

    Terminal window
    MAIL_DRIVER=smtp
    MAIL_HOST=smtp.mailgun.org
    MAIL_PORT=587
    MAIL_USERNAME=your-username
    MAIL_PASSWORD=your-password
    MAIL_ENCRYPTION=tls
    MAIL_FROM_ADDRESS=noreply@yourdomain.com
    MAIL_FROM_NAME=Your Forum Name

  4. Install Extensions

    Enhance your forum with extensions:

    • Go to Administration → Extensions
    • Click Browse Extension to explore available extensions
    • Popular extensions include:
      • Tags: Organize discussions with tags
      • Mentions: @mention users in discussions
      • Likes: Allow users to like posts
      • Markdown: Enable markdown formatting
      • Emoji: Add emoji picker support
      • BBCode: Support for BBCode formatting

  5. Configure Permissions

    Set up user groups and permissions:

    • Go to Administration → Permissions
    • Configure what different user groups can do
    • Create custom user groups if needed

  6. Customize Appearance

    Make your forum visually unique:

    • Go to Administration → Appearance
    • Upload a custom logo and favicon
    • Choose or customize colors
    • Edit CSS for advanced customization
    • Set a custom header

Setting Up a Custom Domain

    1. Add Custom Domain in Klutch.sh

      • In your Klutch.sh app settings, go to the Domains section
      • Add your custom domain (e.g., forum.example.com)
      • Follow the instructions to add DNS records

    2. Update DNS Records

      Point your domain to Klutch.sh:

      • Add an A record or CNAME as instructed by Klutch.sh
      • Wait for DNS propagation (can take up to 48 hours, usually much faster)

    3. Update Flarum URL

      After your custom domain is active:

      • Update the FLARUM_URL environment variable in Klutch.sh to your new domain
      • Redeploy your application
      • Or manually update in the admin panel under Basics

    4. Enable HTTPS

      Klutch.sh automatically provides SSL/TLS certificates for custom domains. Ensure your FLARUM_URL uses https://.

Extensions and Customization

Flarum’s power comes from its extension ecosystem. Here are some recommended extensions for different use cases:

Essential Extensions

  • flarum/tags: Organize discussions with categories and tags
  • flarum/mentions: @mention users and posts
  • flarum/likes: Like posts and see who liked what
  • flarum/markdown: Full markdown support
  • flarum/bbcode: BBCode formatting support
  • flarum/emoji: Emoji picker and emoji in posts

Community Extensions

Install community extensions via Composer by updating your Dockerfile:

# After the initial Flarum installation, add:
RUN composer require fof/upload && \
    composer require fof/polls && \
    composer require fof/best-answer && \
    php flarum cache:clear

Popular community extensions:

  • fof/upload: Upload images and files to posts
  • fof/polls: Create polls in discussions
  • fof/best-answer: Mark best answers in discussions
  • fof/gamification: Add gamification with points and ranks
  • fof/user-directory: Directory of all users
  • fof/pages: Create custom pages

Installing Extensions

Via Admin Panel (for extensions in the marketplace):

  1. Go to Administration → Extensions
  2. Click Browse Extensions
  3. Find the extension and click Install

Via Composer (for any extension):

  1. Update your Dockerfile to include composer require vendor/extension-name
  2. Rebuild and redeploy your application

Production Best Practices

Security Recommendations

  • Strong Passwords: Use complex, randomly generated passwords for admin and database users
  • Regular Updates: Keep Flarum, PHP, and all extensions up to date
  • Environment Variables: Store all credentials as environment variables, never in code
  • Disable Debug Mode: Always set FLARUM_DEBUG=false in production
  • HTTPS Only: Always use HTTPS for your forum
  • Rate Limiting: Enable rate limiting for registration and posting
  • Moderate Registration: Consider requiring email verification or admin approval for new users
  • Regular Backups: Implement automated backup strategy (see below)
  • Security Extensions: Consider installing security-focused extensions like:
    • reCAPTCHA for spam prevention
    • Two-factor authentication
    • IP banning capabilities

Performance Optimization

  • Enable Caching: Flarum uses file-based caching by default
  • Optimize Images: Use image optimization for uploaded avatars and attachments
  • Database Indexes: Ensure your MySQL database has proper indexes (Flarum creates these automatically)
  • CDN for Assets: Consider using a CDN for serving static assets
  • Proper Resource Allocation: Scale your Klutch.sh resources based on active users:
    • Monitor CPU and memory usage
    • Scale vertically (more resources per instance) for better caching
    • Scale horizontally (more instances) for higher traffic
  • Extension Management: Only install extensions you need, as each adds overhead

Backup Strategy

Implement a comprehensive backup strategy to protect your forum data:

Database Backups:

Terminal window
# Backup your Flarum database
mysqldump -h your-mysql-app.klutch.sh -P 8000 -u flarum_user -p flarum > flarum-backup-$(date +%Y%m%d).sql


# Restore from backup
mysql -h your-mysql-app.klutch.sh -P 8000 -u flarum_user -p flarum < flarum-backup-20241121.sql

Volume Backups:

Regularly back up your persistent volumes:

  • /var/www/html/public/assets - User uploads, avatars, attachments
  • /var/www/html/storage - Logs, cache, sessions

Consider:

  • Daily automated database backups
  • Weekly backups of assets and storage volumes
  • Multiple retention periods (daily for 7 days, weekly for 4 weeks, monthly for 12 months)
  • Offsite backup storage (S3, Google Cloud Storage, etc.)
  • Regular restore testing to ensure backups work

Monitoring

Monitor your Flarum forum for:

  • Application Performance: Response times, page load speeds
  • Resource Usage: CPU, memory, and disk usage via Klutch.sh dashboard
  • Database Performance: Query performance and connection count
  • User Activity: Active users, new registrations, posts per day
  • Error Logs: Check /var/www/html/storage/logs for errors
  • Uptime: Use external monitoring services to track uptime
  • Security: Monitor for unusual activity, failed login attempts

Troubleshooting

Cannot Access Forum After Deployment

Symptoms: Browser shows “Cannot connect” or 502 error

Solutions:

  • Check that the internal port is set to 80 in Klutch.sh
  • Verify that HTTP traffic type is selected
  • Check container logs for errors
  • Ensure the Dockerfile exposes port 80
  • Verify Apache is starting correctly

Database Connection Errors

Symptoms: Error messages about database connection failures

Solutions:

  • Verify MySQL is running and accessible
  • Check that DB_HOST points to your MySQL app (e.g., your-mysql-app.klutch.sh)
  • Confirm DB_PORT is set to 8000
  • Verify database credentials are correct
  • Test connection manually: mysql -h your-mysql-app.klutch.sh -P 8000 -u flarum_user -p
  • Ensure the database flarum exists and user has proper permissions
  • Check that MySQL is accepting remote connections

Installation Script Fails

Symptoms: Forum doesn’t complete installation, shows errors

Solutions:

  • Check container logs for detailed error messages
  • Verify all environment variables are set correctly
  • Ensure MySQL database exists and is accessible
  • Try running installation with FLARUM_DEBUG=true for more details
  • Check that install-flarum.sh has execute permissions
  • Verify Composer installed Flarum correctly during build

Assets Not Loading

Symptoms: Forum loads but images, CSS, or JavaScript don’t load properly

Solutions:

  • Verify persistent volumes are correctly mounted at /var/www/html/public/assets
  • Check file permissions: chown -R www-data:www-data /var/www/html/public/assets
  • Ensure Apache is configured to serve from /var/www/html/public
  • Clear Flarum cache: php flarum cache:clear
  • Check Apache configuration for correct DocumentRoot

Extensions Not Working

Symptoms: Installed extensions don’t appear or function

Solutions:

  • Ensure extensions were installed during build process
  • Run php flarum cache:clear after installing extensions
  • Enable extensions in the admin panel
  • Check compatibility with your Flarum version
  • Review extension logs in /var/www/html/storage/logs
  • Verify Composer successfully installed the extension

Performance Issues

Symptoms: Slow page loads, high response times

Solutions:

  • Monitor resource usage in Klutch.sh dashboard
  • Increase CPU and memory allocation if at limits
  • Check database performance and optimize queries
  • Review and disable unnecessary extensions
  • Enable Flarum’s built-in caching
  • Check for slow queries in MySQL: SHOW PROCESSLIST;
  • Consider implementing a CDN for static assets
  • Review /var/www/html/storage/logs for errors

Email Not Sending

Symptoms: Users don’t receive verification or notification emails

Solutions:

  • Verify SMTP credentials are correct
  • Check that SMTP server allows connections from Klutch.sh
  • Test email configuration in Flarum admin panel
  • Review logs for email-related errors
  • Ensure MAIL_FROM_ADDRESS is a valid email address
  • Check spam folders - initial emails often end up there
  • Consider using a dedicated email service (Mailgun, SendGrid, etc.)

Data Loss After Redeploy

Symptoms: User uploads or data disappear after redeployment

Solutions:

  • Verify persistent volumes are attached at correct paths
  • Ensure volumes have sufficient space allocated
  • Check volume mount points:
    • /var/www/html/public/assets
    • /var/www/html/storage
  • Verify volume wasn’t accidentally deleted or detached
  • Implement regular backups to prevent data loss

Advanced Configuration

Custom Themes

Install custom themes to give your forum a unique look:

  1. Via Composer (add to Dockerfile):

    RUN composer require acme/flarum-theme-example

  2. Enable in Admin Panel:

    • Go to Administration → Appearance
    • Select your theme from the dropdown

Multi-Language Support

Enable multiple languages for international communities:

  1. Install Language Packs:

    RUN composer require flarum-lang/spanish && \
        composer require flarum-lang/french && \
        composer require flarum-lang/german

  2. Enable in Admin:

    • Go to Administration → Extensions
    • Enable desired language packs

Search Indexing

For better search performance on large forums, consider implementing advanced search:

  1. Install a search extension like Elasticsearch integration
  2. Configure search indexing
  3. Adjust search settings in admin panel

Custom Domain with Multiple Subdomains

You can run multiple Flarum instances for different communities:

  • Main forum: forum.example.com
  • Regional forum: es.forum.example.com
  • Special interest: tech.forum.example.com

Deploy each as a separate Klutch.sh app with its own database.

Additional Resources

Conclusion

Deploying Flarum to Klutch.sh with Docker provides a modern, elegant forum platform with persistent storage and production-ready configuration. By following this guide, you’ve set up a Flarum forum that’s secure, performant, and ready to build a thriving online community. With Flarum’s beautiful interface and powerful features, you can create engaging discussions that keep users coming back.

Remember to keep your forum updated, monitor performance, implement regular backups, and engage with your community to build a successful online discussion platform. Happy forum building!