Migrer vers Prestashop 8 : guide complet

Tout ce qu'il faut savoir pour migrer votre boutique vers Prestashop 8 en toute sécurité sans perdre de données.

Prestashop 8 apporte des améliorations significatives en termes de performance, sécurité et modernité. Migrer votre boutique vers cette nouvelle version nécessite une préparation minutieuse pour éviter toute perte de données ou interruption de service. Ce guide complet vous accompagne dans chaque étape de la migration.

1. Pourquoi migrer vers Prestashop 8 ?

Prestashop 8 n'est pas qu'une simple mise à jour, c'est une refonte majeure qui apporte de nombreux avantages.

Nouveautés et améliorations

Symfony 5.4 - Framework moderne et performant
PHP 8.1 et 8.2 - Support des versions récentes de PHP
Performances optimisées - Temps de chargement réduit de 30%
Sécurité renforcée - Corrections de nombreuses vulnérabilités
Back-office modernisé - Interface plus intuitive
API améliorée - Meilleure compatibilité avec les outils tiers
Support étendu - Maintenance assurée jusqu'en 2028

Fin de support de Prestashop 1.7

Le support de Prestashop 1.7 prendra fin progressivement. Il est crucial de planifier votre migration pour continuer à recevoir les mises à jour de sécurité.

2. Prérequis avant la migration

Avant de commencer, assurez-vous que votre environnement répond aux exigences de Prestashop 8.

Configuration serveur requise

# Versions minimales
PHP: 8.1 (recommandé: 8.2)
MySQL: 5.7.7+ ou MariaDB: 10.2.7+
Apache: 2.4+ avec mod_rewrite
ou
Nginx: 1.18+

# Extensions PHP requises
- curl
- gd
- intl
- json
- mbstring
- openssl
- pdo_mysql
- zip
- xml
- bcmath
- sodium

Vérifier la compatibilité

<?php
/**
 * Script de vérification de compatibilité serveur
 */
class PrestaShop8CompatibilityChecker
{
    /**
     * Vérifier la compatibilité du serveur
     *
     * @return array Résultats des vérifications
     */
    public function checkCompatibility(): array
    {
        $results = [];

        // Vérifier la version PHP
        $results['php_version'] = [
            'required' => '8.1',
            'current' => PHP_VERSION,
            'compatible' => version_compare(PHP_VERSION, '8.1', '>=')
        ];

        // Vérifier les extensions PHP
        $requiredExtensions = [
            'curl', 'gd', 'intl', 'json', 'mbstring',
            'openssl', 'pdo_mysql', 'zip', 'xml', 'bcmath', 'sodium'
        ];

        foreach ($requiredExtensions as $ext) {
            $results['extensions'][$ext] = extension_loaded($ext);
        }

        // Vérifier MySQL
        $mysqlVersion = $this->getMysqlVersion();
        $results['mysql_version'] = [
            'required' => '5.7.7',
            'current' => $mysqlVersion,
            'compatible' => version_compare($mysqlVersion, '5.7.7', '>=')
        ];

        return $results;
    }

    /**
     * Récupérer la version MySQL
     *
     * @return string Version MySQL
     */
    private function getMysqlVersion(): string
    {
        try {
            $result = Db::getInstance()->getValue('SELECT VERSION()');
            return preg_replace('/[^0-9.]/', '', $result);
        } catch (Exception $e) {
            return 'unknown';
        }
    }

    /**
     * Générer un rapport de compatibilité
     *
     * @return string Rapport HTML
     */
    public function generateReport(): string
    {
        $results = $this->checkCompatibility();
        $html = '<h2>Rapport de compatibilité Prestashop 8</h2>';

        // PHP
        $phpStatus = $results['php_version']['compatible'] ? '✅' : '❌';
        $html .= "<p>{$phpStatus} PHP: {$results['php_version']['current']} (requis: {$results['php_version']['required']}+)</p>";

        // Extensions
        $html .= '<h3>Extensions PHP</h3><ul>';
        foreach ($results['extensions'] as $ext => $loaded) {
            $status = $loaded ? '✅' : '❌';
            $html .= "<li>{$status} {$ext}</li>";
        }
        $html .= '</ul>';

        return $html;
    }
}

3. Phase de préparation

Une préparation minutieuse est la clé d'une migration réussie.

Inventaire de votre boutique

Listez tous vos modules installés et vérifiez leur compatibilité PS8
Identifiez votre thème et vérifiez s'il existe une version PS8
Recensez vos overrides (classes surchargées)
Documentez vos customisations et développements spécifiques
Notez les configurations importantes

<?php
/**
 * Générer un inventaire de la boutique
 */
class ShopInventory
{
    /**
     * Lister tous les modules installés
     *
     * @return array Modules avec leurs versions
     */
    public function getInstalledModules(): array
    {
        $modules = [];

        $query = new DbQuery();
        $query->select('name, version, active')
            ->from('module')
            ->orderBy('name ASC');

        $results = Db::getInstance()->executeS($query);

        foreach ($results as $module) {
            $modules[] = [
                'name' => $module['name'],
                'version' => $module['version'],
                'active' => (bool)$module['active']
            ];
        }

        return $modules;
    }

    /**
     * Lister les overrides existants
     *
     * @return array Fichiers d'override
     */
    public function getOverrides(): array
    {
        $overrides = [];
        $overridePath = _PS_OVERRIDE_DIR_;

        $directories = ['classes', 'controllers'];

        foreach ($directories as $dir) {
            $path = $overridePath . $dir;

            if (is_dir($path)) {
                $files = $this->scanDirectory($path);
                $overrides[$dir] = $files;
            }
        }

        return $overrides;
    }

    /**
     * Scanner un dossier récursivement
     *
     * @param string $dir Dossier à scanner
     * @return array Fichiers trouvés
     */
    private function scanDirectory(string $dir): array
    {
        $files = [];
        $items = scandir($dir);

        foreach ($items as $item) {
            if ($item === '.' || $item === '..') {
                continue;
            }

            $path = $dir . '/' . $item;

            if (is_dir($path)) {
                $files = array_merge($files, $this->scanDirectory($path));
            } else {
                $files[] = str_replace(_PS_OVERRIDE_DIR_, '', $path);
            }
        }

        return $files;
    }

    /**
     * Exporter l'inventaire en JSON
     *
     * @param string $outputPath Chemin du fichier de sortie
     * @return bool Succès de l'export
     */
    public function exportInventory(string $outputPath): bool
    {
        $inventory = [
            'date' => date('Y-m-d H:i:s'),
            'ps_version' => _PS_VERSION_,
            'modules' => $this->getInstalledModules(),
            'overrides' => $this->getOverrides()
        ];

        return (bool)file_put_contents(
            $outputPath,
            json_encode($inventory, JSON_PRETTY_PRINT)
        );
    }
}

4. Sauvegarde complète

Créez une sauvegarde complète avant toute manipulation. C'est votre filet de sécurité.

Sauvegarde de la base de données

#!/bin/bash
# Script de sauvegarde complète

DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR="/backups/prestashop/migration_ps8"
DB_NAME="prestashop_db"
DB_USER="db_user"
DB_PASS="db_password"
SHOP_PATH="/var/www/html"

mkdir -p $BACKUP_DIR

# Sauvegarde base de données
echo "Sauvegarde de la base de données..."
mysqldump -u $DB_USER -p$DB_PASS $DB_NAME | gzip > $BACKUP_DIR/db_backup_$DATE.sql.gz

# Sauvegarde fichiers
echo "Sauvegarde des fichiers..."
tar -czf $BACKUP_DIR/files_backup_$DATE.tar.gz \
    --exclude='var/cache' \
    --exclude='var/logs' \
    -C $SHOP_PATH .

# Vérification des sauvegardes
if [ -f "$BACKUP_DIR/db_backup_$DATE.sql.gz" ] && [ -f "$BACKUP_DIR/files_backup_$DATE.tar.gz" ]; then
    echo "✅ Sauvegardes créées avec succès"
    ls -lh $BACKUP_DIR/*$DATE*
else
    echo "❌ Erreur lors de la création des sauvegardes"
    exit 1
fi

5. Environnement de staging

IMPORTANT : Ne migrez JAMAIS directement en production. Créez un environnement de test.

Créer un environnement de staging

Dupliquez votre installation sur un sous-domaine (staging.votreboutique.com)
Restaurez vos sauvegardes sur cet environnement
Mettez à jour les paramètres de configuration
Testez la migration sur cet environnement

<?php
/**
 * Mettre à jour les URLs après copie vers staging
 */
class StagingUrlUpdater
{
    /**
     * Mettre à jour les URLs de la boutique
     *
     * @param string $newDomain Nouveau domaine (ex: staging.votreboutique.com)
     * @return bool Succès
     */
    public function updateUrls(string $newDomain): bool
    {
        $oldDomain = Configuration::get('PS_SHOP_DOMAIN');

        // Mettre à jour les configurations
        Configuration::updateValue('PS_SHOP_DOMAIN', $newDomain);
        Configuration::updateValue('PS_SHOP_DOMAIN_SSL', $newDomain);

        // Mettre à jour les URLs dans la base
        $tables = [
            'shop_url' => 'domain',
            'shop_url' => 'domain_ssl'
        ];

        foreach ($tables as $table => $field) {
            $sql = 'UPDATE `' . _DB_PREFIX_ . $table . '`
                    SET `' . $field . '` = "' . pSQL($newDomain) . '"
                    WHERE `' . $field . '` = "' . pSQL($oldDomain) . '"';

            Db::getInstance()->execute($sql);
        }

        // Vider le cache
        $this->clearCache();

        return true;
    }

    /**
     * Vider le cache Prestashop
     */
    private function clearCache()
    {
        Tools::clearCache();
        Tools::clearSmartyCache();
        Tools::clearXMLCache();
        Media::clearCache();
    }
}

6. Processus de migration

La migration peut se faire via le module AutoUpgrade officiel ou manuellement.

Migration via AutoUpgrade (recommandé)

Téléchargez le module autoupgrade depuis l'Addons officiel
Installez-le dans /modules/autoupgrade/
Accédez au module : Paramètres avancés > Auto-upgrade
Configurez les options de migration
Lancez la migration

Configuration du module AutoUpgrade

<?php
// Configuration recommandée dans autoupgrade/config.xml
return [
    'channel' => 'major', // Pour migrer vers PS8
    'archive_prestashop' => '', // Laissez vide pour téléchargement auto
    'archive_num' => '8.0.0', // Version cible
    'skip_backup' => false, // Toujours faire un backup
    'deactivate_custom_modules' => true, // Désactiver modules non natifs
    'regenerate_email_templates' => false,
    'keepMails' => true,
    'manual_mode' => false
];

7. Gestion des modules incompatibles

Certains modules peuvent ne pas être compatibles avec Prestashop 8.

Vérifier la compatibilité des modules

<?php
/**
 * Vérifier la compatibilité des modules avec PS8
 */
class ModuleCompatibilityChecker
{
    /**
     * Vérifier si un module est compatible PS8
     *
     * @param string $moduleName Nom du module
     * @return array Informations de compatibilité
     */
    public function checkModuleCompatibility(string $moduleName): array
    {
        $module = Module::getInstanceByName($moduleName);

        if (!$module) {
            return ['error' => 'Module non trouvé'];
        }

        $compatibility = [
            'name' => $module->name,
            'version' => $module->version,
            'ps8_compatible' => false,
            'ps_min' => null,
            'ps_max' => null
        ];

        if (isset($module->ps_versions_compliancy)) {
            $compliancy = $module->ps_versions_compliancy;

            $compatibility['ps_min'] = $compliancy['min'] ?? null;
            $compatibility['ps_max'] = $compliancy['max'] ?? null;

            // Vérifier si compatible avec PS 8.x
            if (isset($compliancy['max'])) {
                $compatibility['ps8_compatible'] = version_compare($compliancy['max'], '8.0.0', '>=');
            }
        }

        return $compatibility;
    }

    /**
     * Générer un rapport de compatibilité pour tous les modules
     *
     * @return array Rapport complet
     */
    public function generateFullReport(): array
    {
        $report = [
            'compatible' => [],
            'incompatible' => [],
            'unknown' => []
        ];

        $modules = Module::getModulesInstalled();

        foreach ($modules as $moduleData) {
            $check = $this->checkModuleCompatibility($moduleData['name']);

            if (isset($check['error'])) {
                $report['unknown'][] = $check;
            } elseif ($check['ps8_compatible']) {
                $report['compatible'][] = $check;
            } else {
                $report['incompatible'][] = $check;
            }
        }

        return $report;
    }
}

Actions pour les modules incompatibles

Cherchez une version mise à jour sur Addons
Contactez le développeur du module
Trouvez une alternative compatible
Développez une migration personnalisée si critique
Désactivez le module si non essentiel

8. Adaptation du thème

Les thèmes Prestashop 1.7 nécessitent des ajustements pour fonctionner sous PS8.

Modifications courantes

Mettre à jour les templates Smarty
Adapter les hooks modifiés
Recompiler les assets (CSS/JS)
Tester tous les overrides de templates
Vérifier la compatibilité Webpack

<?php
/**
 * Vérifier les hooks du thème
 */
class ThemeHookChecker
{
    /**
     * Lister les hooks utilisés par le thème
     *
     * @param string $themeName Nom du thème
     * @return array Hooks trouvés
     */
    public function getThemeHooks(string $themeName): array
    {
        $themePath = _PS_ALL_THEMES_DIR_ . $themeName;
        $hooks = [];

        // Scanner les fichiers du thème
        $files = $this->getTemplateFiles($themePath);

        foreach ($files as $file) {
            $content = file_get_contents($file);

            // Chercher les hooks dans les templates
            preg_match_all('/\{hook h=[\'"]([^\'"]+)[\'"]/i', $content, $matches);

            if (!empty($matches[1])) {
                foreach ($matches[1] as $hook) {
                    if (!in_array($hook, $hooks)) {
                        $hooks[] = $hook;
                    }
                }
            }
        }

        return $hooks;
    }

    /**
     * Récupérer tous les fichiers template
     *
     * @param string $path Chemin du thème
     * @return array Fichiers .tpl
     */
    private function getTemplateFiles(string $path): array
    {
        $files = [];
        $iterator = new RecursiveIteratorIterator(
            new RecursiveDirectoryIterator($path)
        );

        foreach ($iterator as $file) {
            if ($file->getExtension() === 'tpl') {
                $files[] = $file->getPathname();
            }
        }

        return $files;
    }
}

9. Tests post-migration

Après la migration, effectuez des tests exhaustifs avant de mettre en production.

Checklist de tests

☑️ Page d'accueil s'affiche correctement
☑️ Navigation dans les catégories
☑️ Recherche de produits fonctionne
☑️ Fiche produit complète (images, description, stock)
☑️ Ajout au panier
☑️ Processus de commande complet
☑️ Paiement (mode test)
☑️ Création de compte client
☑️ Connexion/déconnexion
☑️ Récupération mot de passe
☑️ Espace client (commandes, adresses)
☑️ Back-office accessible
☑️ Tous les modules actifs fonctionnent
☑️ Emails de notification envoyés
☑️ Performance (vitesse de chargement)
☑️ Responsive (mobile/tablet)

Script de test automatisé

<?php
/**
 * Tests automatisés post-migration
 */
class PostMigrationTests
{
    private $results = [];

    /**
     * Lancer tous les tests
     *
     * @return array Résultats des tests
     */
    public function runAllTests(): array
    {
        $this->testDatabaseIntegrity();
        $this->testProductsCount();
        $this->testCustomersCount();
        $this->testOrdersCount();
        $this->testModulesStatus();
        $this->testConfiguration();

        return $this->results;
    }

    /**
     * Tester l'intégrité de la base
     */
    private function testDatabaseIntegrity()
    {
        $tables = Db::getInstance()->executeS('SHOW TABLES');
        $this->results['database_tables'] = count($tables);

        // Vérifier les tables essentielles
        $essentialTables = [
            'product', 'category', 'customer', 'orders',
            'cart', 'module', 'configuration'
        ];

        $this->results['essential_tables'] = true;

        foreach ($essentialTables as $table) {
            $exists = Db::getInstance()->getRow(
                'SHOW TABLES LIKE "' . _DB_PREFIX_ . $table . '"'
            );

            if (!$exists) {
                $this->results['essential_tables'] = false;
                $this->results['missing_table'] = $table;
                break;
            }
        }
    }

    /**
     * Vérifier le nombre de produits
     */
    private function testProductsCount()
    {
        $query = new DbQuery();
        $query->select('COUNT(*)')
            ->from('product');

        $count = (int)Db::getInstance()->getValue($query);
        $this->results['products_count'] = $count;
    }

    /**
     * Vérifier le nombre de clients
     */
    private function testCustomersCount()
    {
        $query = new DbQuery();
        $query->select('COUNT(*)')
            ->from('customer');

        $count = (int)Db::getInstance()->getValue($query);
        $this->results['customers_count'] = $count;
    }

    /**
     * Vérifier le nombre de commandes
     */
    private function testOrdersCount()
    {
        $query = new DbQuery();
        $query->select('COUNT(*)')
            ->from('orders');

        $count = (int)Db::getInstance()->getValue($query);
        $this->results['orders_count'] = $count;
    }

    /**
     * Vérifier le statut des modules
     */
    private function testModulesStatus()
    {
        $query = new DbQuery();
        $query->select('COUNT(*)')
            ->from('module')
            ->where('active = 1');

        $activeModules = (int)Db::getInstance()->getValue($query);
        $this->results['active_modules'] = $activeModules;
    }

    /**
     * Vérifier les configurations critiques
     */
    private function testConfiguration()
    {
        $criticalConfigs = [
            'PS_SHOP_DOMAIN',
            'PS_SHOP_EMAIL',
            'PS_CURRENCY_DEFAULT',
            'PS_LANG_DEFAULT'
        ];

        $this->results['configurations'] = [];

        foreach ($criticalConfigs as $config) {
            $this->results['configurations'][$config] = Configuration::get($config);
        }
    }
}

10. Mise en production

Une fois les tests validés sur le staging, préparez la mise en production.

Plan de mise en production

Planifier une fenêtre de maintenance (idéalement en heures creuses)
Avertir vos clients via email et bannière sur le site
Activer le mode maintenance
Créer une dernière sauvegarde complète
Lancer la migration sur la production
Tester les fonctionnalités critiques
Désactiver le mode maintenance
Surveiller les logs pendant 24-48h

<?php
/**
 * Gérer le mode maintenance
 */
class MaintenanceManager
{
    /**
     * Activer le mode maintenance
     *
     * @param string $message Message personnalisé
     * @return bool Succès
     */
    public function enableMaintenance(string $message = ''): bool
    {
        $defaultMessage = 'Nous effectuons une mise à jour pour améliorer votre expérience. Nous revenons bientôt !';
        $maintenanceMessage = $message ?: $defaultMessage;

        Configuration::updateValue('PS_SHOP_ENABLE', 0);
        Configuration::updateValue('PS_MAINTENANCE_TEXT', $maintenanceMessage);

        // Créer le fichier de maintenance
        $maintenanceFile = _PS_ROOT_DIR_ . '/maintenance.php';
        if (!file_exists($maintenanceFile)) {
            touch($maintenanceFile);
        }

        return true;
    }

    /**
     * Désactiver le mode maintenance
     *
     * @return bool Succès
     */
    public function disableMaintenance(): bool
    {
        Configuration::updateValue('PS_SHOP_ENABLE', 1);

        // Vider le cache
        Tools::clearCache();

        return true;
    }
}

Troubleshooting : Problèmes courants

Erreur 500 après migration

Vérifiez les logs Apache/Nginx et PHP
Videz le cache : rm -rf var/cache/*
Vérifiez les permissions des fichiers (755/644)
Désactivez les overrides temporairement

Modules ne fonctionnent plus

Réinstallez le module
Vérifiez la compatibilité PS8
Mettez à jour vers la dernière version
Contactez le support du module

Thème cassé

Recompilez les assets : npm run build
Videz le cache Smarty
Vérifiez les templates overridés
Passez temporairement au thème Classic pour tester

Conclusion

Migrer vers Prestashop 8 est un projet d'envergure qui nécessite préparation, rigueur et patience. En suivant méthodiquement ce guide, vous minimisez les risques et assurez une transition en douceur vers cette nouvelle version moderne et performante de Prestashop.

N'oubliez pas : ne précipitez rien, testez abondamment sur un environnement de staging, et gardez toujours des sauvegardes complètes à portée de main.

Besoin d'aide pour migrer votre boutique vers Prestashop 8 ? Contactez-moi pour un accompagnement personnalisé et sécurisé !