Kubernetes with OpenShift World Tour: Get hands-on experience and build applications fast! Find a workshop!

IBM Developer Blog

Follow the latest happenings with IBM Developer and stay in the know.

Container-based, cloud-native development shouldn't be so hard. New open source projects from IBMers make it easier to architect, build, and deploy applications.


As a developer, your goal is to write great code and solve business problems. Efficiency is a key part of being a developer, but being efficient within a team isn’t just about what’s in your head. You need the right tools and technology to work quickly and create the best applications.

The challenge of integrating new tools and frameworks into a platform of some kind can be a distraction from your primary task of solving business problems. While Kubernetes has become a popular platform for developers, it’s not a complete development platform by itself.

How can you get the container-based development platform you need that incorporates your architects’, operations’, and developers’ needs in a single place? You could build it yourself, but that takes time and resources and knowledge that your team might not have right now.

That’s where a new open source-based offering from IBM comes in. The IBM Cloud Pak for Applications (ICPA) brings together the Kubernetes-based Red Hat OpenShift platform with Kabanero, an open source project that makes it faster and easier for enterprises to develop and deploy applications for Kubernetes and Knative.

In this blog post, we take a closer look at the underlying open source software ICPA is built on and some common development problems it addresses.

A closer look at the problem

Teams often adopt Kubernetes with a goal to streamline development and deployments and gain all the benefits of containerization. But they don’t account for the complexity that comes with a container environment. While Kubernetes does a great job of managing container placement on a server infrastructure, routing work to those containers, and bringing them back to life after a failure, it alone can’t fully support developers and architects trying to build cloud-native applications.

Building a platform for a development team is a significant undertaking. You need to account for everything — from selecting and integrating the right set of open source projects to choosing IDEs and build tools, pipelines, source control, security scanning and testing. When you add updates and security fixes, it becomes a full-time development job. Our goal is to solve these problems and reduce the complexity in order to boost the productivity of all developers in a team. So, how do we do that?

Let’s start by recognizing that a certain amount of consistency is good. Consistent tools help teams build efficiently and share knowledge. Consistent tools lead to a consistent delivery process that everyone can understand, and a consistent process reduces the risk of human error. Automation for the win.

Improving collaboration between different parts of an organization and within a team is fundamental to increasing productivity. Architects and developers need a consistent mechanism for capturing their technology decisions and then sharing them with the wider team.

For many teams the use of containers is a step in this direction and an obvious pairing with Kubernetes. Yet, the freedom and flexibility containers offer means it’s easy to end up with too many containers. Too much choice leads to complexity, inconsistency, and inefficiency.

Prototype to production without blinking

Kabanero simplifies the task of building container-based applications for deployment onto a hybrid cloud. Kabanero uses OKD (the upstream project for Red Hat OpenShift) to give you a robust, proven foundation on Kubernetes. Within this foundation, it adds the essential infrastructure to provide a continuous integration/continuous delivery (CI/CD) pipeline and essential services, such as logging, monitoring, service-mesh, and Knative serverless capabilities. So far so good, but what makes Kabanero different?

We’ll look at the specific development tools in more detail in a moment, but first we need to look at how Kabanero provides a common approach to defining, managing, and building applications from a consistent set of container-based artefacts that the IDE extensions exploit.

Kabanero introduces the idea of a “collection”. A collection brings together language, runtime, and framework choices along with the infrastructure bindings that allow it to plug in to the Kabanero foundation. Collections provide a consistent approach to capturing the collaborative decisions made by developers and architects. A set of predefined collections take the guesswork out of integration with the foundation infrastructure.

A critical component of a collection is an Appsody stack.

Appsody, and its associated command line tools (CLIs), provide the fundamental building blocks for creating container-based applications. An Appsody stack combines runtimes and frameworks in a container, along with common code and services. For example, a Java MicroProfile stack includes pre-defined health and metrics endpoints so that all applications built with the stack have common capabilities, out of the box.

Developers can quickly adopt a stack and start building new cloud-native apps. Appsody continually rebuilds the container image for your app using the pre-defined stack. As a result, your app is always built on the latest stack, and is automatically ready for testing in a container, as if it were running in production.

Build apps faster with pipeline automation and IDE integration

Kabanero infrastructure is integrated with GitHub, so that code commits trigger an automated CI/CD pipeline. Using the pre-defined integration points that are part of a Kabanero collection, the pipeline infrastructure builds the application code against the latest version of the Appsody stack.

Because the app is using a common stack, developers can be confident that the application will operate in production just as it did in development. This increases consistency and reduces the risk of things going wrong when code reaches production. This matters when you’re on call and don’t want to be woken in the middle of the night!

Kabanero isn’t just the infrastructure on top of Kubernetes. It starts with developer tooling that integrates with popular IDEs like Eclipse and VSCode. The Eclipse Codewind project helps developers build cloud-native microservices and function-based applications in containers, right from the start. It provides extensions that understand Appsody stacks, so you can start building using the pre-defined stacks and benefit from Codewind’s automated container build right from within the IDE. A performance dashboard in Eclipse Codewind helps you immediately begin to understand the performance characteristics of your new app or service early in the development cycle.

Start with open source, add support when you need it

Kabanero, Appsody, and Codewind, along with the other infrastructure components that create the foundation of Kabanero, are all open source. Together, these technologies make it easier and more convenient for teams to focus on their business problems, rather than on infrastructure decisions.

When the time comes and your team needs support, it’s available through IBM Cloud Pak for Applications. The IBM Cloud Pak for Applications integrates, secures, and certifies these open source projects, giving you a single solution to help you refactor your applications to cloud-native models. With ICPA, you can move existing applications with minimal changes to a more effective, Kubernetes-based operational model. And your developers can get back to writing great code that solves real business needs.

Learn more

Geoff Pirie