Professional Documents
Culture Documents
IBM UrbanCode Deploy V6 Lab-Workbook
IBM UrbanCode Deploy V6 Lab-Workbook
Rational
Contents
OVERVIEW ............................................................................................................................................. 2
LAB 1 CREATE THE VIRTUAL MACHINE TO BE USED IN THE DEPLOY LABS ..................................................... 4
1.1 CREATE THE INITIAL VIRTUAL MACHINE ....................................................................................................... 4
1.2 DOWNLOAD THE REQUIRED SOFTWARE ...................................................................................................... 7
1.3 TOMCAT INSTALL AND SETUP ..................................................................................................................... 9
1.4 SUMMARY ............................................................................................................................................. 12
LAB 2 INSTALL IBM URBANCODE DEPLOY SERVER AND AGENTS ................................................................... 13
2.1 IBM URBANCODE DEPLOY SERVER SETUP .............................................................................................. 13
2.2 OPTIONAL SHUTDOWN AND BACKUP ......................................................................................................... 22
2.3 SUMMARY ............................................................................................................................................. 22
LAB 3 IMPORT APPLICATION AND COMPONENTS................................................................................................ 23
3.1 START THE DEPLOY SERVER IF IT IS NOT RUNNING ..................................................................................... 23
3.2 CREATE AND IMPORT THE JPETSTORE APP COMPONENT ......................................................................... 24
3.3 CREATE AND IMPORT THE JPETSTORE WEB AND DB COMPONENTS ........................................................... 26
3.4 CREATE AND DEFINE THE JPETSTORE APPLICATION .................................................................................. 27
3.5 DEFINE ENVIRONMENTS FOR THE JPETSTORE APPLICATION....................................................................... 28
3.6 SUMMARY ............................................................................................................................................. 30
LAB 4 DEPLOY INITIAL VERSION OF JPETSTORE TO SIT .................................................................................... 31
4.1 LOG INTO THE DEPLOYMENT SERVER DASHBOARD VIA A WEB BROWSER ....................................................... 31
4.2 CREATE THE DEPLOYMENT ENVIRONMENT ................................................................................................ 32
4.3 CREATE RESOURCES FOR EACH ENVIRONMENT ......................................................................................... 36
4.4 DEFINE THE DEPLOYMENT PROCESS FOR JPETSTORE-WEB COMPONENT .................................................. 39
4.5 DEFINE DEPLOYMENT PROCESS FOR JPETSTORE-APP COMPONENT .......................................................... 45
4.6 DEFINE DEPLOYMENT PROPERTIES .......................................................................................................... 52
4.7 DEFINE APPLICATION DEPLOYMENT PROCESS .......................................................................................... 54
4.8 TEST THE APPLICATION DEPLOYMENT PROCESS IN SIT ............................................................................. 56
4.9 DEFINE THE DEPLOYMENT PROCESS FOR JPETSTORE-DB COMPONENT...................................................... 60
4.10 UPDATE THE APPLICATION DEPLOYMENT PROCESS .................................................................................. 62
4.11 DEPLOY, RUN AND TEST JPETSTORE ....................................................................................................... 63
4.12 SUMMARY ............................................................................................................................................. 64
LAB 5 UPGRADE THE SIT AND PROMOTE TO THE UAT ENVIRONMENT ............................................................ 65
5.1 VERIFY YOUR DEPLOY ENVIRONMENT ...................................................................................................... 65
5.2 IMPORT V1.1 OF THE COMPONENTS ......................................................................................................... 65
5.3 DEPLOY VERSION 1.1 OF THE JPETSTORE-WEB AND JPETSTORE-DB IN SIT ............................................ 67
5.4 CONFIGURE THE UAT ENVIRONMENT ...................................................................................................... 70
5.5 CREATE A SNAPSHOT AND PROMOTE IT TO THE UAT ENVIRONMENT ............................................................ 73
5.6 PROMOTE THE SNAPSHOT TO THE UAT ENVIRONMENT............................................................................... 74
5.7 SUMMARY ............................................................................................................................................. 77
LAB 6 USING TEAMS FOR ACCESS CONTROL ...................................................................................................... 78
6.1 CREATE A NEW USER IN THE INTERNAL SECURITY REALM........................................................................... 78
6.2 CREATE A DEVELOPER ROLE................................................................................................................... 79
6.3 CREATE THE JPETSTORE TEAM. ............................................................................................................. 79
6.4 APPLY THE TEAM TO THE EXISTING JPETSTORE APPLICATION. ................................................................... 80
6.5 LOGIN AS A JPETSTORE DEVELOPER....................................................................................................... 82
LAB 7 OPTIONAL RATIONAL TEAM CONCERT INTEGRATION TECHNIQUE ....................................................... 83
7.1 LINK A COMPONENT VERSION TO AN RTC BUILD RESULT RECORD ............................................................... 83
7.2 SUMMARY ............................................................................................................................................. 83
APPENDIX A. NOTICES .......................................................................................................................................................... 84
APPENDIX B. TRADEMARKS AND COPYRIGHTS ............................................................................................................... 86
Contents Page 3
IBM Software
Lab Page 1
IBM Software
Overview
The overall objective of this Lab Workbook is to introduce you to the basic concepts and tool usage of
IBM UrbanCode Deploy. This version of the workbook is based on version 6.0 of uDeploy, which is now
IBM UrbanCode Deploy.
Introduction
The modules in this workbook will guide you through the steps in understanding how to use IBM
UrbanCode Deploy. In the labs, you will be working with a sample application called JPetStore. It
consists of three components: web content, database and J2EE application. You will gain an
understanding of how to install the IBM UrbanCode Deploy tool, configure and deploy the JPetStore
application to two sample environments, Systems Integration Test (SIT) and User Acceptance Test
(UAT). There are six lab modules in this workbook and each are described below:
Lab1: This is the preparation lab for users starting with a local machine or a VMWare image. In this lab
you will download all the necessary software and create the three (logical) serversrequired to perform the
Deploy Labs 2through 6. If using your own local environment these application servers may be installed
on one or more physical locations. If you are using the Smart Cloud Enterprise Cloud image, this lab can
be skipped.
Lab 2: This labs focus is the role of the Deploy Administrator. In this lab you will install the IBM
UrbanCode Deploy server and agents, verify the communications between the server and agents, and
finally create the sample applications (JPetStore) databases. If you are using the Smart Cloud
Enterprise Cloud image, this lab can be skipped.
Lab 3: This labs focus is the role of the Deploy Automation Configurator. In this lab you will create the
JPetStore application, a sample enterprise Java application that you will deploy in following module(s).
In this module you import the components of the JPetStore application into the Deploy server. You will
then define a Deploy Application for JPetStore, which defines which components go into a named
application. Finally, you will define a set of named Environments for the application, such as UAT and
SIT.
Lab 4: This labs focus is the role of the Deploy Automation Configurator. In this lab you will create the
two levels of automation. The first part of the lab will focus on designing the component automation for
each of the components. The second part of the lab will focus on the Application Process, which
orchestrates the deployment of the components. It is this automation that manages the relationship
between the components and the order in which the components are deployed.
Lab 5: This labs focus is the role of the Deployer. In this lab you will deploy additional versions of the
components configured in Lab 3 and create a snapshot. You will then apply that snapshot by promoting
the snapshot from the sample SIT environment to the UAT environment.
Lab 6: This labs focus is the role of the Deploy Automation Configurator. In this lab you will establish a
security role and team and apply them to the JPetStore application.
Lab 7: This optional lab demonstrates how to link a component version to a Rational Team Concert Build
result record.
Lab Page 3
IBM Software
When you have completed this exercise, you will have a completed virtual machine running Red Hat
Enterprise Linux Server 6.4 that is ready for the IBM UrbanCode Deploy server and client software
installation. The IBM UrbanCode Deploy software installation is described in Lab 2 of this workbook.
The exercise has been validated using VMware, a commercial virtualization product
(http://www.vmware.com/products/workstation). Other virtualization solutions, such as KVM (Kernel-
based Virtual Machine, http://www.linux-kvm.org), a full virtualization solution for Linux on x86 hardware
included with many Linux distributions, should work as well. In addition to Red Hat Enterprise Linux
Server, other distributions should work as well but some installation steps may differ slightly.
The labs were built using Linux and the instructions are based on Linux. However, a Windows server
and agent environment can also be used. The IBM UrbanCode Deploy installation package reference
below can be used for Linux or Windows. The one difference in the installation is that on an agent
Windows machine, it is recommended that you install the agent as a Windows service. For more
information regarding a Windows installation, see the IBM UrbanCode Deploy InfoCenter at
http://pic.dhe.ibm.com/infocenter/ucdeploy/v6r0/index.jsp.
The following settings and packages were used in the prepared virtual machine environment for this
workbook. This is the general minimum configuration which is assumed has been prepared before
continuing with the setup of the IBM UrbanCode Deploy environment contained in this workbook.
Resource Notes
Red Hat Enterprise Other versions should work but this version was used for all
Linux 6.4 64-bit screenshots and specific commands contained in the
included instructions
UID: rational All work in this lab was done under the context of an OS
UID that was previously created and added to the sudo
users group. If another UID or root is used you will need to
make the appropriate changes when referring to the home
directories in specific steps.
The installation will be slightly customized to enable access to the server applications through a specific
alias.
127.0.0.1 udeploy.release-and-deploy-learning-circle.com
Lab Page 5
IBM Software
IBM Rational Authorized Resellers obtain installation files from IBM Software Access Catalog. If you are
a Reseller, please review the supplemental document named Software Access Catalog UrbanCode
Download Instructions for details.
IBM Rational Sellers can obtain installation files through the normal process using the Software Sellers
Workplace Software Download site.
All of the software distribution files needed to install and configure our IBM UrbanCode Deploy server
and agents will be copied to this virtual machine. It is assumed at this point in the lab that you have
Lab Page 7
IBM Software
already downloaded the required components as listed in the above table, and they are available on you
host machine.
__1. Navigate to your download folder on the host machine where you saved the installation
packages from the previous step.
__3. Extract to your download location the files DBUpgrader-1.423703.zip and Tomcat-3.423647.zip.
__4. At a minimum your folder with the packages should look like the following
__5. Start the virtual machine that you created in the previous section.
__7. From a terminal window create a new directory to contain the distribution files:
__a. apache-tomcat-7.0.42.tar.gz
__b. artifacts.zip
__c. DBUpgrader-1.423703.zip
__d. Tomcat-3.423647.zip
__e. URBANCODE_DEPLOY_V6.0_MP_EN.zip
__2. Start a Terminal and execute the following commands to expand the Tomcat distribution file.
__a. cd /opt
__c. cd webservers
__3. Add user and role entries to the Tomcat users file:
__b. Uncomment the user and role entries at the bottom of the file.
__c. Add the following lines to the block you just uncommented.
<role rolename="manager"/>
<role rolename="manager-gui"/>
<role rolename="manager-script"/>
<role rolename="manager-jmx"/>
<role rolename="manager-status"/>
Lab Page 9
IBM Software
__4. Configure the correct ports for the SIT Tomcat server to prevent conflicts
__b. Perform a search and replace of all occurrences based on the following:
__a. From the same Terminal session as root start the SIT Tomcat server by entering the
following commands
__ii. /opt/webservers/sit-apache-tomcat-7.0.42/bin/startup.sh
__b. Open the Firefox browser and navigate to the URL: http://udeploy.release-and-deploy-
learning-circle.com:8085/
__i. Verify you can get to the default Tomcat web console
__ii. It may take a few minutes for the SIT Tomcat server to start
__1. From the same Terminal session as root, execute the following commands:
__a. cd /opt/webservers
__2. Add user and role entries to the Tomcat users file:
__b. Uncomment the user and role entries at the bottom of the file.
__c. Add the following lines to the block you just uncommented.
<role rolename="manager"/>
<role rolename="manager-gui"/>
<role rolename="manager-script"/>
<role rolename="manager-jmx"/>
<role rolename="manager-status"/>
__3. Configure the correct ports for the UAT Tomcat server to prevent conflicts
Lab Page 11
IBM Software
__b. Perform a search and replace of all occurrences based on the following:
__a. From the same Terminal session as root start the UAT Tomcat server by entering the
following commands
__ii. /opt/webservers/uat-apache-tomcat-7.0.42/bin/startup.sh
__b. Open the Firefox browser and navigate to the URL: http://udeploy.release-and-deploy-
learning-circle.com:8086/
__i. Verify you can get to the default Tomcat web console
__ii. It may take a few minutes for the UAT Tomcat server to start
1.4 Summary
You have now installed and configured the SIT and UAT Tomcat server environments that will be used.
You are ready to continue with the labs.
In this lab we will install and configure the IBM UrbanCode Deploy server and agents. When completed
we will have a single system running with the main UrbanCode Deploy server, agent, SIT and UAT
environments.
__1. If not already logged in, log in to the server as the root user.
__3. Prepare to install the IBM UrbanCode Deploy server by executing the following commands. This
will expand the IBM UrbanCode Deploy server distribution in the home directory.
__a. cd /home/rational/Distrib
__c. cd udeploy-install
__5. Start the installation by executing the command ./install-server.sh and responding to
the prompts as follows. Note that it is ok if the installation program reports that it can't find
tools.jar. Also note that the Host name to access the Web UI value is the only non-default value.
__d. If it prompts that the specified directory doesn't exist, respond: Yes (default)
Lab Page 13
IBM Software
__g. Web UI to always use secure connections using SSL: Yes (default)
__h. Port on which Web UI listens for secure HTTPS requests: 8443 (default)
__i. Port on which Web UI redirects unsecured HTTP requests: 8080 (default)
__6. Press the Enter/Return key when prompted to exit the installation script.
__1. Start a Terminal (or use existing Terminal). Start the IBM UrbanCode Deploy server running by
executing the following commands.
__a. cd /opt/ibm-ucd/server/bin
__2. You receive no immediate feedback when you start the server. Use the following command to
see the list of running Java applications, which should include the server.
__b. The system presents a list of Java processes. You should see an entry that includes the
text UDeployServer.
__1. Open the Firefox browser and navigate to the URL: https://udeploy.release-and-deploy-
learning-circle.com:8443
The browser may present you with This Connection is
Untrusted. This is normal for the initial setup when using
HTTPS as we have not created a signed certificate. In a
production environment your system admins would create
this for you and configure the system to use your specific
certificate.
For this demonstration and lab exercise use the Add
Exception button. In this next pop-up dialog click Confirm
Security Exception.
__2. Log in using admin for both the user name and password.
Lab Page 15
IBM Software
__6. Browse to the appropriate folder based on your OS user id. Example: /home/rational/Distrib
__2. Click the link for IBM UrbanCode Deploy Agent to initiate a file download
__4. Start a Terminal session as root user if one is not already running.
Lab Page 17
IBM Software
__5. Prepare to install the IBM UrbanCode Deploy agent by executing the following commands. This
will expand the IBM UrbanCode Deploy agent distribution in the home directory.
__a. cd /home/rational/Downloads
__c. cd ibm-ucd-agent-install
__7. Start the installation by executing the command ./install-agent.sh and responding to the
prompts as follows. Note that it is ok if the installation program reports that it can't find tools.jar.
Also note that the hostname of IBM UrbanCode Deploy server and Agent's name values are the
only non-default values.
__8. Press the Enter/Return key when prompted to exit the installation script.
__1. Start a Terminal session (if not already in one) on the virtual machine.
__2. Start the IBM UrbanCode Deploy agent running by executing the following commands.
__a. cd /opt/ibm-ucd/agent/bin
__3. You receive no immediate feedback when you start the agent. Use the following command to
see the list of running Java applications, which should include the server.
__b. The system presents a list of Java processes. You should see an entry that includes the
text AgentWorker as illustrated below.
2.1.6 Verify the IBM UrbanCode Deploy agent and server are communicating
__1. Open the Firefox browser and navigate to the URL: https://udeploy.release-and-deploy-
learning-circle.com:8443.
__2. Log in using admin for both the user name and password.
Lab Page 19
IBM Software
The JPetStore application requires a database. Create the empty database and verify that the database
user can access it.
__1. On the virtual machine, open a Terminal session, start the mysql command as the MySQL root
user. No password is required.
__b. The system will respond with a mysql> prompt. Type the remaining commands at this
prompt.
__c. You will receive a response - Query OK, 1 row affected for each command
__c. You will receive a response - Query OK, 0 rows affected for each command
2.1.8 Verify that the jpetstore user can access the database
__1. In a Terminal session, start the mysql command as the jpetstore user.
__2. Display the databases. The database jpetstore_sit and jpetstore_uat should be visible in the list.
__b. cd /home/JPetStore
Optionally, remove the following distribution files in /home/Distrib that are no longer needed:
artifacts.zip
apache-tomcat-7.0.42.tar.gz
DBUpgrader-1.423703.zip
Tomcat-3.423647.zip
Lab Page 21
IBM Software
URBANCODE_DEPLOY_V6.0_MP_EN.zip
Optionally, remove any files and folders left from installing the IBM UrbanCode Agent from
the downloads folder in /home/rational/Downloads as they are no longer needed.
2.3 Summary
The IBM UrbanCode Deploy server and agents have been deployed to the virtual machine to enable the
remaining IBM UrbanCode Deploy lab exercises. Empty databases for the JPetStore application have
also been created and the web artifacts are ready for deployment by IBM UrbanCode Deploy.
Break down JPetStore into individual components and load each component
Define how the components are assembled to create the deployable application
Define a set of named environments for the application, specifically UAT and SIT
A component is a set of related files that are deployed together one or more deployment processes. IBM
UrbanCode applications consist of a set of one or more components.
In this lab, you will break the JPetStore application into three components.
APP JPetStore Application Component. This component is the JPetStore Java
application that is in a file called JPetStore.war.
DB - Database Component. The initial version of this component contains scripts and
supporting files to create the JPetStore database. Subsequent versions of this
component contain scripts to modify the database schema.
WEB - Web Component. Versions for this component contains the static web content for
JPetStore, such as web page image files.
When you have completed this lab, you will have an application defined with its three components and
ready for the next lab to define the component process to deploy them to the target environments.
If you have stopped the Deploy server or rebooted the virtual machine, then you must start the Deploy
server.
cd /opt/ibm-ucd/server/bin
./server start
__3. You receive no immediate feedback when you start the server. Use the following command to
see the list of running Java applications, which should include the server.
The system presents a list of Java processes. You should see an entry that includes the text
'UDeployServer'.
Lab Page 23
IBM Software
__4. Log into the Deploy server dashboard via a web browser. Start the web browser and navigate to
https://udeploy.release-and-deploy-learning-circle.com:8443. Confirm any security exceptions.
Note: To access the Deploy server from your desktop when using the SmartCloud image, you
will need to edit your operating systems host file and map the image IP to the server name
above.
__5. Login in as user admin. The password is admin. You should now see the Deploy dashboard.
__1. Click on the Components tab then on the Create New Component button to define a new
component.
__2. Name the new component JPetStore-APP. Set the other options as shown below. In
particular, set Template to None, set Source Config Type to File System (Versioned), set
Base Path to /home/JPetStore/shared/app, and set Default Version Type to Full. Click
the save button at the bottom of the pop-up.
By using the 'File System (Versioned)' setting, you are declaring that each folder under the 'Base
Path' folder is actually a named version of the component. Each of the versioned folders actually
contains the files for that version. When using Deploy, quite often you will integrate the Deploy
server to your build system and/or component repository to transfer versions of components.
__1. With the JPetStore-APP component selected, click on the Versions tab. Click on the
Import New Versions button to automatically load any versions that are found in the file
system. For the APP component, the only version defined is 1.0.
Lab Page 25
IBM Software
__1. Repeat the steps that you followed to create and import the JPetStore-APP component to
create and import a component called JPetStore-WEB. Other than the component name, the
only other difference is that the Base Path is /home/JPetStore/shared/web.
__2. When you import the versions, two versions are loaded 1.0 and 1.1. Initially, you only want to
have version 1.0. Later you will add version 1.1 and update the deployment. For now, click on
the Delete text to the right of version 1.1 to delete that version.
__1. Repeat the steps that you followed to create and import the JPetStore-APP component to
create and import a component called JPetStore-DB. Other than the name, the only other
difference is that the Base Path is /home/JPetStore/shared/db.
__2. As with JPetStore-WEB, delete all the imported versions except for version 1.0.
__1. Click on the Applications tab then click on the Create New Application button
__2. Enter JPetStore as the name of the application and then press the Save button.
__1. Within the Application: JPetStore shown, select the nested Components tab.
__2. Click on the Add Component button, select JPetStore-APP and then click on Save.
__3. Click on the Add Component button, select JPetStore-DB and then click on Save.
__4. Click on the Add Component button, select JPetStore-WEB and then click on Save.
Lab Page 27
IBM Software
__5. Verify that you can see the following three components within the JPetStore application.
For this lab, create a SIT and UAT environment for JPetStore. In this single-server playground, both
environments will use a single agent, with a separate resource defined for each environment.
__1. Click on the Applications tab to see the list of defined applications and then click on
JPetStore to open it.
__2. With the Application: JPetStore shown, make sure that the nested Environments tab is
selected. Click on the Create New Environment button.
__3. Name the new environment SIT. You can select a color, otherwise, leave the rest of the options
at their default values. Scroll down to the bottom of the pop-up and press the Save button.
__4. Repeat the previous steps in this section to create another environment called UAT.
__5. Verify this task by clicking on the Applications tab to see the list of defined applications and
then click on JPetStore to open it. You should see the SIT and UAT environments as shown
below.
Lab Page 29
IBM Software
3.6 Summary
You have defined an application in uDeploy called JPetStore and loaded version 1.0 of the applications
three components: APP, WEB and DB. You have defined the target UAT and SIT environments.
In this module you deploy the initial version of the JPetStore application to the SIT environment.
In order to deploy an application and its components to a target system (or set of systems), use scripted
Processes for both the Components and Application.
A Component Process describes and automates the steps to deploy one component. An Application
Process orchestrates the deployment of the Component Processes and any additional supporting
activity.
Once you define the Process scripts, you can then easily deploy versions of applications and
components to any desired target.
4.1 Log into the deployment server dashboard via a web browser
__1. Start the web browser and navigate to IBM UrbanCode Deploy URL:
https://udeploy.release-and-deploy-learning-circle.com:8443
__2. Login in as user admin. The password is admin. You should now see the IBM UrbanCode
Deploy dashboard.
Lab Page 31
IBM Software
The IBM UrbanCode Deploy system uses a server-agent model. The agent is a small execution engine
installed on each server in your environment on which commands must be executed. The agent runs
uDeploy plugin steps which are the scripts needed to perform various actions. In this lab, a single agent
is installed in the lab image.
The deployment of each component is aligned to a resource. The resource is a logical deployment target
that typically resolves to an agent. Resources are managed in a physical or conceptual hierarchy that
allows them to represent an agent, group of agents, component, or an organizational entity that is used
to group other resources.
To understand this, the diagram below represents a theoretical data center with physical servers that
have middleware and application components deployment onto them. The annotations on the left identify
the three SIT environment servers and the annotations on the right represent the QA environment
servers. The server URLs, numbers, etc are merely for demonstration purposes.
To organize the data center hierarchically, use the topology to understand the outline below.
Data Center
In the following lab section, we will review the uDeploy lab topology and a similar outline organization of
resources and components. Then create a set of resources and map them to the components to support
deployment:
__1. Review the lab environment topology below and note the single image, servers and components.
__2. Now review the lab environment outline organization shown in the table below:
- SIT Environment
- http://udeploy.release-and-deploy- - UAT Environment
learning-circle.com:8085 - http://udeploy.release-and-deploy-learning-
- JPetStore Web component circle.com:8086
- JPetStore APP component - JPetStore Web component
- jdbc:mysql://localhost:3306/ jpetstore _sit - JPetStore APP component
- JPetStore DB Component - jdbc:mysql://udeploy.release-and-deploy-
learning-circle.com:3306/ jpetstore_uat
- JPetStore DB Component
__1. Verify that the IBM UrbanCode Deploy agent is online. Click the Resources tab then the
Agents tab. You should see that the udeploy.release-and-deploy-learning-
circle.com agent is Online.
Lab Page 33
IBM Software
__2. If you are using the VMWare image and the agent is offline, go to the command line and start the
agent using the following steps:
cd /opt/ibm-ucd/agent/bin
./ibm-ucdagent start
Look for the Agent process to have started by running ps ef|grep AgentWorker
__1. Under Resources, go to the Resources tab and click the Create Top-Level Group tab
The resource will be your deployment target. In this section we will create a resource for each target
environment and bind the resource to a physical agent.
__2. Under Resources, go to the Resources tab and click the Actions menu to the right of the Lab
Environment resource. Add a group
__3. Click on the Actions drop-down to the right of the new resource and select Add Agent. The
existing agent will appear in the list. Click Save
Lab Page 35
IBM Software
For the single-server playground environment defined for this workbook, putting everything deploy
servers, database, and agent -- on the same box is fine:
By contrast, a real-world infrastructure would typically consist of a standalone deploy server, a database
server and one or more servers for each targeted environment:
__1. Go to the SIT environment created in the last lab for the JPetStore application:
Home> Applications>JPetStore>Environments>SIT
__2. From the Resources Tab, click on the Add Base Resources button and select the JPetStore-
SIT resource group.
The SIT Environment for JPetStore has been defined, and has been associated with a resource. To
complete the setup, bind each component in environment to this resource as well.
__1. Select the Applications tab, click on JPetStore, and then click on the SIT environment.
__2. Click on the Resources tab. Verify that there is an agent associated with this resource and it is
currently online
Lab Page 37
IBM Software
__3. Select the resource and an Actions drop will appear. Select Add Component from the drop-
down list.
__4. A Create New Resource pop-up will appear. Select JPetStore-APP component and save.
__5. Repeat the process to add JPetStore-WEB and JPetStore-DB components. Your resulting
resource map should look like the following:
Remember that the JPetStore web component contains the static content for the JPetStore web
application, such as images.
__1. Within the IBM UrbanCode Deploy web console, select the Components tab and then click on
the JPetStore-WEB component to open it.
__2. Within the JPetStore-WEB component, click on the Processes tab to see and maintain the list
of component processes. Make sure that you select the Processes tab UNDER JPetStore-WEB
and not the Processes tab above the component name.
Lab Page 39
IBM Software
__4. Click on the Create New Process button to create a new Component process.
__5. Name the new process Deploy Web Component. Select Deployment for the Process Type.
The rest of the default values are ok, so then press Save.
Note the Default Working Directory. The pre-populated default is a work directory under the
Agent install on the server the step will execute on. In this environment the default work
directory for the Web component will resolve to:
/opt/ibm-ucd/agent/var/work/JPetStore-WEB
__6. Click on the new process to open its definition. This will open a graphical editor to draw the
process steps. It should be an empty process with a Start and Finish step and nothing else. On
the left-hand side will be the set of plug-ins available from the deployment server. A plug-in
provides a set of application or system-specific step wizards to help implement the process
steps.
Lab Page 41
IBM Software
__1. When this Process is executed, it runs on the target computer, from the working directory
defined by Process configuration. Add a step to the Process to clean up the working directory
by deleting any content that it may already have. To do that, find Scripting > Shell >
Shell in the list of Available Plugins and drag and drop the Shell plugin into the diagram.
__2. When you drop the Shell plugin, a dialog opens to enter the plugin instance properties. Enter the
following information leaving the remaining fields with default values. Then Save the form.
Property Value
__3. Connect the Start step to the Clean Working Directory step: put the mouse cursor over
the Start step, click on the arrow that appears in the center of the step and then drag the cursor
over the Clean Working Directory step and release. A line is drawn from Start to Clean showing
that the Clean step runs after the Start step.
__4. Now you need to retrieve the contents of the Component from the uDeploy server. Add another
plugin to the diagram. This time select Download Artifacts which can be found in
Repositories > Artifact > IBM UrbanCode Deploy
__5. Use all of the default properties and press the Save button
__6. Connect from the Clean Working Directory step to the Download Artifacts step
Lab Page 43
IBM Software
__1. Define a step to move the files (static web content) to the JPetStore application directory. Use
another shell script for this, so add another instance of the Scripting > Shell > Shell to
the Process.
Property Value
Notice the {$p:environment/tomcat.home} in the script. This is a dynamic property. You are
using the Tomcat application server to run the JPetStore application on the target machine. The
files need to be copied to a location relative to the tomcat directory, which may vary by resource
(machine) or environment. In this case, it is an environment variable. Remember that we have
two environments defined SIT and UAT. So each of the environments can define the
'tomcat.home' variable differently. You will define the property later in this lab.
__3. Do NOT connect the previous step (the Download step) to this new one yet. However, go ahead
and connect this step to the Finish step.
__4. Before moving the static web content into the appropriate tomcat application folder, you want to
make sure that any old static content is deleted first. Add another Process step to cleanup the
directory. Use another shell script for this, so add another instance of the Scripting >
Shell > Shell to the Process.
Property Value
Shell
rm -rf ${p:environment/tomcat.home}/webapps/JPetStore/images
Script
__6. Connect the Download Artifacts step to the Remove Old Content step.
__7. Connect the Remove Old Content step to the Deploy New Content step.
There should now be a flow from the Start step of the Process to the Finish step. You have
scripted the process for deploying the Web Component.
Save the process by clicking on the Save icon in the upper left corner of the Process designer as
shown below.
__1. Within the IBM UrbanCode Deploy web console, select the Components tab and the click on the
JPetStore-APP component to open it.
__2. Within the JPetStore-APP component, click on the Processes tab to see and maintain the list of
processes.
__3. Click on the Create New Process button to create a new Component process.
Lab Page 45
IBM Software
__4. Name the new process Deploy App Component. Select Deployment for the Process Type.
The rest of the default values are ok, so then press Save.
__5. Click on the new process to open its definition, which opens a graphical editor to draw the
process steps.
__1. Add a step to the Process to clean up the working directory by deleting any content that it may
already have. To do that, find Scripting > Shell > Shell in list of Available Plugins and
drag and drop the Shell plugin into the diagram.
Property Value
__3. Connect the Start step to the Clean Working Directory step.
__4. Next, you need to retrieve the contents of the Component from the deployment server. Add
another plugin to the diagram. This time select Download Artifacts which can be found in
Repositories > Artifact >IBM UrbanCode Deploy.
__5. Use all of the default properties and press the Save button.
__6. Connect from the Clean Working Directory step to the Download Artifacts step.
JPetStore is a Java enterprise application that is deployed as a WAR file (JPetStore.war). In the case of
JPetStore the WAR file contains the database connection informationthe WAR file must be modified for
each target environment. Specifically, the WAR file contains the database connection information that
will be different for SIT and UAT.
A Java WAR file is compressed using ZIP technology. To modify configuration files, expand (unzip) the
WAR file, update the appropriate files, and then compress (re-zip) the WAR file.
__1. Add the plugin Utilities > FileUtils > Unzip to the Process.
Property Value
Extract
./JPetStore_expanded
directory
Zip JPetStore.war
__3. Connect from the Download Artifacts step to the Expand WAR step.
__4. One property file from the war file must be updated with database information. There is a plugin
for updating property files. Add the plugin Utilities > FileUtils > Update Property
File to the Process.
Property Value
Directory
./JPetStore_expanded/WEB-INF/classes/properties
offset
Add/Update
url=${p:environment/db.url}
properties
__6. Connect from the Expand WAR step to the Update Property File step.
__7. Next, you need to re-compress the WAR file. Add the plugin Utilities > FileUtils >
Create Zip Archive to the Process.
Lab Page 47
IBM Software
Property Value
Zip Archive
JPetStore.war
Name
Base
./JPetStore_expanded
Directory
Include **/*
__9. Connect from the Update Property File step to the Update WAR step.
__1. Add a step to the Process to start Tomcat in case it isn't already running. Select the plugin
Application Server > Java > Tomcat > Start Tomcat.
Note that this plugin is not part of the IBM UrbanCode Deploy base installation. This was a
plugin that you added during the initial configuration of the product. However, notice how the
added plugin has the same basic behavior as the built in plugins.
Property Value
Launcher ${p:environment/tomcat.start}
Startup timout 60
Port ${p:environment/tomcat.port}
The environment variable tomcat.start will contain the path and command to start tomcat.
Since both the SIT and UAT environment are hosted on the same machine, the port will also
differ by environment.
__3. Connect from the Update WAR step to the Start Tomcat step.
__4. Add a step to the Process to undeploy any previous versions of the WAR. Select the plugin
Application Server > Java > Tomcat >Undeploy Application.
Property Value
Tomcat
${p:environment/tomcat.url}/manager/text
Manager URL
Tomcat
Manager demo
Username
Tomcat
Manager demo
Password
Context
/JPetStore
Name
If JPetStore is not already running when this Process Step executes, the step will fail. If that is
the case, you want to continue anyway. That's why you turn the Allow Failure checkbox on.
__6. Connect from the Start Tomcat step to the Undeploy Application step.
__7. Add a step to the Process to deploy the new version of the WAR. Select the plugin
Application Server > Java > Tomcat >Deploy Application.
Lab Page 49
IBM Software
Property Value
Tomcat
${p:environment/tomcat.url}/manager/text
Manager URL
Tomcat
Manager demo
Username
Tomcat
Manager demo
Password
Context
/JPetStore
Name
__9. Connect from the Undeploy Application step to the Deploy Application step.
__10. Connect from the Deploy Application step to the Finish step.Verify that your process
looks similar to the following diagram.
__11. Save the process by clicking on the Save icon in the upper left corner of the Process designer as
shown below.
Lab Page 51
IBM Software
Environment properties are defined inside of the Environments defined within the application.
__1. Select Applications from the top tabs and then click on JPetStore to open the Application
definition.
__4. For each of the following values, click on the Add Property button and fill in the Name and
value as shown.
__5.
Table 2: Summary of the environment-specific Properties
Name Value
db.url jdbc:mysql://localhost:3306/jpetstore_sit
tomcat.home /opt/webservers/sit-apache-tomcat-7.0.42
tomcat.url http://udeploy.release-and-deploy-learning-circle.com:8085
tomcat.start /opt/webservers/sit-apache-tomcat-7.0.42/bin/startup.sh
tomcat.port 8085
Tip: use Batch Edit to add the variables in one pass. Do change to Table Mode when you are done to
make sure that the syntax is correct and no odd characters or spaces were introduced.
Lab Page 53
IBM Software
In the Application Process you coordinate the Component Processes that run. In the case of a
deployment script, you coordinate the deployment of the components.
__1. Select the Applications tab and then click on the JPetStore application to open it.
__2. Select the nested Processes tab (and NOT Processes in the top list of tabs).
__3. Click on the Create New Process button to add a new Application Process.
__4. Name the Application Process Deploy JPetStore. Keep defaults for all of the other fields
then click Save to save the process.
__5. In the screen that returns after you save the process, click on the process name, Deploy
JPetStore, to open it in the graphical Process Editor.
__6. Add a step to the Process that deploys the APP component, which is the applications WAR file.
Select the plugin Install Component.
Property Value
Component JPetStore-APP
Component
Deploy App Component
Process
__8. Connect from the Start step to the Deploy APP step.
__9. Add a step to the Process that deploys the WEB component, which is the static web contents.
Select the plugin Install Component.
Property Value
Component JPetStore-WEB
Component
Deploy WebComponent
Process
__11. Connect from the Deploy APP step to the Deploy WEB step.
__12. Connect from the Deploy WEB step to the Finish step.
__13. Verify that you see a process flow order similar to the following.
__14. Save the Process by clicking on the Save icon in the upper left corner of the editor.
Lab Page 55
IBM Software
You are ready to test your initial deployment model using the two components, APP and WEB, of
JPetStore to the SIT Environment. For this workshop, the SIT environment is a SIT-specific Tomcat
server on the workshop server image.
__1. Select the Applications tab and then click on JPetStore. You should see the list of
Environments.
__2. Click on the Request Process button next to SIT to launch an Application Process for the SIT
Environment.
__3. Select the Process named Deploy JPetStore. Select the Latest Version of both
JPetStore-APP and JPetStore-WEB. Then press the Submit button to start the deployment
process.
IBM UrbanCode Deploy remembers what version of a component has been deployed to a
Resource. Normally, if you run an Application Process that is deploying a component and if the
component version is already deployed, IBM UrbanCode Deploy doesn't re-deploy the
component. However, if you turn off the Only Changed Version checkbox, the component is
deployed even if the same version has already been deployed. This is useful when you are
initially testing new Process scripts and want to repeatedly deploy the same application
components to the same resource.
There are also various options for selecting which versions of the components are deployed.
Note that the Snapshot option is used in the next labs.
__4. The system displays the current application deployment status. You can see which components
aren't started, are running, were successful, or failed. Expand any of the components to see
additional information.
The diagram above is an execution in process. The diagram below completed successfully and
the Deploy App component process is expanded.
__5. Click on the Details hyperlink in the rightmost column to see even more details. This is
particularly useful if a component failed.
Lab Page 57
IBM Software
__6. This screen (shown below) shows the steps within the process and the Status of each step. The
Action buttons on the right show details for each step including log files for the steps.
Note that, as illustrated above, the first time that you deploy JPetStore, the un-deploy step will
fail, since there is no instance of JPetStore to undeploy. However, the un-deploy step is flagged
as "Allow Failure", so the process continues. If you run the process again after a successful
deployment, the undeploy step should work.
__7. If you have drilled into detailed status screens, hit the browser back button until you see the
overall summary showing Deploy APP and Deploy WEB. You should see Success. If you see a
status of Failed, drill into the log details to figure out what failed.
Tip: If you have an error, it might be a simple typo in a variable definition. When debugging a step
failure start by inspecting the Input Properties log the white log file to the right of the step. If the
variable is unexpanded as in the sample log below, it means that corresponding variable (tomcatt.url)
wasnt defined for the specified object (environment)
Lab Page 59
IBM Software
__1. Within the IBM UrbanCode Deploy web console, select the Components tab and the click on the
JPetStore-DB component to open it.
__2. Within the JPetStore-DB component, click on the Processes tab and click Create New
Process button to create a new Component process.
__3. Name the new process Deploy DB Component. Select Deployment for the Process Type.
The rest of the default values are ok, so then press Save.
__4. Click on the new process to open its definition, opening a graphical editor to draw the process
steps.
__1. Add a step to the Process to clean up the working directory by deleting any content that it may
already have. To do that, find Scripting > Shell > Shell in list of Available Plugins and
drag and drop the Shell plugin into the diagram.
Property Value
__3. Connect the Start step to the Clean Working Directory step.
__4. Next, you need to retrieve the contents of the Component from the deployment server. Add
another plugin to the diagram. This time select Download Artifacts which can be found in
Repositories > Artifact > IBM UrbanCode Deploy.
__5. Use all of the default properties and press the Save button.
__6. Connect from the Clean Working Directory step to the Download Artifacts step.
__1. Add the Upgrade DB plugin which can be found in Database >DBUpgrader >Upgrade DB
__2. Set only the values as shown below and then save.
Property Value
Name Upgrade DB
URL ${p:environment/db.url}
User jpetstore
Password jppwd
Lab Page 61
IBM Software
__3. Connect from the Download Artifacts step to the Upgrade DB step.
__5. Save the process by clicking on the Save icon in the upper left corner of the Process designer
__4. Click on the Deploy JPetStore process to open it in the Process designer.
__5. Add a new Install Component process step named Deploy DB Component that deploys
the JPetStore-DB component.
__6. Connect the process steps as shown below. Note that the APP deployment has to happen first,
but then WEB and DB can be deployed in any order or even at the same time.
__1. Follow the same instructions as earlier to deploy JPetStore. You should select these versions
for each component. Do that by selecting Specific Version for the Component Versions and
verifying the version specified:
Web: 1.0
App: 1.0
DB: 1.0
Note that the IBM UrbanCode Deploy tool records each version of a component deploy to a
resource. This maintains a historical record and avoids deploying the same version twice, unless
manually directed. From the test step previously executed, it recognizes that Web 1.0 and App
1.0 have already been deployed to SIT and will not redeploy them. Expand the steps to see the
full status:
Lab Page 63
IBM Software
__1. Open your browser and go to the site for the SIT version of
JPetStore:http://udeploy.release-and-deploy-learning-circle.com:8085/JPetStore
You should see the JPetStore application and graphics. Navigate around the site.
__2. Drill down to any specific animal and make sure that you can see a picture of the animal. That
will verify that the WEB component successfully deployed.
4.12 Summary
In this module you created reusable deployment scripts for the JPetStore components and application.
You used the scripts to deploy version 1.0 of the application to the SIT environment.
In this lab you will deploy additional versions of the components to upgrade the SIT environment to a
newer version of the content and database components. You will then create a snapshot of the SIT
environment and promote the snapshot to the UAT environment. Note that you may set up a component
or component template to automatically import new versions when available.
A snapshot is a collection of specific component versions and processes, usually versions that are
known to work together. Typically, a snapshot is created when a successful deployment has been run in
an uncontrolled environment. Snapshots can be created in controlled environments as well. As the
application moves components through various environments, IBM UrbanCode Deploy ensures that the
exact versions and processes you selected are used in every environment. Snapshots help manage
complex deployments--deployments with multiple environments and development teams.
When you have completed this exercise, you will have promoted the application version from the SIT
environment to the UAT environment using a snapshot.
__1. Click on the Import New Versions button to automatically load any versions that are found
in the file system that have not yet been imported. For the web component, the additional
version 1.1 will be imported.
Lab Page 65
IBM Software
__2. Repeat the above step to import version 1.1 of the component JPetStore-DB.
__3. Click on version 1.1 of JPetStore-DB, then the Configuration tab. Change the type
toIncremental.
The JPetStore product that is loaded into the database with version 1.0 has all but the Bichon dog in the
product list. Version 1.1 is an incremental version that only contains one addition, the Bichon dog
product.
While incremental deployments can make sense for manual deployments, tracking incremental versions
can quickly become a nightmare with automated deployments. If you are deploying 100 files, for
example, deploy all of them every time and let IBM UrbanCode Deploy figure out which ones have
actually changed. This way, if a file was unexpectedly changed, the deployment process itself will fix it.
__1. On the uDeploy server, verify the current version (1.0) of the JPetStore-WEB and JPetStore-DB
components are in the SIT environment
http://udeploy.release-and-deploy-learning-circle.com:8085/JPetStore
Enter the store and navigate to the Dog breed page. Confirm that there are only 6 products on
the list of dogs; (click on the More button to see the last two entries.) V1.0 of the JPetStore-WEB
and JPetStore-DB components do NOT have Bichon in the list.
Lab Page 67
IBM Software
__1. On the IBM UrbanCode Deploy server navigate to the JPetStore application and select Request
Process.
__2. Select the ProcessDeploy JPetStore and select specific component version 1.1 for
JPetStore-WEB and JPetStore-DB and press submit.
__3. On the deployment server, verify that the components deployed successfully. Note that you can
view the steps of each component process by selecting the Details.
__4. Return to the Application Environment page to see that SIT is compliant with the request to
deploy versions 1.1 of the WEB and DB components to SIT
Lab Page 69
IBM Software
__5. Note that the SIT JPetStore inventory has been updated and now Bichon is in the list.
http://udeploy.release-and-deploy-learning-circle.com:8085/JPetStore
Several deployment properties have been referenced as shown below. You need to define values for
these properties. Just as you set these up in Lab 3 for the SIT environment, you need to set them for
the UAT environment.
Environment properties are defined inside of the Environments defined within the
__1. Select Applications from the main folders and then click on JPetStore to open it.
Lab Page 71
IBM Software
__3. Within the Environment: UAT for JPetStore, click on the Configurationtab then select
Environment Properties:
__4. For each of the following values, click on the Add Property button and fill in the Name and
value as shown.
Name Value
tomcat.home /opt/webservers/uat-apache-tomcat-7.0.42
jdbc:mysql://udeploy.release-and-deploy-learning-
db.url
circle.com:3306/jpetstore_uat
tomcat.url http://udeploy.release-and-deploy-learning-circle.com:8086
tomcat.start /opt/webservers/uat-apache-tomcat-7.0.42/bin/startup.sh
tomcat.port 8086
__1. Navigate to the JPetStore application and click the camera icon next to the SIT listing to create a
new snapshot
__2. Enter Lab5-Promote as the name of the snapshot and select Save.
Lab Page 73
IBM Software
The snapshot is populated with the content of the current SIT environment. Go to Component Versions
tab and expand each component. Notice that the Database component includes two versions the
Incremental version 1.1 is not sufficient to recreate the environment, so both are automatically included.
Notice that JPetStore-DB contains both the incremental and the previous full version both are needed
to re-create the deployment instance currently in SIT.
Lab Page 75
IBM Software
__2. Now that you have verified what will be promoted to the UAT environment, you are now ready to
request the deployment from the snapshot. On the snapshot dashboard, select Request
Process. Then select the process Deploy JPetStore process you defined in Lab 3 and
press submit.
__3. Once the process is complete, you can view the details of the deployment of the snapshot to
UAT.
__b. Finally, verify the promotion succesfully updated the UAT tomcat
instancehttp://udeploy.release-and-deploy-learning-
circle.com:8086/JPetStore
5.7 Summary
In this lab, you learned how to deploy specific component versions, in this case version 1.1 of JPetStore-
WEB and JPetStore-DB to the SIT environment. You also learned how to create a snapshot of the SIT
environment and promote that snapshot to the UAT environment.
Lab Page 77
IBM Software
This lab will provide an introduction to the security model in IBM UrbanCode Deploy.
Security is concerned with Authentication and Authorization. Authentication deals with verifying the user
as he or she logs in; Authorization with what rights the user hasonce on the system.
When the IBM UrbanCode Deploy product is first set up, it uses an Internal Security realm for
authentication internal user accounts are created and maintained within the tool. For this workshop we
are using this authentication method. Most active systems will include an LDAP realm as well.
Authorization is based on a set of roles, applied to a set of teams, applied to a set of objects. Each role
defines a set of actions. Each team contains of users, assigned to roles. Objects are things like
applications, environments, and components.
__2. Click on the Create User button and create a new user:
ID: ben
User Name: Ben Franklin
Password: ben
__2. Click on the newly created Developer role and add the following actions:
__a. Under Application, grant Run Component Processes and View permissions
__f. Under Web UI, grant Access to the first five tabs (through Deployment Calendar)
Lab Page 79
IBM Software
__2. Add Ben to the team as a Developer. Save the new Team definition
__1. From Applications, select JPetStore. Select Configuration > Basic Settings.
__2. Update the SIT environment to include JPetStore Team with a Standard Environment Role
From Applications>JPetStore>SIT, select Configuration>Basic Settings. Click Add and Save.
__3. Update the UAT environment to include JPetStore Team with a QA Environment Role
Since the name of each environment is just a tag the IBM UrbanCode Deploy system doesnt
understand the semantics of SIT vs. UAT -- using environment roles provides a way to define different
security rules around the environment type.
Lab Page 81
IBM Software
Notice fewer high-level tabs are available. This was done through configuring the Web UI.
Notice also that, although Ben can see UAT, and compare the content against other
environments, he does not have the rights to do a deployment.
__2. Locate link at the top of the UI listed under the Created on date/time. You can use this to
navigate directly to the RTC build result. You can also enter the URL of this UI into the RTC build
result as a reference of the specific component delivered by the build process.
7.2 Summary
In these labs you took a first look at the IBM UrbanCode Deploy capabilities. You explored installation,
configuration, integration and deployment automation into two test environments. Please take a moment
to comment on your experiences in the learning circle located where you downloaded this lab:
http://ibm.co/devops-learning-circle
Lab Page 83
NOTES
Appendix A. Notices
This information was developed for products and services offered in the U.S.A.
IBM may not offer the products, services, or features discussed in this document in other countries.
Consult your local IBM representative for information on the products and services currently available in
your area. Any reference to an IBM product, program, or service is not intended to state or imply that
only that IBM product, program, or service may be used. Any functionally equivalent product, program, or
service that does not infringe any IBM intellectual property right may be used instead. However, it is the
user's responsibility to evaluate and verify the operation of any non-IBM product, program, or service.
IBM may have patents or pending patent applications covering subject matter described in this
document. The furnishing of this document does not grant you any license to these patents. You can
send license inquiries, in writing, to:
For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property
Department in your country or send inquiries, in writing, to:
The following paragraph does not apply to the United Kingdom or any other country where such
provisions are inconsistent with local law: INTERNATIONAL BUSINESS MACHINES
CORPORATION PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some
states do not allow disclaimer of express or implied warranties in certain transactions, therefore, this
statement may not apply to you.
This information could include technical inaccuracies or typographical errors. Changes are periodically
made to the information herein; these changes will be incorporated in new editions of the publication.
IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this
publication at any time without notice.
Any references in this information to non-IBM Web sites are provided for convenience only and do not in
any manner serve as an endorsement of those Web sites. The materials at those Web sites are not part
of the materials for this IBM product and use of those Web sites is at your own risk.
IBM may use or distribute any of the information you supply in any way it believes appropriate without
incurring any obligation to you.
Any performance data contained herein was determined in a controlled environment. Therefore, the
results obtained in other operating environments may vary significantly. Some measurements may have
NOTES
been made on development-level systems and there is no guarantee that these measurements will be
the same on generally available systems. Furthermore, some measurements may have been estimated
through extrapolation. Actual results may vary. Users of this document should verify the applicable data
for their specific environment.
Information concerning non-IBM products was obtained from the suppliers of those products, their
published announcements or other publicly available sources. IBM has not tested those products and
cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM
products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of
those products.
All statements regarding IBM's future direction and intent are subject to change or withdrawal without
notice, and represent goals and objectives only.
This information contains examples of data and reports used in daily business operations. To illustrate
them as completely as possible, the examples include the names of individuals, companies, brands, and
products. All of these names are fictitious and any similarity to the names and addresses used by an
actual business enterprise is entirely coincidental. All references to fictitious companies or individuals are
used for illustration purposes only.
COPYRIGHT LICENSE:
This information contains sample application programs in source language, which illustrate programming
techniques on various operating platforms. You may copy, modify, and distribute these sample programs
in any form without payment to IBM, for the purposes of developing, using, marketing or distributing
application programs conforming to the application programming interface for the operating platform for
which the sample programs are written. These examples have not been thoroughly tested under all
conditions. IBM, therefore, cannot guarantee or imply reliability, serviceability, or function of these
programs.
NOTES
JPetStore application Copyright (c) 2004 Clinton Begin. All rights reserved
Adobe, the Adobe logo, PostScript, and the PostScript logo are either registered trademarks or
trademarks of Adobe Systems Incorporated in the United States, and/or other countries.
Intel, Intel logo, Intel Inside, Intel Inside logo, Intel Centrino, Intel Centrino logo, Celeron, Intel Xeon, Intel
SpeedStep, Itanium, and Pentium are trademarks or registered trademarks of Intel Corporation or its
subsidiaries in the United States and other countries.
Linux is a registered trademark of Linus Torvalds in the United States, other countries, or both.
Microsoft, Windows, Windows NT, and the Windows logo are trademarks of Microsoft Corporation in the
United States, other countries, or both.
ITIL is a registered trademark, and a registered community trademark of The Minister for the Cabinet
Office, and is registered in the U.S. Patent and Trademark Office.
UNIX is a registered trademark of The Open Group in the United States and other countries.
Java and all Java-based trademarks and logos are trademarks or registered trademarks of Oracle and/or
its affiliates.
Cell Broadband Engine is a trademark of Sony Computer Entertainment, Inc. in the United States, other
countries, or both and is used under license therefrom.
Linear Tape-Open, LTO, the LTO Logo, Ultrium, and the Ultrium logo are trademarks of HP, IBM Corp.
and Quantum in the U.S. and other countries.
NOTES
NOTES
NOTES