Existe-t-il un moyen d'utiliser les utilisateurs de Wordpress sans charger tout le noyau Wordpress?

11

J'ai un site Wordpress et une application Web qui ne peuvent être utilisés que par les utilisateurs enregistrés (Wordpress).

Maintenant, je charge wp-blog-header.php pour vérifier si l'utilisateur est connecté. Tout fonctionne correctement, mais comme chaque demande (y compris AJAX), je dois également charger le noyau Wordpress, mon application est ralentie (plus 70% du temps de chargement total).

Existe-t-il un moyen simple d'utiliser les utilisateurs de Wordpress sans charger tout le noyau Wordpress?

Mise à jour: j'ai besoin de savoir quel utilisateur est connecté et la sécurité est également importante.

Merci!

    
posée Victor 12.09.2011 - 21:32

8 réponses

9

Si je devais le faire, j'utiliserais mon propre cookie pour déterminer la connexion et ne chargerais WordPress que pour vérifier si nécessaire.

Le cookie wordpress_logged_in_ {some-hash} peut être utilisé pour déterminer l'utilisateur, et WordPress l'utilise pour le déterminer. Vous ne pouvez pas facilement le réimplémenter, mais vous pouvez l’utiliser sans charger WordPress sur plusieurs requêtes.

Par exemple, voici mon hachage de cookie (données complètement composées, mais réalistes):

key: wordpress_logged_in_1234567890abcdef1234567890abcdef
value: admin|1234567890|abcdef1234567890abcdef1234567890

La façon dont WordPress sait que le cookie est valide n’est pas pertinente, il suffit de savoir s’il est valide une fois, puis vous le signez avec un secret.

Donc, pour la première fois, l'utilisateur n'a pas encore fait ses preuves. Vous chargez wp-load.php et WP valide le cookie et connecte l'utilisateur. Vous faites maintenant tout ce que vous faites pour vous prouver que l'utilisateur a été connecté, puis vous définissez votre propre cookie. La clé peut être quelque chose de personnalisé pour vous, la valeur que vous donnez à un résumé de message avec une clé secrète à l'aide de la fonction hash_hmac.

$key = ... // the key from the WP cookie
$value = ... // the value from the WP cookie
$hash = hash_hmac ( 'md5' , $key.$value , 'some secret key' );

Vous obtiendrez du charabia que vous leur renverrez à l’aide de setcookie (). Lors de futures demandes, ils vous renverront ce cookie. Vous pouvez d'abord vérifier cela et le valider en utilisant la même fonction de hachage et la même clé secrète.

Vous seul pouvez générer le hachage car vous seul connaissez la clé secrète. Donc, s’ils renvoient un hachage valide qui correspond également à ce qu’ils envoient comme cookie WP, vous savez alors qu’ils ont déjà été validés avec WP, via votre code, et que vous pouvez obtenir le nom d’utilisateur à partir de cette valeur (c’est le premier partie du cookie, évidemment). Ensuite, vous ne devez pas charger WP.

La clé secrète, BTW, doit être longue et aléatoire . Pas un mot de passe court. Pas un mot du dictionnaire. Juste un grand charabia absurde. Le bruit de la ligne, et beaucoup. Exemple de clé: 'GHY5hFNqq4Ntdu=3:SUp8#/+_W!- @@^@xslN*L|N+Vn;(1xo8jNyp,au$v9Ki5*'

    
réponse donnée Otto 13.09.2011 - 01:36
4

Etant donné que j'utilise également certaines fonctions Wordpress en plus de la gestion des utilisateurs, j'ai décidé de continuer à charger le noyau WP, mais j'ai créé un fichier personnalisé qui ne charge que ce dont j'ai besoin et sans charger les plugins. Le nouveau temps de chargement est satisfaisant (il est passé de 1,5 s à 0,3 s avec une charge complète).

J'ai créé un fichier appelé 'wp-load-minimum.php' et j'appelle ce fichier à la place de 'wp-blog-header.php'

Cela remonte à WP 3.3. Voici le contenu du fichier, si vous le trouvez utile:

<?php

//this stops wp-settings from load everything
define ('SHORTINIT',true);

error_reporting( E_CORE_ERROR | E_CORE_WARNING | E_COMPILE_ERROR | E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR | E_USER_WARNING | E_RECOVERABLE_ERROR );

/** Define ABSPATH as this files directory */
define( 'ABSPATH', dirname(__FILE__) . '/' );

//WP config file
require ('wp-config.php');

if (SHORTINIT):

// Load the l18n library.
require( ABSPATH . WPINC . '/l10n.php' );

// Run the installer if WordPress is not installed.
wp_not_installed();


// Load most of WordPress.
require( ABSPATH . WPINC . '/class-wp-walker.php' );
//require( ABSPATH . WPINC . '/class-wp-ajax-response.php' );
require( ABSPATH . WPINC . '/formatting.php' );
require( ABSPATH . WPINC . '/capabilities.php' );
require( ABSPATH . WPINC . '/query.php' );
require( ABSPATH . WPINC . '/theme.php' );
require( ABSPATH . WPINC . '/user.php' );
require( ABSPATH . WPINC . '/meta.php' );
require( ABSPATH . WPINC . '/general-template.php' );
require( ABSPATH . WPINC . '/link-template.php' );
//require( ABSPATH . WPINC . '/author-template.php' );
require( ABSPATH . WPINC . '/post.php' );
//require( ABSPATH . WPINC . '/post-template.php' );
//require( ABSPATH . WPINC . '/category.php' );
//require( ABSPATH . WPINC . '/category-template.php' );
require( ABSPATH . WPINC . '/comment.php' );
//require( ABSPATH . WPINC . '/comment-template.php' );
require( ABSPATH . WPINC . '/rewrite.php' );
//require( ABSPATH . WPINC . '/feed.php' );
//require( ABSPATH . WPINC . '/bookmark.php' );
//require( ABSPATH . WPINC . '/bookmark-template.php' );
require( ABSPATH . WPINC . '/kses.php' );
require( ABSPATH . WPINC . '/cron.php' );
//require( ABSPATH . WPINC . '/deprecated.php' );
require( ABSPATH . WPINC . '/script-loader.php' );
require( ABSPATH . WPINC . '/taxonomy.php' );
//require( ABSPATH . WPINC . '/update.php' );
//require( ABSPATH . WPINC . '/canonical.php' );
require( ABSPATH . WPINC . '/shortcodes.php' );
require( ABSPATH . WPINC . '/media.php' );
require( ABSPATH . WPINC . '/http.php' );
require( ABSPATH . WPINC . '/class-http.php' );
require( ABSPATH . WPINC . '/widgets.php' );
require( ABSPATH . WPINC . '/nav-menu.php' );
//require( ABSPATH . WPINC . '/nav-menu-template.php' );
//require( ABSPATH . WPINC . '/admin-bar.php' );

// Load multisite-specific files.
if ( is_multisite() ) {
    require( ABSPATH . WPINC . '/ms-functions.php' );
    require( ABSPATH . WPINC . '/ms-default-filters.php' );
    require( ABSPATH . WPINC . '/ms-deprecated.php' );
}

// Define constants that rely on the API to obtain the default value.
// Define must-use plugin directory constants, which may be overridden in the sunrise.php drop-in.
wp_plugin_directory_constants( );

// Load must-use plugins.
/*foreach ( wp_get_mu_plugins() as $mu_plugin ) {
    include_once( $mu_plugin );
}
unset( $mu_plugin );*/

// Load network activated plugins.
if ( is_multisite() ) {
    foreach( wp_get_active_network_plugins() as $network_plugin ) {
        include_once( $network_plugin );
    }
    unset( $network_plugin );
}

do_action( 'muplugins_loaded' );

if ( is_multisite() )
    ms_cookie_constants(  );

// Define constants after multisite is loaded. Cookie-related constants may be overridden in ms_network_cookies().
wp_cookie_constants( );

// Define and enforce our SSL constants
wp_ssl_constants( );

// Create common globals.
require( ABSPATH . WPINC . '/vars.php' );

// Make taxonomies and posts available to plugins and themes.
// @plugin authors: warning: these get registered again on the init hook.
create_initial_taxonomies();
create_initial_post_types();

// Register the default theme directory root
//register_theme_directory( get_theme_root() );

// Load active plugins.
/*foreach ( wp_get_active_and_valid_plugins() as $plugin )
    include_once( $plugin );
unset( $plugin );*/

// Load pluggable functions.
require( ABSPATH . WPINC . '/pluggable.php' );
//require( ABSPATH . WPINC . '/pluggable-deprecated.php' );

// Set internal encoding.
wp_set_internal_encoding();

// Run wp_cache_postload() if object cache is enabled and the function exists.
if ( WP_CACHE && function_exists( 'wp_cache_postload' ) )
    wp_cache_postload();

do_action( 'plugins_loaded' );

// Define constants which affect functionality if not already defined.
wp_functionality_constants( );

// Add magic quotes and set up $_REQUEST ( $_GET + $_POST )
wp_magic_quotes();

do_action( 'sanitize_comment_cookies' );

/**
 * WordPress Query object
 * @global object $wp_the_query
 * @since 2.0.0
 */
$wp_the_query = new WP_Query();

/**
 * Holds the reference to @see $wp_the_query
 * Use this global for WordPress queries
 * @global object $wp_query
 * @since 1.5.0
 */
$wp_query =& $wp_the_query;

/**
 * Holds the WordPress Rewrite object for creating pretty URLs
 * @global object $wp_rewrite
 * @since 1.5.0
 */
$wp_rewrite = new WP_Rewrite();

/**
 * WordPress Object
 * @global object $wp
 * @since 2.0.0
 */
$wp = new WP();

/**
 * WordPress Widget Factory Object
 * @global object $wp_widget_factory
 * @since 2.8.0
 */
$GLOBALS['wp_widget_factory'] = new WP_Widget_Factory();

do_action( 'setup_theme' );

// Define the template related constants.
wp_templating_constants(  );

// Load the default text localization domain.
load_default_textdomain();

// Find the blog locale.
$locale = get_locale();
$locale_file = WP_LANG_DIR . "/$locale.php";
if ( ( 0 === validate_file( $locale ) ) && is_readable( $locale_file ) )
    require( $locale_file );
unset($locale_file);

// Pull in locale data after loading text domain.
require( ABSPATH . WPINC . '/locale.php' );

/**
 * WordPress Locale object for loading locale domain date and various strings.
 * @global object $wp_locale
 * @since 2.1.0
 */
$GLOBALS['wp_locale'] = new WP_Locale();

// Load the functions for the active theme, for both parent and child theme if applicable.
/*if ( ! defined( 'WP_INSTALLING' ) || 'wp-activate.php' === $pagenow ) {
    if ( TEMPLATEPATH !== STYLESHEETPATH && file_exists( STYLESHEETPATH . '/functions.php' ) )
        include( STYLESHEETPATH . '/functions.php' );
    if ( file_exists( TEMPLATEPATH . '/functions.php' ) )
        include( TEMPLATEPATH . '/functions.php' );
}*/

do_action( 'after_setup_theme' );

// Load any template functions the theme supports.
//require_if_theme_supports( 'post-thumbnails', ABSPATH . WPINC . '/post-thumbnail-template.php' );

// Set up current user.
$wp->init();

/**
 * Most of WP is loaded at this stage, and the user is authenticated. WP continues
 * to load on the init hook that follows (e.g. widgets), and many plugins instantiate
 * themselves on it for all sorts of reasons (e.g. they need a user, a taxonomy, etc.).
 *
 * If you wish to plug an action once WP is loaded, use the wp_loaded hook below.
 */
do_action( 'init' );

// Check site status
if ( is_multisite() ) {
    if ( true !== ( $file = ms_site_check() ) ) {
        require( $file );
        die();
    }
    unset($file);
}

/**
 * This hook is fired once WP, all plugins, and the theme are fully loaded and instantiated.
 *
 * AJAX requests should use wp-admin/admin-ajax.php. admin-ajax.php can handle requests for
 * users not logged in.
 *
 * @link http://codex.wordpress.org/AJAX_in_Plugins
 *
 * @since 3.0.0
 */
do_action('wp_loaded');

endif;

//require( ABSPATH . WPINC . '/pluggable.php' );
    
réponse donnée Victor 09.03.2012 - 14:56
2

Wordpress seul est activé ou désactivé. Parfois, mais ce n'est que par hasard et non par conception, vous pouvez contourner ce problème. Mais dans votre cas, je ne suis pas vraiment sûr que ce soit possible.

Au lieu de wp-blog-header.php , vous pouvez essayer de ne charger que les fonctions WP, incluez wp-load.php à la place. Peut-être que ça aide.

    
réponse donnée hakre 12.09.2011 - 21:51
2

Pour Wordpress 4.9: Comme je ne peux pas commenter (nouvel utilisateur). La dernière âme (installation d’un seul WP) que j’utilise pour faire fonctionner is_user_logged_in() et current_user_can() est la suivante. Nous require('wp-load.php') d’abord (pour ignorer wp () dans load-blog-header.php) , et obtenons ABSPATH constant, puis inclut manuellement exactement / strong> tout ce dont vous avez besoin.

L'utilisation de define('SHORTINIT', true) + require('wp-load.php') + inclut manuellement:

Chargement de la page: 1.05 sek - Fichiers inclus: 43 fichiers

.

Comparaison: utilisation de UNIQUEMENT require('wp-load.php') :

Chargement de la page: 1.35 sek - Fichiers inclus: 419 fichiers

.

La différence de temps (0.3 sek) peut différer de celle des installations et des moteurs PHP, mais lors de la validation de nombreuses demandes sur une seule page, les choses s'ajoutent!

N'oubliez pas d'utiliser l'appel relatif au répertoire installé WP. À partir d'un répertoire de plug-in personnalisé Wordpress, dans un niveau de sous-répertoire, installation normale, un chemin devrait ressembler à ceci:

$wordpress = '../../../../wp-load.php';

Ensuite:

define('SHORTINIT', true);
include_once $wordpress;

require_once ( ABSPATH . WPINC . '/class-wp-user.php' );
require_once ( ABSPATH . WPINC . '/class-wp-roles.php' );
require_once ( ABSPATH . WPINC . '/class-wp-role.php' );
require_once ( ABSPATH . WPINC . '/class-wp-session-tokens.php' );
require_once ( ABSPATH . WPINC . '/class-wp-user-meta-session-tokens.php' );
require_once ( ABSPATH . WPINC . '/formatting.php' );
require_once ( ABSPATH . WPINC . '/capabilities.php' );
//require_once ( ABSPATH . WPINC . '/query.php' ); // - might be useful
require_once ( ABSPATH . WPINC . '/user.php' );
require_once ( ABSPATH . WPINC . '/meta.php' );

wp_cookie_constants();

require_once ( ABSPATH . WPINC . '/vars.php' );
require_once ( ABSPATH . WPINC . '/kses.php' );
require_once ( ABSPATH . WPINC . '/rest-api.php' );
require_once ( ABSPATH . WPINC . '/pluggable.php' );

Ensuite, la validation de l'utilisateur est accessible. Pour une autre tâche, exécutez une ou deux demandes , la recherche des autres fichiers nécessaires risque de ne pas valoir 0,3 sek. Ignore la constante SHORTINIT et encombre manuellement.

    
réponse donnée Anna Ericson 25.10.2018 - 11:05
1

Vous pouvez essayer d'accéder directement à la table. Si vous connaissez le sel des fichiers de mots de passe, vous pouvez les faire se connecter via votre propre système, salez le mot de passe vous-même (regardez comment wordpress le fait) et gardez-en une trace vous-même. Si vous souhaitez pouvoir naviguer entre votre propre système et wordpress sans réauthentification, vous pouvez créer un plugin pour wordpress qui transmette la session des utilisateurs actuels à votre système.

    
réponse donnée mrkmg 12.09.2011 - 23:05
0

Le plus rapidement possible avec WP consiste à créer un wrapper personnalisé qui définira SHORTINIT , puis chargera le coeur. Cela fera cesser le chargement du noyau juste après la connexion de la base de données et avant que la plupart des API et extensions (thèmes et plugins) soient traitées.

À partir de là, vous pouvez essayer de récupérer uniquement la base de données ou de charger sélectivement les parties du noyau dont vous avez besoin.

C’est une approche assez compliquée, mais elle est aussi proche d’une charge de base plus légère que les choses deviennent dans WP.

    
réponse donnée Rarst 13.09.2011 - 00:05
0

Il semble qu’il y ait déjà eu des discussions à ce sujet. Alors, vérifiez les mises à jour sur: enlace

    
réponse donnée T.Todua 22.02.2018 - 09:47
-1

Si vous souhaitez simplement autoriser tous les utilisateurs Wordpress à utiliser l'application Web, vous pouvez utiliser le système de gestion des utilisateurs Wordpress et vérifier si l'utilisateur est connecté ou non.

Pour vérifier cela, vous devrez vérifier si le cookie nommé wordpress_logged_in_{some-hash} est présent. Sinon, redirigez l'utilisateur vers la page de connexion Wordpress. La partie {some-hash} du nom du cookie est juste une série de lettres et de chiffres.

    
réponse donnée Ofir 12.09.2011 - 21:40

Lire d'autres questions sur les étiquettes