Why a GLPI 12 upgrade needs a staged plan before anyone runs db:update
If your GLPI installation runs on 10.x or 11.x and holds tickets, assets and user records, moving to GLPI 12.0.0 (released October 7, 2026) is a planned change to the whole platform, not a file swap. The application, PHP runtime, database server, installed plugins and encryption keys all move together, and each one can block the others. Treat the upgrade as a change project with a rehearsal on a copy of production, a rollback path and named owners for each component. The upgrade is harder than it looks for three reasons. First, GLPI suspends plugins once it detects a new version, so every plugin your service desk depends on, including any custom or marketplace plugin, will be inactive until someone confirms it works with 12.0.0 and reactivates it. Second, the configuration keys, including glpi.key and glpicrypt.key, must survive the move unchanged, because data encrypted with them becomes unreadable if they are lost or regenerated. Third, the 12.0.0 changes to the knowledge base and session handling affect people directly: the knowledge base has been rewritten, administrators can view and revoke active user sessions, and step-up authentication applies to certain administrative actions. Support staff, knowledge authors and administrators all need to know what will look different on day one. Decisions to make before the copy is built Before touching the staging server, decide which plugins you will keep, which you will replace and which you will retire, and confirm with each plugin's publisher whether a 12.0.0 build exists. Check the PHP and database versions on the current server against the 12.0.0 requirements in the GLPI README, which list PHP 8.3 or later and MariaDB 10.11 or later or MySQL 8.0 or later. Decide who approves knowledge base content migration, who will test the new session view and step-up prompts, and whether the web server document root will be moved to the public directory during the same window. The general update procedure, including backups, file replacement and the db:update command, is covered on the GLPI upgrades and support page. This section focuses on the planning that is specific to 12, so use that page for the step-by-step commands and this one to decide what must be ready before those commands are run. Risks to plan for The most common failure is a plugin that loads under 11.x but breaks on 12.0.0 after activation, leaving tickets or asset forms partly broken for users. Plan a test script that creates and closes a ticket, updates an asset, runs an inventory import and sends a notification, then run it against the staging copy with every plugin reactivated one at a time. A second risk is discovering a missing key backup only after the upgrade starts. Confirm that copies of glpi.key and glpicrypt.key exist outside the server, that someone has verified they match the running instance, and that the rollback plan includes restoring the database and files taken before the change.
Which GLPI 12 components and settings the upgrade touches
GLPI 12 touches the PHP and database versions, the web server layout, the encryption key files, plugin state, the knowledge base and the session controls. The cards below group these items so each one can be checked on a staging copy before the production window.
PHP and database versions
The GLPI README on the main branch requires PHP 8.3 or later and MariaDB 10.11 or later, or MySQL 8.0 or later. The GLPI 11.0 installation docs list PHP 8.2 or later with MySQL 8.0 or MariaDB 10.6, and state that only MySQL and MariaDB are supported. Confirm the exact PHP, MariaDB and MySQL versions in the release notes for your target build, then check the PHP extensions, server and database against them before any application files are replaced.
Web server document root
GLPI runs on Apache, Nginx, lighttpd or IIS. The installation docs require the document root to point to the public directory inside the GLPI installation, and URL rewriting must route requests through index.php. Check this setting during the cutover plan, because a document root that points at the installation root can expose configuration and files directories. After the change, test that direct requests to those paths are refused.
glpi.key and glpicrypt.key files
The config directory holds glpi.key and glpicrypt.key, which GLPI uses for encryption. The update procedure requires backing up the config directory before application files are replaced, and a missing or mismatched key may leave data that GLPI encrypts unreadable. Store copies of both files outside the server, and confirm that a restore from backup returns the same key files before you run db:update on the production copy.
Installed plugins
Since GLPI 11.0, plugins are suspended after GLPI detects a new version, and they must be reactivated after major updates. Build a plugin inventory from the staging copy and record each plugin version. Confirm with each publisher whether a release supports GLPI 12 before you reactivate it. Plugins without a compatible version become blocking items, so decide which ones to retire, replace or keep before the production window.
Rewritten knowledge base
The GLPI 12.0.0 release notes list a rewritten knowledge base. Inventory every custom article template, public FAQ page and integration that reads knowledge base data, then test each one on the staging copy after db:update. Confirm with the project and your partner which content, permissions and visibility settings migrate as they are and which need manual review, and check the answer against the release notes for your target build.
Active session view and revocation
GLPI 12.0.0 adds a view of active user sessions with the ability to revoke them, and it adds step-up authentication for certain administrative actions. Review which accounts hold administrator sessions, how long sessions last, and which service or automation accounts a forced revocation would affect. Test step-up prompts with the admin profiles your staff use, and confirm whether any scheduled or scripted task would need interactive confirmation.
Which upgrade path, host model and plugin strategy fit your environment
This table compares the main ways to reach GLPI 12: upgrading in place, building a new server, running the official Docker image, and sequencing the move before or after plugin updates. Read each row against your instance size, plugin count and team skills, then confirm timing with your vendor and your own staging results.
| Option | When it fits | Operational cost | Watch for |
|---|---|---|---|
| In-place upgrade on the existing server | Small instance with few plugins, all of them known to support GLPI 12, and a maintenance window the business accepts | Downtime while files are replaced and db:update runs; rollback means restoring database, files and config from backup | Reverting files without restoring the matching database leaves the instance inconsistent |
| New server, then migrate data | Aging operating system or PHP stack, or an instance you want to rebuild with the PHP 8.3 and MariaDB 10.11 prerequisites already in place | Extra build and staging effort; downtime limited to final data sync and cutover; old server kept as fallback | Document root, URL rewriting, cron and mail collectors must be recreated and tested on the new host |
| Official GLPI 12 Docker image | Team already runs containers and can manage persistent volumes for files, config and the database connection | Requires container and volume skills; upgrades become image changes; rollback is redeploying the previous image with its data | Confirm which volumes hold glpi.key and glpicrypt.key and that they persist across image replacement |
| Upgrade to 11.x first, then 12 | Instance is on GLPI 10 or an early 11.x release and needs a stepped path to reach 12 | Two upgrade cycles and two rounds of plugin checks; more staging runs but smaller changes per step | Confirm the supported upgrade sequence with the GLPI release notes before scheduling |
| Plugins updated before the core upgrade | Plugins have published GLPI 12 compatible versions and custom plugins have been tested against 12 in staging | Plugin vendors or internal developers must deliver first; core upgrade carries less risk per change | Plugin changes can break on the current core version, so keep the old plugin versions for rollback |
| Core upgrade first, then plugin reactivation | Plugins are mature, well documented, or a fast core move is needed and plugins can be reactivated after testing | GLPI suspends plugins after a new version is detected, so users lose plugin functions until each is reactivated and tested | Schedule time for reactivation checks and confirm each plugin's status with its author |
| Team skills required | Admins comfortable with Linux, PHP, web server configuration and console commands can run in-place or new-server paths | Container path needs platform engineers; in-house admins may need training or a partner for the first run | Ask any partner which tasks they will perform and which your staff must own after go-live |
| Staging effort | Every path benefits from a staging copy of database and files before production is touched | Staging needs production-sized data, a restored config directory and a dry run of db:update | Staging with stale data or missing encryption keys gives results that do not predict production |
How to plan and rehearse the GLPI 12 upgrade on a staging copy
This sequence takes a production GLPI instance through a rehearsed upgrade on a staging copy before anything changes in production. Each step closes with a named check, so the team knows which evidence to keep and which findings must be resolved before cutover.
Inventory versions, plugins and configuration
Record the current GLPI version, the PHP and database versions, the web server, every installed plugin with its version, and the contents of the config directory. The platform or service desk administrator owns the inventory, and a partner reviews it if the work is scoped as a fixed engagement. The step is complete when the starting version is confirmed by running php bin/console version on the production host and every plugin has a named owner and a known source. Plugins that cannot be matched to a release supporting GLPI 12 become separate work items before any staging copy is built.
Check PHP and database against 12.0.0 requirements
Compare the running PHP and database versions with the requirements for GLPI 12.0.0. The GLPI README on the main branch lists PHP 8.3 or later and MariaDB 10.11 or later, or MySQL 8.0 or later, and the prerequisites page for the target release should be read alongside it. Older GLPI 11 documentation lists lower versions, so confirm the table for the exact release you are installing. The check passes when the PHP command line and the web server's PHP runtime both report a supported version and the database server reports a supported version. Record the output of php -v and the database version query, because the command line and web runtime can differ.
Confirm document root and rewrite rules
Confirm that the web server serves GLPI from the public directory inside the installation, and that requests are routed through index.php using the rewrite rules the installation documentation describes for Apache, Nginx, lighttpd or IIS. The web server team makes the change on staging first, then carries the same configuration into production. The check has two parts: a syntax test of the web server configuration, and a browser request to the login page that loads without errors while a direct request for a file in the config directory is refused. Keep the test results with the change record.
Build the staging copy from fresh backups
Take a new database dump and a file backup of the production instance, then restore both onto a separate staging host with the same PHP and database stack. Staging must not point at production's database or file storage, because the upgrade writes to both. The platform team performs the restore, and the service desk owner confirms the data set is sufficient for testing. The check is a login with a test administrator account and a spot check of tickets, assets and users against production, confirming the data matches the backup. Staging should still report the starting version before the upgrade begins.
Back up and verify encryption keys
Copy glpi.key and glpicrypt.key from the config directory to a secure location separate from the database and file backups, and record their checksums. Restore those copies to a scratch host and confirm the application can read them, because a lost or unreadable key can make fields encrypted by GLPI unrecoverable. Limit access to the key copies to named administrators. The check is a restored key test: decrypt a known encrypted field, such as a stored credential, using the restored keys and confirm the value matches what production shows. Do not proceed to file replacement until this test passes.
Replace application files and run db:update
On staging, replace the application files with the GLPI 12.0.0 release without overwriting the key files or local configuration in the config directory, and review any local customizations against the new release. Run php bin/console db:update from the installation root and let it complete without interruption. The platform engineer runs the job and keeps the output in the change record. The check is the output of php bin/console version reporting 12.0.0, a db:update log with no failed migrations, and a login test that loads the dashboard without errors. If a migration fails, restore the staging snapshot and investigate before repeating the run.
Reactivate plugins one at a time
After an update to a new version, GLPI suspends plugins until they are reactivated, so each plugin must be enabled deliberately. Check each plugin against its vendor or marketplace listing for GLPI 12.0.0 compatibility, then reactivate them one at a time in a fixed order, starting with plugins that other customizations depend on. The plugin owner signs off each activation. The check is a plugin status review after every activation, recording the state, the version and any errors in the logs, followed by a test of the workflow that plugin supports. Any plugin without a compatible release stays inactive, and its replacement is planned before cutover.
Rehearse the cutover and record evidence
Run the full sequence from inventory to plugin reactivation at least once more on a fresh staging copy, following the written runbook without improvisation. Include the session and step-up authentication features introduced in GLPI 12.0.0, testing how the active session view and session revocation behave for your administrators and how step-up prompts appear for the administrative actions you rely on. The check is a rehearsal log showing the same version output, key test, login test and plugin reviews as the first run, with every deviation recorded. The change board approves the production window only after a clean rehearsal.
What the new GLPI 12 knowledge base and session controls change for your users and admins
The GLPI 12.0.0 release notes list three changes that affect people in daily use: a rewritten knowledge base, a view of active user sessions with the ability to revoke them, and step-up authentication for certain administrative actions. Each one touches a different group. Helpdesk staff will notice the knowledge base first when they search for answers while working tickets. Knowledge authors will feel the change in how they create and maintain articles. Administrators will see new session and authentication behaviour, and end users may meet a new prompt when an action requires extra verification. The release notes describe what changed at a feature level, so your team needs to confirm the detail in its own environment before assuming how any screen behaves.
For helpdesk staff and knowledge authors, the first task is to list every workflow that depends on the knowledge base today. That includes article categories, visibility settings, links from ticket forms or templates, and any reporting or search habits that rely on the current layout. Because the knowledge base has been rewritten, existing articles should be opened, searched and linked on a staging copy with a representative set of profiles. Confirm which article fields survive migration, whether attachments and internal-only content behave as before, and whether any custom links or bookmarks still resolve. Ask the GLPI 12 release notes and the project documentation which parts of the editing experience changed, and record any gap before go-live.
For administrators, the session view and revocation feature changes how you respond to a lost laptop, a departing employee or a suspicious login. Test it with real accounts on staging: sign in from two browsers, confirm that both sessions appear in the view, revoke one, and check that the revoked session is actually forced out. Also check how the view behaves for users in different entities, since your profiles and entity structure determine who can see or act on other people's sessions. Step-up authentication for certain administrative actions may affect scripted or delegated work, including service accounts, API clients, plugin screens and any runbook that expects a single login to cover a sequence of changes. Identify which actions trigger the extra check, who needs to complete it, and whether automation is affected.
Customizations and documentation need the same scrutiny. Review custom templates, CSS or JavaScript changes, plugin screens that add administrative actions, and internal guides that describe how to revoke access or perform privileged tasks. Any of these may describe steps that no longer match the interface. End users should also be tested, because a step-up prompt or changed session behaviour can appear in a self-service portal where people have less context than administrators. Plan a short test script for each profile and entity, record results, and update the internal guide before cutover. Confirm each behaviour with the release notes, the GLPI documentation and your own staging results rather than relying on this summary.
What drives the effort and cost of a GLPI 12 upgrade
This table lists the factors that most change the work of a GLPI 12 upgrade and the steps that keep each one manageable. Read it as a checklist to run against your own instance before asking for a quote. The biggest levers are the plugin inventory, the size of your data, and how many environments you need to test in.
| Driver | Why it changes effort | How to keep it down |
|---|---|---|
| Installed plugins | Each plugin must be checked for GLPI 12 compatibility, and plugins are suspended after a new version is detected until reactivated. Marketplace plugins and custom plugins carry different levels of compatibility risk. | Remove unused plugins before the upgrade. Confirm each remaining plugin's GLPI 12 status with its publisher or author, and list custom plugins for code review. |
| Database size and history | Larger databases take longer to back up, copy, and migrate with db:update. Long history increases the chance of legacy data that needs cleanup. | Archive or purge stale tickets and logs where your retention policy allows. Test db:update on a copy of production data to measure the run time in your environment. |
| Entities and profiles | Each entity, profile and access rule must be checked after the upgrade so that users keep the right visibility and rights. | Document the current entity tree and profile matrix before the upgrade. Use the same matrix as the test checklist. |
| Custom templates, business rules and forms | Ticket templates, business rules, forms and notifications may behave differently after the upgrade and each one needs a functional test. | Export and inventory these objects. Test the most used ones first, and remove duplicates or outdated rules. |
| Integrations (LDAP, mail collectors, agents) | LDAP authentication, IMAP or mail collectors, and GLPI Agent inventory all depend on the server configuration and must be retested after the upgrade. | List each integration with its owner and test account. Verify LDAP sync, collector polling and agent check-ins on staging before cutover. |
| Number of environments | Each environment (staging, test, production) needs its own copy, configuration and test run, so effort grows with each added environment. | Keep one representative staging copy and one production-like test run. Use the same runbook for each run so results are comparable. |
| Encryption keys and backup scope | Losing glpi.key or glpicrypt.key can make encrypted data unusable, so backup, storage and restore checks add work before any change. | Back up the database, files and config directory including the key files before starting. Prepare a documented restore test as part of the plan. |
| Compliance evidence needs | Auditors or internal reviewers may need change records, test results, approvals and before and after configuration evidence. | Agree the evidence list before the work starts. Record test results and approvals in the change ticket as the work proceeds. |
How the GLPI 12 upgrade differs on a single server, split servers and Docker
On a single server, the web server, PHP and database share one host, so the upgrade is simplest to sequence but easiest to get wrong in the rollback plan. A full host snapshot plus a database dump and a copy of the GLPI files gives you a restore point that matches the current state. Keys and configuration sit in the GLPI installation tree, so they travel with the application files when you replace them.
- Rollback: Take a VM or disk snapshot before replacing files, and keep a separate database dump so you can restore data without reverting the whole host.
- Keys: Copy glpi.key and glpicrypt.key out of the installation tree before you replace any files, and store them apart from the update workspace.
- Document root: Confirm that your virtual host still points to the public directory after the new files are in place.
- Staging: Clone the VM or copy files and the database to a second host, then run php bin/console db:update there first.
- Plugins: Expect plugins to be suspended after the new version is detected, and reactivate them only after checking compatibility.
Before go-live, confirm that PHP 8.3 and MariaDB 10.11 or later are installed on the staging host, because the upgrade will not proceed on older runtimes.
With separate web and database servers, the upgrade touches two hosts that must stay in step. The web node holds the application files and keys, while the database node holds the data, so a restore point is only useful if both halves come from the same moment. Plan the rollback as a paired operation rather than two independent ones.
- Rollback: Snapshot both hosts together, and dump the database at the same point you back up the web node's files.
- Keys: Keep glpi.key and glpicrypt.key on the web node with the rest of the configuration, and record a checksum so you can confirm they match after restore.
- Document root: Set the document root to the public directory on the web node only. The database server has no web root to configure.
- Staging: Build the staging copy from a database dump and a file copy taken from the same run, and point the staging web node at the staging database.
- Database access: Confirm that the staging web node can reach only the staging database, so that db:update never runs against production data.
If your layout uses more than one web node behind a load balancer, or database replication, plan that work with the GLPI high availability page first, because those changes affect where sessions and shared files live during the upgrade.
GLPI 12.0.0 lists an official Docker image among its distribution options. In a container deployment, application code lives in the image, while persistent data, configuration and keys must live in mounted volumes. Rollback is therefore a matter of switching image tags and volumes, provided that the data layer was preserved. Confirm the image tag, the volume layout and the required environment variables against the official image documentation before you write the runbook, because these details can change between releases.
- Rollback: Keep the previous image tag available, and restore the database dump if the new version has already written schema changes.
- Keys: Confirm which path the image expects for glpi.key and glpicrypt.key, and make sure that path sits on a persistent volume rather than inside the container layer.
- Document root: The image defines how the public directory is served, so do not change the web server configuration inside the container without checking the image documentation.
- Staging: Start a second container set with copies of the database and volumes, on different ports or a separate network.
- Updates: Replace the image rather than patching files inside a running container, so that the deployed state can be reproduced from the image tag and the volumes.
Run db:update through the procedure documented for the image, and verify that plugins and the key files are in the expected volumes before you retire the old containers.
How to test a GLPI 12 upgrade and confirm it fails safely
The purpose of staging acceptance is to decide, before production is touched, whether the GLPI 12 upgrade is good enough to keep and whether the pre-upgrade system can be brought back if it is not. Both answers need evidence, so the test plan should be written and agreed before the staging copy is upgraded. Run it on a copy restored from a production backup taken on the same day, with the same PHP 8.3 and MariaDB 10.11 or later versions you intend to use in production, so that results carry over. Start with access. Log in with a test account for each authentication source in use, in the order GLPI tries them: internal database, LDAP directory, IMAP mail server and any external method such as REMOTE_USER through a reverse proxy. Confirm that each account lands in the expected entity and profile. Next, run a restored key check. Open a record that holds an encrypted stored value, such as a mail collector or LDAP bind password, and confirm it still decrypts. A failure here usually means glpi.key or glpicrypt.key was not restored with the database and files, which is the most common reason an upgrade appears to succeed and then breaks integrations. Then sample the data. Open a set of tickets across several statuses and categories, a set of assets from each inventory type, and a set of knowledge base articles, including articles migrated or edited under the rewritten knowledge base. Check attachments, linked items and visibility rules, not just whether the page loads. Check plugin status in the administration area, confirm that each plugin you depend on has been reactivated after the update, and test its main function with a real workflow rather than only its settings page. Confirm that scheduled tasks run, that the agent check-in times show new inventory, and that a test ticket generates the expected notification. The rollback rehearsal is the part most often skipped, and it should be run on staging after the acceptance tests pass. Restore the pre-upgrade database, the files and the key files from the same backup set, point the web server back at the old application directory, and confirm the old version serves login, ticket lists and asset pages. Record the time each step takes. A rehearsal that cannot be completed within the change window is a finding in its own right. For change control, keep a short evidence pack: the test plan with named testers, the GLPI and PHP versions before and after, the backup identifiers and checksums, a table of each acceptance test with pass or fail and the tester's initials, screenshots or log extracts for the key check and notifications, the plugin list with versions, and the rollback rehearsal log. Ask the auditor or change board which items they require and agree the go or no-go criteria in writing before the production window.
How to protect keys, sessions and admin actions during the upgrade
A GLPI 12 upgrade changes the files, database and administrator access that protect your instance, so the same controls need to hold before and after the move. The cards below cover key custody, web root placement, session and step-up settings, update rights and plugin review, each with a check your team can run.
Store encryption keys in a controlled secret store
The glpi.key and glpicrypt.key files protect encrypted data in the database, so losing them makes that data unreadable after a restore. Place both in a secret store with named read access, log every read, and keep a separate backup of each key outside the database and file backups. Verify by restoring a staging copy using only the separate key backup and confirming that encrypted fields decrypt.
Keep the config directory outside the web root
The config directory holds database credentials and key references, so it must not be served over HTTP. Move it to a path that the web server cannot map to a URL and confirm that the file system permissions allow only the service account to read it. Verify by requesting a config file URL from outside the network and confirming that the server returns no content.
Confirm the document root targets the public directory
GLPI requires the web server document root to point to the public directory rather than the installation root, with URL rewriting routing requests through index.php. After the file replacement, check the server configuration for Apache, Nginx, lighttpd or IIS, since a stale path can expose source and configuration files. Verify by requesting files in the installation root and confirming they are not reachable.
Plan session revocation for administrators
GLPI 12 adds a view of active user sessions with the ability to revoke them, which changes how quickly an administrator can cut off a compromised account. Decide who may revoke sessions, which roles are covered, and how revocations are logged in your ticketing or audit process. Verify by revoking a test administrator session on staging and confirming the next request is rejected.
Configure step-up authentication for admin actions
GLPI 12 introduces step-up authentication for certain administrative actions, so a session alone may not be enough for sensitive changes. Confirm which actions trigger the prompt in your release, agree the authentication factor that satisfies it with your identity team, and document the exceptions. Verify by attempting each listed action with a fresh session and confirming the prompt appears before the change is saved.
Limit who can run db:update
The db:update command migrates the schema and can change data that every user depends on, so the right to run it should be a named, short list of operators. Restrict shell access to the application server, require a change record for each run, and capture the console output. Verify by checking the access list on the server and confirming that each run on staging and production has a matching record.
Review plugin sources before reactivation
Since GLPI 11.0, plugins are suspended when a new version is detected and must be reactivated after a major update, which makes reactivation a deliberate security gate. Before enabling each plugin, confirm its source, its version against the GLPI 12 release, and whether its code was changed locally. Verify by comparing each plugin's checksum or source tag with the approved record before reactivating it on staging.
What to monitor, back up and document after the GLPI 12 upgrade
The upgrade is not finished when the login page loads on 12.x. The first weeks on the new version decide whether the team trusts the platform, so the operating routine should be written down before cutover. Keep the pre-upgrade backup, including the database, the application files and the config directory with glpi.key and glpicrypt.key, until the new version has run through a full business cycle. For most service desks that means a complete month-end or quarter-end pass, covering ticket closure, contract renewals and reporting. Restoring from that backup is the only clean rollback path if a defect appears late, so the retention date should be set as a decision, not left to whoever reclaims disk space first.
Watch the logs for the first several weeks. Review the PHP error log for the web server and PHP-FPM, and the GLPI application logs, for deprecation notices, fatal errors and plugin warnings that did not appear on 11.x. On the database side, check the MariaDB or MySQL error log and slow query log for new warnings after the db:update run. Set a short recurring review rather than relying on users to report failures. Agree who owns each log, how often it is read, and what severity opens an incident.
Confirm that the background work still runs. Check the scheduled tasks (crontab-driven GLPI cron) for failures or tasks that stopped running, because a silent cron failure leaves notifications, SLA escalations and inventory cleanup undone without any visible error on the front end. Test each mail collector by sending a test ticket to the collector address and confirming it arrives. Track GLPI Agent check-ins against the expected device count, since a drop in reporting agents often signals a network, certificate or endpoint-configuration problem introduced during the move. Plugin updates need the same discipline: list every installed plugin, its version, and whether the vendor or author has confirmed compatibility with 12.x. Plugins were suspended during the major update and must already have been reactivated, so verify their state again after each plugin update.
Record the operating facts in the runbook while they are fresh. The record should include the installed GLPI 12.x version and PHP and database versions, the document root path, the location of the config directory and both key files, the backup locations and restore procedure, the cron and mail collector settings, the plugin inventory with versions, and the step-by-step rollback. Keep the key files out of ordinary file-share backups and document who may access them. On patching, the GLPI release history shows a steady cadence of point releases on the 11.x line, for example 11.0.11 on October 1, 2026. Ask your vendor or support provider to confirm the patch policy for 12.x, including how security fixes are delivered, how long older lines receive support, and what testing they expect before a patch goes to production. Put the answer into the runbook.
Questions teams ask before a GLPI 12 upgrade
Can a GLPI 11.x instance move directly to GLPI 12?
Confirm this in the GLPI 12 release notes and update documentation before you plan the path, because a direct jump depends on your exact 11.x build. The GLPI 12.0.0 release was published on October 7, 2026, and 11.0.11 on October 1, 2026, so record which 11.x version you run now. Check the prerequisites first: the GLPI README lists PHP 8.3 or later and MariaDB 10.11 or later, or MySQL 8.0 or later. Confirm that the web server's document root points to the public directory and that every installed plugin has a version compatible with GLPI 12. Test the path on a staging copy with a full backup of the database, files and config directory, including glpi.key and glpicrypt.key, and run php bin/console db:update there first. Record the version at each step so the rollback point is clear.
What does a GLPI 12 upgrade cost and what drives it?
A GLPI 12 upgrade has no standard price, so the figure comes from the written scope. A quote should cover planning and prerequisite checks, the staging copy and test run, plugin review and reactivation, backup and rollback design, cutover, and post-upgrade verification. The main drivers are the number of plugins and customizations, the size of the database and file store, whether the web server, PHP or database must be upgraded first, the number of environments, and how many integrations such as LDAP, mail collectors or GLPI Agent need retesting. Ask the provider to price each phase separately and to state which items are one-time and which recur, such as later upgrades or support. GLPI itself is distributed under GPL-3.0. GLPI Network subscriptions from Teclib' are a separate purchase and do not change the cost of the upgrade work. DeployOpen does not publish a price list; a quote follows from the written scope.
How long does a GLPI 12 upgrade take from start to finish?
There is no standard duration, so the schedule should come from the written plan for your environment. The timeline depends on the number of environments (production, staging and test), the volume of data and files to back up and restore, the number and condition of plugins, any prerequisites that must be upgraded first, and how many integrations need retesting. Plan time for a staging rehearsal before the production window, because the first db:update often exposes plugin or configuration issues that take time to resolve. Also allow for your change approval steps and for users to verify their workflows after cutover. Ask the provider to show the phases, the dependencies between them and the items on the critical path. In a fixed-scope engagement, scope, deliverables and timelines are agreed in writing before work starts.
What does a GLPI 12 upgrade need from our internal staff?
Four roles are usually needed: a business owner who approves scope and the cutover date, a systems administrator with access to the web, PHP and database servers, a database administrator who can run backup and restore checks, and a service desk owner who can test tickets, assets, notifications and any plugin workflows. Someone should also control DNS, certificates and the cron and mail collector schedules. Staff will typically provide access, a maintenance window, test accounts, a list of plugins and custom fields in use, and sign-off on test results. Make sure the encryption keys, glpi.key and glpicrypt.key, are stored in a secure, known location, because encrypted data depends on them after a restore. Ask the provider which tasks it performs and which it expects your team to perform, and ask the quote to state the internal time required.
Can an internal team upgrade GLPI 12 without an outside partner?
Yes, if the team has the skills and time to run the procedure carefully. The official update steps require backing up the database, files and config directory, replacing the application files, and running php bin/console db:update. The team needs working knowledge of Linux web servers, PHP configuration, MariaDB or MySQL backup and restore, and GLPI administration, including plugins. Teams that have not performed a major upgrade before often benefit from outside help with the staging rehearsal, plugin review and rollback planning. Before you decide, confirm that someone can complete a restore test on a staging copy, because a backup that has never been restored is unproven as a rollback plan. Assign plugin decisions and final sign-off to named people. If capacity is the constraint, a fixed-scope engagement can cover specific phases while your team keeps ownership of the platform.
What happens to plugins and encryption keys if upgrade steps are skipped?
Skipped steps can leave plugins disabled and encrypted data unreadable. Since GLPI 11.0, plugins are suspended after GLPI detects a new version and must be reactivated after major updates. If nobody checks reactivation, features such as custom forms or integrations may stop working until a user reports the problem. Without a copy of glpi.key and glpicrypt.key, a restored instance may be unable to decrypt stored secrets, so backing up the config directory is essential. Skipping the staging run means the first db:update happens in production, where plugin incompatibilities reach users directly. Backing up only the database, and not the files, leaves no consistent rollback point. Ask the provider to deliver the key backup location, the plugin compatibility list and the reactivation checklist as part of the work.
Do the new knowledge base and session controls require user retraining?
Some retraining is likely for knowledge base authors and administrators, and the amount depends on how each group uses these features. The GLPI 12.0.0 release notes list a rewritten knowledge base, a view of active user sessions with the ability to revoke them, and step-up authentication for certain administrative actions. Knowledge base authors and approvers should review the new editing and publishing flow before go-live. Administrators need to learn how to review and revoke sessions and when step-up authentication will prompt them, which can affect scripts and routine tasks. Service desk agents and end users who only read articles may see little change. Plan short role-based guides, a test script for each role and a notice to the service desk about new prompts. Confirm the exact behavior on your own test instance, because release notes describe features and do not replace hands-on testing.
Which PHP and database versions does GLPI 12 require before upgrading?
The GLPI README on the main branch lists PHP 8.3 or later and MariaDB 10.11 or later, or MySQL 8.0 or later. The installation docs for GLPI 11.0 list PHP 8.2 or later with MySQL 8.0 or MariaDB 10.6, so the GLPI 12 requirements are higher and must be checked against your current stack before scheduling. The docs also state that only MySQL and MariaDB are supported. Upgrading PHP can affect plugins, extensions and web server configuration, so test those together on staging. Confirm the full extension list in the prerequisites page for the release you plan to install. A database upgrade needs its own backup and a tested restore. Also confirm that the web server serves the public directory with URL rewriting to index.php, which the installation docs require on Apache, Nginx, lighttpd or IIS.
How DeployOpen scopes, rehearses and hands over a GLPI 12 upgrade
DeployOpen plans and carries out GLPI 12 upgrades inside infrastructure you control, starting from a written, fixed scope. The work moves through a rehearsal on a staging copy before production, and ends with documented steps, verified backups and a clear support arrangement.
How we scope
- Inventory your current GLPI version, PHP and database versions, web server and document root layout.
- List every installed plugin and record whether each has a GLPI 12 compatible release from its publisher.
- Agree the written scope, deliverables and timeline in writing before any change is made to production.
How we build
- Prepare PHP 8.3 and MariaDB 10.11 or MySQL 8.0 on a staging copy, then confirm the web server serves GLPI's public directory.
- Back up the database, files and config directory, including glpi.key and glpicrypt.key, and test that the backups restore.
- Replace the application files, run php bin/console db:update on staging, then reactivate and test each plugin before cutover.
How we hand over
- Deliver the rehearsed upgrade runbook with exact commands, rollback steps and the order of plugin reactivation.
- Document the new knowledge base set up and the session view and revocation controls, with the admin settings your team owns.
- Walk your administrators through the post-upgrade checks so they can repeat the steps for future releases.
How we support
- Confirm which post-go-live support, if any, is covered by the fixed-scope agreement and what is excluded.
- Offer ongoing upgrades, patching and support for GLPI as a retainer, scoped separately from the upgrade project.
- Ask your team to confirm the support contacts, maintenance window and plugin owners before the scope is signed.

