This tutorial demonstrates the development lifecycle of
a new service asset as it moves through the integration between Rational
Asset Manager and WebSphere® Service Registry
and Repository (WSRR).
This demonstration presents a use-case of high-level
work flow: a fictitious insurance company creates a service to meet
the requirements of the claims department.
The solution development
lifecycle stages:
- Stage 1: An architect searches the Rational Asset Manager repository
to find service assets that can be reused to meet the needs of this
solution. These service assets are references to developed or deployed
web services that are stored permanently in the WebSphere Service
Registry and Repository.
- Stage 2: The developer develops, tests, and modifies a prototype
of the solution. She then submits the solution as an asset in Rational® Asset
Manager.
- Stage 3: (This review stage is out of the scope of this demonstration.)
After the developer submits the solution to Rational Asset
Manager as an asset, a review committee ensures that the solution
meets all of the requirements of the department. This committee recommends
whether the solution is ready to be published into the service repository.
- Stage 4: The review committee approves the solution and requests
that the concept be created in WebSphere Service
Registry and Repository.
- Stage 5: After the developer develops, tests, and builds the solution
in a regular development build, she submits the solution in an asset
to Rational Asset Manager as a formal solution.
The developer must publish this solution-level asset to WSRR. This
solution includes the WSDL and all of the code that implements the
service.
- Stage 6: The developer publishes the formal build that is associated
with the WSDL service to WSRR and places the service concept in the
publish state. To allow WSRR to govern the service interface, the
developer publishes the service WSDL by using the implementation asset
in Rational Asset Manager. This creates the
production-ready solution in WSRR.
- Stage 7: After the developer publishes both the WSDL and the implementation
assets to complete the production-ready solution, she returns to WSRR
and changes the service governance to the 'Versioned' state. The developer
creates a formal relationship in WSRR to the existing service concept.
Creating the formal relationship allows the implementation and the
service to be mapped together at deployment time.
- Stage 8: The asset is ready to be deployed into production and
the endpoints will be manually added in WebSphere Service
Registry and Repository. After the operations department reviews and
approves the asset, it can be moved into the managed state in WSRR.
- Stage 9: The administrator of Rational Asset
Manager synchronizes the repository with WSRR and updates the WSRR
governance state for the asset to 'Manage'.
Learning objectives
After viewing
this demonstration, you will understand the lifecycle and development
process of a service asset as it moves through the Rational Asset
Manager and WSRR integration.
Time required
This tutorial takes approximately
45 minutes to complete. If you explore other concepts that are related
to this tutorial, it might take longer to complete.
Skill level
Intermediate and advanced.
Audience
All users of the Rational Asset
Manager Eclipse client, web client, and WebSphere Service
Registry and Repository.