Deploying ITFlow

Introduction

ITFlow is an open-source IT documentation, ticketing, and billing platform designed specifically for Managed Service Providers (MSPs) and IT professionals. It combines client management, asset tracking, documentation, ticketing, and invoicing into a single, cohesive application that helps IT teams stay organized and deliver better service.

Built with PHP and MySQL, ITFlow provides a clean, modern interface for managing all aspects of IT service delivery. Unlike enterprise PSA tools that can cost hundreds per user per month, ITFlow offers a comprehensive feature set at no licensing cost, making it accessible to small and growing IT businesses.

Key highlights of ITFlow:

Client Management: Store client information, contacts, and locations
Asset Tracking: Document hardware, software, and network devices
Ticketing System: Track issues, requests, and projects
Documentation: Create and organize knowledge base articles and procedures
Password Management: Securely store client credentials
Domain/SSL Tracking: Monitor domain and certificate expirations
Network Documentation: Document IP addresses, VLANs, and network topology
Invoicing: Generate quotes and invoices, track payments
Time Tracking: Log billable time against tickets
Client Portal: Give clients access to view tickets and documents
Recurring Services: Manage recurring revenue and services
Reports: Generate business and client reports
API Access: Integrate with other tools and systems

This guide walks through deploying ITFlow on Klutch.sh using Docker, setting up a complete IT service management platform.

Why Deploy ITFlow on Klutch.sh

Deploying ITFlow on Klutch.sh provides several advantages for IT service management:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds ITFlow without complex server configuration. Push to GitHub and your PSA platform deploys automatically.

Persistent Storage: Attach persistent volumes for your database and uploaded files. Your client data, tickets, and documentation survive container restarts.

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

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

Accessible Anywhere: Access your IT documentation and ticketing from client sites, home, or anywhere with internet access.

Custom Domains: Assign a professional domain for client portal access.

Scalable: Grow your ITFlow deployment as your client base expands.

Prerequisites

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

A Klutch.sh account
A GitHub account with a repository for your ITFlow configuration
Basic familiarity with Docker and containerization concepts
A MySQL/MariaDB database (can be deployed separately)
(Optional) SMTP server for email notifications

Understanding ITFlow Architecture

ITFlow is built on a traditional LAMP stack:

PHP Application: The web interface and business logic run on PHP.

MySQL Database: Client data, tickets, documentation, and configuration are stored in MySQL/MariaDB.

File Storage: Attachments, documents, and assets are stored on the filesystem.

Email Integration: SMTP for sending notifications, ticket updates, and reports.

Preparing Your Repository

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

Repository Structure

itflow-deploy/
├── Dockerfile
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM php:8.1-apache

# Install dependencies
RUN apt-get update && apt-get install -y \
    libpng-dev \
    libjpeg-dev \
    libfreetype6-dev \
    libzip-dev \
    libcurl4-openssl-dev \
    git \
    cron \
    && rm -rf /var/lib/apt/lists/*

# Configure PHP extensions
RUN docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-install -j$(nproc) gd pdo pdo_mysql mysqli zip curl

# Configure PHP settings
RUN echo "upload_max_filesize=100M" >> /usr/local/etc/php/conf.d/custom.ini \
    && echo "post_max_size=100M" >> /usr/local/etc/php/conf.d/custom.ini \
    && echo "memory_limit=256M" >> /usr/local/etc/php/conf.d/custom.ini \
    && echo "max_execution_time=300" >> /usr/local/etc/php/conf.d/custom.ini

# Clone ITFlow
RUN git clone https://github.com/itflow-org/itflow.git /var/www/html

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

# Enable Apache rewrite module
RUN a2enmod rewrite

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

# Expose port 80
EXPOSE 80

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:80/ || exit 1

# Volumes for persistent data
VOLUME ["/var/www/html/uploads"]

Environment Variables Reference

ITFlow is configured through its web-based setup and settings panel, but the container environment can set:

Variable	Required	Default	Description
`TZ`	No	UTC	Server timezone
`ITFLOW_NAME`	No	ITFlow	Application name
`ITFLOW_URL`	No	-	Base URL for the application

Deploying ITFlow on Klutch.sh

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

Set Up Your Database

ITFlow requires a MySQL or MariaDB database. You can:

Deploy a MariaDB app on Klutch.sh
Use a managed database service
Use an existing database server

Create a database and user for ITFlow with full privileges.

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore
git commit -m "Initial ITFlow deployment configuration"
git remote add origin https://github.com/yourusername/itflow-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 “itflow” or “msp-tools”.

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

Configure HTTP Traffic

ITFlow 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
`TZ`	Your timezone (e.g., `America/Chicago`)

Attach Persistent Volumes

Persistent storage is essential for your data. Add:

Mount Path	Recommended Size	Purpose
`/var/www/html/uploads`	10+ GB	File attachments and uploads

Deploy Your Application

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

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

Complete Initial Setup

Once deployment completes, access your ITFlow instance at https://your-app-name.klutch.sh. Complete the web-based setup wizard:

Enter database connection details
Create your admin account
Configure company information
Set up email settings

Configuring ITFlow

Company Settings

After initial setup, configure your company:

Go to Settings > Company
Enter your company name and details
Upload your logo for invoices and reports
Configure regional settings (currency, date format)

Email Configuration

Set up email for notifications:

Go to Settings > Mail
Configure SMTP server details
Set up email templates
Enable ticket notifications

User Management

Add your team members:

Go to Admin > Users
Create user accounts
Assign roles and permissions
Configure two-factor authentication

Using ITFlow

Client Management

Create and manage clients:

Go to Clients in the main menu
Click “Add Client”
Enter client information, contacts, and locations
Add assets, documentation, and passwords

Ticketing

Track issues and requests:

Create tickets from the dashboard or client page
Assign priority and category
Track time spent on tickets
Communicate with clients through the ticket

Documentation

Build your knowledge base:

Create documentation per client
Document procedures and configurations
Use templates for common documentation
Link documents to assets

Asset Tracking

Document client infrastructure:

Add hardware (servers, workstations, network devices)
Add software and licenses
Track network information (IPs, VLANs)
Monitor domain and SSL certificate expiration

Invoicing

Bill clients for your services:

Create invoices from tickets or manually
Add recurring services
Track payments and balances
Generate quotes for projects

Client Portal

Give clients access to ITFlow:

Enable client portal in settings
Create client user accounts
Clients can:
- View and create tickets
- Access documentation you share
- View invoices and make payments
- See asset information

Troubleshooting Common Issues

Database Connection Errors

Symptoms: Cannot connect to database during setup.

Solutions:

Verify database host is accessible
Check username and password
Ensure database exists with proper permissions

File Upload Issues

Symptoms: Cannot upload attachments.

Solutions:

Check PHP upload settings
Verify uploads directory is writable
Ensure volume is properly mounted

Email Not Sending

Symptoms: Notifications and emails don’t arrive.

Solutions:

Verify SMTP settings are correct
Check for firewall blocking SMTP ports
Review PHP mail logs

Additional Resources

Conclusion

Deploying ITFlow on Klutch.sh gives you a complete IT service management platform with automatic builds, persistent storage, and secure HTTPS access. You get the functionality of expensive PSA tools without the per-user licensing costs.

Whether you’re a solo IT consultant or a growing MSP, ITFlow on Klutch.sh provides the tools to manage clients, track tickets, document infrastructure, and bill for your services - all from a single, accessible platform.