Deploying Limbas

Introduction

Limbas is an open-source low-code platform for creating database-driven business applications. With Limbas, organizations can build custom ERP systems, CRM solutions, document management systems, and other business applications through a visual interface without extensive programming knowledge.

Built with PHP and supporting multiple database backends, Limbas provides a comprehensive framework for defining data structures, forms, workflows, and reports. The platform has been developed since 2000 and is used by organizations worldwide for building custom business solutions.

Key highlights of Limbas:

Visual Database Design: Create tables and relationships through a GUI
Form Builder: Design data entry forms without coding
Report Generator: Build custom reports and exports
Workflow Engine: Automate business processes
User Management: Role-based access control
Document Management: Store and manage files
API Access: REST API for integrations
Multi-Language: Interface in multiple languages
Multi-Tenant: Support for multiple organizations
Extensible: PHP-based customization options

This guide walks through deploying Limbas on Klutch.sh using Docker.

Why Deploy Limbas on Klutch.sh

Deploying Limbas on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically builds Limbas from your Dockerfile. Push to GitHub, and your platform deploys.

Persistent Storage: Attach persistent volumes for your database and documents.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure access.

GitHub Integration: Connect your repository for automatic redeployments.

Scalable Resources: Allocate resources based on your application complexity.

Environment Variable Management: Configure database connections securely.

Custom Domains: Assign a professional domain for your business application.

Always-On Availability: Your business applications remain accessible 24/7.

Prerequisites

Before deploying Limbas 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 PostgreSQL or MySQL database
(Optional) A custom domain

Understanding Limbas Architecture

Limbas uses a traditional web application architecture:

PHP Application: Core application handling UI and business logic.

Database Layer: PostgreSQL or MySQL for data storage.

File Storage: Directory for documents and uploads.

Session Management: PHP sessions for user authentication.

Preparing Your Repository

Repository Structure

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

Creating the Dockerfile

FROM php:8.1-apache

# Install required extensions
RUN apt-get update && apt-get install -y \
    libpng-dev \
    libjpeg-dev \
    libfreetype6-dev \
    libpq-dev \
    libzip-dev \
    unzip \
    curl \
    && docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install gd pdo pdo_pgsql pdo_mysql zip \
    && rm -rf /var/lib/apt/lists/*

# Enable Apache modules
RUN a2enmod rewrite

# Download Limbas
WORKDIR /var/www/html
RUN curl -L https://github.com/limbas/limbas/archive/refs/heads/master.tar.gz | tar -xz --strip-components=1 || \
    echo "Manual download required"

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

# Environment configuration
ENV DB_HOST=${DB_HOST:-localhost}
ENV DB_NAME=${DB_NAME:-limbas}
ENV DB_USER=${DB_USER:-limbas}
ENV DB_PASSWORD=${DB_PASSWORD}

# Expose port
EXPOSE 80

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

CMD ["apache2-foreground"]

Creating the .dockerignore File

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env
.env.local

Environment Variables Reference

Variable	Required	Default	Description
`DB_HOST`	Yes	localhost	Database hostname
`DB_NAME`	No	limbas	Database name
`DB_USER`	Yes	-	Database username
`DB_PASSWORD`	Yes	-	Database password

Deploying Limbas on Klutch.sh

Set Up Database

Deploy PostgreSQL or MySQL and create a database for Limbas.

Push Your Repository to GitHub

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Limbas deployment configuration"
git remote add origin https://github.com/yourusername/limbas-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 named “limbas” or “business-app”.

Create a New App

Within your project, create a new app. Connect your GitHub account and select your Limbas repository.

Configure HTTP Traffic

In the deployment settings:

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

Set Environment Variables

Add the following:

Variable	Value
`DB_HOST`	Your database hostname
`DB_NAME`	`limbas`
`DB_USER`	Your database username
`DB_PASSWORD`	Your database password

Attach Persistent Volumes

Mount Path	Recommended Size	Purpose
`/var/www/html/UPLOAD`	50+ GB	Document storage
`/var/www/html/TEMP`	5 GB	Temporary files

Deploy Your Application

Click Deploy to start the build process.

Complete Installation

Access the Limbas installer and configure your instance.

Initial Configuration

Database Setup

Initialize the database:

Run the installation wizard
Configure database connection
Import initial schema
Create admin account

Creating Your Application

Build your business application:

Define tables and fields
Create relationships
Design forms
Set up workflows

User Management

Configure access:

Create user accounts
Define roles and permissions
Assign users to groups

Production Best Practices

Security Recommendations

Use strong passwords
Enable HTTPS
Configure proper permissions
Regular backups

Performance Tips

Optimize database queries
Configure PHP caching
Monitor resource usage

Backup Strategy

Back up database regularly
Back up uploaded documents
Export application definitions

Troubleshooting

Installation Errors

Check database connectivity
Verify PHP extensions
Review error logs

Performance Issues

Optimize database indexes
Increase PHP memory
Check disk space

Additional Resources

Conclusion

Deploying Limbas on Klutch.sh gives you a powerful low-code platform for building custom business applications. Whether you need a CRM, ERP, or document management system, Limbas provides the tools to create tailored solutions without extensive programming.

With automatic builds and persistent storage, you can focus on building your applications rather than managing infrastructure.