2. Who am I ?
Wim Godden (@wimgtr)
Founder of Cu.be Solutions (http://cu.be)
Open Source developer since 1997
Developer of OpenX, PHPCompatibility, Nginx extensions, ...
Zend / ZF Certified Engineer
MySQL Certified Developer
Speaker at PHP and Open Source conferences
3. Who are you ?
Developers ?
System/network engineers ?
Managers ?
Caching experience ?
4. Goals of this tutorial
Everything about caching and tuning
A few techniques
How-to
How-NOT-to
→ Increase reliability, performance and scalability
5 visitors/day → 5 million visitors/day
(Don't expect miracle cure !)
7. Test page
3 DB-queries
select firstname, lastname, email from user where user_id = 5;
select title, createddate, body from article order by createddate desc limit 5;
select title, createddate, body from article order by score desc limit 5;
Page just outputs result
8. Our base benchmark
Apachebench = useful enough
Result ?
Single webserver Proxy
Static PHP Static PHP
Apache + PHP 3900 17.5 6700 17.5
Limit :
CPU, network
or disk
Limit :
database
11. What is caching ?
x = 5, y = 2
n = 50
Same result
CACHECACHE
select
*
from
article
join user
on article.user_id = user.id
order by
created desc
limit
10
Doesn't change
all the time
12. Theory of caching
DB
Cache
$data = get('key')
false
GET /page
Page
select data from
table
$data = returned result
set('key', $data)
if ($data == false)
16. Some figures
Pageviews : 5000 (4000 on 10 pages)
Avg. loading time : 200ms
Cache 10 pages
Avg. loading time : 20ms
→ Total avg. loading time : 56ms
Worth it ?
17. Caching goals - 3rd
goal
Send less data across the network / Internet
You benefit → lower bill from upstream provider
Users benefit → faster page load
Wait a second... that's mostly frontend stuff !
18. Caching techniques
#1 : Store entire pages
Company Websites
Blogs
Full pages that don't change
Render → Store in cache → retrieve from cache
19. Caching techniques
#2 : Store parts of a page
Most common technique
Usually a small block in a page
Best effect : reused on lots of pages
Can be inserted on dynamic pages
21. Caching techniques
#3 : Store SQL queries
↔ SQL query cache
Limited in size
Resets on every insert/update/delete
Server and connection overhead
Goal :
not to get rid of DB
free up DB resources for more hits !
Better :
store returned object
store group of objects
22. Caching techniques
#4 : Store complex PHP results
Not just calculations
CPU intensive tasks :
Config file parsing
XML file parsing
Loading CSV in an array
Save resources → more resources available
23. Caching techniques
#xx : Your call
Only limited by your imagination !
When you have data, think :
Creating time ?
Modification frequency ?
Retrieval frequency ?
24. How to find cacheable data
New projects : start from 'cache everything'
Existing projects :
Look at MySQL slow query log
Make a complete query log (don't forget to turn it off !)
→ Use Percona Toolkit (pt-query-digest)
Check page loading times
25. Caching storage - MySQL query cache
Use it
Don't rely on it
Good if you have :
lots of reads
few different queries
Bad if you have :
lots of insert/update/delete
lots of different queries
26. Caching storage - Database memory tables
Tables stored in memory
In MySQL : memory/heap table
↔ temporary table :
memory tables are persistent
temporary tables are session-specific
Faster than disk-based tables
Can be joined with disk-based tables
But :
default 16MByte limit
master-slave = trouble
if you don't need join → overhead of DB software
So : don't use it unless you need to join
28. Caching storage - Opcode caching
APC
De-facto standard
Will be in PHP core in 5.4 ? 5.5 ? 6.0 ?
PECL or packages
29. Caching storage - Opcode caching
Zend Optimizer+
Will be in PHP core in 5.5
APC
eAccelerator
30. Caching storage - Opcode caching
Zend Optimizer+
Will be in PHP core in 5.5
APC
eAccelerator
PHP PHP + Zend O+ PHP + APC
42.18 req/sec 206.20 req/sec 211.49 req/sec
31. Caching storage - Disk
Data with few updates : good
Caching SQL queries : preferably not
DON'T use NFS or other network file systems
high latency
possible problem for sessions : locking issues !
32. Caching storage - Memory disk (ramdisk)
Usually faster than physical disk
But : OS file caching makes difference minimal
(if you have enough memory)
33. Caching storage - Disk / ramdisk
Overhead : filesystem
Limited number of files per directory
→ Subdirectories
Local
5 Webservers → 5 local caches
How will you keep them synchronized ?
→ Don't say NFS or rsync !
34. Caching storage - Memcache(d)
Facebook, Twitter, YouTube, … → need we say more ?
Distributed memory caching system
Multiple machines ↔ 1 big memory-based hash-table
Key-value storage system
Keys - max. 250bytes
Values - max. 1Mbyte
35. Caching storage - Memcache(d)
Facebook, Twitter, YouTube, … → need we say more ?
Distributed memory caching system
Multiple machines ↔ 1 big memory-based hash-table
Key-value storage system
Keys - max. 250bytes
Values - max. 1Mbyte
Extremely fast... non-blocking, UDP (!)
38. Memcache - installation & running it
Installation
Distribution package
PECL
Windows : binaries
Running
No config-files
memcached -d -m <mem> -l <ip> -p <port>
ex. : memcached -d -m 2048 -l 172.16.1.91 -p 11211
39. Caching storage - Memcache - some notes
Not fault-tolerant
It's a cache !
Lose session data
Lose shopping cart data
...
40. Caching storage - Memcache - some notes
Not fault-tolerant
It's a cache !
Lose session data
Lose shopping cart data
…
Different libraries
Original : libmemcache
New : libmemcached (consistent hashing, UDP, binary protocol, …)
Firewall your Memcache port !
41. Memcache in code
<?php
$memcache = new Memcache();
$memcache->addServer('172.16.0.1', 11211);
$memcache->addServer('172.16.0.2', 11211);
$myData = $memcache->get('myKey');
if ($myData === false) {
$myData = GetMyDataFromDB();
// Put it in Memcache as 'myKey', without compression, with no expiration
$memcache->set('myKey', $myData, false, 0);
}
echo $myData;
Careful : false is a valid value !
42. Memcache in code
<?php
$memcache = new Memcache();
$memcache->addServer('172.16.0.1', 11211);
$memcache->addServer('172.16.0.2', 11211);
$myData = $memcache->get('myKey');
if ($memcache->getResultCode() == Memcached::RES_NOTSTORED) {
$myData = GetMyDataFromDB();
// Put it in Memcache as 'myKey', without compression, with no expiration
$memcache->set('myKey', $myData, false, 0);
}
echo $myData;
43. Benchmark with Memcache
Single webserver Proxy
Static PHP Static PHP
Apache + PHP 3900 17.5 6700 17.5
Apache + PHP + MC 3900 55 6700 108
44. Where's the data ?
Memcache client decides (!)
2 hashing algorithms :
Traditional
Server failure → all data must be rehashed
Consistent
Server failure → 1/x of data must be rehashed (x = # of servers)
No replication !
45. Memcached ? Couchbase ? Redis ? … ?
Memcached Couchbase Redis
Purpose Key-value store Document store Key-value store
Additional indexes No Yes No
Replication No Master-master
Master-slave
Master-slave
Persistency No Yes Yes
Interesting read : http://kkovacs.eu/cassandra-vs-mongodb-vs-couchdb-vs-redis
(Cassandra vs MongoDB vs CouchDB vs Redis vs Riak vs HBase vs Couchbase
vs Neo4j vs Hypertable vs ElasticSearch vs Accumulo vs VoltDB vs Scalaris
comparison)
46. Memcache slabs
(or why Memcache says it's full when it's not)
Multiple slabs of different sizes :
Slab 1 : 400 bytes
Slab 2 : 480 bytes (400 * 1.2)
Slab 3 : 576 bytes (480 * 1.2) (and so on...)
Multiplier (1.2 here) can be configured
Store a lot of very large objects
→ Large slabs : full
→ Rest : free
→ Eviction of data !
47. Memcache - Is it working ?
Connect to it using telnet
"stats" command →
Use Cacti or other monitoring tools
STAT pid 2941
STAT uptime 10878
STAT time 1296074240
STAT version 1.4.5
STAT pointer_size 64
STAT rusage_user 20.089945
STAT rusage_system 58.499106
STAT curr_connections 16
STAT total_connections 276950
STAT connection_structures 96
STAT cmd_get 276931
STAT cmd_set 584148
STAT cmd_flush 0
STAT get_hits 211106
STAT get_misses 65825
STAT delete_misses 101
STAT delete_hits 276829
STAT incr_misses 0
STAT incr_hits 0
STAT decr_misses 0
STAT decr_hits 0
STAT cas_misses 0
STAT cas_hits 0
STAT cas_badval 0
STAT auth_cmds 0
STAT auth_errors 0
STAT bytes_read 613193860
STAT bytes_written 553991373
STAT limit_maxbytes 268435456
STAT accepting_conns 1
STAT listen_disabled_num 0
STAT threads 4
STAT conn_yields 0
STAT bytes 20418140
STAT curr_items 65826
STAT total_items 553856
STAT evictions 0
STAT reclaimed 0
51. Memcache - tip
Page with multiple blocks ?
→ use Memcached::getMulti()
But : what if you get some hits and some misses ?
getMulti($array)
Hashing
algorithm
52. Naming your keys
Key names must be unique
Prefix / namespace your keys !
Only letters, numbers and underscore
Why ? → Change caching layer
md5() is useful
→ BUT : harder to debug
Use clear names
Document your key names !
63. Cache warmup scripts
Used to fill your cache when it's empty
Run it before starting Webserver !
2 ways :
Visit all URLs
Error-prone
Hard to maintain
Call all cache-updating methods
Make sure you have a warmup script !
64. Cache stampeding - what about locking ?
Seems like a nice idea, but...
While lock in place
What if the process that created the lock fails ?
65. Quick word about expiration
General rule : don't let things expire
Exception to the rule : things that have an end date (calendar
items)
66. So...
DON'T DELETE FROM CACHE
&
DON'T EXPIRE FROM CACHE
(unless you know you'll never store it again)
67. Time for...
a break (15 min)
After the break :
Byebye Apache
Reverse proxying
The importance of frontend
lots of hints & tips...
71. Nginx - a true alternative to Apache ?
Not all Apache modules
mod_auth_*
mod_dav*
…
Basic modules are available
Lots of 3rd
party modules (needs recompilation !)
73. Nginx - Configuration
server {
listen 80;
server_name www.domain.ext *.domain.ext;
index index.html;
root /home/domain.ext/www;
}
server {
listen 80;
server_name photo.domain.ext;
index index.html;
root /home/domain.ext/photo;
}
74. Nginx - phase 1
Move Apache to a different port (8080)
Put Nginx at port 80
Nginx serves all statics (images, css, js, …)
Forward dynamic requests to Apache
87. Varnish - VCL
Varnish Configuration Language
DSL (Domain Specific Language)
→ compiled to C
Hooks into each request
Defines :
Backends (web servers)
ACLs
Load balancing strategy
Can be reloaded while running
88. Varnish - whatever you want
Real-time statistics (varnishtop, varnishhist, ...)
ESI
89. Article content page
/page/732
Article content (TTL : 15 min)
/article/732
Varnish - ESI
Perfect for caching pages
Header (TTL : 60 min)
/top
Latest news (TTL : 2 min) /news
Navigation
(TTL :
60 min)
/nav
In your /page/732 output :
<esi:include src="/top"/>
<esi:include src="/nav"/>
<esi:include src="/news"/>
<esi:include src="/article/732"/>
In your Varnish config :
sub vcl_fetch {
if (req.url == "/news") {
esi; /* Do ESI processing */
set obj.ttl = 2m;
} elseif (req.url == "/nav") {
esi;
set obj.ttl = 1m;
} elseif ….
….
}
90. Varnish with ESI - hold on tight !
Single webserver Proxy
Static PHP Static PHP
Apache + PHP 3900 17.5 6700 17.5
Apache + PHP + MC 3900 55 6700 108
Nginx + PHP-FPM + MC 11700 57 11200 112
Varnish - - 11200 4200
91. Varnish - what can/can't be cached ?
Can :
Static pages
Images, js, css
Pages or parts of pages that don't change often (ESI)
Can't :
POST requests
Very large files (it's not a file server !)
Requests with Set-Cookie
User-specific content
92. ESI → no caching on user-specific content ?
Logged in as : Wim Godden
5 messages
TTL = 5minTTL=1h
TTL = 0s ?
93. Coming soon...
Based on Nginx
Reduces load by 50 – 95%
Requires code changes !
Well-built project → few changes
Effect on webservers and database servers
95. Requesting /page ESI subrequests (1st
time)
Nginx
1
2
3
/menu
/news
/top (in ESI session)
96. Requesting /page (next time)
Nginx
Shared memory
1
2
/page
/menu
/news
/top (in ESI session)
/page
97. New message is sent...
POST /send
DB
insert into...
set(...)
top (in ESI session)
98. Advantages
No repeated GET hits to webserver anymore !
At login : POST → warm up the cache !
No repeated hits for user-specific content
Not even for non-specific content
100. How many Memcache requests ?
Logged in as : Wim Godden
5 messages
<scl:include key="news" src="/news" ttl="5m" />
<scl:include
key="menu"
src="/menu"
ttl="1h" />
<scl:include key="top" src="/top" session="true" ttl="1h" />
101. First release : ESI
Part of the ESI 1.0 spec
Only relevant features implemented
Extension for dynamic session support
But : unavailable for copyright reasons
102. Rebuilt from scratch : SCL
Session-specific Caching Language
Language details :
Control structures : if/else, switch/case, foreach
Variable handling
Strings : concatenation, substring, ...
104. Figures
Second customer (already using Nginx + Memcache) :
No. of web servers : 72 → 8
No. of db servers : 15 → 4
Total : 87 → 12 (86% reduction !)
Latest customer :
Total no. of servers : 1350 → 380
72% reduction → €1.5 million / year
105. A real example : vBulletin
DB Server Load Web Server Load Max Requests/sec (1 = 282)
0
5
10
15
20
25
30
35
Standard install
With Memcached
Nginx + SCL + memcached
106. Availability
Good news :
It will become Open Source
It's solid : stable at 3 customers, being installed at 1 more
Bad news :
First customer holds copyrights
Total rebuild
→ Open Source release
Beta : Sep 2013
Final : End 2013 (on Github !)
108. PHP speed - some tips
Upgrade PHP - every minor release has 5-15% speed gain !
Use an opcode cache (Zend O+, APC, eAccelerator, XCache)
Profile your code
XHProf
Xdebug
But : turn off profilers on acceptance/production platforms !
110. PHP speed - some tips
Most performance issues are in DB queries → look there first !
Log PHP errors and review those logs !
Shorter code != faster code → keep your code readable !
Hardware cost < Manpower cost
→ 1 more server < 30 mandays of labor
Keep micro-optimizations in code = last thing on list
111. Apache - tuning tips
Disable unused modules → fixes 10% of performance issues
Set AllowOverride to None. Enable only where needed !
Disable SymLinksIfOwnerMatch. Enable only where needed !
MinSpareServers, MaxSpareServers, StartServers, MaxClients,
MPM selection → a whole session of its own ;-)
Don't mod_proxy → use Nginx or Varnish !
High load on an SSL-site ? → put SSL on a reverse proxy
112. DB speed - some tips
Avoid dynamic functions
Ex. : select id from calendar where startDate > curdate()
Better : select id from calendar where startDate > "2013-05-14"
Use same types for joins
i.e. don't join decimal with int, bigint with int, etc.
RAND() is evil !
count(*) is evil in InnoDB without a where clause !
Persistent connect is sort-of evil
Index, index, index !
→ But only on fields that are used in where, order by, group by !
114. Caching in the browser
HTTP 304 (Not modified)
Expires/Cache-Control header
2 notes :
Don't use POST if you want to cache
Don't cache user-specific pages in browser (security !)
115. HTTP 304
Browser Server
No header
Last Modified: Fri 28 Jan 2011 08:31:01 GMT
If-Modified-Since: Fri 28 Jan 2011 08:31:01 GMT
200 OK / 304 Not Modified
First request
Next requests
116. HTTP 304 with ETag
Browser Server
No header
Etag: 8a53321-4b-43f0b6dd972c0
If-None-Match: 8a53321-4b-43f0b6dd972c0
200 OK / 304 Not Modified
First request
Next requests
117. Expires/Cache-control header
Cache-Control
HTTP/1.1
Seconds to expiry
Used by browsers
Browser Server
No header
Expires: Fri 29 Nov 2011 12:11:08 GMT
Cache-Control: max-age=86400
First request
Next requests No requests until item expires
Expires
HTTP/1.0
Date to expire on
Used by old proxies
Requires clock to be accurate !
118. Pragma: no-cache = evil
"Pragma: no-cache" doesn't make it uncacheable
Don't want caching on a page ?
HTTP/1.0 : "Expires : Fri, 30 Oct 1998 00:00:00 GMT" (in the past)
HTTP/1.1 : "Cache-Control: no-store"
119. Frontend tuning
1. You optimize backend
2. Frontend engineers messes up → havoc on backend
3. Don't forget : frontend sends requests to backend !
SO...
Care about frontend
Test frontend
Check what requests frontend sends to backend
126. Tuning frontend
Minimize requests
Combine CSS/JavaScript files
Use inline images in CSS/XHTML (not supported on all browsers yet)
Use CSS Sprites (horizontally if possible)
Put CSS at top
Put JavaScript at bottom
Max. no connections
Especially if JavaScript does Ajax (advertising-scripts, …) !
Avoid iFrames
Again : max no. of connections
Don't scale images in HTML
Have a favicon.ico (don't 404 it !)
→ see my blog
127. Tuning frontend
Don't use inline CSS/JavaScript
CSS/JavaScript need to be external files (minified, merged)
Why ? → Cacheable by browser / reverse proxy
Use GET for Ajax retrieval requests (and cache them !)
Optimize images (average 50-60% !)
Split requests across subdomains
Put statics on a separate subdomain (without cookies !)
www.domain.ext
Max. 2
requests
www.domain.ext
Max. 2
requests
Max. 2
requests
images.domain.ext
128. Tuning miscellaneous
Avoid DNS lookups
Frontend : don't use too many subdomains (2 = ideal)
Backend :
Turn off DNS resolution in Apache : HostnameLookups Off
If your app uses external data
Run a local DNS cache (timeout danger !)
Make sure you can trust DNS servers (preferable run your own)
Compress non-binary content (GZIP)
mod_deflate in Apache
HttpGzipModule in Nginx (HttpGzipStaticModule for pre-zipped statics !)
No native support in Varnish
129. What else can kill your site ?
Redirect loops
Multiple requests
More load on Webserver
More PHP to process
Additional latency for visitor
Try to avoid redirects anyway
→ In ZF : use $this->_forward instead of $this->_redirect
Watch your logs, but equally important...
Watch the logging process →
Logging = disk I/O → can kill your server !
130. Above all else... be prepared !
Have a monitoring system
Use a cache abstraction layer (disk → Memcache)
Don't install for the worst → prepare for the worst
Have a test-setup
Have fallbacks
→ Turn off non-critical functionality
131. So...
Cache
But : never delete, always push !
Have a warmup script
Monitor your cache
Have an abstraction layer
Apache = fine, Nginx = better
Static pages ? Use Varnish
Tune your frontend → impact on backend !
Caching serves 3 purposes : - Firstly, to reduce the number of requests or the load at the source of information, which can be a database server, content repository, or anything else.
Secondly, you want to improve the response time of each request. If you request a page that takes 50ms to load without caching and you get 10 hits/second, you won't be able to serve those requests with 5 Apache processes. If you could cache some of the data used on the page you might be able to return the page in 20ms. That doesn't just improve user experience, but reduces the load on the webserver, since the number of concurrent connections is a lot lower. → connections closed faster → handle more connections and, as a result, more hits on the same machine. → If you don't : more Apache processes needed → will eat memory, will eat system resources and as a result will also cause context switching.
More tuning → Reduce the amount of data that needs to be sent over the network or the Internet - benefits you, as application provider, because you have less traffic on your upstream connection. - also better for the enduser because there will be less data to be downloaded. → Ofcourse part of frontend side, which we'll discuss near the end of the tutorial.
The first way to cache in a web application, or actually more commonly a website, is to cache entire pages. This used to be a very popular caching technique, back in the days when pages were very static. It's still popular for things like company websites, blogs, and any site that has pages that don't change a lot. Basically, you just render the page once, put it in a cache, and from the moment onwards, you just retrieve it from the cache.
Store part of a page. Probably most common + best way to cache data. - Basically what you do is, take piece of data : - data from the database - result of a calculation - an aggregation of two feeds - parsed data from CSV-file from NFS share located on the other side of the world - could be data that was stored on a USB stick your kid is now chewing on. What I mean is : it doesn't matter where the data came from. Part of a page, usually a block on a page and want save time by not having to get that data from its original source every time again. Instead of saving entire page, where you can have multiple dynamic parts, some of which might not be cached because they are really dynamic, like the current time. So store small block, so that when we render the page, all we do is get small block from cache and place it in dynamic page and output it.
Store the output of SQL queries. → Now, who of you know what SQL query caching is, MySQL query cache for example ? → Basically, the MySQL query cache is a cache which stores the output of recently run SQL queries. It's built into MySQL, it's... not enabled by default everywhere, it depends on your distribution. → And it speeds up queries by a huge margin. Disabling it is something I never do, because you gain a lot by having it enabled. → However, there's a few limitations : - First of all, the query cache is limited in size.
But, basically one of the big drawbacks of MySQL query cache, is that every time you do an insert, update or delete on a table, the entire query cache for queries referencing that table, is erased. → Another drawback is that you still need to connect to the MySQL server and you still need to go through a lot of the core of MySQL to get your results. → So, storing the output of SQL queries in a separate cache, being Memcache or one of the other tools we're going to see in a moment, is actually not a bad idea. Also because of the fact that, if you have a big Website, you will still get quite a bit load on your MySQL database. So anything that takes the load off the database and takes it to where you have more resources available, is a good idea. → Better : store returned object or group of objects
Another caching technique I want to mention is storing the result of complex PHP processes. - You might think about some kind of calculation, but when I mention calculation, people tend to think about getting data from here and there and then summing them. - That's not what I mean. By complex PHP processes I mean things like parsing configuration files, parsing XML files, loading CSV-data in an array, converting mutliple XML-files into an object structure, and so on. - End result of those complex PHP processes can be cached, especially if the data from which we started doesn't change a lot. That way you can save a lot of system resources, which can be used for other things.
There's plenty of other types of data to store in cache. The only limit there is your imagination. All you need to think of is : - I have this data - how long did it take me to create it - how often does it change - how often will it be retrieved ? That last bit can be a difficult thing to balance out, but we'll get back to that later.
OK, let's talk about where cached data can be stored. I already mentioned MySQL query cache. Turn it on But don't rely on it too heavily especially if you have data that changes often.
I said I was going to discuss some do's and don'ts... → This one falls under the category don't → There's a second database mechanism for "caching", at least some people use it for that purpose. It's called database memory tables. → MySQL has such as storage type : it's called a memory or a heap table. And basically it allows you to store data in tables that are stored in memory. → Don't confuse it with a temporary table, which is only valid for your connection. → This is actually a persistent table, well persistent meaning that it will survive after you disconnect, but it won't survive a server reboot, because it's in-memory only. → Advantages of this storage type are that it's faster than disk-based tables and you can join it with disk-based tables. Also, there's a default limit of 16MByte per table and it can be troublesome getting it to work on a master-slave setup. → So my advise is : don't use it.
Alright, next. Opcode caching... this is definitely a DO. → There's a few opcode caches out there. → Now what is opcode caching ? Basically, when you run a PHP file, the PHP is converted by the PHP compiler to what is called bytecode. This code is then executed by the PHP engine and that produces the output. → Now, if your PHP code doesn't change a lot, which normally it shouldn't while your application is live, there's no reason for the PHP compiler to convert your source code to bytecode over and over again, because basically it's just doing the same thing, every time. → So an opcode cache caches the bytecode, the compiled version of your source code. That way, it doesn't have to compile the code, unless your source code changes. This can have a huge performance impact.
APC is the most popular one and will probably be included in one of the next few releases. Might be 5.4, but there's still a lot of discussion about that. I'm guessing we probably won't see it before 5.5 or who knows 6.0, if that ever comes out. To enable APC, all you have to do is install the module, which can be done using PECL or through your distribution's package management system. Then make sure apc is enabled in php.ini and you're good to go. → The other opcode caches are eAccelerator, which is sort of slightly outdated now, although it does in some cases produce a better performance. But since APC will be included in the PHP core, I'm not sure if it's going to survive for very long anymore. → Then there's Zend Accelerator, which is built into Zend Server. Basically, it's similar to APC in terms of opcode caching functionality, but it's just bundled with the Zend products.
APC is the most popular one and will probably be included in one of the next few releases. Might be 5.4, but there's still a lot of discussion about that. I'm guessing we probably won't see it before 5.5 or who knows 6.0, if that ever comes out. To enable APC, all you have to do is install the module, which can be done using PECL or through your distribution's package management system. Then make sure apc is enabled in php.ini and you're good to go. → The other opcode caches are eAccelerator, which is sort of slightly outdated now, although it does in some cases produce a better performance. But since APC will be included in the PHP core, I'm not sure if it's going to survive for very long anymore. → Then there's Zend Accelerator, which is built into Zend Server. Basically, it's similar to APC in terms of opcode caching functionality, but it's just bundled with the Zend products.
APC is the most popular one and will probably be included in one of the next few releases. Might be 5.4, but there's still a lot of discussion about that. I'm guessing we probably won't see it before 5.5 or who knows 6.0, if that ever comes out. To enable APC, all you have to do is install the module, which can be done using PECL or through your distribution's package management system. Then make sure apc is enabled in php.ini and you're good to go. → The other opcode caches are eAccelerator, which is sort of slightly outdated now, although it does in some cases produce a better performance. But since APC will be included in the PHP core, I'm not sure if it's going to survive for very long anymore. → Then there's Zend Accelerator, which is built into Zend Server. Basically, it's similar to APC in terms of opcode caching functionality, but it's just bundled with the Zend products.
Slightly better than using local disk is using a local memory disk or a ramdisk. → Advantage : slightly faster, on the other hand if you're using Linux the standard file caching system will cache recently accessed files anyway, so there might not be a big performance impact when comparing to standard disk caching.
See slide >> replication!<<
See slide
See slide
- Key names must be unique - Prefix/namespace your keys ! → might seem overkill at first, but it's usually necessary after a while, at least for large systems. → Oh, and don't share the same Memcache with multiple projects. Start separate instances for each !) - Be careful with charachters. Use only letters, numbers and underscore ! - Sometimes MD5() is your friend → but : harder to debug - Use clear names. Remember you can't make a list of data in the cache, so you'll need to document them. I know you don't like to write documentation, but you'll simply have to in this case.
OK, that sort of covers the basics of how we can use Memcache to cache data for your site. So purely in terms of caching in the code, we've done a lot. → There's still things that you can always add. If you're using Zend Framework or any other major framework, you can cache things like the initialization of the configuration file, creation of the route object (which is a very heavy process if you have a lot of routes). → Things like translation and locale can be cached in Zend Framework using 1 command, so do that ! → But as I said before, the only limit is your imagination... → and your common sense ! → Don't overdo it... make sure that the cache has enough space left for the things you really need to cache.
So, why don't we switch everything from Apache to nginx ? → Well, it's not THAT easy. There's a lot of Apache modules that Nginx doesn't have, like WebDAV support and many of the authentication modules. → The basic modules are there and they're built into Nginx, which again makes them faster than Apache, because they don't go through some module API whcih causes overhead. → But there are some specific solutions that you can not build using Nginx, although there are some third-party modules out there now, but keep in mind you have to add these by recompiling Nginx. → Now, since we're talking mostly about scaling public websites, chances are we're not going to need any of those modules, so we'll have no trouble at all putting the N in LANMMP.
→ see slide → And that's all there is to it : it's running. Well, not exactly, we still need to configure it ofcourse.
Now, as I mentioned Nginx is very fast and as a first step to using it to scale our website, we're going place it in front of Apache. So, we're going to run it on the same server, but we're going to move Apache to a different port, preferably one that's not accessible from the outside, and we're going to have Nginx forward requests to Apache. → Ofcourse we're not going to send all requests to Apache, 'cause that would be quite stupid, adding overhead. → We're only going to send all dynamic content requests to Apache and serve all static files directly from Nginx.
So, we're serving all those extensions directly from disk and forwarding all the rest to the Apache running on port 8080. We're also forwarding the Set-Cookie headers and adding a few headers so Apache can log the original IP if it wants to. → Something to keep in mind here : you will have 2 logfiles now : 1 from Nginx and 1 from Apache. → What you should notice once you start using this type of setup is that your performance from an enduser perspective will remain somewhat the same if your server was not overloaded yet. If it was having issues because of memory problems or too many Apache workers, ... → However, you will suddenly need a lot less Apache workers, which will save you quite a lot of memory. That memory can be used for... Memcache maybe ?
OK, what we just did is very nice. → But if you're really not relying on any of the special Apache modules, why would you keep Apache anyway ? → Why not just replace it alltogether ? Well, it depends on what your bottleneck is. → If you're looking for a way to lower your memory usage and you don't mind losing some processing power, this is certainly the way to go. → So let's go for a LNMMP stack. We're going to kick out Apache.
If one of the backend webservers goes down, you want all traffic to go to the other one ofcourse. That's where health checks come in
>> platforms ! <<
>> thing on list <<
Indicates how long the file should not be retrieved
Split requests across subdomains : - HTTP/1.1 spec advises 2 connections per hostname - To get around that, use multiple subdomains. - Especially put your statics separately → helps when you grow and put them on a CDN - Be careful : don't use too many subdomains → DNS penalty