Introducing the Cloud-Native Programming Model – Java MicroProfile Focus
Eric N Herness 0600000ECH Visits (554)
Introducing the Cloud-Native Programming Model – Java MicroProfile Focus
Are you embarking on your cloud native journey? Does your journey involve microservices, Kubernetes, and a multitude of programming languages including Java? Are you looking for expert guidance on how to optimize your Java-based microservices application to run in your Kubernetes platform? If so, you will want to download and study the IBM cloud-native programming model book.
Download now! http
The speed of technology evolution has never been more rapid. The need to adopt and harness new technology to deliver business value in almost any industry is a fixture in most strategies. Early adopters enjoy a first mover’s advantage, but the life span of that advantage seems to shrink with each passing decade.
While all this change can be overwhelming, it is also the case that many of the foundational concepts brought to use by past technology breakthroughs remain important. That is the case in our current era as it relates to software engineering. Distributed computing is still important and in fact underpins all cloud native solutions. Java remains an important language for capturing business logic, but in the current era is joined by other programming languages. Containers are not a new concept, but they are relatively new to their central role in architecting software systems. We also still think about network, compute and storage but I would assert that today’s higher bandwidth and more reliable networks do influence how systems are built. Similar statements can be made about storage and compute.
Harnessing the raw materials available from technology shifts or new concepts are often very challenging for the early adopters. Early adopters, however, seem to thrive on the challenge and somehow get the funding and support to grind through the details and deliver new and improved value. What they learn as pioneers also shapes and evolves the technologies themselves and paves a clearer more navigable path for those that follow.
For us, our role as early adopters requires us to document what we’ve learned, limitations we've found, and provide a detailed “how to guide” to accelerate those that are about to embark on their cloud native journey.
It would be easy for us to point to the vast array of capabilities available and call it a day. We could suggest that unique and expensive projects to stand up a PaaS that supports cloud native development be initiated immediately. But instead of just that, we have created this programming model definition, in hopes that it can be a starting point that allows adoption to begin now, rather than waiting a few months or more for a project that will setup and define a technology approach.
It is fair to ask, “Why now?” Now is a good time to provide this programming model because we have programming languages providing frameworks for microservices that are ready to use. We have Kubernetes that has emerged as the underpinnings for container orchestration. We have Istio as a service mesh which is ready to blend together with language frameworks and the underlying Kubernetes platform. The blending together of all this is illustrated in the following figure:
Finally, we have underlying platforms, tools and middleware that are ready to support commercial enterprise scale use of the cloud native approach. Adopters no longer have to construct their own path through the technologies and their own Platform as a Service (PaaS) to support the programming model.
What to Expect
One of the watchwords of this new era is microservices. Microservices is a concept and an approach, but there is no specific language or environment into which microservices must be written and run. Mostly what we get from the world of microservices is a clearer and more precise set of guidelines for building distributed systems than would have existed in the past generations of distributed computing. Many good things are coming from this evolution. This all needs to inspire a true programming model.
The “IBM Cloud-Native Programming Model – Java MicroProfile Focus ” is a specific programming model that can be used to create net new solutions where the components of that solution are written using microservices. A programming model for this purpose calls out specific technologies at the programming language level and at the platform level. This book shows how to blend those together to get the best resultant solution. Tradeoffs and options will be provided along the way, supported by details that point out advantages and disadvantages of various approaches. In most cases, this will remain a very technical explanation of a programming model. Tradeoffs will be elaborated upon looking at dimensions such as DevOps velocity, testability, resilience and maintainability.
A java and MicroProfile combination has been chosen to start with because of the appeal it should have to the many JEE programmers out there and because of the applicability of this approach in the context of the many modernization activities which are happening at this time. Many of the popular modernization approaches require some new code to be written. ( http
What is it?
What is a programming model? This is a question that often comes up. For purposes of this book the programming model is a specific and documented approach to creating solutions. A programming model is described by the precise collection of artifacts that bring the programming model to life. Relationships and linkages between the artifacts and the content inside of these artifacts are essential to fully understanding and leveraging the programming model. This programming model covers specific approaches that should be leveraged to do basic things like exposing REST APIs, managing units of work, leveraging data services and leveraging messaging services.
Creating microservices involves applying a programming model. This book suggests that this programming model, given the context of targeting IBM Cloud Private and IBM Cloud Kubernetes Service, is a combination of both polyglot and platform capabilities combined with language specific implementation approaches. Whenever appropriate, and where there are alternatives in place, this book will prefer to use a polyglot feature in favor of a language specific feature. However, in cases where the language specific feature is richer or is an accelerator to implementing a polyglot definition, then the language specific feature will be preferred or at a minimum explained in this book.
To complement the programming model basics, explanations of our tools that support the programming model will also be outlined as appropriate. While a programming model generally is described at a level that does not require any specialized tooling, commercial scale use of a programming model depends on a development platform that supports the programming model in a first-class way. The tools section will also describe how a DevOps pipeline should work, so that when you commit updates to one of your microservices, those changes will get deployed into your cloud environment.
The rest of this book is organized in way that a reader can go from end to end, or can selectively look at concepts, specific programming language approaches or just reference sections that might be of interest for any given interest in programming model that might arise.
The platform for which this programming model is intended has some basic capabilities and related terminologies that are good to understand. These influence later sections in many ways. This comes first. Then there is an overall view of what it takes to really build and maintain systems built from these programming models. This development flow and related considerations come after the basics of the target execution environment.Then the featured programming models are introduced, each in succession. This sets additional context around the programming language and related frameworks that make up a particular approach. We are featuring the Java language and MicroProfile framework combination but will add others as we get to them and as they are requested.
From that set of basic capabilities and terms, the primary programming model concepts are then introduced one at a time, immediately followed by the framework and language specifics necessary for a developer to get started embracing those concepts using the selected style. Configuration, logging, tracing, metrics, creating APIs, microservice to microservice communications, security, fault tolerance, readiness checks and managing service interaction are all tackled in succession.
Language and framework specific recommendations might actually not be so language specific after all, if a more polyglot approach is recommended. Therefore, these prior sections specific to language and framework are followed up with a section on Istio. Istio features are polyglot in that they can be used with any programming language. Using Istio features as the preferred approach means that information in the Istio section is often pointed to directly from the language and framework specific sections.
After this, additional features that may be of interest are elaborated upon, continuing to follow the approach of describing the concept and any language and framework specific guidance that might exist. Look for this topic list to fill out the basic programming model and evolve over time. These include:
Excited yet!?! Download the book now or stay tuned as we highlight essential sections in future blog entries.
This excerpt was taken from the IBM Cloud Native Programming Model
Download now! http