Introduction
Les performances d’un site WordPress dépendent majoritairement de deux facteurs critiques : l’optimisation de la base de données et l’implémentation d’un système de cache efficace. En 2025, avec l’augmentation des exigences en matière de Core Web Vitals et l’importance croissante du temps de chargement pour le SEO, l’optimisation des performances n’est plus optionnelle. Ce guide complet vous accompagnera dans l’optimisation avancée de votre base de données et la mise en place de stratégies de caching performantes.
Optimisation de la base de données
Comprendre la structure de la base de données WordPress
WordPress utilise plusieurs tables principales :
wp_posts: Articles, pages, CPT, révisionswp_postmeta: Métadonnées des postswp_users: Utilisateurswp_usermeta: Métadonnées utilisateurswp_options: Configuration et options (autoload)wp_terms,wp_term_taxonomy,wp_term_relationships: Taxonomieswp_comments,wp_commentmeta: Commentaires
Optimiser les options autoload
Le problème d’autoload est l’un des plus critiques pour les performances. WordPress charge automatiquement toutes les options avec autoload = 'yes' à chaque requête.
get_results(
"SELECT option_name, LENGTH(option_value) as option_size
FROM $wpdb->options
WHERE autoload = 'yes'
ORDER BY option_size DESC
LIMIT 50"
);
$total_size = 0;
$report = array();
foreach ( $autoload_data as $option ) {
$total_size += $option->option_size;
$report[] = array(
'option_name' => $option->option_name,
'size' => self::format_bytes( $option->option_size ),
'size_bytes' => $option->option_size,
);
}
error_log( sprintf(
'Total autoload size: %s (%d bytes)',
self::format_bytes( $total_size ),
$total_size
) );
return array(
'total_size' => $total_size,
'total_human' => self::format_bytes( $total_size ),
'options' => $report,
);
}
/**
* Désactiver l'autoload pour des options spécifiques
*/
public static function disable_autoload( $option_names ) {
global $wpdb;
if ( ! is_array( $option_names ) ) {
$option_names = array( $option_names );
}
foreach ( $option_names as $option_name ) {
$wpdb->update(
$wpdb->options,
array( 'autoload' => 'no' ),
array( 'option_name' => $option_name ),
array( '%s' ),
array( '%s' )
);
error_log( "Disabled autoload for: $option_name" );
}
// Nettoyer le cache
wp_cache_flush();
}
/**
* Nettoyer les options orphelines
*/
public static function clean_orphaned_options() {
global $wpdb;
// Supprimer les transients expirés
$deleted = $wpdb->query(
"DELETE FROM $wpdb->options
WHERE option_name LIKE '*transient_timeout*%'
AND option_value < UNIX_TIMESTAMP()"
);
error_log( "Deleted $deleted expired transient timeouts" );
// Supprimer les transients correspondants
$wpdb->query(
"DELETE FROM $wpdb->options
WHERE option_name LIKE '*transient*%'
AND option_name NOT LIKE '*transient_timeout*%'
AND option_name NOT IN (
SELECT REPLACE(option_name, '*timeout', '')
FROM $wpdb->options
WHERE option_name LIKE '*transient_timeout*%'
)"
);
// Supprimer les options de plugins désactivés
$deleted_plugin_options = $wpdb->query(
"DELETE FROM $wpdb->options
WHERE option_name LIKE '%*plugin*%'
AND autoload = 'yes'
AND option_name NOT IN (
SELECT DISTINCT meta_key
FROM $wpdb->postmeta
)"
);
error_log( "Deleted $deleted_plugin_options orphaned plugin options" );
return $deleted + $deleted_plugin_options;
}
/**
* Formater les octets en format lisible
*/
private static function format_bytes( $bytes ) {
$units = array( 'B', 'KB', 'MB', 'GB' );
for ( $i = 0; $bytes > 1024 && $i < count( $units ) - 1; $i++ ) {
$bytes /= 1024;
}
return round( $bytes, 2 ) . ' ' . $units[ $i ];
}
}
// Commande WP-CLI pour analyser l'autoload
if ( defined( 'WP_CLI' ) && WP_CLI ) {
WP_CLI::add_command( 'autoload analyze', array( 'AutoloadOptimizer', 'analyze_autoload' ) );
WP_CLI::add_command( 'autoload clean', array( 'AutoloadOptimizer', 'clean_orphaned_options' ) );
}
Optimisation des requêtes avec indexation
Les index de base de données accélèrent considérablement les requêtes :
$wpdb->postmeta,
'name' => 'meta_key_value',
'sql' => "CREATE INDEX meta_key_value ON {$wpdb->postmeta} (meta_key(191), meta_value(100))",
);
// Index composite pour post_type et post_status
$indexes[] = array(
'table' => $wpdb->posts,
'name' => 'type_status_date',
'sql' => "CREATE INDEX type_status_date ON {$wpdb->posts} (post_type, post_status, post_date)",
);
// Index pour les recherches de commentaires
$indexes[] = array(
'table' => $wpdb->comments,
'name' => 'comment_approved_date',
'sql' => "CREATE INDEX comment_approved_date ON {$wpdb->comments} (comment_approved, comment_date_gmt)",
);
// Index pour les relations de termes
$indexes[] = array(
'table' => $wpdb->term_relationships,
'name' => 'object_id_term_id',
'sql' => "CREATE INDEX object_id_term_id ON {$wpdb->term_relationships} (object_id, term_taxonomy_id)",
);
foreach ( $indexes as $index ) {
if ( ! self::index_exists( $index['table'], $index['name'] ) ) {
$result = $wpdb->query( $index['sql'] );
if ( $result !== false ) {
error_log( "Successfully created index: {$index['name']} on {$index['table']}" );
} else {
error_log( "Failed to create index: {$index['name']} on {$index['table']}" );
}
} else {
error_log( "Index already exists: {$index['name']} on {$index['table']}" );
}
}
}
/**
* Vérifier si un index existe
*/
private static function index_exists( $table, $index_name ) {
global $wpdb;
$result = $wpdb->get_var(
$wpdb->prepare(
"SHOW INDEX FROM $table WHERE Key_name = %s",
$index_name
)
);
return ! is_null( $result );
}
/**
* Analyser et recommander des index
*/
public static function analyze_slow_queries() {
global $wpdb;
// Activer le slow query log (nécessite des privilèges MySQL)
$wpdb->query( "SET GLOBAL slow_query_log = 'ON'" );
$wpdb->query( "SET GLOBAL long_query_time = 1" );
// Analyser les requêtes lentes
$slow_queries = $wpdb->get_results( "SHOW PROCESSLIST" );
$recommendations = array();
foreach ( $slow_queries as $query ) {
if ( $query->Time > 1 ) {
$recommendations[] = array(
'query' => $query->Info,
'duration' => $query->Time,
'state' => $query->State,
);
}
}
return $recommendations;
}
/**
* Optimiser toutes les tables
*/
public static function optimize_tables() {
global $wpdb;
$tables = $wpdb->get_col( "SHOW TABLES" );
$results = array();
foreach ( $tables as $table ) {
$result = $wpdb->query( "OPTIMIZE TABLE $table" );
$results[ $table ] = $result !== false;
error_log( "Optimized table: $table - " . ( $results[ $table ] ? 'Success' : 'Failed' ) );
}
return $results;
}
/**
* Nettoyer les révisions de posts
*/
public static function clean_post_revisions( $keep = 5 ) {
global $wpdb;
// Trouver et supprimer les vieilles révisions
$deleted = $wpdb->query(
$wpdb->prepare(
"DELETE FROM $wpdb->posts
WHERE post_type = 'revision'
AND post_parent IN (
SELECT p.ID FROM (
SELECT ID FROM $wpdb->posts
WHERE post_type NOT IN ('revision', 'auto-draft')
) p
)
AND ID NOT IN (
SELECT ID FROM (
SELECT r.ID
FROM $wpdb->posts r
WHERE r.post_type = 'revision'
ORDER BY r.post_modified DESC
LIMIT %d
) keep_revisions
)",
$keep
)
);
error_log( "Deleted $deleted old revisions (keeping $keep per post)" );
return $deleted;
}
/**
* Nettoyer les auto-drafts
*/
public static function clean_auto_drafts() {
global $wpdb;
$deleted = $wpdb->query(
"DELETE FROM $wpdb->posts
WHERE post_status = 'auto-draft'
AND post_modified < DATE_SUB(NOW(), INTERVAL 7 DAY)"
);
error_log( "Deleted $deleted auto-drafts older than 7 days" );
return $deleted;
}
}
// Exécuter au switch de thème ou activation de plugin
add_action( 'after_switch_theme', array( 'DatabaseIndexManager', 'add_performance_indexes' ) );
// Tâche cron pour maintenance
add_action( 'montheme_weekly_maintenance', function() {
DatabaseIndexManager::clean_post_revisions( 5 );
DatabaseIndexManager::clean_auto_drafts();
AutoloadOptimizer::clean_orphaned_options();
DatabaseIndexManager::optimize_tables();
} );
// Enregistrer la tâche cron
if ( ! wp_next_scheduled( 'montheme_weekly_maintenance' ) ) {
wp_schedule_event( time(), 'weekly', 'montheme_weekly_maintenance' );
}
Optimiser les requêtes WP_Query
'post',
'posts_per_page' => 10,
'no_found_rows' => true, // Désactiver le comptage total
'update_post_meta_cache' => false, // Désactiver si pas de meta
'update_post_term_cache' => false, // Désactiver si pas de termes
'fields' => 'ids', // Récupérer seulement les IDs
);
$args = wp_parse_args( $args, $defaults );
return new WP_Query( $args );
}
/**
* Requête avec cache personnalisé
*/
public static function get_cached_posts( $args = array(), $cache_duration = 3600 ) {
$cache_key = 'query*' . md5( serialize( $args ) );
$cached = wp_cache_get( $cache_key, 'montheme_queries' );
if ( false !== $cached ) {
return $cached;
}
$query = new WP_Query( $args );
$posts = $query->posts;
wp_cache_set( $cache_key, $posts, 'montheme_queries', $cache_duration );
return $posts;
}
/**
* Pré-charger les métadonnées pour éviter les requêtes multiples
*/
public static function prime_post_caches( $post_ids ) {
if ( empty( $post_ids ) ) {
return;
}
// Pré-charger les posts
*prime_post_caches( $post_ids, true, true );
// Pré-charger les termes
update_object_term_cache( $post_ids, 'post' );
// Pré-charger les métadonnées
update_meta_cache( 'post', $post_ids );
}
/**
* Requête SQL directe pour de meilleures performances
*/
public static function get_posts_raw( $post_type = 'post', $limit = 10 ) {
global $wpdb;
$cache_key = "raw_posts*{$post_type}*{$limit}";
$posts = wp_cache_get( $cache_key, 'montheme_queries' );
if ( false === $posts ) {
$posts = $wpdb->get_results(
$wpdb->prepare(
"SELECT ID, post_title, post_name, post_date
FROM $wpdb->posts
WHERE post_type = %s
AND post_status = 'publish'
ORDER BY post_date DESC
LIMIT %d",
$post_type,
$limit
)
);
wp_cache_set( $cache_key, $posts, 'montheme_queries', 3600 );
}
return $posts;
}
/**
* Désactiver les requêtes inutiles sur certaines pages
*/
public static function disable_unnecessary_queries() {
// Désactiver les emojis (économise 2 requêtes)
remove_action( 'wp_head', 'print_emoji_detection_script', 7 );
remove_action( 'admin_print_scripts', 'print_emoji_detection_script' );
remove_action( 'wp_print_styles', 'print_emoji_styles' );
remove_action( 'admin_print_styles', 'print_emoji_styles' );
// Désactiver les embeds (économise plusieurs requêtes)
remove_action( 'wp_head', 'wp_oembed_add_discovery_links' );
remove_action( 'wp_head', 'wp_oembed_add_host_js' );
// Désactiver XML-RPC si non utilisé
add_filter( 'xmlrpc_enabled', '**return_false' );
// Limiter les révisions
if ( ! defined( 'WP_POST_REVISIONS' ) ) {
define( 'WP_POST_REVISIONS', 3 );
}
// Augmenter l'intervalle d'autosave
if ( ! defined( 'AUTOSAVE_INTERVAL' ) ) {
define( 'AUTOSAVE_INTERVAL', 300 ); // 5 minutes
}
}
}
add_action( 'init', array( 'QueryOptimizer', 'disable_unnecessary_queries' ) );
Stratégies de caching avancées
Object Cache avec Redis
prefix = 'wp*' . DB_NAME . ':';
if ( class_exists( 'Redis' ) ) {
$this->redis = new Redis();
try {
$this->redis->connect(
defined( 'WP_REDIS_HOST' ) ? WP_REDIS_HOST : '127.0.0.1',
defined( 'WP_REDIS_PORT' ) ? WP_REDIS_PORT : 6379
);
if ( defined( 'WP_REDIS_PASSWORD' ) && WP_REDIS_PASSWORD ) {
$this->redis->auth( WP_REDIS_PASSWORD );
}
$this->redis->setOption( Redis::OPT_SERIALIZER, Redis::SERIALIZER_PHP );
$this->redis->setOption( Redis::OPT_PREFIX, $this->prefix );
} catch ( Exception $e ) {
error_log( 'Redis connection failed: ' . $e->getMessage() );
$this->redis = null;
}
}
}
/**
* Récupérer une valeur du cache
*/
public function get( $key, $group = 'default' ) {
if ( ! $this->redis ) {
return wp_cache_get( $key, $group );
}
$cache_key = $this->build_key( $key, $group );
try {
$value = $this->redis->get( $cache_key );
return $value !== false ? $value : false;
} catch ( Exception $e ) {
error_log( 'Redis get failed: ' . $e->getMessage() );
return false;
}
}
/**
* Définir une valeur dans le cache
*/
public function set( $key, $value, $group = 'default', $expiration = 0 ) {
if ( ! $this->redis ) {
return wp_cache_set( $key, $value, $group, $expiration );
}
$cache_key = $this->build_key( $key, $group );
$expiration = $expiration ?: $this->default_expiration;
try {
return $this->redis->setex( $cache_key, $expiration, $value );
} catch ( Exception $e ) {
error_log( 'Redis set failed: ' . $e->getMessage() );
return false;
}
}
/**
* Supprimer une valeur du cache
*/
public function delete( $key, $group = 'default' ) {
if ( ! $this->redis ) {
return wp_cache_delete( $key, $group );
}
$cache_key = $this->build_key( $key, $group );
try {
return $this->redis->del( $cache_key ) > 0;
} catch ( Exception $e ) {
error_log( 'Redis delete failed: ' . $e->getMessage() );
return false;
}
}
/**
* Vider un groupe de cache
*/
public function flush_group( $group ) {
if ( ! $this->redis ) {
return wp_cache_flush_group( $group );
}
try {
$pattern = $this->prefix . $group . ':*';
$keys = $this->redis->keys( $pattern );
if ( ! empty( $keys ) ) {
return $this->redis->del( $keys ) > 0;
}
return true;
} catch ( Exception $e ) {
error_log( 'Redis flush group failed: ' . $e->getMessage() );
return false;
}
}
/**
* Récupérer ou générer avec callback
*/
public function remember( $key, $group, $callback, $expiration = 0 ) {
$value = $this->get( $key, $group );
if ( false === $value ) {
$value = $callback();
$this->set( $key, $value, $group, $expiration );
}
return $value;
}
/**
* Construire la clé de cache
*/
private function build_key( $key, $group ) {
return $group . ':' . $key;
}
/**
* Obtenir les statistiques Redis
*/
public function get_stats() {
if ( ! $this->redis ) {
return array();
}
try {
$info = $this->redis->info();
return array(
'connected' => true,
'memory_used' => $info['used_memory_human'] ?? 'N/A',
'total_keys' => $this->redis->dbSize(),
'hits' => $info['keyspace_hits'] ?? 0,
'misses' => $info['keyspace_misses'] ?? 0,
'hit_rate' => $this->calculate_hit_rate( $info ),
'evicted_keys' => $info['evicted_keys'] ?? 0,
'connected_clients' => $info['connected_clients'] ?? 0,
);
} catch ( Exception $e ) {
error_log( 'Redis stats failed: ' . $e->getMessage() );
return array( 'connected' => false );
}
}
/**
* Calculer le taux de hits
*/
private function calculate_hit_rate( $info ) {
$hits = $info['keyspace_hits'] ?? 0;
$misses = $info['keyspace_misses'] ?? 0;
$total = $hits + $misses;
if ( $total === 0 ) {
return 0;
}
return round( ( $hits / $total ) * 100, 2 );
}
}
// Initialiser le cache Redis
global $montheme_redis_cache;
$montheme_redis_cache = new RedisObjectCache();
Page Cache avancé
cache_dir = WP_CONTENT_DIR . '/cache/montheme-page-cache/';
add_action( 'init', array( $this, 'serve_cached_page' ), 1 );
add_action( 'shutdown', array( $this, 'cache_page' ) );
add_action( 'save_post', array( $this, 'clear_cache_for_post' ) );
add_action( 'comment_post', array( $this, 'clear_cache_for_post' ) );
add_action( 'switch_theme', array( $this, 'clear_all_cache' ) );
}
/**
* Servir une page en cache
*/
public function serve_cached_page() {
// Ne pas mettre en cache si :
if ( is_admin() ||
is_user_logged_in() ||
( defined( 'DOING_AJAX' ) && DOING_AJAX ) ||
( defined( 'DOING_CRON' ) && DOING_CRON ) ||
( defined( 'WP_CLI' ) && WP_CLI ) ||
'GET' !== $*SERVER['REQUEST_METHOD'] ) {
return;
}
$cache_file = $this->get_cache_file_path();
if ( ! $cache_file || ! file_exists( $cache_file ) ) {
return;
}
// Vérifier si le cache est expiré
if ( time() - filemtime( $cache_file ) > $this->cache_duration ) {
@unlink( $cache_file );
return;
}
// Servir le cache
$cached_content = file_get_contents( $cache_file );
if ( $cached_content ) {
// Ajouter des en-têtes
header( 'X-Cache-Status: HIT' );
header( 'X-Cache-Time: ' . date( 'Y-m-d H:i:s', filemtime( $cache_file ) ) );
echo $cached_content;
exit;
}
}
/**
* Mettre une page en cache
*/
public function cache_page() {
// Conditions pour ne pas mettre en cache
if ( is_admin() ||
is_user_logged_in() ||
is_404() ||
is_search() ||
is_feed() ||
( defined( 'DOING_AJAX' ) && DOING_AJAX ) ||
'GET' !== $*SERVER['REQUEST_METHOD'] ) {
return;
}
// Récupérer le contenu de la page
$content = ob_get_contents();
if ( empty( $content ) || strlen( $content ) < 500 ) {
return;
}
$cache_file = $this->get_cache_file_path();
if ( ! $cache_file ) {
return;
}
// Créer le répertoire si nécessaire
$cache_dir = dirname( $cache_file );
if ( ! file_exists( $cache_dir ) ) {
wp_mkdir_p( $cache_dir );
}
// Ajouter un commentaire avec la date de mise en cache
$content .= "n";
// Écrire le fichier de cache
file_put_contents( $cache_file, $content, LOCK_EX );
// Ajouter un en-tête indiquant que c'est un MISS
header( 'X-Cache-Status: MISS' );
}
/**
* Obtenir le chemin du fichier de cache
*/
private function get_cache_file_path() {
$request_uri = $*SERVER['REQUEST_URI'] ?? '/';
// Nettoyer l'URI
$request_uri = trim( $request_uri, '/' );
$request_uri = str_replace( array( '../', './', '//' ), '', $request_uri );
if ( empty( $request_uri ) ) {
$request_uri = 'index';
}
// Sous-répertoire pour mobile si activé
$subdir = '';
if ( $this->mobile_cache && wp_is_mobile() ) {
$subdir = 'mobile/';
}
// Hash pour la sécurité
$hash = md5( $request_uri );
return $this->cache_dir . $subdir . $hash . '.html';
}
/**
* Nettoyer le cache pour un post spécifique
*/
public function clear_cache_for_post( $post_id ) {
$post = get_post( $post_id );
if ( ! $post ) {
return;
}
// Nettoyer la page du post
$post_url = get_permalink( $post_id );
$this->clear_url_cache( $post_url );
// Nettoyer la page d'accueil
$this->clear_url_cache( home_url( '/' ) );
// Nettoyer les archives liées
if ( $post->post_type === 'post' ) {
$this->clear_url_cache( get_post_type_archive_link( 'post' ) );
// Nettoyer les archives de catégories
$categories = get_the_category( $post_id );
foreach ( $categories as $category ) {
$this->clear_url_cache( get_category_link( $category->term_id ) );
}
}
}
/**
* Nettoyer le cache d'une URL
*/
private function clear_url_cache( $url ) {
$request_uri = str_replace( home_url(), '', $url );
$request_uri = trim( $request_uri, '/' );
if ( empty( $request_uri ) ) {
$request_uri = 'index';
}
$hash = md5( $request_uri );
// Desktop
$cache_file = $this->cache_dir . $hash . '.html';
if ( file_exists( $cache_file ) ) {
@unlink( $cache_file );
}
// Mobile
if ( $this->mobile_cache ) {
$mobile_cache_file = $this->cache_dir . 'mobile/' . $hash . '.html';
if ( file_exists( $mobile_cache_file ) ) {
@unlink( $mobile_cache_file );
}
}
}
/**
* Vider tout le cache
*/
public function clear_all_cache() {
$this->delete_directory_contents( $this->cache_dir );
error_log( 'Page cache cleared' );
}
/**
* Supprimer le contenu d'un répertoire
*/
private function delete_directory_contents( $dir ) {
if ( ! is_dir( $dir ) ) {
return;
}
$files = glob( $dir . '*', GLOB_MARK );
foreach ( $files as $file ) {
if ( is_dir( $file ) ) {
$this->delete_directory_contents( $file );
@rmdir( $file );
} else {
@unlink( $file );
}
}
}
/**
* Obtenir les statistiques de cache
*/
public function get_stats() {
if ( ! is_dir( $this->cache_dir ) ) {
return array(
'total_files' => 0,
'total_size' => 0,
'oldest' => null,
'newest' => null,
);
}
$files = glob( $this->cache_dir . '*.html' );
$total_size = 0;
$oldest = PHP_INT_MAX;
$newest = 0;
foreach ( $files as $file ) {
$total_size += filesize( $file );
$mtime = filemtime( $file );
if ( $mtime < $oldest ) {
$oldest = $mtime;
}
if ( $mtime > $newest ) {
$newest = $mtime;
}
}
return array(
'total_files' => count( $files ),
'total_size' => $this->format_bytes( $total_size ),
'oldest' => $oldest !== PHP_INT_MAX ? date( 'Y-m-d H:i:s', $oldest ) : null,
'newest' => $newest !== 0 ? date( 'Y-m-d H:i:s', $newest ) : null,
);
}
/**
* Formater les octets
*/
private function format_bytes( $bytes ) {
$units = array( 'B', 'KB', 'MB', 'GB' );
for ( $i = 0; $bytes > 1024 && $i < count( $units ) - 1; $i++ ) {
$bytes /= 1024;
}
return round( $bytes, 2 ) . ' ' . $units[ $i ];
}
}
// Initialiser le page cache
new AdvancedPageCache();
Fragment Caching
query(
"DELETE FROM $wpdb->options
WHERE option_name LIKE '*transient_fragment*%'
OR option_name LIKE '*transient_timeout_fragment*%'"
);
}
}
// Exemple d'utilisation dans un template
function montheme_display_popular_posts() {
echo FragmentCache::get( 'popular_posts', function() {
$popular = new WP_Query( array(
'post_type' => 'post',
'posts_per_page' => 5,
'meta_key' => 'post_views_count',
'orderby' => 'meta_value_num',
'order' => 'DESC',
) );
if ( $popular->have_posts() ) {
echo '';
while ( $popular->have_posts() ) {
$popular->the_post();
?>
###
vues
';
}
wp_reset_postdata();
}, 1800 ); // Cache pour 30 minutes
}
Configuration MySQL optimale
Fichier my.cnf recommandé
[mysqld]
# Configuration optimisée pour WordPress
# InnoDB Buffer Pool (70-80% de la RAM disponible)
innodb_buffer_pool_size = 2G
innodb_buffer_pool_instances = 2
# Logs
innodb_log_file_size = 256M
innodb_log_buffer_size = 16M
innodb_flush_log_at_trx_commit = 2
innodb_flush_method = O_DIRECT
# Connexions
max_connections = 200
max_allowed_packet = 64M
wait_timeout = 300
interactive_timeout = 300
# Cache de requêtes (désactivé pour MySQL 8.0+)
query_cache_type = 0
query_cache_size = 0
# Tables temporaires
tmp_table_size = 64M
max_heap_table_size = 64M
# Performances
innodb_file_per_table = 1
innodb_stats_on_metadata = 0
# Monitoring
slow_query_log = 1
slow_query_log_file = /var/log/mysql/mysql-slow.log
long_query_time = 2
# Character set
character-set-server = utf8mb4
collation-server = utf8mb4_unicode_ci
Monitoring et debugging
Dashboard de performances
#
##
****
800000 ) : ?>
##
get_results( "SHOW TABLE STATUS" );
$total_size = 0;
foreach ( $table_status as $table ) {
$total_size += $table->Data_length + $table->Index_length;
}
?>
****
****
##
get_stats();
if ( $redis_stats['connected'] ) :
?>
****
****
**** %
##
get_stats();
?>
****
****
Conclusion
L'optimisation des performances WordPress en 2025 repose sur trois piliers : une base de données bien indexée et maintenue, un système de caching multi-niveaux (object cache, page cache, fragment cache), et une configuration MySQL optimale. En suivant ces pratiques, vous pouvez réduire les temps de chargement jusqu'à 80% et améliorer significativement l'expérience utilisateur.
Points clés :
Maintenir l'autoload sous 800 KB
Indexer les colonnes fréquemment requêtées
Implémenter Redis pour l'object cache
Utiliser le fragment caching pour les widgets
Optimiser les requêtes WP_Query
Nettoyer régulièrement la base de données
Monitorer les performances en continu
Ressources supplémentaires
WordPress Performance Optimization
MySQL Performance Tuning
Redis Documentation
Query Monitor Plugin
Mots-clés:** optimisation WordPress, performances WordPress, cache WordPress, Redis WordPress, MySQL optimisation, WP_Query performance, autoload WordPress, base de données WordPress, object cache, page cache WordPress 2025