MACROMEDIA COLDFUSION MX-CLUSTERCATS, Use Manual

Page: 23 / 156

Successful scalability implementations 13
Successful scalability implementations
Achieving scalable web servers is not a trivial task. There are various solutions from which
to pick, setup and configuration tasks to understand and perform, and many delicate
dependencies between related but heterogeneous technologies. This section describes
some of the major issues affecting successful scalability implementations:
•
“Designing and coding scalable applications” on page 13
•
“Avoiding common bottlenecks” on page 16
•
“DNS effects on website performance and availability” on page 17
•
“Load testing your web applications” on page 20
Designing and coding scalable applications
Application architects must create designs that are inherently flexible by relying on open
standards that don’t restrict the application’s construction and implementation to
vendor-specific interfaces and tools. Similarly, web developers that construct the designed
application must be aware that they can significantly impact the application’s scalability
in the way in which they write their code, build their SQL queries, invoke thread
management, access databases, and partition the application.
This section discusses the following topics to consider when designing and building a
web application:
•
“Application session and state management” on page 13
•
“Database locking and concurrency issues” on page 14
•
“Application partitioning” on page 15
Application session and state management
As you create web applications, you will probably create specific variables that you intend
to carry across multiple interactions between a user’s browser and a site’s web server(s).
Using
client variables that are stored in a shared state repository, or session variables that
are stored in memory of a specific server, are popular approaches for accomplishing this
task. The latter approach, however, introduces a significant challenge for a website that is
supported by multiple servers. When a user has begun a session and variables are stored
on a specific server, the user must return to that server for the life of the session to
maintain correct state information.
An example that illustrates this concept is an e-commerce application that uses shopping
carts. With this type of application, as a customer accumulates items in a cart, there must
be a mechanism to ensure that the user can see the items as they are added. One approach
is to store these items in session variables on a specific web server. However, if you use this
approach, there must also be a way to ensure that the user always returns to the same
server for the life of the session. ClusterCATS automatically handles this challenge for
you.
Another approach to solving this problem is to store client variables in a back-end
common state repository. This approach enables all web servers in a cluster to access
variables in a common, shared back-end data store, such as a database. However, this
approach can potentially affect your site’s performance.