Skip to content
Klutch.sh Docs

Deploying GLPI

Introduction

GLPI (Gestionnaire Libre de Parc Informatique) is a powerful open-source IT asset management and service desk platform designed to help organizations efficiently manage their IT infrastructure, track assets, handle help desk tickets, and maintain an accurate inventory of hardware and software resources. Built with PHP and MySQL, GLPI provides a comprehensive suite of IT management tools including asset tracking, incident management, project management, and detailed reporting capabilities. With its modular architecture and extensive plugin ecosystem, GLPI adapts to organizations of all sizes, from small businesses to large enterprises.

GLPI stands out for its:

  • Comprehensive Asset Management: Track hardware, software, licenses, and warranties throughout their lifecycle
  • Help Desk & Ticketing: Full-featured ITIL-compliant incident and request management system
  • Inventory Management: Automatic discovery and inventory of network devices, computers, and peripherals
  • Knowledge Base: Centralized documentation system for FAQs, solutions, and procedures
  • Contract & Supplier Management: Track vendors, contracts, and maintenance agreements
  • Reservation System: Manage bookings for shared IT resources like meeting rooms and equipment
  • Project Management: Built-in project tracking and task management capabilities
  • Financial Management: Track costs, budgets, and TCO (Total Cost of Ownership)
  • Plugin Architecture: Extensive marketplace with plugins for additional functionality
  • Multi-language Support: Available in 45+ languages for global organizations
  • LDAP Integration: Seamless integration with Active Directory and other LDAP directories
  • API Access: RESTful API for integration with other systems
  • Comprehensive Reporting: Generate detailed reports on assets, tickets, and operations

This comprehensive guide walks you through deploying GLPI on Klutch.sh using Docker, including detailed installation steps, database configuration, persistent storage setup, and production-ready best practices for managing your IT service management platform.

Prerequisites

Before you begin, ensure you have the following:

  • A Klutch.sh account
  • A GitHub account with a repository for your GLPI project
  • Docker installed locally for testing (optional but recommended)
  • Basic understanding of Docker, PHP applications, and database management
  • A MySQL or MariaDB database (can be deployed on Klutch.sh or use a managed service)

Installation and Setup

Step 1: Create Your Project Directory

First, create a new directory for your GLPI deployment project:

Terminal window
mkdir glpi-klutch
cd glpi-klutch
git init

Step 2: Create the Dockerfile

Create a Dockerfile in your project root directory. This will define your GLPI container configuration:

FROM php:8.1-apache


# Set working directory
WORKDIR /var/www/html


# Install system dependencies and PHP extensions
RUN apt-get update && apt-get install -y \
    git \
    curl \
    libpng-dev \
    libonig-dev \
    libxml2-dev \
    libzip-dev \
    libldap2-dev \
    libicu-dev \
    libfreetype6-dev \
    libjpeg62-turbo-dev \
    zlib1g-dev \
    unzip \
    wget \
    && docker-php-ext-configure gd --with-freetype --with-jpeg \
    && docker-php-ext-configure ldap --with-libdir=lib/x86_64-linux-gnu/ \
    && docker-php-ext-install -j$(nproc) \
    pdo_mysql \
    mysqli \
    mbstring \
    exif \
    pcntl \
    bcmath \
    gd \
    zip \
    intl \
    ldap \
    opcache


# Download and install GLPI
ARG GLPI_VERSION=10.0.11
RUN wget https://github.com/glpi-project/glpi/releases/download/${GLPI_VERSION}/glpi-${GLPI_VERSION}.tgz \
    && tar -xzf glpi-${GLPI_VERSION}.tgz \
    && rm glpi-${GLPI_VERSION}.tgz \
    && mv glpi/* . \
    && rm -rf glpi


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


# Configure Apache
RUN a2enmod rewrite
COPY apache-config.conf /etc/apache2/sites-available/000-default.conf


# Configure PHP for GLPI
RUN { \
    echo 'memory_limit = 256M'; \
    echo 'upload_max_filesize = 100M'; \
    echo 'post_max_size = 100M'; \
    echo 'max_execution_time = 300'; \
    echo 'session.cookie_httponly = On'; \
    echo 'session.cookie_secure = On'; \
    } > /usr/local/etc/php/conf.d/glpi.ini


# Expose HTTP port
EXPOSE 80


# Copy entrypoint script
COPY docker-entrypoint.sh /usr/local/bin/
RUN chmod +x /usr/local/bin/docker-entrypoint.sh


ENTRYPOINT ["docker-entrypoint.sh"]
CMD ["apache2-foreground"]

Step 3: Create Apache Configuration

Create an apache-config.conf file for Apache virtual host configuration:

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html/public


    <Directory /var/www/html/public>
        Options -Indexes +FollowSymLinks
        AllowOverride All
        Require all granted
    </Directory>


    <Directory /var/www/html/files>
        AllowOverride None
        Require all denied
    </Directory>


    <Directory /var/www/html/config>
        AllowOverride None
        Require all denied
    </Directory>


    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Step 4: Create Entrypoint Script

Create a docker-entrypoint.sh script to handle initialization:

#!/bin/bash
set -e


cd /var/www/html


# Create necessary directories if they don't exist
mkdir -p files/_cache
mkdir -p files/_cron
mkdir -p files/_dumps
mkdir -p files/_graphs
mkdir -p files/_lock
mkdir -p files/_pictures
mkdir -p files/_plugins
mkdir -p files/_rss
mkdir -p files/_sessions
mkdir -p files/_tmp
mkdir -p files/_uploads


# Set proper permissions
chown -R www-data:www-data files config
chmod -R 755 files


# Wait for database to be ready
if [ -n "$DB_HOST" ]; then
    echo "Waiting for database at $DB_HOST:${DB_PORT:-3306}..."
    until php -r "new PDO('mysql:host=${DB_HOST};port=${DB_PORT:-3306}', '${DB_USER}', '${DB_PASSWORD}');" 2>/dev/null; do
        echo "Database not ready, waiting..."
        sleep 3
    done
    echo "Database is ready!"
fi


# Check if GLPI is already installed
if [ ! -f /var/www/html/config/config_db.php ]; then
    echo "GLPI not yet configured. Please complete the installation wizard."
else
    echo "GLPI configuration found, starting application..."
fi


# Execute the main command
exec "$@"

Step 5: Create Environment Configuration

Create a .env.example file to document the required environment variables:

Terminal window
# Application Configuration
APP_URL=https://example-app.klutch.sh


# Database Configuration
DB_HOST=mysql-host
DB_PORT=3306
DB_NAME=glpi
DB_USER=glpi_user
DB_PASSWORD=secure_password_here


# GLPI Configuration
GLPI_ADMIN_EMAIL=admin@example.com
GLPI_ADMIN_PASSWORD=admin_password_here


# PHP Configuration
PHP_MEMORY_LIMIT=256M
PHP_UPLOAD_MAX_FILESIZE=100M
PHP_POST_MAX_SIZE=100M


# Session Configuration
SESSION_COOKIE_SECURE=On
SESSION_COOKIE_HTTPONLY=On


# Timezone
TZ=UTC

Security Note: Never commit actual passwords or sensitive data to your repository. Use environment variables in Klutch.sh dashboard.

Step 6: Test Locally with Docker Compose (Optional)

Create a docker-compose.yml file for local testing:

version: '3.8'


services:
  glpi:
    build: .
    ports:
      - "8080:80"
    environment:
      - DB_HOST=mysql
      - DB_PORT=3306
      - DB_NAME=glpi
      - DB_USER=glpi
      - DB_PASSWORD=glpi_password
      - APP_URL=http://localhost:8080
    volumes:
      - glpi-files:/var/www/html/files
      - glpi-config:/var/www/html/config
    depends_on:
      - mysql


  mysql:
    image: mysql:8.0
    environment:
      - MYSQL_DATABASE=glpi
      - MYSQL_USER=glpi
      - MYSQL_PASSWORD=glpi_password
      - MYSQL_ROOT_PASSWORD=root_password
    volumes:
      - mysql-data:/var/lib/mysql
    command: --default-authentication-plugin=mysql_native_password


volumes:
  glpi-files:
  glpi-config:
  mysql-data:

Note: This Docker Compose file is for local development and testing only. Klutch.sh does not support Docker Compose for deployment.

Test locally:

Terminal window
# Build and start services
docker-compose up -d


# View logs
docker-compose logs -f glpi


# Access GLPI at http://localhost:8080


# Stop services when done
docker-compose down

Step 7: Create Documentation

Create a README.md file with deployment instructions:

# GLPI IT Asset Management Platform


## Deployment on Klutch.sh


This repository contains the Docker configuration for deploying GLPI on Klutch.sh.


## Configuration


1. Set up a MySQL database (version 8.0 or higher recommended)
2. Configure environment variables in Klutch.sh dashboard
3. Attach persistent volumes for files and config
4. Deploy the application


## Environment Variables


Required environment variables:
- `DB_HOST`: Database hostname
- `DB_PORT`: Database port (usually 3306)
- `DB_NAME`: Database name
- `DB_USER`: Database username
- `DB_PASSWORD`: Database password
- `APP_URL`: Your application URL (e.g., https://example-app.klutch.sh)


## Storage


Mount persistent volumes at:
- `/var/www/html/files` - Uploaded files, documents, and cache
- `/var/www/html/config` - GLPI configuration files


## First-Time Setup


After deployment, access your GLPI installation at your app URL and complete the setup wizard.

Step 8: Push to GitHub

Commit your configuration files to your GitHub repository:

Terminal window
git add Dockerfile apache-config.conf docker-entrypoint.sh .env.example README.md
git commit -m "Add GLPI Docker configuration for Klutch.sh deployment"
git remote add origin https://github.com/yourusername/glpi-klutch.git
git push -u origin main

Important: Do not commit docker-compose.yml to your production repository as it contains test credentials and is only for local development.

Deploying to Klutch.sh

Now that your GLPI project is ready and pushed to GitHub, follow these steps to deploy it on Klutch.sh with persistent storage and database configuration.

Deployment Steps

    1. Log in to Klutch.sh

      Navigate to klutch.sh/app and sign in to your account.

    2. Create a New Project

      Click on “Create Project” and give your project a meaningful name (e.g., “GLPI IT Management”).

    3. Set Up Database

      Before deploying GLPI, you need a MySQL database:

      Note: If deploying MySQL on Klutch.sh, configure it with TCP traffic type on port 8000, and set the internal port to 3306 (MySQL’s default port).

    4. Create a New App

      Click on “Create App” within your project and configure the following settings:

    5. Select Your Repository

      • Choose GitHub as your Git source
      • Select the repository containing your GLPI Dockerfile
      • Choose the branch you want to deploy (usually main or master)

    6. Configure Traffic Type

      • Traffic Type: Select HTTP (GLPI serves a web application via HTTP)
      • Internal Port: Set to 80 (the port Apache listens on inside the container)

    7. Set Environment Variables

      Add the following environment variables for your GLPI configuration:

      Database Settings:

      • DB_HOST: Your database hostname (e.g., mysql-app.klutch.sh if deployed on Klutch.sh, or external hostname)
      • DB_PORT: Set to 8000 if using Klutch.sh MySQL, or 3306 for external databases
      • DB_NAME: Database name (e.g., glpi)
      • DB_USER: Database username
      • DB_PASSWORD: Database password (mark as secret)

      Application Settings:

      • APP_URL: Your full application URL (e.g., https://example-app.klutch.sh)
      • TZ: Timezone (e.g., America/New_York or UTC)

      Optional Settings:

      • PHP_MEMORY_LIMIT: PHP memory limit (default: 256M)
      • PHP_UPLOAD_MAX_FILESIZE: Maximum file upload size (default: 100M)
      • PHP_POST_MAX_SIZE: Maximum POST size (default: 100M)

      Security Note: Always mark sensitive variables like passwords as secrets in Klutch.sh dashboard.

    8. Attach Persistent Volumes

      This is critical for ensuring your GLPI data persists across deployments and restarts:

      Volume 1 - Files Storage:

      • Click “Add Volume”
      • Mount Path: Enter /var/www/html/files (stores uploads, documents, cache, and temporary files)
      • Size: Choose based on expected usage (e.g., 20GB for small organizations, 100GB+ for larger deployments)

      Volume 2 - Configuration:

      • Click “Add Volume”
      • Mount Path: Enter /var/www/html/config (stores GLPI configuration and database settings)
      • Size: 1GB is sufficient for configuration files

      Important: GLPI requires persistent storage to maintain uploaded files, asset documentation, tickets, and configuration between container restarts.

    9. Configure Additional Settings

      • Region: Select the region closest to your users for optimal performance
      • Compute Resources: Choose CPU and memory based on your needs (minimum 1GB RAM recommended for GLPI)
      • Instances: Start with 1 instance (you can scale up later as your organization grows)

    10. Deploy Your Application

      Click “Create” to start the deployment. Klutch.sh will:

      • Automatically detect your Dockerfile in the repository root
      • Build the Docker image
      • Attach the persistent volumes
      • Start your GLPI container
      • Assign a URL for external access

      This process may take several minutes as it builds the image and installs all dependencies.

    11. Complete Initial Setup

      Once deployment is complete, you’ll receive a URL like https://example-app.klutch.sh. Navigate to this URL in your browser to access the GLPI installation wizard:

      The setup wizard will guide you through:

      • Language selection
      • License agreement
      • Prerequisites check (PHP extensions, permissions)
      • Database configuration (this will be filled with your environment variables)
      • Database initialization
      • Creating your admin account

      Default Installation Credentials: During the wizard, GLPI will provide default credentials for initial login. Make sure to change these immediately after first login.

      Important: Complete the setup wizard as soon as possible after deployment to secure your GLPI installation.

Database Configuration

Using MySQL on Klutch.sh

If you’re deploying MySQL on Klutch.sh alongside GLPI:

  1. Create a separate MySQL app in the same project
  2. Configure MySQL with:
    • Traffic Type: TCP
    • Internal Port: 3306
    • Public Port: 8000 (Klutch.sh default for TCP traffic)
  3. Attach persistent storage to MySQL at /var/lib/mysql
  4. Create the database and user:
CREATE DATABASE glpi CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'glpi_user'@'%' IDENTIFIED BY 'secure_password';
GRANT ALL PRIVILEGES ON glpi.* TO 'glpi_user'@'%';
FLUSH PRIVILEGES;
  1. In your GLPI app, set the environment variables:
    • DB_HOST: mysql-app.klutch.sh (your MySQL app URL)
    • DB_PORT: 8000
    • DB_NAME: glpi
    • DB_USER: glpi_user
    • DB_PASSWORD: secure_password

Using External MySQL Service

For production deployments with higher reliability requirements, consider using a managed MySQL service:

Option 1: DigitalOcean Managed Database

  1. Create a MySQL database cluster on DigitalOcean
  2. Create a database named glpi
  3. Get your connection details from the DigitalOcean dashboard
  4. Set environment variables in Klutch.sh: 
    DB_HOST=your-db-cluster.db.ondigitalocean.com
    DB_PORT=25060
    DB_NAME=glpi
    DB_USER=doadmin
    DB_PASSWORD=your-db-password

Option 2: AWS RDS MySQL

  1. Create an RDS MySQL instance on AWS
  2. Configure security groups to allow connections from Klutch.sh
  3. Create the glpi database
  4. Set environment variables with your RDS connection details

Option 3: PlanetScale

  1. Create a database on PlanetScale
  2. Get your connection string
  3. Set environment variables in Klutch.sh

Persistent Storage Configuration

GLPI requires persistent storage for several critical functions:

Storage Structure

Files Volume (/var/www/html/files):

  • _cache - Cached data for improved performance
  • _cron - Scheduled task data
  • _dumps - Database backup dumps
  • _graphs - Generated charts and graphs
  • _pictures - User and item images
  • _plugins - Installed plugin files
  • _sessions - User session data
  • _tmp - Temporary files
  • _uploads - Uploaded documents and attachments

Config Volume (/var/www/html/config):

  • GLPI configuration files
  • Database connection settings
  • Plugin configurations

Files Volume:

  • Small Organization (< 100 users): 10-20 GB
  • Medium Organization (100-500 users): 50-100 GB
  • Large Organization (500+ users): 200+ GB

Config Volume:

  • All Deployments: 1-2 GB

Backup Strategy

Regularly backup your persistent volumes to prevent data loss:

  1. Use Klutch.sh volume snapshots (if available)
  2. Export important files periodically to external storage
  3. Maintain database backups separately using mysqldump
  4. Test your restore process regularly

Database Backup Command:

Terminal window
mysqldump -h $DB_HOST -P $DB_PORT -u $DB_USER -p$DB_PASSWORD $DB_NAME > glpi-backup-$(date +%F).sql

GLPI Configuration and Post-Deployment

Initial Configuration Steps

After completing the installation wizard:

  1. Log in with Admin Account

    Use the credentials you created during setup to access the GLPI admin panel.

  2. Configure General Settings

    Navigate to Setup → General:

    • Set your organization name
    • Configure the public URL
    • Set default language and timezone
    • Configure session timeout settings

  3. Set Up Email Notifications

    Navigate to Setup → Notifications:

    • Configure SMTP settings for email notifications
    • Test email delivery
    • Set up notification templates for tickets and updates

  4. Configure Authentication

    Navigate to Setup → Authentication:

    • Configure LDAP/Active Directory integration if needed
    • Set up SSO if applicable
    • Configure password policies

  5. Create User Profiles and Entities

    • Define user profiles with appropriate permissions
    • Create entities to represent departments or locations
    • Assign users to entities and profiles

SMTP Configuration

To enable email notifications, configure SMTP settings:

Using Gmail:

SMTP Host: smtp.gmail.com
SMTP Port: 587
SMTP Encryption: TLS
SMTP Username: your-email@gmail.com
SMTP Password: your-app-password

Using SendGrid:

SMTP Host: smtp.sendgrid.net
SMTP Port: 587
SMTP Encryption: TLS
SMTP Username: apikey
SMTP Password: your-sendgrid-api-key

Using Mailgun:

SMTP Host: smtp.mailgun.org
SMTP Port: 587
SMTP Encryption: TLS
SMTP Username: your-mailgun-username
SMTP Password: your-mailgun-password

Plugin Installation and Management

GLPI’s functionality can be extended with plugins from the official marketplace.

Installing Plugins

  1. Via Web Interface:

    • Navigate to Setup → Plugins
    • Click “Get More Plugins”
    • Browse the marketplace
    • Click “Download” on desired plugins
    • Return to Setup → Plugins
    • Click “Install” then “Enable”

  2. Via Manual Upload:

    • Download plugin from GLPI Plugins Marketplace
    • Extract to /var/www/html/plugins/ directory
    • Install and enable via the web interface
  • FusionInventory - Automated inventory collection
  • PDF - Enhanced PDF export capabilities
  • Datainjection - Mass data import tool
  • Fields - Additional custom fields
  • News - Display announcements and news
  • Behaviors - Additional behavioral options
  • Accounts - Password and account management
  • Order Management - Purchase order tracking

Environment Variables Reference

Complete list of GLPI environment variables you can configure in Klutch.sh:

VariableDescriptionRequiredDefault
DB_HOSTDatabase hostnameYesNone
DB_PORTDatabase portYes3306
DB_NAMEDatabase nameYesNone
DB_USERDatabase userYesNone
DB_PASSWORDDatabase passwordYesNone
APP_URLFull application URLYesNone
TZTimezoneNoUTC
PHP_MEMORY_LIMITPHP memory limitNo256M
PHP_UPLOAD_MAX_FILESIZEMax upload file sizeNo100M
PHP_POST_MAX_SIZEMax POST sizeNo100M
SESSION_COOKIE_SECURESecure cookiesNoOn
SESSION_COOKIE_HTTPONLYHTTP-only cookiesNoOn

Production Best Practices

Security Recommendations

  • Strong Passwords: Use a password manager to generate strong, random passwords for database and admin accounts
  • Environment Variables: Store all sensitive credentials as environment variables in Klutch.sh, never in your Dockerfile or repository
  • HTTPS Only: Klutch.sh provides HTTPS by default; ensure you access GLPI only via HTTPS
  • Regular Updates: Keep GLPI updated to the latest version for security patches and new features
  • Database Backups: Implement a backup strategy for your MySQL database using automated backups
  • File Backups: Regularly backup your persistent volumes containing files and configuration
  • Access Control: Use GLPI’s built-in role-based access control to limit user permissions
  • Two-Factor Authentication: Enable 2FA for administrative accounts
  • Audit Logging: Enable and monitor audit logs for security events
  • IP Restrictions: Consider implementing IP allowlisting for admin access

Performance Optimization

  • Database Optimization: Ensure your MySQL database has proper indexing and is configured for your workload
  • Enable OPcache: PHP OPcache is configured by default; monitor cache hit rates
  • Session Management: Configure appropriate session timeout values
  • Cron Tasks: Set up automated cron tasks for maintenance operations
  • File Cleanup: Regularly clean up old temporary files and cache
  • CDN Integration: Consider using a CDN for static assets if serving global users
  • Database Connection Pooling: Use persistent database connections for better performance
  • Monitor Query Performance: Identify and optimize slow database queries

Monitoring and Maintenance

Monitor your GLPI deployment for:

  • Response Times: Ensure the application loads quickly for users
  • Database Performance: Monitor query execution times and slow queries
  • Storage Usage: Track persistent volume usage and plan for expansion
  • Error Logs: Regularly check Apache and GLPI logs for errors
  • Ticket Volume: Monitor help desk ticket creation and resolution rates
  • User Activity: Track user login patterns and application usage
  • Backup Status: Verify that automated backups are running successfully
  • Security Updates: Subscribe to GLPI’s security announcements
  • Plugin Updates: Keep installed plugins up to date

Data Management

  • Ticket Retention: Configure retention policies based on your organizational requirements
  • Database Cleanup: Use GLPI’s built-in tools to purge old tickets and logs
  • Asset Lifecycle: Regularly review and update asset records
  • Inventory Accuracy: Schedule periodic inventory audits
  • Document Management: Organize uploaded documents with clear naming conventions
  • Audit Trail: Maintain audit logs for compliance purposes
  • Data Export: Regularly export data for reporting and analysis
  • Privacy Compliance: Ensure compliance with GDPR, HIPAA, or other regulations

LDAP / Active Directory Integration

Integrate GLPI with your organization’s directory service for centralized user management.

Configuration Steps

  1. Navigate to Setup → Authentication → LDAP Directory

  2. Click “Add LDAP Server”

  3. Configure connection settings:

    Name: Active Directory
    Server: ldap://ad.example.com
    Port: 389 (or 636 for LDAPS)
    BaseDN: dc=example,dc=com
    Connection filter: (&(objectClass=user)(objectCategory=person))
    Login field: samaccountname

  4. Configure user import settings:

    • First name field: givenname
    • Last name field: sn
    • Email field: mail
    • Phone field: telephonenumber

  5. Test connection and import users

Security Best Practices for LDAP

  • Use LDAPS (LDAP over SSL) on port 636
  • Create a dedicated service account with read-only permissions
  • Restrict LDAP queries to specific OUs
  • Enable SSL certificate verification

Asset Management and Inventory

Manual Asset Entry

  1. Navigate to Assets → Computers (or other asset type)
  2. Click “Add”
  3. Fill in asset details:
    • Name and serial number
    • Location and user assignment
    • Warranty information
    • Financial details (purchase date, value)

Automated Inventory with FusionInventory

  1. Install the FusionInventory plugin
  2. Deploy FusionInventory agents on client machines
  3. Configure agent communication with GLPI server
  4. Schedule automatic inventory collection

Asset Lifecycle Management

  • Track asset status: In Use, Available, Retired
  • Monitor warranty expiration dates
  • Schedule maintenance tasks
  • Track Total Cost of Ownership (TCO)

Ticketing and Help Desk

Creating Tickets

As an End User:

  1. Navigate to Assistance → Create a ticket
  2. Fill in ticket details (title, description, category)
  3. Submit the ticket

As a Technician:

  1. Navigate to Assistance → Tickets
  2. Click “Add”
  3. Assign to appropriate technician or group
  4. Set priority and category

Ticket Workflow

  1. New - Ticket created
  2. Assigned - Assigned to a technician
  3. In Progress - Work has started
  4. Pending - Waiting on external input
  5. Solved - Issue resolved
  6. Closed - Ticket archived

SLA Configuration

Set up Service Level Agreements:

  1. Navigate to Setup → SLAs
  2. Create SLA levels (e.g., Critical: 4 hours, Normal: 24 hours)
  3. Define escalation rules
  4. Assign SLAs to ticket categories or priorities

Reporting and Analytics

GLPI provides comprehensive reporting capabilities:

Built-in Reports

Access reports via Tools → Reports:

  • Asset inventory reports
  • Ticket statistics
  • Software license compliance
  • Contract and warranty reports
  • User activity reports

Custom Reports

Create custom reports using the report builder:

  1. Navigate to Tools → Reports → Custom Reports
  2. Select data sources (assets, tickets, users)
  3. Choose fields and filters
  4. Configure grouping and sorting
  5. Generate and export reports (PDF, CSV, Excel)

Dashboard Widgets

Customize your dashboard with widgets:

  • Ticket statistics by status
  • Recent tickets
  • Asset counts
  • License expiration alerts
  • Contract renewals

Troubleshooting

Cannot Access GLPI Application

Symptoms: Browser shows connection error or timeout

Solutions:

  • Verify your app is running in the Klutch.sh dashboard
  • Check that the internal port is set to 80
  • Ensure HTTP traffic type is selected
  • Review application logs for startup errors
  • Verify environment variables are set correctly

Database Connection Errors

Symptoms: GLPI shows “Database connection failed” or similar errors

Solutions:

  • Verify database credentials in environment variables
  • Check database host and port are correct
  • Ensure database server is running and accessible
  • Test database connectivity from a temporary container
  • Verify database user has proper permissions
  • Check if database exists and is properly initialized

File Upload Failures

Symptoms: Cannot upload documents or attachments to tickets

Solutions:

  • Confirm persistent volume is attached at /var/www/html/files
  • Check volume has sufficient free space
  • Verify file permissions on files directory (chmod 755)
  • Review PHP upload limits in environment variables
  • Check Apache error logs for permission issues

Session Timeout Issues

Symptoms: Users are logged out frequently

Solutions:

  • Increase session timeout in GLPI settings
  • Verify session storage directory has proper permissions
  • Check that /var/www/html/files/_sessions directory exists
  • Ensure persistent volume is properly mounted

Slow Performance

Symptoms: Slow page loads, timeouts, or unresponsive interface

Solutions:

  • Monitor CPU and memory usage in Klutch.sh dashboard
  • Consider increasing compute resources
  • Review and optimize database queries
  • Clear GLPI cache: Delete contents of /var/www/html/files/_cache
  • Check for slow database queries in MySQL slow query log
  • Ensure adequate storage I/O performance
  • Review Apache and PHP-FPM logs for bottlenecks

Email Notifications Not Working

Symptoms: Users not receiving email notifications

Solutions:

  • Verify SMTP settings in GLPI configuration
  • Test SMTP connection from GLPI settings
  • Check email logs in GLPI
  • Verify sender email is authorized by SMTP provider
  • Check for rate limiting or quota issues
  • Ensure TLS/SSL encryption is configured correctly

Plugin Installation Fails

Symptoms: Plugins fail to install or enable

Solutions:

  • Check plugin compatibility with your GLPI version
  • Verify write permissions on /var/www/html/plugins directory
  • Review PHP error logs for specific issues
  • Ensure sufficient memory allocation for plugin installation
  • Try manual installation method

Inventory Agent Not Connecting

Symptoms: FusionInventory agents not reporting inventory

Solutions:

  • Verify agent can reach GLPI server URL
  • Check firewall rules allow agent communication
  • Confirm plugin is properly installed and configured
  • Review agent logs on client machines
  • Verify API credentials if using token authentication

Upgrading GLPI

To upgrade GLPI to a new version:

Step 1: Backup Before Upgrading

Critical: Always backup before upgrading:

  1. Create a snapshot of your persistent volumes
  2. Export your database:
    Terminal window
    mysqldump -h $DB_HOST -P $DB_PORT -u $DB_USER -p$DB_PASSWORD $DB_NAME > glpi-backup-$(date +%F).sql
  3. Store backup in a secure location

Step 2: Update Dockerfile

Modify your Dockerfile to use the new GLPI version:

# Change from:
ARG GLPI_VERSION=10.0.11


# To:
ARG GLPI_VERSION=10.0.12

Step 3: Deploy Update

Terminal window
git add Dockerfile
git commit -m "Upgrade GLPI to version 10.0.12"
git push

Klutch.sh will automatically rebuild and redeploy your application. Your data will be preserved in the persistent volumes and database.

Step 4: Run Database Migration

After deployment, access GLPI. If a database migration is needed, GLPI will automatically detect it and prompt you to run the upgrade script.

Step 5: Verify Upgrade

After deployment:

  1. Access your GLPI installation
  2. Check version in Setup → General
  3. Verify all features work correctly
  4. Test critical functions (tickets, assets, plugins)
  5. Review application logs for any errors

Scaling GLPI for Growth

Horizontal Scaling

For high-traffic deployments:

  1. Separate Database: Move to a managed MySQL service with read replicas
  2. Load Balancer: Deploy multiple GLPI instances behind a load balancer
  3. Shared Storage: Use network file system (NFS) or object storage for shared files
  4. Session Management: Configure database-backed sessions for multi-instance deployments
  5. Cache Layer: Implement Redis or Memcached for application caching

Vertical Scaling

Increase resources as needed:

  • Start with 1GB RAM, 1 vCPU for small organizations (< 100 users)
  • Scale to 2-4GB RAM, 2 vCPUs for medium organizations (100-500 users)
  • Use 4-8GB RAM, 4+ vCPUs for large organizations (500+ users)

Performance Tuning for Scale

  • Enable MySQL query cache
  • Use PHP-FPM with appropriate worker processes
  • Configure Apache MPM for optimal performance
  • Implement CDN for static assets
  • Use database connection pooling
  • Enable OPcache with adequate memory allocation

Additional Resources

Conclusion

Deploying GLPI on Klutch.sh with Docker provides a robust, scalable IT asset management and service desk solution for your organization. By following this guide, you’ve set up a production-ready GLPI instance with proper database configuration, persistent storage, plugin support, and security best practices. Your IT service management platform is now ready to handle asset tracking, help desk ticketing, inventory management, and comprehensive reporting while maintaining full control over your IT infrastructure data and operational processes.