Quarkus Superheroes on Azure

Are you a developer building microservices? Do you struggle with developing and testing individual microservices? Do you want to learn about building and deploying microservices with Quarkus?

In this session, we will introduce the Quarkus Superheroes application and demonstrate how the application can facilitate local development within a microservices architecture. We will show how applications can be developed and tested in isolation. Additionally, we will demonstrate how the application can be easily deployed to a remote Kubernetes environment and how Quarkus features assist in the local development of individual microservices.

The Quarkus Superheroes application consists of several microservices demonstrating Quarkus features and best practices. The application allows superheroes to battle against supervillains. The applications access databases and communicate either synchronously or event-driven. Some of the applications are reactive while others are more traditional.

Taming Kubernetes: Tackling Inner Loop Development for Distributed Systems

Microservices and distributed systems in general are often deployed on a platform such as Kubernetes, which orchestrates the deployment and management of containerized applications. Microservices, however, don't exist in a vacuum. They typically communicate with other services, such as databases, message brokers, other microservices, or even AI models. This distributedness makes it hard for you to do local/inner-loop development and test efficiently.

In this talk, you will learn about some potential solutions you can use to help tackle some of these challenges by either running services locally in a more efficient way or by interacting with external dependencies/systems remotely.

You should come away from this session with some new ideas on how to work with distributed applications using technologies such as Docker Compose, Podman Desktop, Podman AI Lab, TestContainers, Quarkus, LangChain4j, Remote Development, Skupper, and Eclipse JKube.

You’ve all been there, haven’t you? You are developing an application that needs to connect to something else in order to function properly, yet you can’t (or don’t want to) run that “something else” on your local developer laptop. What are some of the tools and technologies that could help in this situation?

When Java and AI meet Open Source

AI and LLMs are all the rage these days, and if your applications aren’t incorporating them, then you will most likely be left behind.

In this talk, we will explore how to integrate AI into your cloud-native Java applications using Open Source tools and libraries, such as Quarkus and LangChain4j. We will demonstrate how to use and interact with various LLMs, such as GPT, Dall-E, or HuggingFace.

We will showcase a fun, yet practical, example using a real-world Quarkus microservices application, deployed in Azure and integrated with OpenAI providers. We will also demonstrate some of the Quarkus Langchain4J extension capabilities. Through these examples, you will see just how easy it is to supercharge your applications with AI!

#opensource #ai #quarkus #langchain #hugginface #azure #java #kotlin #react #openai

Quarkus for Spring Developers

In this session, I will show concepts and conventions familiar to Spring developers and how those same concepts and conventions can be implemented in Quarkus, all while highlighting similarities and differences between them. Additionally, I will show similarities and differences in how testing is done, highlighting Quarkus Dev Services.

This session will be mostly live coding while minimizing the amount of slides. I will introduce an existing Spring application with a full test suite and build a Quarkus equivalent version of it, live.

TDD: It's easier than you think!

Everyone loves writing tests, don’t they? How do you write good tests? What tools are available for you to write good tests?

In this session, I will dive into the many features of Quarkus that help developers write good tests. I will highlight some of the features of Quarkus, Dev Services and Continuous Testing, which help make testing easier. Additionally, I will live code some tests for common use cases developers encounter, including unit, integration, and “black box” testing of imperative and reactive RESTful and event-driven applications that use common services, such as databases and Kafka brokers. I will discuss techniques such as mocking, spying, and interaction-based testing/verification.

How to avoid common pitfalls with modern microservices testing

Have you ever wondered why your microservices break in production after all the tests have passed during CI/CD? Have you ever wondered if you’re testing too much or too little? If you want to learn about common pitfalls and how to catch them at build time rather than at runtime, this session is for you!

In this session, we’ll share some common battle scars from our experiences in the field. Additionally, we will introduce the testing pyramid and explain why it is important in helping to continuously deploy microservices independently without fear. We will demonstrate, through a test-driven development approach, how the combination of Pact contract testing combined with Quarkus developer joy can help prevent your microservices from breaking in production

Testing AI-powered applications doesn't have to be hard

Applications today don't exist in a vacuum. They typically communicate with other services, such as databases, message brokers, cache servers, and even AI models. These interconnectivity requirements make it hard to do local/inner-loop development and testing efficiently, often forcing developers to write lots of code and configuration that never gets to production.

And what about the surge of AI-powered applications? What happens when the applications start using advanced features, such as RAG? These applications integrate with various AI model providers (such as OpenAI, HuggingFace, and Claude), yet results from these models are non-deterministic. How do you effectively test these integrations without costing your organization lots of money?

What if there was a better way? What if you didn't need to write any extra code or configuration and things just worked out of the box, making your life simpler and easier?

We will show how you can easily and efficiently test these integrations, proving that testing AI-powered applications doesn't have to be hard!

Microservice Superheroes to the rescue!

Are you a developer building microservices? Do you struggle with how to develop and test individual microservices that are part of a larger system? Do you want to learn about building REST-based, event-driven, and AI-powered applications?

In this session, I will introduce the Quarkus Superheroes application and demonstrate how the application can facilitate local development within a microservices architecture. I will show how individual applications within the system can be tested (both unit and integration testing), as well as how “upstream” applications can be developed and tested in isolation of their “downstream” dependencies. Additionally, I will demonstrate how the application can be easily deployed to a remote Kubernetes environment and assist in the local development of individual applications within the overall system.

The Quarkus Superheroes application is a sample application consisting of several microservices demonstrating Quarkus features and best practices. The application allows superheroes to fight against supervillains. The application consists of several microservices, communicating either synchronously via REST or event-driven via Apache Kafka, all with a web-based user interface. Some of the applications are reactive while others are more traditional, showcasing how to build each kind. There’s even ChatGPT and Dall-e integration!