Deploying Group Office

Introduction

Group-Office is a comprehensive enterprise groupware and CRM platform that brings together email, calendar, file sharing, projects, and customer relationship management in one integrated solution. Built with privacy by design, Group-Office lets organizations collaborate effectively while maintaining full control over their data.

With over 20 years of development and trusted by organizations worldwide, Group-Office provides a mature, feature-rich platform for team collaboration. The modular architecture allows you to enable only the features you need, keeping the interface clean and focused.

Key highlights of Group-Office:

Email Integration: Full email client with CalDAV and CardDAV support
Calendar & Tasks: Shared calendars, scheduling, and task management
File Sharing: Document management with version history
CRM: Contact management, sales pipeline, and customer tracking
Projects: Project management with time tracking
Address Book: Shared contacts with CardDAV sync
Document Generation: Create documents from templates
Mobile Sync: ActiveSync support for mobile devices
Two-Factor Authentication: Enterprise-grade security
GDPR Compliant: Privacy by design approach
100% Open Source: Core features available under AGPL-3.0

This guide walks through deploying Group-Office on Klutch.sh using Docker, configuring the platform, and setting up collaborative tools for your team.

Why Deploy Group-Office on Klutch.sh

Deploying Group-Office on Klutch.sh provides several advantages for enterprise collaboration:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Group-Office without complex orchestration. Push to GitHub and your groupware platform deploys automatically.

Persistent Storage: Attach persistent volumes for your database, files, and email. Your data survives container restarts.

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

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

Scalable Resources: Allocate CPU and memory based on your team size and usage patterns.

Custom Domains: Assign a custom domain for professional branding.

Always-On Availability: Your groupware platform remains accessible 24/7.

Prerequisites

Before deploying Group-Office on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your Group-Office configuration
A MySQL or MariaDB database (can be deployed on Klutch.sh)
Basic familiarity with Docker and containerization concepts
(Optional) SMTP server credentials for email sending

Understanding Group-Office Architecture

Group-Office is built on a modular architecture:

PHP Backend: Core application running on PHP with Zend Framework.

MySQL/MariaDB Database: Stores users, contacts, calendar events, and configuration.

File Storage: Document storage with version control.

Email Integration: IMAP client with SMTP sending support.

Web Interface: Responsive interface built with ExtJS.

API: RESTful API for integrations and mobile apps.

Preparing Your Repository

To deploy Group-Office on Klutch.sh, create a GitHub repository containing your Dockerfile.

Repository Structure

group-office-deploy/
├── Dockerfile
├── README.md
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM intermesh/groupoffice:latest

# Set environment variables
ENV GO_DB_HOST=${GO_DB_HOST}
ENV GO_DB_USER=${GO_DB_USER}
ENV GO_DB_PASS=${GO_DB_PASS}
ENV GO_DB_NAME=${GO_DB_NAME:-groupoffice}

# Create data directories
RUN mkdir -p /var/lib/groupoffice /var/log/groupoffice

# Expose the web interface port
EXPOSE 80

# The base image includes Apache and the application

Advanced Dockerfile

For more configuration:

FROM intermesh/groupoffice:latest

# Database Configuration
ENV GO_DB_HOST=${GO_DB_HOST}
ENV GO_DB_USER=${GO_DB_USER}
ENV GO_DB_PASS=${GO_DB_PASS}
ENV GO_DB_NAME=${GO_DB_NAME:-groupoffice}
ENV GO_DB_PORT=${GO_DB_PORT:-3306}

# Email Configuration (optional)
ENV GO_SMTP_HOST=${GO_SMTP_HOST}
ENV GO_SMTP_PORT=${GO_SMTP_PORT:-587}
ENV GO_SMTP_USER=${GO_SMTP_USER}
ENV GO_SMTP_PASS=${GO_SMTP_PASS}

# Application Settings
ENV GO_TMP_DIR=/tmp
ENV GO_FILE_STORAGE_PATH=/var/lib/groupoffice

# Create directories
RUN mkdir -p /var/lib/groupoffice /var/log/groupoffice

# Set permissions
RUN chown -R www-data:www-data /var/lib/groupoffice /var/log/groupoffice

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

EXPOSE 80

Creating the .dockerignore File

Create a .dockerignore file:

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

Environment Variables Reference

Variable	Required	Default	Description
`GO_DB_HOST`	Yes	-	MySQL/MariaDB host
`GO_DB_USER`	Yes	-	Database username
`GO_DB_PASS`	Yes	-	Database password
`GO_DB_NAME`	No	groupoffice	Database name
`GO_DB_PORT`	No	3306	Database port
`GO_SMTP_HOST`	No	-	SMTP server for outgoing email
`GO_SMTP_PORT`	No	587	SMTP port
`GO_SMTP_USER`	No	-	SMTP username
`GO_SMTP_PASS`	No	-	SMTP password
`GO_FILE_STORAGE_PATH`	No	/var/lib/groupoffice	File storage directory

Deploying Group-Office on Klutch.sh

Once your repository is prepared, follow these steps to deploy Group-Office:

Deploy a MySQL Database

Group-Office requires MySQL or MariaDB. Deploy one on Klutch.sh first. See the MySQL deployment guide.

Create a database and user for Group-Office:

CREATE DATABASE groupoffice CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'groupoffice'@'%' IDENTIFIED BY 'your-secure-password';
GRANT ALL PRIVILEGES ON groupoffice.* TO 'groupoffice'@'%';
FLUSH PRIVILEGES;

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial Group-Office deployment configuration"
git remote add origin https://github.com/yourusername/group-office-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 “group-office” or “groupware”.

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 Group-Office Dockerfile.

Configure HTTP Traffic

Group-Office 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

In the environment variables section, add:

Variable	Value
`GO_DB_HOST`	Your MySQL host
`GO_DB_USER`	`groupoffice`
`GO_DB_PASS`	Your database password
`GO_DB_NAME`	`groupoffice`

Add SMTP configuration if you want email functionality.

Attach Persistent Volumes

Persistent storage is essential for Group-Office. Add the following volumes:

Mount Path	Recommended Size	Purpose
`/var/lib/groupoffice`	50 GB	File storage, documents, and attachments
`/var/log/groupoffice`	5 GB	Application logs

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 Group-Office container
Provision an HTTPS certificate

Complete Installation Wizard

After deployment, access your Group-Office instance:

Navigate to https://your-app-name.klutch.sh
Follow the installation wizard
Create your admin account
Configure basic settings

Access Group-Office

Once setup completes, log in and start configuring your groupware environment.

Initial Configuration

Setting Up Modules

Enable the features you need:

Log in as administrator
Go to System Settings > Modules
Enable desired modules:
- Email
- Calendar
- Address Book
- Files
- Projects
- Notes
- Tasks

Configuring Email

Set up the email module:

Go to Email settings
Add email accounts using IMAP/SMTP
Configure shared mailboxes if needed
Set up email signatures

Setting Up Users

Create accounts for your team:

Go to System Settings > Users
Click Add User
Enter user details
Assign to groups
Set module permissions

Configuring Groups

Organize users into groups:

Go to System Settings > Groups
Create groups (e.g., Sales, Support, Management)
Add users to groups
Set shared resources and permissions

Using Group-Office

Email

Full-featured email client:

Connect multiple IMAP accounts
Shared mailboxes for teams
Email templates and signatures
Calendar invites integration
Contact integration

Calendar

Shared scheduling:

Personal and shared calendars
Meeting scheduling with availability
CalDAV sync with external apps
Recurring events
Resource booking (rooms, equipment)

Contacts/Address Book

Contact management:

Personal and shared address books
Company and contact records
CardDAV sync with phones
Import/export vCard
Link contacts to emails and events

Files

Document management:

File storage with folders
Version history
File sharing with links
WebDAV access
Document templates

Projects

Project management:

Project creation and tracking
Time registration
Task management
Resource allocation
Project reporting

CRM

Customer relationship management:

Lead and opportunity tracking
Sales pipeline
Activity logging
Customer communication history
Reports and analytics

Mobile Access

ActiveSync

Sync with mobile devices:

Configure ActiveSync in Group-Office
Add account on your phone
Sync email, calendar, and contacts

WebDAV/CalDAV/CardDAV

For standard protocol support:

CalDAV: Calendar sync with any CalDAV client
CardDAV: Contact sync with any CardDAV client
WebDAV: File access from file managers

Mobile Browser

Access Group-Office from mobile browsers:

Responsive interface
Touch-friendly design
Full feature access

Security Best Practices

User Security

Strong Passwords: Enforce password policies
Two-Factor Authentication: Enable 2FA for all users
Regular Audits: Review user access regularly

Data Security

Backup Strategy: Regular database and file backups
Encryption: Use HTTPS (automatic on Klutch.sh)
Access Controls: Configure proper permissions

Compliance

GDPR: Built with privacy by design
Audit Logging: Track user activities
Data Retention: Configure retention policies

Troubleshooting Common Issues

Cannot Connect to Database

Symptoms: Application shows database errors.

Solutions:

Verify database credentials
Check database is accessible from Klutch.sh
Ensure database user has all privileges
Check database character set is utf8mb4

Email Not Sending

Symptoms: Outgoing emails fail.

Solutions:

Verify SMTP configuration
Check SMTP credentials
Ensure SMTP port is not blocked
Review email logs for errors

File Upload Failures

Symptoms: Cannot upload files.

Solutions:

Check file storage volume is mounted
Verify permissions on storage directory
Check PHP upload limits
Ensure sufficient disk space

Slow Performance

Symptoms: Application is sluggish.

Solutions:

Increase container resources
Optimize database queries
Check for large file storage issues
Review and archive old data

Additional Resources

Conclusion

Deploying Group-Office on Klutch.sh gives you a comprehensive enterprise groupware platform with full control over your data. The combination of Group-Office’s mature feature set and Klutch.sh’s deployment simplicity means you can enable team collaboration without complex infrastructure.

With integrated email, calendar, CRM, and project management, Group-Office provides everything your organization needs to work together effectively. Whether you’re a small team needing basic collaboration tools or an enterprise requiring full CRM capabilities, Group-Office on Klutch.sh delivers a professional, self-hosted solution that respects your privacy and keeps your data under your control.