My wife is a second grade school teacher. As part of the curriculum, the students observe different life cycle stages – such as “tadpoles to frogs” and “caterpillars to butterflies.” The culmination is always the “eggs to chicks” unit where the students anxiously watch an incubator for three weeks – looking for signs of life – until the eggs finally (hopefully) hatch. A few days after hatching, the students get to hold the newborn chicks, feel their soft feathers, and create a picture memento before the chicks are sent to Old McDonald’s organic, free-range farm.
Thankfully the students usually don’t get to witness a complete lifecycle during this study – ending in death. They see just a small part of the cycle in this great “circle of life” – and nothing on this Earth is immune from this cycle.
Software applications go through a lifecycle too – from the conception of a new idea to birth, youth, and learning (test, patch, and QA), production (adulthood, patching aging parts), and eventually termination (death).
IBM PureApplication System virtual application patterns are designed with this complete application lifecycle in mind. A virtual application pattern is one of the “patterns of expertise” in IBM PureApplication System. It is a radically simplified way to define and manage an application. This definition is in terms that make sense to the application owner rather than a systems architect. With virtual applications, you don’t have to build the infrastructure from the ground up – allocating hardware, provisioning the operating system and software, configuring the network, installing monitoring agents, and all the other steps that were previously required to create the necessary environment to host your application. You simply specify your application components with functional and non-functional requirements of the application (basically your service level agreements or SLAs). IBM PureApplication System takes care of the details to launch, configure, provide high availability, monitor, manage, and scale your application to meet changing demand – all in an integrated and simplified common user interface.
So how does IBM PureApplication System do all of this? How can it possibly understand what is necessary to facilitate all of the various application components and then monitor, manage, and scale the application throughout the complete application lifecycle? Is all of this intelligence built into IBM PureApplication System itself? In a manner of speaking it both is and isn’t. IBM PureApplication System provides the structure and orchestrates the solution. But the detailed intelligence for each specific middleware component is included with each virtual application pattern type using a pluggable infrastructure. Working together they provide the necessary intelligence.
But I’m getting ahead of myself — let’s get back to the lifecycle of our new application. At conception of the application you consider the requirements of the application – what it must do, the desired user interactions, how it should perform, and so forth. You can find a ready-made solution that fulfills those requirements in the IBM PureSystems Centre. If that’s the case, then it’s a simple process to acquire the application pattern and try it out. But that doesn’t eliminate lifecycle stages such as validation, test, stress testing, pre-production validation, and so forth.
But let’s say that you decide to build your own web application using a specific virtual application type that we deliver with IBM PureApplication System – the Web Application pattern type. This virtual application pattern type is created specifically for online transaction processing web applications and integrates with another pattern type provided for database systems.
As you begin to define your application, a software architect might begin by deciding the types of application components that are needed, how they should interact, and other characteristics such as performance requirements, minimal configurations, and so forth. IBM PureApplication System supports the definition of these application rules in the virtual application builder. Using the builder, the architect can define the virtual application pattern structure using a simple drag and drop interface – choosing the application components, parameters, and more. The architect will also provide the policies for how the application should behave.
A developer or group of developers is typically assigned the task of creating the application logic for the various application components. The developer will typically work within the context of a Integrated Development Environment (IDE) such as the Rational tooling provided by IBM. We’ve made it easy to integrate automation with IBM PureApplication System by providing public APIs, and this interface is leveraged by our Rational tooling (and other software vendors) allowing seamless interaction with the patterns. When the developer has completed the core application component using the IDE, it is easy to include that into the pattern, deploy to the cloud, and validate the function running from within the IDE itself (see this video, which demonstrates this same integration using IBM Workload Deployer).
It is easy to share and control access to the pattern as the application moves from conception through various stages of test to production using the granular resource and role-based authorization built into IBM PureApplication System. Furthermore, IBM PureApplication System provides the capability to segment the cloud resources and provide isolation as the application progresses.
As you prepare your application for pre-production test you might want to attempt various stress scenarios to validate that the SLAs can be met. Using features of the Web Application pattern, such as scaling and routing policies, you can ensure that your application will adjust to changing demand – scaling both in and out automatically.
When you are ready to deploy your application for the first or the twenty-first time, IBM PureApplication System takes care of the details necessary to launch, configure, provide high availability, monitor, manage, and scale your application to meet changing demand – all in an integrated and simplified common user interface. You no longer have to bounce between different consoles and user interfaces to manage and monitor the various components of your application stack. Everything you need is provided right from the start.
When running in the cloud, it is simple to update the application using configuration views provided by the Web Application pattern type and made available in the integrated IBM PureApplication System workload console. From the virtual application instance, you simply select the item that needs to be changed, such as updating the EAR, provide the new artifact, click Submit, and the change will be applied to the running system.
You can also monitor your running application at various levels. General monitor views are provided for each virtual machine that is active in the pattern. In addition, middleware-specific monitor views are provided by the various pattern types – such as these views provided by the Web Application pattern type.
Finally, any management of an application must also include access to logs that will inevitably be needed to aid in problem determination at all phases of the life cycle. IBM PureApplication System has integrated the logs from all of the various elements involved in this application into one location for easy access and debugging.
All of these same capabilities are available for your application in production, and also test. After all, when in production, you still need to manage, monitor, and update your application with additional enhancements and fixes (see this video, which demonstrates the same functionality using IBM Workload Deployer). Eventually requirements will change or the technology will evolve. The application must release its resources to newer, younger applications that will soon take its place in the great “circle of life” (envision credits rolling on the screen at the end of a movie as the reprise continues).
So, as you can see, IBM PureApplication System is designed to cover the complete lifecycle of the virtual application. Furthermore, it does all of this while also optimizing the management, execution, and placement of the application — a true cradle to grave solution.
The second grade class did put the eggs in the incubator just this week and are excitedly waiting to see signs of hatching and hear peeps. It’s also time to get your applications incubating and hatching by using virtual application patterns in IBM PureApplication System. It is after all, the circle of life.