Deploying Microweber

Introduction

Microweber is an open-source drag-and-drop website builder and CMS that enables users to create beautiful websites and online stores without writing code. Built with PHP and Laravel, Microweber provides an intuitive visual editor that allows real-time editing directly on your pages.

The platform combines the flexibility of a traditional CMS with the simplicity of modern website builders. Whether you’re creating a blog, portfolio, business website, or full e-commerce store, Microweber offers the tools and templates to bring your vision to life.

Key highlights of Microweber:

Drag-and-Drop Editor: Visual page builder with real-time preview
E-Commerce Built-In: Full shopping cart, payments, and inventory management
Template System: Professional templates with easy customization
Blog Platform: Complete blogging with categories, tags, and comments
SEO Tools: Built-in SEO optimization features
Multi-Language: Support for multiple languages and localization
Module System: Extend functionality with modules and plugins
Responsive Design: Mobile-friendly websites out of the box
White-Label Ready: Rebrand for agencies and resellers
100% Open Source: Self-host with complete code access

This guide walks through deploying Microweber on Klutch.sh using Docker, configuring persistent storage, and setting up your website builder.

Why Deploy Microweber on Klutch.sh

Deploying Microweber on Klutch.sh provides several advantages for self-hosted website building:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Microweber without complex orchestration. Push to GitHub, and your website builder deploys automatically.

Persistent Storage: Attach persistent volumes for your database, uploads, and website content. Your sites survive container restarts and redeployments.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure website access and e-commerce transactions.

GitHub Integration: Connect your configuration repository directly from GitHub. Updates trigger automatic redeployments.

Scalable Resources: Allocate CPU and memory based on your traffic and content needs.

Custom Domains: Assign custom domains for professional websites.

Always-On Availability: Your websites remain accessible 24/7 without managing your own hardware.

Prerequisites

Before deploying Microweber on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your configuration
Basic familiarity with Docker and containerization concepts
A MySQL/MariaDB database (can be deployed on Klutch.sh)
(Optional) Custom domains for your websites

Preparing Your Repository

To deploy Microweber on Klutch.sh, create a GitHub repository containing your Dockerfile and configuration.

Repository Structure

microweber-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM php:8.1-apache

# Install system dependencies
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    zip \
    unzip \
    libfreetype6-dev \
    libjpeg62-turbo-dev \
    && docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd zip \
    && rm -rf /var/lib/apt/lists/*

# Enable Apache mod_rewrite
RUN a2enmod rewrite

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

# Set working directory
WORKDIR /var/www/html

# Download Microweber
RUN curl -L https://github.com/microweber/microweber/archive/master.tar.gz | tar xz --strip-components=1

# Install PHP dependencies
RUN composer install --no-dev --optimize-autoloader

# Set permissions
RUN chown -R www-data:www-data /var/www/html \
    && chmod -R 755 /var/www/html/storage \
    && chmod -R 755 /var/www/html/userfiles

# Configure Apache
RUN sed -i 's!/var/www/html!/var/www/html/public!g' /etc/apache2/sites-available/000-default.conf

# PHP configuration
RUN echo "upload_max_filesize = 100M" >> /usr/local/etc/php/conf.d/uploads.ini \
    && echo "post_max_size = 100M" >> /usr/local/etc/php/conf.d/uploads.ini \
    && echo "memory_limit = 256M" >> /usr/local/etc/php/conf.d/uploads.ini

# Expose port
EXPOSE 80

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
  CMD curl -f http://localhost/ || exit 1

Environment Variables Reference

Variable	Required	Default	Description
`APP_KEY`	Yes	-	Laravel application key
`APP_URL`	Yes	-	Public URL of your installation
`DB_CONNECTION`	Yes	mysql	Database driver
`DB_HOST`	Yes	-	Database hostname
`DB_PORT`	No	3306	Database port
`DB_DATABASE`	Yes	-	Database name
`DB_USERNAME`	Yes	-	Database username
`DB_PASSWORD`	Yes	-	Database password
`MW_APP_KEY`	No	-	Microweber specific encryption key

Deploying on Klutch.sh

Set Up a Database

Deploy a MySQL or MariaDB database on Klutch.sh or use an external provider. Note the connection details.

Generate an Application Key

Generate a Laravel application key:

php -r "echo 'base64:'.base64_encode(random_bytes(32)).PHP_EOL;"

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Microweber deployment configuration"
git remote add origin https://github.com/yourusername/microweber-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “microweber” or “website-builder”.

Create a New App

Within your project, create a new app. Connect your GitHub account if you haven’t already, then select the repository containing your Microweber Dockerfile.

Configure HTTP Traffic

Microweber serves its web interface over HTTP. In the deployment settings:

Select HTTP as the traffic type
Set the internal port to 80

Set Environment Variables

Add the following environment variables:

Variable	Value
`APP_KEY`	Your generated application key
`APP_URL`	`https://your-app.klutch.sh`
`DB_CONNECTION`	`mysql`
`DB_HOST`	Your database host
`DB_DATABASE`	Your database name
`DB_USERNAME`	Your database user
`DB_PASSWORD`	Your database password

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
`/var/www/html/storage`	10 GB	Application storage and cache
`/var/www/html/userfiles`	50 GB	User uploads and media

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will:

Detect your Dockerfile automatically
Build the container image
Attach the persistent volumes
Start the Microweber container
Provision an HTTPS certificate

Access Microweber

Once deployment completes, access your Microweber instance at https://example-app.klutch.sh and complete the installation wizard.

Initial Setup

Installation Wizard

On first access, complete the setup:

Select your language
Enter database connection details
Create your admin account
Choose a website template
Complete installation

Admin Dashboard

Access the admin panel at /admin:

Log in with your admin credentials
Explore the dashboard
Configure site settings
Start building your website

Building Your Website

Using the Visual Editor

Create pages with the drag-and-drop editor:

Navigate to your page
Click Edit to enter edit mode
Drag modules from the sidebar
Drop onto the page
Click elements to customize
Save your changes

Available Modules

Microweber includes many built-in modules:

Text: Rich text content blocks
Image: Single images with effects
Gallery: Image galleries and sliders
Video: Embed videos from any source
Contact Form: Customizable forms
Posts: Blog post listings
Shop: E-commerce product displays
Social: Social media integrations

Templates and Themes

Customize your site’s appearance:

Go to Admin > Templates
Browse available templates
Install and activate your choice
Customize colors and layouts

E-Commerce Features

Setting Up Your Store

Configure online selling:

Go to Admin > Online Shop
Configure payment methods
Set up shipping options
Configure tax settings

Adding Products

Create products for sale:

Navigate to Admin > Shop > Products
Click Add Product
Enter product details
Upload images
Set pricing and inventory
Publish

Payment Integration

Accept payments with:

PayPal
Stripe
Bank transfer
Cash on delivery
Custom payment modules

Content Management

Blog Posts

Create blog content:

Go to Admin > Content > Posts
Click Add Post
Write your content
Add categories and tags
Publish or schedule

Organize your content:

Create categories for posts and products
Build navigation menus
Set up breadcrumbs
Configure URL structure

SEO Optimization

Built-in SEO Tools

Optimize for search engines:

Meta titles and descriptions
Open Graph tags
XML sitemaps
URL customization
Image alt texts

Per-Page SEO

Configure SEO for each page:

Edit the page
Click SEO Settings
Enter meta title and description
Preview search appearance

Troubleshooting

Installation Issues

Verify database credentials
Check PHP extensions are installed
Ensure proper file permissions
Review PHP error logs

Editor Not Loading

Clear browser cache
Check JavaScript console for errors
Verify all assets are loading
Test in incognito mode

File Upload Errors

Check PHP upload limits
Verify file permissions on userfiles
Ensure sufficient disk space
Review allowed file types

Additional Resources

Conclusion

Deploying Microweber on Klutch.sh gives you a powerful, self-hosted website builder with complete control over your web presence. The drag-and-drop editor makes it easy to create professional websites without coding, while the built-in e-commerce features enable online selling.

The combination of Microweber’s user-friendly interface and Klutch.sh’s reliable infrastructure provides everything needed to build and host websites for yourself, clients, or your organization. Whether you’re creating a simple portfolio or a full-featured online store, Microweber on Klutch.sh delivers a complete website building solution.