UrbanCode Deploy course and product overview slides

© Copyright IBM Corporation 2015
Welcome to
Essentials of IBM UrbanCode Deploy
Our session will begin shortly

Essentials of IBM UrbanCode Deploy
Course code: QQ147
Course Overview

3 © Copyright IBM Corporation 2015
Intended audience
Primary audience:
 Users
 Configurators
 Producers
 Administrators
Secondary audience:
 Administrators

Course description
This course introduces IBM® Rational® Urban Code
Deploy
After completing this course you will know this information:
How UrbanCode Deploy solves customer problems
The workflow for a simple project
How key concepts and terms such as component, resource, processes are used in the product
How resources are organized and accessed
How to orchestrate deployments to different environments
You will also be able to complete these tasks:
Create a resource
Add agents to the base resource
Add a base resource to an application environment
Add component resources to the agents in the resource tree
Create components
Import artifacts from a build to create component versions
Identify the different kinds of component properties
Add components
Create component processes and add them to components

Course description continued
You will also learn how to complete these tasks:
Create an application and an environment
Create an application process
Update an application
Approve deployments
Examine the inventory and compliance for an environment and identify what
versions of components are installed in the environment
Schedule deployments
Execute a deployment

Course materials
Materials for this course:
 Slides
 Lab workbook
 Student workbook
 Lab environment setup instructions
 Videos

Course outline
Module 0: About this course
Module 1: Product overview
Module 2: Resources
Module 3: Components
Module 4: Applications
Module 5: Deployments
Module 6: Teams and roles

Essentials of IBM Urban Code Deploy
Course code: QQ147
UrbanCode Deploy product overview

Agenda
Solving customer problems
Key terminology
Workflow
Explore the user interface

Module objectives
In this module you learn about:
 Problems that UrbanCode Deploy helps to solve
 A workflow for a basic deployment
 The purpose of snapshots and inventory
 User interface navigation
 The UrbanCode Deploy topology
 Server and agent communication

Deployment and release problems are serious business
Costly, error prone
manual processes and
efforts to deliver software
throughout an enterprise
are pain points.
CHALLENGES
Upgrade risks arise because
of managing multiple
application configurations and
versions on servers.
Slow deployment
to development and test
environments leave teams
waiting and unproductive.
CHALLENGES
Operations and
Production
Development and
TestCustomers
Business
Owners
Knight Capital loses
$440 million because of
a misconfigured release
(in only 45 minutes).
A bad software upgrade
at RBS Bank left
millions unable to access
money for 4 days.
New Zealand’s biggest phone company,
Telecom, paid $2.7 million to
approximately 47,000 customers who
were overcharged after a software glitch.

What’s going wrong?
Differences in dev and
ops environments and
procedures cause
failures.
Time-to-market pressure
generates more frequent
releases.
Manual processes for
release lack repeatability
and speed.
Major releases take days;
hundreds of people and are
organized by spreadsheet.
Daily
build
Release
Who did
this last
time?
Dave…
Dave’s
not here,
man….
Dev
Prod
I’ll order
breakfast

Common application deployment problems

The UrbanCode Deploy solution
 Automated, consistent deployments and application
rollbacks
 Orchestration of changes on servers and tiers
 Configuration and security differences between
environments
 Clear visibility: What is deployed where and who
changed what
 Integration with middleware, provisioning, and service
virtualization

Accelerate
software delivery
Balance speed, cost,
quality, and risk
Reduce time to
customer feedback
People Process Technology
Develop/Test
Deploy
Operate
Steer
IBM DevOps architecture
Enterprise capability for continuous software delivery that enables clients to
seize market opportunities and reduce time for customer feedback.
15
DevOps Practices Self Assessment tool.
Blog that explains the Self Assessment tool: https://ibm.biz/BdRUbh
Direct link to the tool : https://ibm.biz/devops-practices-assessment

Urbancode Deploy focus areas in the DevOps process

Deployment definition
“Deployment” is the process of completing these actions:
 Selecting component versions from a repository.
 Moving those components to one or more targets, such as a web server.
 Completing the required tasks for bringing those pieces of the application
online.
– For example, a deployment might remove the previous version from an
application server, install a new version, and then start the new version.

UrbanCode Deploy
Deployment is the process of moving software through
various preproduction stages to final production.
What refers to the deployable items: binary files, static content,
middleware updates, database changes and configurations, and
anything else that is associated with the software that IBM
UrbanCode Deploy delivers to targets.
How refers to combining deployable items with processes to
create components and designing applications that coordinate
and orchestrate multicomponent deployments.
Where refers to the target's hosts and environments.

Intuitive and scalable model-driven deployment
Composite applications
Components
Reusable workflows
Environment
management
SIT
PROD
The “What”
The “How”
The “Where”
Deployment
automation
19

Application model
Reliably capture application content and configuration
settings with versions and traceability.
The “What”

Application environments
21
Define where components are deployed and capture
configuration settings per deployment environment for
an application.
The “Where”

Deploy the application
- Orchestrate the deployment of many components.
- Represent deploy-time dependencies
Deploy the component
- Create a fully automated workflow
to be executed on target servers
Use a drag-and-drop workflow designer.
Precisely control of execution flow.
Use hundreds of integration steps are provided
Create custom steps.
Deployment processes The “How”

The continuous delivery pipeline

Before any
deployments to
production, manual
approvals are
required.
The exact combination of
component versions which
passed tests is captured in a
snapshot.
On build completion, the
latest artifacts are
published to UrbanCode
Deploy and deployed to
a development or SIT
environment.
After deployment,
automated tests are
started. If they pass,
we mark the tested
versions as such.
Putting it all together: Continuous delivery

Installation elements
UrbanCode Deploy server
 The main server provides a web interface for administration and user
operations.
 The server manages authentication and authorization for users (LDAP
integration is available too).
 The server orchestrates integrations with other elements: agents, other IBM
software, or third-party software.
Agents
 Are installed on each deployment target.
 Communicate with the UrbanCode Deploy Server to receive file transfers
and initiate operations on local computers to install and initiate the
application pieces.
– Local operations are accomplished with “plug-ins.”
– Agents include Groovy libraries for running plug-ins, but plug-ins can be
written in any language or format that provides execution capability on
the local computer.
Relay server (optional)

Welcome to UrbanCode deploy
Represent
deployable
items and the
processes to
deploy them
Orchestrate
component
deployments
Add
properties to
applications,
components,
and
environments
Are generic
processes
that run
outside the
context of
components
and
applications
Represent a
deployment
target
Shows
scheduled
deployments

Web applications
Web applications are made of multiple pieces:
 They are often created by many different groups, including third parties.
 They are updated on separate schedules and have different version
numbers.
 They are installed on multiple pieces of hardware at run time.
Application user
Web servers App servers Database servers
Page designers Programmers
Database architects
Web pages
Data
structures
Note: You can use UrbanCode Deploy for any kind of application code
distribution, but web applications provide the best illustration of its value.

Architecture and environment before the lab exercise
The lab is set up with one agent and two-servers as deployment targets.

A basic workflow
1. Create a base resource.
2. Add an agent to your base resource.
3. Create a component.
4. Add versions to your components.
5. Add component processes to your components.
6. Create an application.
7. Add components to your application.
8. Create application processes.
9. Create application environments.
10. Add a base resource to the application environment.
11. Add to the agents in resource tree component resources for
each component that is used in your application
12. In the application environment click Run Process

Architecture and environment for the JPetStore lab exercise
After the lab is complete the components have deployed as
shown below:

Different groups use different component versions
Editors might use the latest version that exists.
QA uses a combination of old and new components.
 QA tests “candidate” application releases to make sure they work together without
errors.
 Multiple combinations of versions might be in various test stages.
Production uses only versions that are proven to work together without errors.
Development
systems
Production
systems
QA
systems
v1 v1v1
v4 v2v3
v6 v2v4

IBM UrbanCode Deploy
UrbanCode Deploy gives engineers a way to quickly
manage what pieces go where.
Development
environment
Production
environment
QA
environment
v1 v1v1
v4 v2v3
v6 v2v4
IBM
UrbanCode
Deploy
Build or release
engineer

UrbanCode Deploy topology

The UrbanCode Deploy key elements
UrbanCode Deploy maintains these elements to represent
deployment activities and artifacts:
 Components: The pieces of your application that are being deployed.
 Applications: The collection of components that are deployed together.
 Resource: The target of a deployment; a computer where an agent is
installed.
 Environments: A collection of resources (computers) where an application
is hosted.
 Snapshots: A collection of specific versions of components.
 Processes: A list of steps that operate on a component. These steps
include moving a component to a target environment and acting on that
environment to initiate the running application.
 Plug-ins provide basic functions and provide an extension point for
integration with other software.

Get visibility and automated control of your application
deployment process.
• Manage application
components and versions.
• Manage configurations
among all environments.
• Offer secure “self-service”
capabilities.
• Increase transparency.
• Ensure governance and
compliance.
UrbanCode Deploy automation benefits

Inventory
Inventory shows what versions
are “where”:
Environments and
resources
Resources (deployment
targets) support different
scenarios.
When did the component get
there?
What used to be there?
How do things differ?

Snapshots
Creating a Snapshot
Component Versions
1
1
2
2
3
3
321Web
Mid. Code
DB
Snapshot
3
2
1
Mid. Config 1 2 3 3
Snapshot Deployment
ENVSnapshot
3
2
1
WEB HOST
MID HOST
DB HOST
2
1
1
3
2
X
3 3 1
• Create a snapshot after testing
• Snapshots contain deployable components and configuration
• Deployment changes are tracked by default
Snapshots help in these areas:
 Automation, audits, and visibility

Components, applications, and snapshots
Fix bugs
Add features
Remove obsolete functions
v1
v4
v1
v1
v2
v2
v2
v3
v3
v4 v5 v6

Resources, environments, processes
Resources - Resources are assigned to environments.
A resource represents a logical deployment target that
typically resolves to an agent. The agent does the
work.
Environments – may have multiple servers, logical and
physical deployment target
Processes – Executed by applications on components

Process editor
A graphical editor in which to
construct elemental processes to
complete operations on resources.
A drag-and-drop interface to create
process flows.
Web based and accessible through
the UrbanCode Deploy server.
Parameter-based logic, which is
highly customizable.
Ability to write customized
procedures and plug-ins.

Representation model review questions:
What is a component?
What is a resource?
What is a snapshot?
What is deployed to an environment?
What are processes packaged with and what are
they executed by?

Simple deployment demonstration
Let’s take a look at an example of a simple deployment
of the JPetStore application.

Model elements in the web user interface

Use tabs to access model elements
Access the structural elements by using the tabs.

Model structure is reflected in the navigation
Click the Applications tab to see a list of
applications under management…
Click the name of an application to drill down into
the details.

Drilling down into an application
Subtabs provide functions that are in context with
what you are viewing.

Navigating back
With the breadcrumb, you can navigate back up
the hierarchy.

The Process editor
With the Process editor, you can drag processes
to create logical workflows from many prebuilt
operations.

Results are logged
In the web user interface, you can
see the results of an attempt to
deploy components into
environments.

Artifact repositories versus software configuration management
Artifact repositories:
 Locations where creators of deployable components are deposited and
distributed to many types of users
Software configuration management (RTC or GIT) systems:
 Locations where source code is deposited by and distributed to developers
Similarities:
 Both use content-addressable storage to contain and distribute data.
 Both maintain a notion of “versions” of the elements that they hold.
 Both require credentials for access.

The continuous delivery pipeline

Agents
Light-weight processes that are
installed on every deployment target
(resource).
Provide two-way communication with
the UrbanCode server
 Stateless (resilient to network outages)
 Can be secured by using SSL
Built on Java (requires JVM 1.7 or
later)

Agent
Agent processes: Monitor and worker
Monitor
Worker
(JMS)
Installed as
a service
Multi-
threaded
Plug-in
Run-
time Non-JMS
HTTP
Resource
An agent consists of a
worker process and
a monitor process.

Server-agent communication
Most agent communication is via JMS (bi-directional).
Some activities use HTTP, however (one-directional
from agent to server):
 Posting logs
 Transmitting test results
 Posting files to CodeStation
Agents
UrbanCode Deploy server
HTTP:8080
HTTPS:8443
JMS:7918
HTTP / REST
JMS Channel*
*The agent polls for items in the queue to initiate communication.

Agents and the relay server
In simple configurations, agents communicate directly
with the UrbanCode server.
In more complex situations, direct communication
becomes inefficient or impossible:
 The number of agents increase from tens to hundreds to
thousands.
 Network topology becomes complex.
 Agent-server communication crosses firewalls with port
restrictions.
Agent relay servers resolve this issue.

Topology example with an UrbanCode Deploy relay server
Agents
HTTP or REST
JMS channel
Primary server
Relay server
QA department network
Development department network
Relay server

Resources
• See the material posted on the Urban Code Release
and Deploy learning circle – learning circle link

Module summary
In this module you learned about:
 Problems that UrbanCode Deploy helps to solve
 A workflow for a basic deployment
The purpose of snapshots and inventory
 User interface navigation
 The UrbanCode Deploy topology
 Server and agent communication

UrbanCode Deploy course and product overview slides

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to UrbanCode Deploy course and product overview slides (20)

More from IBM Rational software (20)

Recently uploaded (20)

UrbanCode Deploy course and product overview slides

Editor's Notes