Qual è la migliore opzione di memorizzazione nella cache per WordPress multi-sito su hosting non condiviso?

Quale configurazione di plugin di memorizzazione nella cache consigliate e perché, in base ai seguenti presupposti:

• pieno controllo della configurazione del server
• eseguire WordPress in modalità multi-sito / multi-dominio
• la maggior parte dei domini non utilizza il www.prefisso (cookie)
• (desidero) poter disabilitare la memorizzazione nella cache per IP specifici o in base a un cookie, quando si apportano modifiche al sito non è necessaria la memorizzazione nella cache.

Dettagli: sto usando il plug-in Google Page Speed ​​di Firefox per cercare di ottimizzare la velocità del sito Web.

Inoltre, non guidare con linee guida generiche, come immagini più piccole.

Cerchiamo di essere onesti, l'utilizzo di più di un plug-in di cache ti porterà più problemi di quanti ne risolva, quindi prova a dare un approccio semplice.

La risposta di base a "quale plug-in" sarebbe probabilmente W3 Total Cache . È uno dei plugin più funzionali e sviluppati attivamente al momento. Tuttavia, la catena di prestazioni completa è molto più lunga che solo il plug-in di WordPress può gestire.

1. Configurazione del server Web (Apache o qualcos'altro) (tempo di risposta, tempo al primo byte, intestazioni).
2. Database (tempo impiegato per l'elaborazione delle query).
3. PHP / WordPress (tempo di generazione della pagina, consumo di memoria).
4. Prestazioni front-end (quantità di richieste HTTP, larghezza di banda).

Un buon inizio sarebbe il plugin di cache statica (come W3) con cache basata su memoria opcode come APC .

Ma da lì ci sono molte più cose (e molto più complesse) che potresti fare, come reti di distribuzione di contenuti, server Web alternativi, ecc.

My WordPress Performance e Caching Stack

Questo è il miglior stack di prestazioni di WordPress per un singolo server o VPS di fascia medio-bassa. Sto classificando la gamma media come single core con circa 1G di memoria e unità abbastanza veloci.

Stack di server

• Linux - Debian Lenny o Ubuntu
• Nginx: configurato come cache di file statici proxy inverso
• Apache: Apache gestirà il PHP scaricato da Nginx su una porta alternativa
• MySql: richiesto da WP, assicurati di eseguire l'ultima versione stabile
• PHP - Ultima versione stabile del ramo 5.2 o 5.3

Cache PHP

• APC: configuralo con memoria mmap e dimensioni shm di almeno 128M

Stack di plugin per prestazioni WordPress

• Integratore di cache proxy Nginx
• W3 Total Cache - Imposta la cache della pagina su disco migliorato, minimizza su disco e oggetti e db su APC.
  • Self Hosted CDN - Crea 4 alias di cname che puntano al dominio sul server impostato solo per servire file statici

Con W3 Total Cache stiamo usando il disco per la cache della pagina e minimizziamo perché Nginx servirà i nostri file statici molto velocemente.

Come configurare Nginx per servire file statici e passare PHP ad Apache

Il problema con l'utilizzo di Apache da solo è che apre una connessione e colpisce php su ogni richiesta anche per i file statici. Questo spreca le connessioni perché Apache le terrà aperte e quando hai molto traffico le tue connessioni verranno bloccate anche se non vengono utilizzate.

Per impostazione predefinita, Apache è in attesa di richieste sulla porta 80, che è la porta Web predefinita. Per prima cosa faremo modifiche ai nostri file conf e host virtuali di Apache per l'ascolto sulla porta 8080.

Config Apache

httpd.conf

disattivare KeepAlive

ports.conf

NameVirtualHost *:8080
Listen 8080

Host virtuale per sito

<VirtualHost 127.0.0.1:8080>
     ServerAdmin info@yoursite.com
     ServerName yoursite.com
     ServerAlias www.yoursite.com
     DocumentRoot /srv/www/yoursite.com/public_html/
     ErrorLog /srv/www/yoursite.com/logs/error.log
     CustomLog /srv/www/yoursite.com/logs/access.log combined
</VirtualHost>

Dovresti anche installare mod_rpaf in modo che i tuoi log contengano gli indirizzi IP reali dei tuoi visitatori. In caso contrario, i tuoi registri avranno 127.0.0.1 come indirizzo IP di origine.

Config Nginx

Su Debian è possibile usare i repository per l'installazione ma contengono solo la versione 0.6.33. Per installare una versione successiva è necessario aggiungere i pacchetti di backport di lenny

$ nano /etc/apt/sources.list

Aggiungi questa riga al file deb http://www.backports.org/debian lenny-backports main

$ nano /etc/apt/preferences

Aggiungi quanto segue al file:

Package: nginx
Pin: release a=lenny-backports 
Pin-Priority: 999

Immettere i comandi seguenti per importare la chiave da backports.org per verificare i pacchetti e aggiornare il database dei pacchetti del sistema:

$ wget -O - http://backports.org/debian/archive.key | apt-key add -
$ apt-get update

Ora installa con apt-get

apt-get install nginx

Questo è molto più semplice della compilazione dal sorgente.

Nginx conf e file config

nginx.conf

user www-data;
worker_processes  4;

error_log  /var/log/nginx/error.log;
pid        /var/run/nginx.pid;

events {
    worker_connections  1024;
}

http {
    include       /etc/nginx/mime.types;
    default_type  application/octet-stream;

    access_log  /var/log/nginx/access.log;
    client_body_temp_path /var/lib/nginx/body 1 2;
    gzip_buffers 32 8k;
    sendfile        on;
    #tcp_nopush     on;

    #keepalive_timeout  0;
    keepalive_timeout  65;
    tcp_nodelay        on;

    gzip  on;

  gzip_comp_level   6;
  gzip_http_version 1.0;
  gzip_min_length   0;
  gzip_types        text/html text/css image/x-icon
        application/x-javascript application/javascript text/javascript application/atom+xml application/xml ;



    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}

Ora dovrai configurare il tuo hosting virtuale Nginx. Mi piace usare il metodo abilitato per i siti con ogni sym v host collegato a un file nella directory dei siti disponibili.

$ mkdir /etc/nginx/sites-available  
$ mkdir /etc/nginx/sites-enabled
$ touch /etc/nginx/sites-available/yourservername.conf
$ touch /etc/nginx/sites-available/default.conf
$ ln -s  /etc/nginx/sites-available /etc/nginx/sites-enabled
$ nano /etc/nginx/sites-enabled/default.conf

default.conf

Nota:

Le impostazioni della cache statica nei seguenti file funzioneranno solo se il plug-in integratore della cache proxy Nginx è abilitato.

proxy_cache_path  /var/lib/nginx/cache  levels=1:2   keys_zone=staticfilecache:180m  max_size=500m;
proxy_temp_path /var/lib/nginx/proxy;
proxy_connect_timeout 30;
proxy_read_timeout 120;
proxy_send_timeout 120;

#IMPORTANT - this sets the basic cache key that's used in the static file cache.
proxy_cache_key "$scheme://$host$request_uri";

upstream wordpressapache {
        #The upstream apache server. You can have many of these and weight them accordingly,
        #allowing nginx to function as a caching load balancer 
        server 127.0.0.1:8080 weight=1 fail_timeout=120s;
}

Per la configurazione del sito WordPress (per più siti è necessario un solo vhost)

server {
        #Only cache 200 responses, and for a default of 20 minutes.
        proxy_cache_valid 200 20m;

        #Listen to your public IP
        listen 80;

        #Probably not needed, as the proxy will pass back the host in "proxy_set_header"
        server_name www.yoursite.com yoursite.com;
        access_log /var/log/nginx/yoursite.proxied.log;  

        # "combined" matches apache's concept of "combined". Neat.
        access_log  /var/log/apache2/nginx-access.log combined;
        # Set the real IP.
        proxy_set_header X-Real-IP  $remote_addr;

        # Set the hostname
        proxy_set_header Host $host;

        #Set the forwarded-for header.
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

        location / {
                        # If logged in, don't cache.
                        if ($http_cookie ~* "comment_author_|wordpress_(?!test_cookie)|wp-postpass_" ) {
                                set $do_not_cache 1;
                        }
                        proxy_cache_key "$scheme://$host$request_uri $do_not_cache";
                        proxy_cache staticfilecache;
                        proxy_pass http://wordpressapache;
        }

        location ~* wp\-.*\.php|wp\-admin {
                        # Don't static file cache admin-looking things.
                        proxy_pass http://wordpressapache;
        }

        location ~* \.(jpg|png|gif|jpeg|css|js|mp3|wav|swf|mov|doc|pdf|xls|ppt|docx|pptx|xlsx)$ {
                        # Cache static-looking files for 120 minutes, setting a 10 day expiry time in the HTTP header,
                        # whether logged in or not (may be too heavy-handed).
                        proxy_cache_valid 200 120m;
                        expires 864000;
                        proxy_pass http://wordpressapache;
                        proxy_cache staticfilecache;
        }

        location ~* \/[^\/]+\/(feed|\.xml)\/? {
 # Cache RSS looking feeds for 45 minutes unless logged in.
                        if ($http_cookie ~* "comment_author_|wordpress_(?!test_cookie)|wp-postpass_" ) {
                                set $do_not_cache 1;
                        }
                        proxy_cache_key "$scheme://$host$request_uri $do_not_cache";
                        proxy_cache_valid 200 45m;
                        proxy_cache staticfilecache;
                        proxy_pass http://wordpressapache;
        }

        location = /50x.html {
                root   /var/www/nginx-default;
        }

        # No access to .htaccess files.
        location ~ /\.ht {
                deny  all;
        }

        }

Conf. CDN self-hosted

Per la tua configurazione CDN self hosted devi solo configurarlo per servire file statici senza il proxy pass

server {

        proxy_cache_valid 200 20m;
        listen 80;
        server_name yourcdndomain.com;
        access_log   /srv/www/yourcdndomain.com/logs/access.log;
        root   /srv/www/yourcdndomain.com/public_html/;

 proxy_set_header X-Real-IP  $remote_addr;

      location ~* \.(jpg|png|gif|jpeg|css|js|mp3|wav|swf|mov|doc|pdf|xls|ppt|docx|pptx|xlsx)$ {
                                # Cache static-looking files for 120 minutes, setting a 10 day expiry time in the HTTP header,
                                # whether logged in or not (may be too heavy-handed).

                                proxy_cache_valid 200 120m;
                        expires 7776000;
                        proxy_cache staticfilecache;
                }

location = /50x.html {
                root   /var/www/nginx-default;
        }

 # No access to .htaccess files.
        location ~ /\.ht {
          deny  all;
        }

    }

Ora avvia i server

$ /etc/init.d/apache2 restart  
$/etc/init.d/nginx start

I risultati del benchmark

Su Apache Bench questa configurazione può teoricamente servire 1833,56 richieste al secondo

$ ab -n 1000 -c 20 http://yoursite.com/

Usa uno spazio web con almeno 64 MB di RAM per Multisito e usa APC e Memcached su Apache, cache non statica e puoi usare tutte le funzioni WP senza problemi. Puoi scansionare tramite PageSpeed ​​anche leggere altre opzioni, c'era un codice nel tema. Una cache può fare un ottimo lavoro, ma non può riparare un tema o un plug-in difettoso. Un'altra soluzione è utilizzare i sottodomini senza cookie come CDN in WordPress. Aggiungilo a wp-config.php per i cookie solo sul dominio, non per il sottodominio.

define( 'COOKIE_DOMAIN', 'example.com' );

Ora imposta nuove funzioni nel function.php del tema o scrivi un plugin per sostituire il percorso del contenuto statico ai tuoi sottodomini, il tuo CDN personalizzato.

// replace for CDN on bloginfo
if ( !function_exists('fb_add_static_wpurl') ) {
    function fb_add_static_wpurl($info, $show) {

        if ( is_admin() )
            return $info;

        $keys = array(
            'url',
            'wpurl',
            'stylesheet_url',
            'stylesheet_directory',
            'template_url',
            'template_directory',
            );

        if ( in_array( $show, $keys ) ) {

            $wpurl = get_bloginfo('wpurl');

            $search = array(
                $wpurl . '/wp-content/images/',
                $wpurl . '/wp-content/download/',
                $wpurl . '/wp-content/themes/',
                $wpurl . '/wp-content/plugins/',
            );

            $replace = array(
                'http://cdn1.example.com/',
                'http://cdn2.example.com/',
                'http://cdn3.example.com/',
                'http://cdn4.example.com/',
            );

            return str_replace( $search, $replace, $info );

        } else {
            return $info;
        }
    }
    add_filter( 'bloginfo_url', 'fb_add_static_wpurl', 9999, 2 );
}

ora la funzione per modello e percorso foglio di stile

function fb_add_static_stylesheet_uri($uri) {

            if ( is_admin() )
                return $uri;

            $wpurl = get_bloginfo('wpurl');

            $search = array(
                $wpurl . '/wp-content/images/',
                $wpurl . '/wp-content/download/',
                $wpurl . '/wp-content/themes/',
                $wpurl . '/wp-content/plugins/',
            );

            $replace = array(
                'http://cdn1.example.com/',
                'http://cdn2.example.com/',
                'http://cdn3.example.com/',
                'http://cdn4.example.com/',
            );
            return str_replace( $search, $replace, $uri );

}
add_filter ( 'template_directory_uri', 'fb_add_static_stylesheet_uri' );
add_filter ( 'stylesheet_uri', 'fb_add_static_stylesheet_uri' );
add_filter ( 'stylesheet_directory_uri', 'fb_add_static_stylesheet_uri' );

Ora leggi Page Speed ​​sugli URL statici CDN front-end senza cookie.

Aggiungi anche la seguente fonte a .htaccess per bloccare il contenuto pubblico:

##
# Explicitly send a 404 header if a file on cdn[0-9].example.org is not
# found. This will prevent the start page (empty URL) from being loaded.
##
RewriteCond %{HTTP_HOST} ^cdn[0-9]\.example\.org [NC]
RewriteCond %{REQUEST_FILENAME} !-f
RewriteRule .* - [R=404,L]

##
# Do not dispatch dynamic resources via cdn[0-9].example.org.
##
RewriteCond %{HTTP_HOST} ^cdn[0-9]\.example\.org [NC]
RewriteCond %{REQUEST_FILENAME} \.(php|html)$
RewriteRule .* - [R=404,L]

Si prega di utilizzare la funzione, è anche esempi e puoi scrivere le tue soluzioni con le mie idee.

Stack del server web

Sostanzialmente conservare ogni operazione in memoria!

• CPU moderna, elevata larghezza di banda della memoria poiché WordPress è principalmente copia della memoria, tempo di accesso al disco sotto msec, prova UpCloud!
• Sottile livello di virtualizzazione, prova UpCloud! Tenere lontano da provider popolari e non aziendali
• Sistema operativo veloce: nessun sistema, abbastanza entropia, bilanciamento IRQ, utilizzo di memoria insufficiente
• Blocca gli attaccanti martellanti: Fail2ban, blocca permanentemente le reti ombra
• DNS Anycast
• Web server rapido: Apache Event MPM
• Connessione parallela CDN con velocità simili a RAM (Amazon CloudFront)
• SSL ad alta velocità: certificato ECDSA, sorgente Entropy, TLS1.2, Ciphersuites per AES-NI, cache di sessione SSL, pinzatura OCSP, HTTP / 2
• PHP moderno con OPcache, collegato tramite FastCGI
• Installazione snella di WordPress: solo plugin minimali e controllati
• Redis cache degli oggetti in memoria
• TokuDB (albero frattale) Motore MariaDB
• Ottimizzazione delle risorse
• Taglia su JavaScripts
• Monitoraggio continuo: Pingdom, HetrixTools

Tutta la mia conoscenza è open-source https://github.com/szepeviktor/debian-server-tools