Deploying WackoWiki

Introduction

WackoWiki is a lightweight, multilingual wiki engine written in PHP. Known for its simplicity and powerful features, WackoWiki provides an intuitive markup language, hierarchical page organization, and flexible access controls, making it suitable for everything from personal notes to team documentation.

Key highlights of WackoWiki:

Intuitive Markup: Simple wiki syntax that’s easy to learn and use
Hierarchical Pages: Organize content in nested page structures
Access Control: Fine-grained permissions for pages and namespaces
Multi-Language: Built-in support for multiple languages
Revision History: Track all changes with full version history
File Uploads: Attach files and images to pages
Search: Full-text search across all wiki content
Comments: Discussion system for page feedback
Themes: Customizable appearance with theme support
Lightweight: Minimal server requirements

This guide walks through deploying WackoWiki on Klutch.sh using Docker, configuring the wiki engine, and setting up collaborative documentation.

Why Deploy WackoWiki on Klutch.sh

Deploying WackoWiki on Klutch.sh provides several advantages:

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

Persistent Storage: Attach persistent volumes for your wiki content and uploads. Your documentation survives container restarts.

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

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

Team Access: Share your wiki with team members for collaborative documentation.

Prerequisites

Before deploying WackoWiki 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 or MariaDB database

Preparing Your Repository

Create a GitHub repository containing your Dockerfile for WackoWiki deployment.

Repository Structure

wackwiki-deploy/
├── Dockerfile
├── php.ini
└── .dockerignore

Creating the Dockerfile

FROM php:8.1-apache

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

# Enable Apache modules
RUN a2enmod rewrite

# Set working directory
WORKDIR /var/www/html

# Download WackoWiki
RUN curl -L https://github.com/WackoWiki/wackowiki/archive/refs/heads/master.tar.gz | tar xz --strip-components=1 \
    && chown -R www-data:www-data /var/www/html

# Copy custom PHP configuration
COPY php.ini /usr/local/etc/php/conf.d/custom.ini

# Create upload directories
RUN mkdir -p /var/www/html/file/global \
    && mkdir -p /var/www/html/file/local \
    && chown -R www-data:www-data /var/www/html/file

# Set environment variables
ENV WACKO_DB_HOST=${WACKO_DB_HOST:-localhost}
ENV WACKO_DB_NAME=${WACKO_DB_NAME:-wackwiki}
ENV WACKO_DB_USER=${WACKO_DB_USER:-wackwiki}
ENV WACKO_DB_PASS=${WACKO_DB_PASS}

# Expose Apache port
EXPOSE 80

# Volume for persistent data
VOLUME ["/var/www/html/file", "/var/www/html/config"]

Creating PHP Configuration

Create a php.ini file:

upload_max_filesize = 32M
post_max_size = 32M
memory_limit = 256M
max_execution_time = 300

Environment Variables Reference

Variable	Required	Default	Description
`WACKO_DB_HOST`	Yes	`localhost`	MySQL/MariaDB host
`WACKO_DB_NAME`	Yes	`wackwiki`	Database name
`WACKO_DB_USER`	Yes	`wackwiki`	Database username
`WACKO_DB_PASS`	Yes	-	Database password

Deploying WackoWiki on Klutch.sh

Set Up MySQL Database

Deploy a MySQL or MariaDB instance on Klutch.sh or use an external database service. Create a database for WackoWiki.

Push Your Repository to GitHub

Initialize your repository and push to GitHub with your Dockerfile and configuration files.

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “wackwiki” or “team-wiki”.

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 WackoWiki Dockerfile.

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 environment variables:

Variable	Value
`WACKO_DB_HOST`	Your MySQL hostname
`WACKO_DB_NAME`	`wackwiki`
`WACKO_DB_USER`	Your database username
`WACKO_DB_PASS`	Your database password

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
`/var/www/html/file`	10 GB	Uploaded files and attachments
`/var/www/html/config`	1 GB	Configuration files

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will build the container, attach volumes, and provision an HTTPS certificate.

Complete Installation

Access your WackoWiki instance and complete the web-based installer:

Navigate to https://your-app-name.klutch.sh
Follow the installation wizard
Enter database connection details
Create your admin account
Complete the setup

Wiki Syntax Basics

Text Formatting

**bold text**
//italic text//
__underlined__
--strikethrough--
##monospace##

Headings

== Heading Level 1 ==
=== Heading Level 2 ===
==== Heading Level 3 ====

Links

[[PageName]]
[[PageName Description text]]
((https://example.com External link))

Lists

  * Unordered item
  * Another item

  1. Numbered item
  2. Second item

Page Organization

Hierarchical Structure

Create nested pages using slashes:

/Documentation
/Documentation/GettingStarted
/Documentation/GettingStarted/Installation

Namespaces

Organize content into namespaces:

/Projects/ - Project documentation
/Team/ - Team information
/Help/ - User guides

Access Control

Page Permissions

Set permissions per page:

Navigate to page settings
Configure read/write permissions
Assign to users or groups

User Groups

Create groups for role-based access:

Admins: Full access
Editors: Can edit pages
Viewers: Read-only access

Troubleshooting

Installation Issues

Verify database connectivity
Check file permissions on config directory
Review Apache error logs

Upload Errors

Verify upload directory permissions
Check PHP upload_max_filesize setting
Ensure sufficient disk space

Search Not Working

Verify database indexes are created
Check search configuration
Rebuild search index if needed

Additional Resources

Conclusion

Deploying WackoWiki on Klutch.sh gives you a lightweight, feature-rich wiki for team documentation. The combination of WackoWiki’s intuitive markup and Klutch.sh’s deployment simplicity means you can quickly set up collaborative documentation with flexible access controls and hierarchical organization.