Red Hat Developer Program at JavaOne 2016
At JavaOne 2016 the Red Hat Developer Program team presented on topics like: Kubernetes, Docker, Red Hat OpenShift, Red Hat JBoss, Microservices, Eclipse Vert.x, Wildfly Swarm and more. See below to watch the recordings:
Intro to Microservices
Speaker: Burr Sutter
We start with a private cloud for your laptop and walk through the critical capabilities of microservices architectures - demonstrating Spring Boot, Wildfly Swarm and Eclipse Vert.x.
Microservices and How WildFly Swarm Can Play a Part
Speaker: Kenneth Finnigan, Bob McWhirter
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
Kubernetes for Java Developers
Speaker: Edson Yanaga, Rafael Benevides
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.
Reactive Distributed Applications with Eclipse Vert.x
Speaker: Burr Sutter
Microservices with Kubernetes, Docker, and Jenkins
Speaker: Rafael Benevides, Christian Posta
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.
Dockerized System Testing, with a Dash of Chaos
Speaker: Aslak Knutsen, Bartosz Majsak
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!
CDI 2.0 Is Coming
Speaker: Antoine Sabot-Durand
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.
Microservices for Java Developers
Speaker: Christian Posta
Come see how easy it is for developers to create and build microservices with Spring Boot and WildFly Swarm and deploy them to Kubernetes
Java and DevOps: supercharge your delivery pipeline with Containers!
Speaker: Edson Yanaga
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.
Refactoring your Code with Java 8: Functional Programming to the Rescue!
Speaker: Eder Ignatowicz
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.
High Performance Apache Spark using In Memory Data
Speaker: Thomas Qvarnström
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.