Deploying Gibbon

Introduction

Gibbon is a flexible, open-source school management platform designed to make life better for teachers, students, parents, and administrators. Built to be adaptable to different educational contexts worldwide, Gibbon provides comprehensive tools for managing all aspects of school operations.

From attendance tracking and gradebook management to timetabling and behavior records, Gibbon offers a complete solution for educational institutions. The platform is designed with simplicity in mind while providing powerful features that scale from small schools to large educational networks.

Key highlights of Gibbon:

• Student Management: Complete student information system with enrollment, demographics, and history
• Attendance Tracking: Flexible attendance recording by class, day, or period
• Gradebook: Comprehensive grade management with multiple marking systems
• Timetabling: Schedule management for classes, teachers, and facilities
• Behavior Management: Record and track student behavior incidents
• Parental Access: Parent portal for viewing student progress
• Staff Management: Teacher and staff information management
• Reporting: Generate reports for students, classes, and school-wide metrics
• Modules: Extensible through additional modules for specific needs
• Multi-Language: Interface available in numerous languages
• Open Source: Licensed under GPL

This guide walks through deploying Gibbon on Klutch.sh using Docker, configuring the school management system, and setting up for your educational institution.

Why Deploy Gibbon on Klutch.sh

Deploying Gibbon on Klutch.sh provides several advantages for educational institutions:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Gibbon. Push to GitHub, and your school management platform deploys automatically.

Persistent Storage: Attach persistent volumes for your database and uploads. Student records and documents survive container restarts.

HTTPS by Default: Klutch.sh provides automatic SSL certificates, ensuring secure access to sensitive student information.

GitHub Integration: Connect your configuration repository directly from GitHub for automatic updates.

Scalable Resources: Allocate resources based on your school size and user count.

Custom Domains: Assign a custom domain for your institution’s portal.

Always-On Availability: Your school management system remains accessible 24/7 for staff, students, and parents.

Prerequisites

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

• A Klutch.sh account
• A GitHub account with a repository for your Gibbon configuration
• Basic familiarity with Docker and containerization concepts
• A MySQL/MariaDB database
• (Optional) A custom domain for your school portal

Understanding Gibbon Architecture

Gibbon uses a traditional PHP web application architecture:

PHP Backend: Core application logic written in PHP, handling all school management functions.

MySQL/MariaDB Database: Stores all school data including students, staff, grades, and configuration.

Apache/Nginx Web Server: Serves the application with mod_rewrite support.

Module System: Extensible architecture allowing additional functionality through modules.

Preparing Your Repository

To deploy Gibbon on Klutch.sh, create a GitHub repository containing your Dockerfile.

Repository Structure

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

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM php:8.1-apache

# Install required extensions and dependencies
RUN apt-get update && apt-get install -y \
    libpng-dev \
    libjpeg-dev \
    libfreetype6-dev \
    libzip-dev \
    unzip \
    git \
    && rm -rf /var/lib/apt/lists/*

# Configure GD extension
RUN docker-php-ext-configure gd --with-freetype --with-jpeg

# Install PHP extensions
RUN docker-php-ext-install pdo pdo_mysql mysqli gd zip gettext

# Enable Apache modules
RUN a2enmod rewrite

# Set working directory
WORKDIR /var/www/html

# Download Gibbon
RUN curl -L https://github.com/GibbonEdu/core/archive/refs/heads/main.tar.gz | tar xz --strip-components=1

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

# Configure Apache
RUN echo '<Directory /var/www/html>\n\
    AllowOverride All\n\
    Require all granted\n\
</Directory>' >> /etc/apache2/apache2.conf

# Recommended PHP settings
RUN echo "upload_max_filesize = 50M" >> /usr/local/etc/php/conf.d/gibbon.ini \
    && echo "post_max_size = 50M" >> /usr/local/etc/php/conf.d/gibbon.ini \
    && echo "max_execution_time = 300" >> /usr/local/etc/php/conf.d/gibbon.ini

EXPOSE 80

CMD ["apache2-foreground"]

Creating the .dockerignore File

Create a .dockerignore file:

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

Environment Variables Reference

Gibbon uses environment variables or configuration file:

Variable	Required	Default	Description
GIBBON_COUNTRY	No	-	Default country code
GIBBON_CURRENCY	No	-	Currency symbol
GIBBON_ORGANISATION_NAME	No	-	School/organization name
GIBBON_ORGANISATION_INITIALS	No	-	Short code for organization

Deploying Gibbon on Klutch.sh

Once your repository is prepared, follow these steps to deploy Gibbon:

Set Up MySQL/MariaDB Database

Deploy a MySQL or MariaDB instance. Create a database named gibbon with appropriate user permissions.

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Gibbon deployment configuration"
git remote add origin https://github.com/yourusername/gibbon-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 “gibbon” or “school-management”.

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

Configure HTTP Traffic

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

• Select HTTP as the traffic type
• Set the internal port to 80 (Apache’s default port)

Attach Persistent Volumes

Persistent storage is essential for Gibbon. Add the following volumes:

Mount Path	Recommended Size	Purpose
/var/www/html/uploads	10 GB	File uploads and documents

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 Gibbon container
• Provision an HTTPS certificate

Run Installation Wizard

Access your Gibbon instance at https://your-app-name.klutch.sh and complete the installation wizard:

1. Enter database connection details
2. Configure school information
3. Create administrator account
4. Complete setup

Access Gibbon

Once setup completes, log in with your administrator credentials to begin configuring your school.

Initial Setup and Configuration

Installation Wizard

The wizard guides you through:

1. System Check: Verifies PHP requirements
2. Database: Enter MySQL/MariaDB credentials
3. School Info: Configure organization details
4. Admin Account: Create initial administrator
5. Completion: Finalize installation

School Year Setup

Configure your academic year:

1. Go to School Admin → School Year
2. Add your school years
3. Set the current year as active

Department Setup

Create academic departments:

1. Navigate to School Admin → Departments
2. Add departments (e.g., Math, Science, English)
3. Assign staff to departments

Year Groups and Classes

Set up your student groupings:

1. Create Year Groups (e.g., Grade 9, Grade 10)
2. Create Form Groups/Classes within year groups
3. Configure class capacity and teachers

Core Modules

Student Management

Manage student information:

Feature	Description
Enrollment	Student admission and registration
Demographics	Personal information and contacts
Medical	Health records and allergies
History	Academic history and transcripts

Attendance

Track student presence:

1. Go to Attendance
2. Select class and date
3. Mark attendance:
   • Present
   • Absent
   • Late
   • Other codes

Gradebook

Manage student grades:

1. Create grade scales
2. Set up assessment items
3. Enter student grades
4. Calculate final grades

Timetabling

Create schedules:

1. Define periods and days
2. Create timetable structure
3. Assign classes to slots
4. Handle conflicts

User Roles

Built-in Roles

Role	Access Level
Administrator	Full system access
Teacher	Class and grade management
Student	Personal dashboard and grades
Parent	Child’s information and progress
Support Staff	Limited administrative access

Custom Roles

Create custom roles:

1. Go to User Admin → Roles
2. Create new role
3. Assign permissions
4. Apply to users

Parent Portal

Enable parent access:

1. Create parent accounts
2. Link parents to students
3. Parents can view:
   • Attendance
   • Grades
   • Behavior
   • Timetable

Reporting

Standard Reports

Generate various reports:

• Student reports
• Class lists
• Attendance summaries
• Grade reports
• Behavior logs

Custom Reports

Create custom reports using the report builder for specific institutional needs.

Modules and Extensions

Additional Modules

Extend Gibbon functionality:

Module	Purpose
Library	Book and resource management
Activities	Extracurricular activities
Examinations	Formal exam management
Finance	Billing and fees

Installing Modules

1. Download module from Gibbon community
2. Upload to modules directory
3. Enable in System Admin

Production Best Practices

Security Recommendations

• Strong Passwords: Enforce password policies
• Regular Updates: Keep Gibbon updated
• Backup Database: Regular MySQL backups
• HTTPS: Always use HTTPS (provided by Klutch.sh)
• Access Control: Review user permissions regularly

Data Protection

For student data:

• Comply with local data protection laws (FERPA, GDPR, etc.)
• Limit access to sensitive information
• Regular audit of user access
• Secure backup procedures

Backup Strategy

Protect school data:

1. Daily Database Backups: Automated MySQL dumps
2. Upload Backups: Back up student documents
3. Off-site Storage: Store backups securely
4. Test Restores: Verify backup integrity

Troubleshooting Common Issues

Installation Errors

Solutions:

• Verify PHP extensions installed
• Check database connection
• Ensure file permissions
• Review PHP error logs

Performance Issues

Solutions:

• Optimize database queries
• Increase PHP memory limit
• Enable caching if available
• Review resource allocation

Login Problems

Solutions:

• Reset password via database
• Check session configuration
• Clear browser cache
• Verify database connectivity

Additional Resources

• Official Gibbon Website
• Gibbon Documentation
• Gibbon GitHub Repository
• Gibbon Support Forum
• Klutch.sh Persistent Volumes
• Klutch.sh Deployments

Conclusion

Deploying Gibbon on Klutch.sh gives you a comprehensive school management platform with automatic builds, persistent storage, and secure HTTPS access. The combination of Gibbon’s flexible feature set and Klutch.sh’s deployment simplicity means you can focus on education rather than IT infrastructure.

With tools for attendance, grades, timetabling, and parent communication, Gibbon provides everything a school needs to manage daily operations. Whether you’re running a small private school or a larger educational institution, Gibbon on Klutch.sh delivers reliable school management that adapts to your needs.