DevOps and cloud: An end-to-end scenario video series
A lot of introductory and theoretical blog posts have been written to explain the notion of a DevOps “continuous delivery pipeline” and its relationship to cloud technology. I’ve even written some myself, but I thought it was time to show some actionable scenarios.
Some colleagues and I from the German Rational and cloud team recently implemented an end-to-end DevOps scenario that we also demonstrated with great success at CeBIT fair in Hannover, Germany. Thanks to Rene Meyer, Dr. Patrick Schneider, Robert Michel, Thomas Mueller and Bruno Bartl for helping to put all of this together. Great teamwork!
We split the scenario into various sections and recorded them in seven videos that we would like to share with you in this blog series.
First, let me describe the overall scenario before introducing the seven sections that we will offer to you in the rest of the series:
· In this DevOps implementation, we used an IBM internal claim recording application to walk through the overall development lifecycle as depicted in the preceding diagram.
· The overall lifecycle starts with a requirement to change some behavior inside the claiming application. We used IBM
· The development team then takes ownership of those work items and changes the code of the claiming application inside their Eclipse development environment or integrated development environment (IDE).
· After the developer has done his job and checked his code into the source control management system (SCM) based on Rational Team Concert, the continuous integration and build process starts and generates the application artifacts. From a tooling perspective all of this is based on a combination of Rational Team Concert, Apache Ant jobs and Maven as an open source technology solution.
· The artifacts for the various layers of the application (front end, application server, database) that are produced by the build system are automatically pushed and registered into the deployment automation system based on IBM
· The build process can also automatically deploy the application and its related components into the systems running inside the cloud. We use the IBM private cloud solution IBM
· After deploying the application we automatically run a functional test as part of the deployment process. We use IBM
· While we deploy the new build of the application into existing systems running inside the cloud, we have an alternative scenario in which we implicitly provision the overall infrastructure stack as part of the application deployment process. In other words, with each new build a defined infrastructure and middleware stack based on a standardized cloud pattern definition is automatically provisioned before deploying the application itself. All of that is controlled by IBM UrbanCode Deploy as the central deployment automation system using IBM SmartCloud Orchestrator as the cloud solution. We demonstrate how to provision a new user acceptance test environment on demand in the cloud and deploy or stage the latest application release from the previous environment stage into this new environment.
There is a lot of detail behind this end-to-end DevOps scenario, so we’ve split the demonstration into seven distinct videos:
Part 1: We start by introducing the current state of the claiming application itself and explaining the business requirement for the intended change. We also show the flow—from capturing and integrating the business requirements inside the requirements management system, to the CLM system defining the work items for the development department based on the defined requirements.
Part 2: The second video shows how the developer takes ownership of the work items within the CLM system before changing the application code according to the defined requirement. He develops the required changes and checks his revised code.
Part 3: The third video focuses on the integration of the continuous integration and build systems and the deployment automation system. It shows how the build system pushes the artifacts into the deployment system before automatically deploying the application components into the cloud environment.
Part 4: The fourth video highlights some key concepts of the IBM UrbanCode Deploy deployment automation solution. Since it plays a key role in the overall end-to-end scenario we thought it would be helpful to give you some background of the concepts behind it—all in the context of the claiming application.
Part 5: The fifth video highlights how we integrated automated testing into the application deployment process.
Part 6: The sixth video focuses on cloud integration in more detail. We demonstrate how we provision a new user acceptance test environment inside the cloud based on a predefined blueprint model. The overall process is controlled by the deployment automation system.
Part 7: The new environment is then used to stage the claiming application from successfully deployed and tested environments into the new user acceptance test (UAT) environment.
In each blog post we’ll give you a short intro text to explain that specific step in this end-to-end process.
Have fun watching them, and please let us know your feedback. And, by the way, although we implemented our end-to-end scenario using foremost IBM technology, we could also integrate open source or other commercial solutions at various places of the overall architecture.