The relationship between PureApplication, UrbanCode and DevOps

When we first set up our PureApplication Practice, DevOps was not an issue that customers came to us with, but, as time has gone on, more and more customers are starting to identify with having a “DevOps” problem.

Here I try to define the DevOps problem and discuss how IBM tools like PureApplication and UrbanCode could help.

Defining DevOps

Ask three people what they think DevOps is and chances are they’ll give you three different answers. There are lots of definitions of what DevOps means but the diagram below is the best that I’ve seen and is how I like to express what I see as the problem …

This diagram shows how the “left hand side” of the problem, the Development cycle, has been revolutionised over the past ten years or so. We’ve got to a state where the dev cycles are short and snappy. Developers have lots of skills and toolsets available to them, such as agile development and continuous integration, which help them produce code ever quicker.

However, the “right hand side” of the problem, Ops, is not working with the same level of agility. They are increasingly unable to keep up with the speed of deployment requests and are often unable to provide the quick feedback that the agile development system needs. This causes friction at the boundaries.

To grossly generalise: Devs think Ops are slow and Ops think Devs have no idea what they’re asking of the Ops folks! DevOps’ raison d’être is to reduce that friction. Its practical aim is to break down the glass wall between the two groups and make each other aware of the other’s view point while also providing more tools on the “right hand side” of the problem to get Ops up to the same velocity as the Devs.

PureApplication To Help Ops

In order to achieve this high *velocity* (an agile term) you’ll need to automate as much as you can throughout your entire software development process. This is where tools like IBM’sUrbanCode Deploy and IBM’s PureApplication come in.

Terms like continuous integration and agile programming are all well known in the Development cycle. What PureApplication does is bring that level of automation and agility into the right hand side of the problem (Ops). PureApplication lets you create environments on-demand, in a repeatable manner so that the devs and testers can have access to the platforms they require when they need them. It enables the Ops guys by giving them re-usable components in a modelling environment which they can then create instances of at a click of a button – helping them to become more agile.

In the IBM diagram below there are a few annotations to show just some of your tooling options when considering a fully automated Solution development lifecycle.

Development teams have loads of tools available to them, from the modelling environments in eclipse to the fully automated build systems like Jenkins & Rational’s Build Forge.

I’ve added the modelling and cloud environment that PureApplication gives you into the “right hand side” of the picture. This shows how you can take the output from the development teams and deploy it to solution topologies which have been stood-up by PureApplication.

This shows us how PureApplication fits into the software development lifecycle, at a high-level; so, what about UrbanCode?

Leveraged By UrbanCode

UrbanCode is a company acquired by IBM in 2013. It has two main tools that are well known – UrbanCode Release and UrbanCode Deploy (commonly called UDeploy). The Release tool is centred around that automated build process on the left hand side and is not the feature that I’ll focus on here. It’s UDeploy that’s of interest to us in this blog.

UDeploy fits in the gap between the automated development and build processes that appear on the left hand side of the problem and the automated Solution infrastructure piece that PureApplication brings us on the right hand side – as shown below.

UDeploy comes under the category of “solution deployment tooling”.  It helps you deploy solutions coming out of your build systems (the dev or left hand side of the problem) to the solution platform itself (the ops or right hand side of the problem).

NOTE: You do not have to have PureApplication to use UDeploy but PureApplication is a great tool to help you get that proper DevOps mentality in the ops side of the problem.

How It Works

UDeploy helps you in several ways:

One of the first thing it allows us to do is attach the infrastructure requirements of an artifact to the artifact itself. What I mean by this is that, say an EAR file needs a queue in order for the application to work, UDeploy gives you the ability to attach the code that creates that queue to the EAR artifact. Thus, every time the EAR file gets deployed the queue will get created as well.

This is a very subtle but very important change to the way you probably create solutions today. What often happens is that the Ops folks get a request from the Dev team to say that their solution needs a queue. It’s then up to the Ops teams to implement that queue. At that point you have a communication between two teams that can break down at any point. For example; what if the EAR file needs another queue later on its life ? This has to be documented somewhere. UDeploy helps you solve these logistical problems. It allows you to maintain that relationship between versions of code and their requirements on the base platform that they are about to be deployed to. What this also means is that the Ops folks can now create more re-usable components. They can create say a standard MQ environment and leave the specifics of the queues to the applications and not create bespoke MQ environments for each application. Thus helping to bring that re-usable component mentality, that developers have had for years, into the ops space.

The second big thing that UDeploy allows us to talk about a solution as a single entity. Traditionally solution artifacts (EAR files etc) are usually deployed as just that, single artifacts. Someone will deploy the EAR file and then make sure the Bar file is deployed and all the images are available etc. etc. UDeploy allows you to say “all these artifacts make up this solution” and keep track of the whole solution and not individual artifacts.

Once you have this level of governance you are now in a position to migrate your entire solution easily from one environment to another; very clear in the knowledge that the artifacts are all at the right level and that the changes to the middleware required by the solution will be done correctly every time.

Clear Benefits For DevOps

I’ve shown that DevOps is about making each side of the Software Development Lifecycle aware of each other and helping Ops get those same agility levels as Dev have had for some years.

PureApplication can help your Ops team get application and middleware environments stood up quickly and accurately time and again.

UrbanCode helps you then deploy your entire solution as one entity to that platform repeatedly and consistently –  thus allowing you to transfer your solution from dev to test to prod seamlessly.

Together they can help to break that DevOps barrier.