in http{} section please define the path to proxy cache, levels, keys_zone name, expire time in minutes and max size in megabytes:

proxy_cache_path /path/to/cache levels=1:2 keys_zone=staticfilecache:180m max_size=500m;
proxy_temp_path /path/to/proxy_temp;

Please note that proxy_cache_path and proxy_temp_path should be on the same file system.

proxy_cache_key “$scheme://$host$request_uri $do_not_cache”;
proxy_cache staticfilecache;

in server {} location setting you should define the following values/settings:

proxy_cache_valid 200 15m;

The above caching settings will cache all valid 200 response for 15 minutes.

Now, if you want to boost performance of your Wordpress blog it’s quite easy – get a W3-total-cache plugin, configure it and you are set (remember, you will need a memcached server running otherwise you can’t use memcached “storage” from W3-total-cache plugin).

In our tests it boosted our Wordpress blog performance from 20-200% depending on different scenarios. Very nice plugin and it’s quite easy to set-up. Get it now.

Expire header option is also a very nice feature – you have full control when to expire the cache.

I am sure we will use this plugin for some in-house tests and then use it on some high load blogs we manage for our clientele. We will keep you posted!

You can easily increase your website performance by generating static files and serving such files much faster rather than generating files in real-time. Static files can be kept on the hard drive or in memory for blazing fast access, for example, using memcached.

Generating PHP static content
You can generate PHP output in multiple ways – from PHP code directly writing output to files or by fetching specific PHP output via HTTP protocol, or using PERL code. If you are using specific web server based values and features – you will have to fetch file via HTTP and write output to local file. This is very easy to do and doesn’t require much programming skill.

Fetching file via HTTP using WGET

wget http://www.your-domain-is-here.com/page1.php -O /var/www/page1.html

Where /var/www/page1.html is the output file.

Fetching file using CURL

curl -o /var/www/page1.html http://www.your-domain-is-here.com/page1.php

fetch -o /var/www/page1.html http://www.your-domain-is-here.com/page1.php

lynx -source http://www.your-domain-is-here.com/page1.php > /var/www/page1.html

Generating php output using a PHP script:

<?php
$files = file(“filelist.txt”);
for($i = 0; $i < count($files); $i++) {
ob_start();
include($files[$i]);
$page = ob_get_contents();
ob_end_clean();
if(strpos($files[$i], “.php”) > -1) {
$file = fopen(substr($files[$i], -4) . “.html”);
fputs($file, $page);
fclose($file);
}
}
?>

where filelist.txt is the list of the files with every file listed in new line you want it to be generated.

Perl code for fetching a remote website page. Please save the following code into the filename fetch.pl:

#!/usr/bin/perl

use LWP::Simple;
getprint “http://www.your-domain-is-here.com/page1.php“;
$content = get( $url );
print $content;

And then run it with the following Linux command line:

perl fetch.pl > outputfile.html

In the next article we will review a solution where website content is saved to memcached and content served from fast memory-based cache without generating content on the fly.

eAccelerator is also a good choice for Wordpress blog hosting and this op-code cache doesn’t cause problems with WP plugins – WP Super Cache, WP Cache and even when you run memcached caching.

Our standard settings for eAccelerator in 99% solutions is as follows:

zend_extension=”/usr/local/lib/php/extensions/no-debug-non-zts-20060613/eaccelerator.so”
eaccelerator.shm_size=”16″
eaccelerator.cache_dir=”/tmp/eaccelerator”
eaccelerator.enable=”1″
eaccelerator.optimizer=”1″
eaccelerator.check_mtime=”1″
eaccelerator.debug=”0″
eaccelerator.filter=”"
eaccelerator.shm_max=”0″
eaccelerator.shm_ttl=”0″
eaccelerator.shm_prune_period=”0″
eaccelerator.shm_only=”0″
eaccelerator.compress=”1″
eaccelerator.compress_level=”9″

Remember, it’s always better to run a few small inexpensive boxes rather than a big “monster.” You can always buy 5 boxes with 4GB RAM each for dedicated memcached servers. This will make a total of about 20GB for data caching. It will also provide redundancy, but may also add problems with keeping the state, unless you do memcached sharding and applications can determine where to fetch the data.

Scaling your all servers and services vertically is the KEY.

One of the most important performance boosts is the use of caching. In this guide, we will review multiple caching strategies that will boost your website performance and, if done correctly, decrease your site loading times and offer better online experience to your web visitors.

Javascript code.
It’s better to place Javascript code into external JS files and then call from the HTML or PHP code. By using this method, we take advantage of caching. This works great if you have a Javascript code used on multiple pages.

Example:

<script language=”JavaScript” src=”http://www.yourwebsitegoeshere.com/mycode.js” type=”text/JavaScript”></script>

Style sheets.
Move all CSS definitions to an external file, and call the file from your HTML or PHP code.

Example:

<link rel=”stylesheet” type=”text/css” href=”http://www.yourwebsitegoeshere.com/my-own.css”/>

Database queries.
The more database queries you use to generate the website or blog, the higher load it will place on your database server. This will add extra latency, and if you are getting a high number of concurrent web visitors (for example “Slashdot” effect), it may cripple the server, causing a halt. You may want to check out memcached and implement it in your website or blog code. It’s also very important to have the right indexes on the database tables. Limit SQL SELECT queries with LIMIT, you don’t need to select all table rows if you need to display only 10 records from 1,520.

If you have millions of records, a database sharding must be implemented. You can split records in multiple tables or even databases this will provide much lower query latency and greatly speed up your MySQL performance. With database sharding, you can also easily lower index creation time, as well as increase and scale INSERT and UPDATE operations.

Wordpress blog caching
By default, Wordpress works perfectly fine even for popular blogs when there are no high bursts of concurrent connections . If you get Dugg, the standard Wordpress install will not scale, and most likely the server hosting your blog will be inaccessible. Wordpress uses PHP to generate output on the fly thus, all pages are generated in real time, including data from the database.

If your content doesn’t change that often, why generate files on the fly all the time? Correct. There are wp-cache and wp super cache plug-ins that offer Wordpress caching. In other words, the plug-in will generate a static file on the server hard drive and serve it to visitors without querying the database at all. When the content changes, the static cache file is removed and a new file is generated once again.

You can also offload static content to Content Delivery Network (CDN) – see below. Offload static content section, or serve static images from a different server that is optimized to serve static content only.

Memcached
Memcached is perfect for file, data and SQL query caching that is heavily used and accessed. Caching is very good and recommended for content that is not so important to be generated from database back-end in real-time. Examples include recent comments, statistics, logged-in users in the system and news links.

Please keep in mind that there’s little of benefit to caching MySQL queries or files in memcached if the output is dedicated for one user only for example, a customer control panel displaying client-only settings or dynamic content that depends on cookies or very specific GET values.

Offloading static content
From the very beginning implement static content separate URL from your main site. Separate static content from dynamic content serving URL – for example, with subdomain http://images.yourwebsiteishere.com/ so that all images are served from this URL.

At the very beginning, you can have http://images.yourwebsiteishere.com/ on the same server to save on hosting expenses. When your site or blog grows, this will allow more flexibility in the future, and you can then point this URL to a Content Delivery Network like Akamai or ValueCDN, serve images from another server and so on.

Apache mod_expires
You should implement the HTTP protocol expire header feature to lower the hits for content that doesn’t change very often, including images, CSS, Javascript and even static HTML content. You need to compile Apache with mod_expires module for this to work.  For Apache2, you need to add the --enable-expires switch to ./configure line.

Next, you activate it with the LoadModule expires_module modules/mod_expires.so line.

Then, add the following lines to the Apache configuration file (usually httpd.conf). You can also add this to .htaccess but from the performance point of view, it’s better to have in httpd.conf.

<IfModule mod_expires.c>
ExpiresActive on
ExpiresByType image/jpg “access plus 1 weeks”
ExpiresDefault “access plus 1 days”
</IfModule>

ExpiresByType image/jpg “access plus 1 weeks” tells the browser to reload the file with the document type image/jpg from the server one week after it was first accessed.

ExpiresDefault “access plus 1 day” tells the browser to reload default files from the server one day after it was accessed.