Vertical scaling
Vertical scaling provides a straightforward mechanism for creating multiple instances of an appserver, and hence multiple JVM processes.
In the simplest case, one can create many appservers on a single machine, and this single machine also runs the HTTP server process. This configuration is illustrated in Vertical scaling with cluster.
Figure 3-7 Vertical scaling with cluster
To set up a vertical scaling topology, refer to Chapter 7, Implementing the sample topology.
It is recommended that you plan vertical scaling configurations ahead of time. However, since they do not require any special installation steps, you can always implement them later on an as-needed basis.
Although there is a limit to the resources available on a single machine, and an availability risk when using a single machine, this configuration provides process isolation. It may also provide improved throughput over a configuration where only a single appserver process is running.
This assumes, of course, that sufficient CPU and memory are available on the machine (and that the application can take advantage of such a configuration). Therefore, when implementing a vertically scaled WebSphere environment, make sure you do not exceed the available resources.
Important: The best way to ensure good performance in a vertical scaling configuration is to tune a single instance of an appserver for throughput and performance, then incrementally add additional instances. Test performance and throughput as each application server instance is added. Once CPU utilization is 85% or greater, it's likely that adding additional instances will do little to improve performance and throughput as the operating system starts performing context switching between processes. Always monitor memory use when you are configuring a vertical scaling topology and do not exceed the available physical memory on a machine. |
Some reasons to use vertical scaling are:
An instance of an appserver runs in a single Java Virtual Machine (JVM) process. However, the inherent concurrency limitations of an application in the JVM process may prevent it from fully utilizing the processing power of a machine. Creating additional JVM processes provides multiple thread pools, each corresponding to the JVM associated with each application server process. This can enable the application in the application server(s) to make the best possible use of the processing power and throughput of the host machine.
A vertical scaling topology also provides process isolation and failover support within an appserver cluster. If one application server instance goes offline, the requests to be processed will be redirected to other instances on the machine.
Vertical scaling topologies can make use of the WAS workload management facility. The HTTP server plug-in distributes requests to the Web containers and the ORB distributes requests to EJB containers.
With the concept of cells and clusters in WAS V5, it is easy to administer multiple appservers from a single point.
We can implement vertical scaling on more than one machine in the configuration (IBM WAS Network Deployment V5.1 must be installed on each machine). We can combine vertical scaling with the other topologies described in this chapter to boost performance and throughput.
Again, this assumes, of course, that sufficient CPU and memory are available on the machine.
Consider the following when using vertical scaling:
Single machine vertical scaling topologies have the drawback of introducing the host machine as a single point of failure in the system. However, this can be avoided by using vertical scaling on multiple machines.
Scalability is limited to the resources available on a single machine.
When you are deciding how many appservers to create on a machine, you need to take several factors into account:
Note Version 1.2 and above of the IBM Java 2 Software Development Kit (SDK) handles parallel JVM processes better than earlier versions. |
WebSphere is a trademark of the IBM Corporation in the United States, other countries, or both.
IBM is a trademark of the IBM Corporation in the United States, other countries, or both.