Micro Focus is now part of OpenText. Learn more >

You are here

You are here

5 steps to building an open-source toolchain for DevOps

public://pictures/Bernard Golden Photo 3.png
Bernard Golden CEO, Navica

It's no secret that enterprises are increasingly preferring open-source products, and that's quite a change from the past. Just a few years ago most enterprises avoided open source, and some went so far as to attempt to ban its use.

Today things are quite different. Most enterprises have moved from a stance of begrudging acceptance of open-source projects to an active embrace, and many have gone so far as to make open source a key part of their strategic infrastructures and architectures, creating a new, open-source toolchain for DevOps.

One obvious reason for this is cost. Open-source products are significantly less expensive than their proprietary counterparts. There's a second reason: innovation. The nature of IT is changing, with increased importance in the new, digital enterprise. Simply put, IT is becoming the way businesses do business, and companies now look to their IT organization to deliver innovation. That, in turn, commonly means turning to open source.

Open source offers much more flexibility than proprietary software. Users are free to modify the product code to incorporate changes they want. In addition, the less restrictive open source licenses allow companies to incorporate open-source packages into their products, thereby allowing innovation to diffuse into those offerings.

The new DevOps toolchain

This need for innovation dramatically affects the way IT operates. It needs to go faster than it did in the past, when most of its efforts were focused on internal process automation. The need for speed means IT must transform its internal processes, resulting in an integrated development and operations toolchain. This need for a new DevOps toolchain is driving open-source adoption even further into IT.

A wide variety of open-source packages are available to automate specific parts of the application process. For example, Gradle builds application components. Jenkins automates integration of separate application code components. Selenium automates application testing. And there are dozens of open-source packages that enterprise IT groups can leverage to make their application processes more agile. Most IT groups implementing a DevOps strategy make use of open-source components for some or all of the toolchain.

That presents its own challenge. While open-source products offer fantastic potential for flexibility and innovation, they don't come pre-assembled in an integrated toolchain package. That is, as the saying goes, left as an exercise for the reader.

So what is an enterprise IT group to do? It's critical to move to an open-source toolchain to support agility and innovation, but there's no "easy" button to obtain such a thing. Figuring out how to implement and sustain an open-source toolchain is one of the most critical action items enterprise IT groups need to achieve over the next 36 months.

Your toolchain action plan

Here are five steps for creating an open-source DevOps toolchain that should be part of any action plan.

1. Recognize that you'll need a new end-to-end toolchain strategy

Your current toolchain undoubtedly imposes lengthy delays in the developer-to-production assembly line. It's not enough to move to agile development, worthy though that is. If development changes can't move into production quickly, you've optimized just one part of the overall application lifecycle, and the overall lifecycle will still be agonizingly slow. What's worse, this will lead to increased organizational friction as different groups point fingers at one another for update delays (although, if you're like many companies, you already have this down to a fine art).

2. Learn from other organizations' experiences

There are DevOps Days throughout the world, as well as other DevOps-oriented events. They offer presentations, discussions, and opportunities to mingle with experienced people all focused on one thing—how to implement and manage automated toolchains. Leveraging other people's knowledge and learning from their setbacks can help you move forward.

3. Analyze your current application process

This analysis, known as value chain mapping, involves analyzing each step of the development-to-production process to determine which group is involved and how long each step takes. This enables you to identify all the areas you'll need to automate and directs your tool selection efforts. Also, as part of this effort, you should document current metrics, such as time to run smoke tests on new code check-ins. In this way you can compare your current process with the new, automated version and help to galvanize organizational commitment.

4. Select a set of open-source tools on a trial basis and build a prototype development toolchain

This is where the rubber hits the road. In taking this step, leverage the knowledge you obtained from hearing other peoples' experiences, and focus on well-established open-source components so that you're in the mainstream of this effort. Also, be sure to measure the outcomes of your prototype against current metrics to ensure that you're actually improving the situation. After all, going through all this work and ending up no faster or—heaven forbid—even slower than current practices isn't good.

5. Determine your long-term toolchain support strategy

This is critical, since your development toolchain is going to be the foundation of your company's future. I've seen too many IT organizations turn a couple of sysadmins loose to put together a toolchain consisting of a collection of open-source components, only to find a year or two later that those employees have departed, the toolchain isn't documented, no current employee understands it, and any breakdown threatens core revenue-generating applications.

Here are your options regarding your open-source toolchain support:

Recognize that your toolchain is a core IT capability that you want to control

And commit to the investment required to do so. This will imply sufficient staffing to maintain your toolchain, with some requirements that may not be obvious at first glance. For example, you'll need to track and implement code changes and security patches for every component in the toolchain. You'll also need to treat the toolchain as a product and perform QA, staging, and controlled updates, just like the applications the toolchain builds. Finally, you'll need to commit to staffing levels, coverage, and training appropriate to keeping your toolchain up and running.

Look to a small, specialized integrator focused on DevOps to take responsibility for your toolchain

This approach to toolchains is still emerging and the knowledge to implement and support them isn't widely available. Using a highly technical, boutique integrator or consulting firm to support your toolchain can jump-start your efforts and ensure that you benefit from leading-edge knowledge. On the downside, these are by definition local or regional firms, so distributed IT organizations may find that a boutique firm can't provide the coverage the organization requires.

Engage a global integrator

These firms have the ability to support you wherever your personnel are located. One common reservation about this approach is the perception that these companies are focused on implementing high-priced, legacy, proprietary products that don't deliver the end-to-end agility you need to meet future needs. This is a valid concern, but the situation is changing. For example, IBM just acquired StrongLoop, a small open-source company, to increase its ability to support node.js applications. We'll see more of this as global integrators come to terms with the changing nature of enterprise IT and conclude that it's better to jump in than to be left behind.

A competitive edge

There's an enormous change occurring in the role of enterprise IT and an accompanying change in the processes and tooling it will require to fulfill its future mission. Open source is bound to be a part of tomorrow's application toolchain, and if you're a savvy IT leader, you'll aggressively move forward with a plan to get ahead of the competition. The five steps outlined above provide a structured approach to developing a strategy and should prepare you for success.

Keep learning

Read more articles about: App Dev & TestingDevOps