This session takes a holistic view and considers the bigger context in which frameworks such as WildFly Swarm exist. It highlights some of the common problems found in microservice architectures and looks at the de facto standards. It covers

Service discovery and integration

Securing services

Decoupling services and handling faults

Monitoring and diagnosing the system

WildFly Swarm brings different technologies together into a cohesive whole. See, through demos, how these pieces can be easily utilized. By the end of the session, some pieces of a Java EE application will have been converted into services and you’ll have learned how WildFly Swarm integrates with external tools to provide a complete solution for service delivery

Yes, Docker is great. We are all very aware of that, but now it’s time to take the next step: wrapping it all and deploying to a production environment. For this scenario, we need something more. For that “more,” we have Kubernetes by Google, a container platform based on the same technology used to deploy billions of containers per month on Google’s infrastructure. Ready to leverage your Docker skills and package your current Java app (WAR, EAR, or JAR)? Come to this session to see how your current Docker skill set can be easily mapped to Kubernetes concepts and commands. And get ready to deploy your containers in production.

Everybody is talking about microservices and reactive programming these days. Meet Eclipse Vert.x, a toolkit for building reactive applications on the JVM. Come to this session to learn how you can use Eclipse Vert.x to create reactive code using Java, Groovy, JavaScript, or other JVM languages. See a demonstration of how to build Eclipse Vert.x-based systems leveraging the unique Eclipse Vert.x event bus for creating apps with real-time communications from the modern web browser to the cloud and back again. Have fun with many live demonstrations that will cause you to reconsider your reliance on monoliths and consider leaving tradition behind for an event-driven, reactive, microservice-focused architecture.

A lot of functionality necessary for running in a microservices architecture have been built into Kubernetes; why would you re-invent the wheel with lots of complicated client-side libraries? Have you ever asked why you should use containers and what are the benefits for your application? This talk will present a microservices application that have been built using different Java platforms: WildFly Swarm and Eclipse Vert.x. Then we will deploy this application in a Kubernetes cluster to present the advantages of containers for MSA (Microservices Architectures) and DevOps. The attendees will learn how to create, edit, build, deploy Java Microservices, and also how to perform service discovery, rolling updates, persistent volumes and much more. Finally we will fix a bug and see how a CI/CD Pipeline automates the process and reduces the deployment time.

With microservices, polyglot, and DevOps on the rise, where are we at with testing? Does it bring more complexity and make our testing effort harder? Or maybe, on the contrary, it actually helps us write better tests more easily? This session explores not only how we can do our testing in this new world but also how the new world can help us test better. Meet Arquillian Cube and Q. The presentation takes a close look at topics ranging from polyglot services and orchestrated microservices to system scale testing. All are within reach. And with full control, let’s add a dash of chaos!

This session shows how to use the major features coming in CDI 2.0. It explains synchronous events, Java SE bootstrap, the new builder API for CDI SPI metadata, and other cool features and demonstrates them in live coding. Come see a great preview of CDI 2.0, coming a few months after JavaOne.

As developers we have one main goal: solve problems through software development. For that, the code we write has to be put to use, in the hands of the intended user. But more often then not, our code get stuck in interminable delivery processes... But we can do better, and we can create streamlined delivery pipelines, and implement continuous delivery and deploy processes in our projects. And one of the most promising technologies to get our code ready to solve real problems is software containers. This panel will bring together developers that understand the benefits of containers technologies, to clarify their importance, their problems, and how to apply to real world projects.

In this talk, we'll show how you can refactor your traditional object-oriented Java code using Functional Programming features and APIs from Java 8, following several recipes and refactor legacy code in order to make it more readable and flexible. We discuss: - How to separate concerns using Lambda Expressions - How to handle with requirement changes using first-class functions - How to make several traditional OO design patterns more concise using lambda expressions The talk will consist of a balance between theoretical concepts and practical applications. Attendees will leave with concrete knowledge to refactor their traditional object-oriented Java code to make the best use of Functional Programming features and new APIs Java 8 APIs.

This session explains how JBoss Data Grid (Infinispan) can be used as a high performance data storage and how to use Apache Spark analytics to avoid data silos.
When building microservices it’s a common practice to use a separate data store per service so that it can scale together with the service. Even if this scales better and enables individual release schedules per services it also leads to more data silos.