Chapter 6 Implementation of a Deployment Design

During the implementation phase of the solution life cycle you work from specifications
and plans created during deployment design to build and test the deployment architecture,
ultimately rolling out the deployment into production. Implementation is beyond the
scope of this guide, however this chapter provides a high-level view of this phase.

About Implementing Deployment Designs

After the deployment architecture has been approved and implementation specifications
and plans have been completed, you enter the implementation phase of the solution
life cycle. Implementation is a complex set of processes and procedures that requires
careful planning to ensure success. Implementation includes the following tasks:

Building the network and hardware infrastructure

Installing and configuring software according to an installation plan

Migrating data from existing applications to the current solution

Implementing a user management plan

Designing and deploying pilots or prototypes in a test environment
according to a test plan

Designing and running functional tests and stress tests according
to a test plan

Rolling out the solution from a test environment to a production environment
according to a rollout plan

Training administrators and users of the deployment according to a
training plan

Details of implementation are beyond the scope of this guide. However, the following
sections provide overview information for some of these tasks.

Installing and Configuring Software

The installation and configuration of Sun JavaTM Enterprise System for a distributed enterprise
application requires the planning and coordination of many tasks and procedures. During
the deployment design phase, you create an installation plan based on the high-level
deployment architecture that provides installation and configuration information needed
to install Java Enterprise System software.

Developing Pilots and Prototypes

Java Enterprise System deployments typically fall into two categories, those based primarily
on services provided with Java Enterprise System and those that require a significant number
of custom services that are integrated with Java Enterprise System services. You can think of
the former type of deployment as an 80:20 deployment (80% of the services are provided
by Java Enterprise System) and similarly, the former as a 20:80 deployment.

For 80:20 deployments, during the implementation phase, you typically develop
a pilot deployment for testing purposes. Because 80:20 deployments use mature Java Enterprise System services
that provide “out-of-the-box” functionality, pilot deployments move relatively
quickly from development, testing, and modification steps, to production deployments.
A pilot deployment verifies the functionality of a solution, but also provides information
on how well the system performs.

20:80 deployments, on the other hand, introduce new, custom services that
do not have the history of interoperability that comes with 80:20 deployments. For
this reason, you create a prototype, which is a proof-of-concept deployment that typically
requires a more rigorous development, testing, and modification cycle before going
into production. A prototype lets you determine how well a proposed solution solves
the problem in a test environment. Once the prototype demonstrates the functionality
is sufficient, you can move on to more rigorous testing and then to a pilot deployment.

Note –

Actual enterprise deployments can vary greatly in the amount of custom
development of services they require. How you use pilot and prototype deployments
for testing purposes depends on the complexity and nature of your deployment.

Testing Pilot and Prototype Deployments

The purpose of testing pilot and prototype deployments is to determine as best
as possible under test conditions whether the deployment satisfies the system requirements
and also meets the business goals.

Ideally, functional tests should model scenarios based on all identified use cases
and a set of metrics should be developed to measure compliance. Functional testing
can also involve a limited deployment to a select group of beta users to determine
if business requirements are being satisfied.

Stress tests measure performance under peak loads. These tests typically
use a series of simulated environments and load generators to measure throughput of
data and performance. System requirements for the deployment are typically the basis
for designing and passing stress tests.

Note –

Functional and stress tests are particularly important for large deployments
where system requirements might not be well-defined, there is no previous implementation
on which to base estimates, and the deployment requires a significant amount of new
development.

Testing can indicate problems with the deployment design specification and might
involve several design, build, and test iterations before you can roll out the deployment
to a production environment. When testing prototype deployments, you might discover
problems with the deployment design, in which case you can iterate back to earlier
phases in the solution life cycle to address the problems.

Make sure you have thoroughly tested your deployment design before proceeding
to a pilot deployment. A pilot deployment indicates you have already verified the
deployment design with earlier series of tests. Problems you uncover during the testing
of a pilot deployment must generally be addressed within the parameters of the deployment
design.

Because testing never completely simulates a production environment, and also
because the nature of a deployed solution can evolve and change, you should continue
to monitor deployed systems to identify any areas that require tuning, maintenance,
or service.

Rolling Out a Production Deployment

Once the pilot or proof-of-concept deployment passes the test criteria, you
are ready to roll out the deployment to a production environment. Typically, you roll
out to a production environment in stages. A staged rollout is especially important
for large deployments that affect a significant number of users.

The staged deployment can start with a small set of users and eventually expand
the user base until the deployment is available to all users. A staged deployment
can also start with a limited set of services and eventually phase in the remaining
services. Staging services in phases can help isolate, identify, and resolve problems
a service might encounter in a production environment.