|Anything is possible with interoperable container|
When your background is application development, you have spent many hours, days and years perfecting your craft. You have not only mastered languages and concepts, you have made it a point to learn to make good architectural decisions when pulling together the applications you develop.
The problem is, we tend to ignore the stack we are working on as much as we can. Well it's time that we as application developers broadened our horizons a bit, expanding our understanding of the stack we work on with the introduction of Cloud, Platform As A Service (PaaS) and containers to our toolboxes.
Our tour of your Cloud stack continues, from our previous article in this series where we talked about our PaaS interface for our application delivery, onto how open interoperability is critical to the success of our Cloud stack.
Crucial stack interoperabilityThe basic definition that covers our interoperability needs from the application developer standpoint in this article can be found on the Open Group organization. It states that interoperability is "...the ability to share information and services" across our Cloud stack.
As an application developer we have consistently looked with great skepticism at our stacks, first at the stack we had to set up and maintain on our local machines, later at our Cloud stacks that are forced upon us by our work environments. It is always the barrier that has acted as a delay for us to get our applications developed and delivered in a timely manner. Well, at least that was the response we would give if we honestly answered any questions around what we thought of our stacks.
The thing is, these stack tended to change over time as new components, new layers and new products are added or removed. Often these new stack components are not open technologies like those we have in the Red Hat portfolio, meaning they require us to adapt our way of working to accommodate their lack of open interoperability. They eat up our time as we have to both integrate them into our stacks and find ways to standardizing our application development teams ability to engage with these new components.
The strength of having an Open Source based stack, either local to your machine or out in the Clouds, is that you have a guarantee of open standards that facilitate open interoperability. This happens because the upstream projects in the community have a deep seated desire to not hide how component interact, provide insights into the protocols being used to communicate and foster collaboration at the grass-roots level ensuring that everyone in the industry is on the same page when interoperating with layers of their stacks.
|Red Hat Cloud Suite|
Application developers can much more easily roll with the changing stack landscape when new components are brought in, when old layers are retired and never have to fear that proprietary communication methods will ever hamper their paths to success.
Open interoperability is a given with the Red Hat Cloud stack, from layer to layer, component to component:
- Management solution with Red Hat Cloud Forms
- Application development with OpenShift by Red Hat
- Infrastructure interoperability with choices of:
If you are ready to see this in action, check out the following Red Hat Cloud Suite video showcases around the following use cases that support open interoperability:
There are many easy container based examples that will showcase the ability you have to leverage your Cloud stacks while delivering powerful applications in a timely manner. Take a look at the growing collection in the Red Hat Demo Central.
Next time around we will take a look at securing your containers at scale and why this is important within the Cloud stack.
App Dev Cloud Stack seriesMissed a previous article or looking for a specific article in the series?
- Can’t ignore the stack anymore
- Foundations for a stable Cloud
- Beginners guide to containers at scale
- Why containers at scale matter
- It’s all about the PaaS baby
- Open interoperability critical to success
- Securing containers at scale (coming soon...)
[Note: This post was originally published on JBoss Middleware Blog.]