Now that Kubernetes has become the de facto standard for Linux container orchestration and the new monolith and microservices application platform, the next battle is for serverless architecture where Functions rule and there are numerous Open Source players competing for relevance in this space. Your future cloud native applications will consist of both microservices and functions, often wrapped as Linux containers, but in many cases where you the developer ignore the operational aspects of managing that infrastructure. In this session, we will be diving into Knative as serverless “base primitives” for Kubernetes.

Introducing … Quarkus.io! The rise in popularity of the linux container as the primary way to package your application seemed like a simple change on the surface. Yet, as we saw with the Java Docker Fail problem, it was not a transition completely without challenges for the Java community. Furthermore, we have now seen a number developers at many organizations considering a move to Node.js or Golang to get the performance and tiny memory footprint they need to run in a Kubernetes and cloud environment. In this session, we’ll demonstrate how you can optimize your enterprise Java apps, your APIs, your microservices, and your “serverless functions” for a Kubernetes/OpenShift and cloud architecture —vastly smaller, vastly faster, and fundamentally more scalable.

view slides
view video

In the Java ecosystem, we’ve historically been enamored of the concept of the “Application Server”—the runtime engine that not only gave us portable APIs (e.g., JMS, JAX-RS, JSF, EJB), but also gave us critical runtime infrastructure for things like farm deployments, configuration, load-balancing, fail-over, distributed management, and monitoring. This session is a demonstration of how Kubernetes and OpenShift give you the critical runtime infrastructure you need for JVM-based applications, whether they be Java EE, Spring, MicroProfile, Vert.x, Kotlin, etc.,—because in a cloud-native world, your APIs can be whatever best fit your project’s requirements.

view slides
view video

One human can be responsible for a multitude of servers. We recognize that our end-users, Linux systems administrators (AKA ‘Ops’), are under ever-increasing pressure to deliver more needed infrastructure resources at greater velocity. With RHEL 8, we provide notable productivity enhancing tools, such as the new:

• Web Console, a GUI for common everyday tasks
• Application Streams, supporting multiple versions of popular language runtimes, databases, etc.
• VM image building GUI, allowing for RHEL 8 to easily move across the hybrid cloud
• An easy and safe upgrade tool to get you from RHEL 7 to RHEL 8

We also introduce a feature that many had previously missed: Insights at cloud.redhat.com, a Software-as-a-Service (SaaS) inclusion for all RHEL subscribers that allows a single human to better manage hundreds to thousands of computers by providing proactive guidance on security, performance, and compliance concerns. For good measure, we also throw in some Ansible, Ansible Tower and Satellite to illustrate the complete sysadmin experience.

Where software Operators empower human operators, to enable Ops and Dev to work more efficiently than ever before. With Openshift 4, we have provided notable productivity enhancing capabilities such as:

• Full-stack management/updates: from Pods to Nodes to Machines with auto-scaling of machine provisioning and the underlying RHEL CoreOS
• Developer Self-Service via Operators for critical application-level infrastructure like databases, message brokers, application runtimes, etc.
• Automated updates of application infrastructure such as Microsoft SQL Server
• Multi-cluster console at cloud.redhat.com

Where containers, VMs, storage, and networking are all managed by Kubernetes/OpenShift in an on-stage, on-premises bare-metal cluster.

• Windows VM running as a Pod
• New Dashboards for Cluster and Storage overview
• Live migration of the Windows VM from bare-metal node to new bare-metal node
• Knative Eventing + Azure Functions responding to the migration event (kubectl get events)
• Pre-certified hardware from Dell

We created a custom application on top of OpenShift 4 to support a vibration (shaking/motion) sensing system—leveraging numerous aspects of Red Hat Middleware technologies—and put it into production with 1000+ audience members testing it live. Vibration is the leading indicator of possible large industrial machine failure. Technologies demoed include:

• OpenShift 4
• Knative, auto-scaling from 0 to 100 pods in seconds
• Apache Kafka via AMQ Streams
• Node.js via OpenShift Application Runtimes
• Quarkus, live coding of a REST endpoint, Java compiled to native
• Camel-K via Red Hat Integration
• Optaplanner via Red Hat Process Automation for optimizing the schedule of repair people/mechanics
• Opendatahub.io, Jupyter Notebook: we trained an AI model that could discern different types of motions/vibrations
  and we measured the audience’s ability to dance!

Check out video clips of the team and audience in action on Twitter from:

• Kyle Buchanan (Kyle’s video)
• Laura Hamlyn (Laura’s video #1 and video #2)

In the extreme and harsh environment of the cloud, where your Linux container may be rescheduled across the cluster or perhaps your serverless function auto-scaled to zero. When the flow of inbound transactions becomes a massive stream, then small memory footprint, ultra fast start-up speed, mixed reactive & imperative programming model become critical abilities. This is where GraalVM meets Quarkus, giving you server-side and enterprise-capable Java, compiled to a native executable, enabling you to build truly cloud native apps.

view slides
view video

Now that Kubernetes has become the de facto standard for cloud native application architecture involving microservices and serverless functions, it does represent an extreme environment for your application logic. In this deep dive session, we will be exploring 12 ways, steps along the path, from Linux container neophyte to cloud native application architect. Topics include: Kubernetes basic objects, custom resource definitions (CRD), Istio VirtualServices, advanced rollout/deployment patterns, auto-scale to zero with Knative, source-to-url automated build machinery and more.

view slides
view video

Java was born in the mid-90s, the era of TLC and Boyz II Men, long before the rise of Linux server virtualization and the Linux container. We took great pride in running Java applications for weeks if not months without restarts and Java assumed the whole computer belonged to itself, that it could consume all available memory and CPU.  In this presentation, we will demonstrate the problems associated with using Java for “microservices”, and how the open source ecosystem is working to ensure the future of Java by being cloud first, container native, serverless focused and Kubernetes optimized.  This is where GraalVM meets Quarkus, bringing server-side and enterprise-capable Java to enable you to build truly cloud native apps.

The first generation of microservices was primarily shaped by Netflix OSS and leveraged by numerous Spring Cloud annotations sprinkled all throughout your business logic. The next generation of cloud native apps and 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 distributed applications on Kubernetes and OpenShift. Istio allows you to deal with traffic shaping, network fault-injection (chaos engineering), smart canary deployments, dark launches, and observability. This session is for application architects and experienced developers who are ready to take their cloud native microservice skills to the next level, potentially increasing deployment frequency of your cloud native apps from weeks to days to minutes.

In this session, we are going to explore an open source event-driven lambda style serverless programming model and runtime set of capabilities for Kubernetes called Knative. Knative provides a suite of middleware components & building blocks that enhance developer productivity, enable a “source-to-url” pipeline and event-driven Serverless application architectural pattern. Developers have run their code in application servers for many years. However, the cloud paradigm brought new ways to think and design applications. One example of this change is serverless architecture where event-driven code is executed on an ephemeral Linux container on an as-needed basis. It does not mean that there are no servers involved, but for the developer’s perspective, it means that they don’t need to worry about those servers so they can more focus on differentiating business logic, often designed as microservices and functions.

Introducing … Quarkus.io! The rise in popularity of the Linux® container as the primary way to package your application seemed like a simple change on the surface. Yet, as we saw with the Java Docker Fail problem, it was not a transition completely without challenges for the Java™ community. Furthermore, we have now seen a number developers at many organizations considering moving to Node.js or Golang to get the performance and tiny memory footprint they need to run in a Kubernetes/OpenShift environment. In this session, we’ll demonstrate how you can optimize your enterprise Java apps, your APIs, your microservices, and your “serverless functions” for a Kubernetes/OpenShift environment—vastly smaller, vastly faster, and fundamentally more scalable.

You adopted microservices architecture to fundamentally change your time-to-market, your code-to-production time from months to days, perhaps even hours. The next generation of microservices architectural style has been enabled by the rise of Kubernetes, now the de facto standard cloud native application infrastructure. The next generation of microservices will leverage sidecars, a service mesh and on-demand serverless services.

In this session, our mission is to get you hands-on quickly with Knative on top of Kubernetes/OpenShift, where we’ll focus on: (1) exploring Serverless application architecture (event-driven apps running in ephemeral containers); (2) installation of Knative into a Kubernetes cluster; (3) Knative Build (your source code to a runnable container/pod); (4) Knative Serving (pay only for what you use with auto-scale-to-zero); (5) Knative Eventing (input sources based on Cloud Events); and (6) Tips & Tricks (exploring clever and cool ways to use Knative on Kubernetes).

In a cloud-native world enamored of Microservices and Serverless, meet Quarkus—Java’s brilliant response to technologies like Node.js, Python and Go that had until recently proven quicker, smaller and arguably more nimble. But we know seeing is believing—we’ll show you Quarkus in action. Get ready to experience “Supersonic, Subatomic Java”— and make Open Source frameworks like Hibernate and Apache Camel faster, smaller and more dynamically scalable than ever before.

view slides
view video

Software architectures have been redefined by the availability of cloud computing, this includes even your traditional applications that you intend to run on your premises, on your private infrastructure for many years to come. In this session, we are going to talk about skills, techniques and technologies that enable you to leverage capabilities like Kubernetes from the Cloud Native Computing Foundation (cncf.io) to imbue your applications with seemingly magical capabilities.

Some have said that Java is too “big” and too “slow” for a cloud native microservices or serverless architecture that leverages ephemeral Linux containers, that flow quickly through a CI/CD pipeline, canary deployed via a service mesh. Here, we will introduce you to a new way of running Java in Cloud, in Kubernetes/OpenShift with Quarkus leveraging GraalVM or vanilla Hotspot on OpenJDK.

In a cloud native world enamored of Microservices and Serverless, meet Quarkus—Java’s brilliant response to technologies like Node.js, Python and Go that had until recently proven quicker, smaller and arguably more nimble. But we know seeing is believing—we’ll show you Quarkus in action. Get ready to experience “Supersonic, Subatomic Java”— and make Open Source frameworks like Hibernate and Apache Camel faster, smaller and more dynamically scalable than ever before.

Now that Kubernetes has become the de facto standard for cloud native application architecture involving microservices and serverless functions, it does represent an extreme environment for your application logic. In this deep dive, 3-hour session, we will be exploring 12 ways, steps along the path, from Linux container neophyte to cloud native application architect. Topics include: Kubernetes basic objects, custom resource definitions (CRD), Istio VirtualServices, advanced rollout/deployment patterns, auto-scale to zero with Knative, source-to-url automated build machinery and more.

Quarkus allows developers not only to address the challenges of container-first application but also to jump into the serverless world easier with combining imperative and reactive codes. But you may not know what this really looks like if you’re, say, a Java developer. In this session, we’ll explore how cool Quarkus with Knative is for developers and makes it more comfortable, easier, and quicker to run serverless cloud native apps.

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.

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.

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.

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.

This is your opportunity to get hands-on with Kubernetes and OpenShift, Istio service mesh, and Knative serverless. 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 application architecture continues to evolve at an amazing pace where Microservices architecture from 2012 to the rise of Linux containers in 2014 and Kubernetes/OpenShift in 2015. In this session, we are going to show you how the next generation of microservices will be augmented by event-driven serverless elements, where your application code is awoken and executed based on demand rather than being always-on, even if unused. Technologies include: Kubernetes, OpenShift, Knative, Apache Kafka, Apache Camel and Quarkus.

Cloud Native application architecture continues to evolve at an amazing pace where Microservices architecture from 2012 to the rise of Linux containers in 2014 and Kubernetes/OpenShift in 2015. In this session, we are going to show you how the next generation of microservices will be augmented by event-driven serverless elements, where your application code is awoken and executed based on demand rather than being always-on, even if unused. Technologies include: Kubernetes, OpenShift, Knative, Apache Kafka, Apache Camel and Quarkus.

In the extreme and harsh environment of the cloud, where your Linux container may be rescheduled across the cluster or perhaps your serverless function auto-scaled to zero. When the flow of inbound transactions becomes a massive stream, then small memory footprint, ultra fast start-up speed, mixed reactive & imperative programming model become critical abilities. This is where GraalVM meets Quarkus, giving you server-side and enterprise-capable Java, compiled to a native executable, enabling you to build truly cloud native apps.

You have likely heard of open source technologies and terms like Kubernetes, OpenShift, Istio, Knative, Microservices, Serverless, Apache Kafka and Apache Camel. In this session, we are going to swizzle them altogether and show you the key aspects of an event-driven application architecture.

In this session, we are going to get you hands-on quickly with OpenShift, Red Hat’s Kubernetes Platform, allowing you to gain first-hand experience by using many new super powers such as the Linux container, Kubernetes, Service Mesh via Istio and Serverless via Knative plus Camel. 

In this session, we are going to explore an open source event-driven lambda style serverless programming model and runtime set of capabilities for Kubernetes called Knative. Knative provides a suite of middleware components & building blocks that enhance developer productivity, enable a “source-to-url” pipeline and event-driven Serverless application architectural pattern. Developers have run their code in application servers for many years. However, the cloud paradigm brought new ways to design applications. One example of this change is serverless architecture where event-driven code is executed on an ephemeral Linux container on an as-needed basis. It does not mean that there are no servers involved, but for the developer’s perspective, it means that they don’t need to worry about those servers so they can better focus on differentiating business logic, often designed as microservices and functions.

In a cloud-native world enamored of Microservices and Serverless, meet Quarkus—Java’s brilliant response to technologies like Node.js, Python and Go that had until recently proven quicker, smaller and arguably more nimble. But we know seeing is believing—we’ll show you Quarkus in action. Get ready to experience “Supersonic, Subatomic Java”— and make Open Source frameworks like Hibernate and Apache Camel faster, smaller and more dynamically scalable than ever before.

In the extreme and harsh environment of the cloud, where your Linux container may be rescheduled across the cluster or perhaps your serverless function auto-scaled to zero. When the flow of inbound transactions becomes a massive stream, then small memory footprint, ultra fast start-up speed, mixed reactive & imperative programming model become critical abilities. This is where GraalVM meets Quarkus, giving you server-side and enterprise-capable Java, compiled to a native executable, enabling you to build truly cloud native apps, for bare metal, VMs or Kubernetes, across any cloud.

In this session, I will be demonstrating the power of the automated build and deployment pipeline augmented by the flexibility of infrastructure-as-code via Kubernetes/OpenShift. We will be specifically focusing on the concepts of the smart and dark canary deployment model via pipeline automation leveraging open source technologies like Istio, Knative and Tekton.

In a cloud native world enamored of Microservices and Serverless, meet Quarkus—Java’s brilliant response to technologies like Node.js, Python and Go that had until recently proven quicker, smaller and arguably more nimble. Seeing is believing. Get ready to experience “Supersonic, Subatomic Java”— and make Open Source frameworks like Hibernate and Apache Camel faster, smaller and more dynamically scalable than ever before.

Moving beyond HTTP-based microservices into the world of event-driven messaging-based architecture. Eclipse MicroProfile Reactive Messaging is a new open standard, brought together with the open source Quarkus Java runtime & framework for building cloud native applications that run as native code. RM is a portable reactive programming model & API across both AMQP and Kafka. In this session, we will explore both Reactive Messaging and Kafka Streams APIs, leveraging these technologies to build event-driven microservices on Kubernetes/OpenShift.

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 distributed Java applications on Kubernetes. Check out how we use Envoy and Istio to deal with traffic shaping, network fault-injection, canary deployments, dark launches, mirroring, and much more.

Kubernetes from the Cloud Native Computing Foundation has become the defacto standard for the next generation of applications, be they hosted in a public cloud or living on your premises, in your private datacenter, for many years to come.  This is a session to introduce the key aspects of Kubernetes: Pod, Deployment, ReplicaSet, Service and the CRD. As well as, how to craft your applications to take advantage of this declarative, dynamic and highly scalable cloud native infrastructure.  The session will primarily be live code, live demonstration.

Serverless is a misnomer, your future cloud native applications will consist of both microservices and functions, wrapped as Linux containers, but in most cases where you the developer ignore the operational aspects of managing that infrastructure because it is orchestrated by Cloud Native Computing Fundation’s Kubernetes. In this session, we will focus on Apache Kafka, Apache Camel, Apache ActiveMQ and Knative – technologies that allow you to craft your own event-driven application architecture on top of Kubernetes/OpenShift.

Moving beyond HTTP-based microservices into the world of event-driven messaging-based architecture. Eclipse MicroProfile Reactive Messaging is a new open standard, brought together with the open source Quarkus Java runtime & framework for building cloud native applications that run as native code. RM is a portable reactive programming model & API across both AMQP and Kafka. In this session, we will explore both Reactive Messaging and Kafka Streams APIs, leveraging these technologies to build event-driven microservices on Kubernetes/OpenShift.