Next Generation Microservices
You adopted microservices architecture to fundamentally change your time-to-market, and your code-to-production time from months to weeks — perhaps even days. The first generation of microservices was primarily shaped by Netflix OSS and leveraged by numerous Spring annotations throughout your business logic. The second generation of microservices architectural style was enabled by the rise of Kubernetes and OpenShift, now the de facto standard cloud-native application infrastructure. The next generation of microservices will leverage sidecars, a service mesh (Istio), serverless principles, and a new insanely fast and light Java runtime (Quarkus).
Track A: Java
Coding that sparks joy with Quarkus
Does your heart beat faster when you’re developing your Java application? Does it spark joy when you’re coding? If not, then it’s time to leave some old ways behind.
Join us on this live coding session and get familiar with Quarkus. You’ll learn to love how your old and new favorite APIs will start in a matter of milliseconds and consume tiny amounts of memory. Hot reload capabilities for development will give you instant sparks of joy!
What's the magic behind Quarkus, and how can I help (myself)?
Quarkus is revolutionizing the way that we develop Java applications for the cloud-native era. Do you want to learn why Quarkus is different from everything else? Then come and join us on this session to take a look at how Quarkus works and the techniques it uses to achieve its dramatic startup speed improvements. As part of this we will also cover the Quarkus extension API, so you can see how to write your own extensions that take advantage of Quarkus’ unique architecture.
Dreaming of streaming with reactive programming
Reactive programming, Reactive Extensions, Reactive Streams, reactive systems, Reactive Manifesto… Do you know what they mean? Do you know why it matters?
Learn about reactive and why it matters in this new cloud-native era. We’ll use live coding demos to explain how to be reactive and benefit from this brave new streaming world.
Java microservices: Being a cloud ultra-native
Many of us are on a journey from traditional monolithic applications to a more distributed cloud-native microservices architecture. In this session, we will discuss what the key microservices architecture principles are, and the how and why to evolve to this approach. We will show you how to become a new cloud-native developer and architect.
Apache Kafka Streams and event-driven microservices/architecture
Some concepts are evergreen, and events are one of them. Once you shape your mind around events, messaging becomes an essential asset in your toolbox. Using an event-driven architecture on top of a message-driven architecture helps us unleash the benefits of distributed computing.
In this tutorial, we’ll dive into events, message-oriented middleware, CQRS, event sourcing, JMS, Apache Kafka, data streaming, and analytics to explain the fundamentals for creating a distributed, resilient, and scalable application. You'll learn that events and messaging are not hard—you were just never taught how to do them properly.
Track B: Kubernetes/OpenShift
9 steps to awesome with Kubernetes/OpenShift
Everybody seems to be rocking with Kubernetes from the Cloud Native Computing Foundation (cncf.io) as it has become the defacto standard for hybrid cloud portable application architecture. Even your favorite open source repositories at GitHub are running on top of it. Microservice architecture adoption continues to boom and Kubernetes/OpenShift is the ideal solution for deploying and managing the dozens of microservices that your organization crafting.
This live hands-on session is for any developer who is interested in Linux containers and cloud-native application architecture. Our examples will primarily be in Java, as there is some special “care and feeding” related to Java in a container, but the lessons are applicable to any programming language.
Sail into cloud :: Introduction to Istio
The first generation of microservices was primarily shaped by Netflix OSS and leveraged by numerous Spring Cloud annotations all throughout your business logic. The next generation of microservices will leverage sidecars and a service mesh. In this session, we will give you a taste of Envoy and Istio, two open source projects that will change the way you write cloud-native Java applications on Kubernetes.
Service mesh alleviates most of the common distributed computing pain points like smart routing, traffic splitting, canaries, etc. In this session, we will explore on how to download, set up Istio on your local laptop, and deploy Java microservices as part of the Istio service mesh with Istio sidecar proxy.
Istio proxy sidecars will spice up cloud-native applications with ability for splitting traffic between various version of services, smart routing using request headers, doing chaos engineering, and much more—all without code redeploys.
Kubernetes serverless application architecture
The first generation of microservices was primarily shaped by Netflix OSS, for example, Spring Cloud annotations all throughout business logic. As a result of few constraints and difficult experiences with the previous generation, the next generation of microservices leveraged on sidecars and a service mesh.
A service mesh offers consistent discovery, security, tracing, monitoring, and failure handling without the need for a shared asset such as an API gateway or ESB. A typical implementation involves lightweight reverse-proxy processes deployed alongside each service process, perhaps in a separate container.
Using serverless architectures has become one of the common approaches in organizations that want to be more effective in DevOps and optimize their IT resources. This adds further flexibility to the next generation of microservices to be more agile (i.e., serve on-demand). Knative helps running your microservices’ serverless workloads on Kubernetes/OpenShift be more agile and effective.
Cloud-native integration patterns: Kubernetes and Camel K
Starting in 2019, we saw "serverless" taking center stage in all application architectures. Enterprise integration is no exception. Apache Camel has been the de facto platform for performing application and service integrations in the enterprise integration world. In this session, we will learn how to apply common Enterprise Integration Patterns (EIP) with Apache Camel and Kubernetes/OpenShift.
We will see the new Camel K framework and how it helps in deploying Camel DSL code as "integrations" in Kubernetes/OpenShift. We will dive deeper by making them serverless and "on-demand" using Knative.
Plumbing Kubernetes CI/CD with Tekton
Now that Kubernetes/OpenShift has become the de facto Linux container orchestration platform, it has still missed one crucial feature of in-cluster build of the container images. This missing feature made continuous integration and delivery inside of a Kubernetes cluster more challenging. The market had various solutions to solve the problem, but 99% of the solutions missed something: being Kubernetes native.
In this session, I will introduce you to Tekton, Kubernetes’ native way of defining and running CI/CD. The session explores the characteristics of Tekton: cloud native, decoupled, and declarative. This demo-filled session will show how to stitch various building blocks of Tekton to do in-cluster build and deploy (Tasks and Pipelines) a cloud-native application.
Burr Sutter is currently Red Hat’s Director of Developer Experience. A Java Champion since 2005 and former president of the Atlanta Java User Group, he founded the DevNexus conference, now the second largest U.S. Java event, with the aim of making access to the world’s leading developers affordable to the developer community. Burr is a featured speaker at technology events around the globe as a lifelong developer advocate, community organizer, and technology evangelist. When not speaking abroad, Burr passionately creates and orchestrates highly interactive live demo keynotes at Red Hat Summit, the company’s premier annual event.
Edson Yanaga, Red Hat’s Director of Developer Experience, is a Java Champion and a Microsoft MVP. He is also a published author and a frequent speaker at international conferences, discussing Java, microservices, cloud computing, DevOps, and software craftsmanship. Yanaga considers himself a software craftsman, and is convinced that we all can create a better world for people with better software. His life’s purpose is to help developers worldwide to deliver better software quickly and safely—and he can even call that a job!
Kamesh is a Principal Software Engineer and a Director of Developer Experience at Red Hat. He actively educates on Kubernetes/OpenShift, service mesh, and serverless technologies. With a career spanning close to two decades, most of Kamesh’s career is with the services industry helping various enterprise customers build Java-based solutions. For more than a decade, Kamesh has contributed to open source projects and he now actively contributes to projects such as Knative, Minishift, Eclipse Che, Fabric8, and more. His developer philosophy is: Learn more, do more, and share more!