Scaling Web Apps P Falcone
- 1. Scaling your PHP Web Applications (a.k.a. make your web applications alive and still responsive even with thousands of users hammering your site per second)
- 2. There is no silver bullet Merely adding more servers, or buying the hype for some exotic architecture, or getting that ultra-expensive technology will not make your web application scale in the long run.
- 3. Start with the fundamentals in coding Design your code to be testable at all levels Know your data structures and algorithms Design your application with eventual change in mind
- 4. Design your code to be testable at all levels Write unit and integration tests that test both behavior and outcome in positive and error conditions. The design of classes and functions affect testability.
- 5. Know your data structures and algorithms Inelegant data structures and algorithms collapse when subjected to high load due to protracted run times and insane memory usage Certain problems will require different algorithms and data structures to be deployed, and will have to be deployed and used by your application differently
- 6. Design your application with eventual change in mind Make classes and functions that do only one thing and do it well Favor loose coupling of dependencies Improve on software design patterns that promote extensible design Eventually you will replace pieces of your application with better parts
- 7. Going further Getting rid of obvious boo-boos Using an RDBMS Caching Know how and when to take advantage of the language Further tuning the performance of your application
- 8. Getting rid of obvious boo-boos Avoid multiple loops over the same structure when processing Simpler usually means better – you do not need to bring out tanks to crush ants Reserve use of encryption to where you really need it.
- 9. Using an RDBMS A relational database is primarily intended to store relational data You won't miss doing referential integrity checks at the database level Forget about using SQL JOIN in a live web application Query in chunks when the data set is huge Favor a bulk database query rather than doing multiple loops with the same database query Make judicious use of database indexes during queries
- 10. Caching To avoid expensive page rebuilds, use output page caching – PHP has output buffering (via the ob_ functions) by default, and there are libraries that abstract this functionality Reduce compile time for redundant objects by using op-code caching (e.g. APC , eAccelerator , XCache ) Take a look at other caching strategies (e.g. CDN, caching HTTP proxies, memcached ) If you are using memcached , chunk entries into smaller collections rather than storing very big objects in cache. Cache database results as much as you can
- 11. Know how and when to take advantage of the language PHP isset() is implemented as a hash table – consider using this over the function in_array() for huge array searches PHP evaluates strings within single quotes faster than strings within double quotes Consider passing references rather than copies of objects and arrays to save memory The ctype_ functions are faster than using regular expression testing for validating types
- 12. Further tuning the performance of your application Optimize and profile your database queries so that the results will fit in memory Do performance tests that simulate real-world conditions to ensure your application survives high loads. Profile the code to find out bottle necks and excessive calls – there are tools like APD and Xdebug to aid in this task. Know the capabilities and limitations of your application's dependencies and tune according to the purpose of the said dependency, or replace them.
- 13. Surviving the horde Employing asynchronous and parallel computing techniques Knowing when to use the better tools for the job Spreading your application's infrastructure across many machines Employing a service oriented architecture
- 14. Employing asynchronous and parallel computing techniques Responsiveness is a highly desirable goal. Do not put long running routines on code that will be rendered by the application. Consider using a queueing service for long running tasks. Maximize parallelism. Some tasks can be executed off-line and in parallel as long as they do not lock on the same resources.
- 15. Knowing when to use the better tools for the job Consider writing extensions for commonly-used functions that are not practical (speed-wise) to implement in PHP, yet require to constantly interact with PHP Parallel distributed computing, or any computing that requires concurrency (e.g. threads, shared memory, map-reduce) is outside PHP's strengths. You may consider using more appropriate tools (MPI, etc) Sometimes the filesystem is better than a database.
- 16. Spreading your application's infrastructure across many machines Your application will vertically-scale up to a certain point – after which you have to start considering employing more machines for better throughput. Depending on a couple of factors (e.g. CPU intensiveness, network traffic, e.g.) - some application dependencies will have to be deployed on their own clusters (e.g. databases), while some can be bundled together with the application, in order for the application to remain responsive.
- 17. Employing a service-oriented architecture This allows replacement and isolation of component dependencies much easier as component dependencies are designed to perform one task and perform them well, while isolating problems is reduced to targeting the service responsible. The use of persistent connections to resources (e.g. databases, cache, etc) from services (to save memory, multiplex requests, etc) scales better than having all application servers connect directly to the resources.
- 18. After everything else... Throwing money at the problem would probably work