JCON EUROPE 2023

Immer mehr Entwicklerinnen schreiben Anwendungen, die später in einem Kubernetes Cluster laufen sollen. Was kann dabei so schwierig sein? Angefangen “Wie strukturiere ich meine Repositories?”, “Wo lege ich meinen Code für das Deployment ab (Containerfiles, Helm Charts, Config Values)?”, “Was muss bei der Entwicklung der Anwendung beachtet werden?”, “Wie bekomme ich den Code lokal getestet?”, “Wie bekomme ich mit, was im Test-Cluster passiert?”

Dieser Vortrag geht am Beispiel einer Java-Anwendung die typischen Entwicklungschritte von der Ablage im VCS bis hin zum Deployment auf einem Cluster aus Sicht einer Entwicklerin durch.

Traffic management, security, authentication and authorisation, discovery, routing, fault tolerance, etc - it's a LOT of logic for the single most crucial component of your infrastructure.

In this topic I'll share our experience, how to utilise the best aspects of Nginx and Java
(a) to achieve

After more than 15 years of JPA existence, the rise of NoSQL storages, and the increasing popularity of microservices architecture, software engineers have been facing new challenges on when defining reliable persistence layers. The persistence layer has on its sholders the heaviest weight of responsibility when considering architectures that are - or should we say, should be - customer-centric and domain-driven, resilient and scalable, and finally, evolutionary.


When handling data, we have the option of adoptingpersistence paradigms such as SQL and NoSQL, or even of relying on integration with external services. With a considerable amount of options or flavors (+200 options!), how can we have technically reflect the a business need without coupling it withsuch technical decisions? Or how to have a loosely coupled application and the persistence engine?

In this presentation we'll discuss the new trends in the modern persistence model around enterprise architecture. After 25 years of Java, we must revisist our persistence strategies and get to know all the new hot techs such as framework categories, data patterns, good practices, and several tips that will allow you to leverage the best of database integration with Java - the dream of scalability can finally become a reality.

Do you still remember EJBs and application servers? Then you are a "serverless expert." :-) In this session, I will explain the serverless principles ...with 10+ years old code, application servers, EJBs, and Java EE APIs. I will discuss possible J2EE application migrations to full stack "low code" Java serverless architectures. We will entirely focus on business logic, consider CO2 reduction, costs, and energy efficiency, use standards and minimize external dependencies.

Live coding, live deployments, and live interactions with the audience are included.

As more organizations are moving to the cloud, cloud architectures are getting more sophisticated by having a kind of technology diversity. This includes for example container orchestrators, database services, event meshes, networking components and virtual machines.

When it comes to security, observability on this diversity is paramount. The main question here is, do you really perceive when your app landscape is under attack?

In this session, you will have the opportunity to see various attack vectors and ways to mitigate and observe them. Many technologies will be used such as Kubernetes, eBPF, Cillium, Falco and much more!

Come and watch a live attack on a real-world based cloud architecture and see the attacker scan web applications and start lateral movement with the goal of exfiltrating data. Furthermore, become a part of the blue-team, defending and securing the architecture with modern open source tools.

Have you ever had a database migration fail on production because of a random NULL value somewhere? Ever had a hard time identifying all the possible scenarios in a database migration? Have you ever had to debug a database issue, without having access to the production database? Ever had to wait for a database copy of multiple terabytes worth of relation data? Validating that your database migrations work before running them on production databases should be a standard practice. However, writing test cases that cover all (or even most) cases isn’t easy nor feasible for a multitude of reasons. Data quality in production might not be 100% or not all data might have the constraints that are currently present due to previous migrations. Testing the migration on actual production (like) data is often a cumbersome and slow process, if it’s possible at all. Postgres.ai’s Database Lab Engine provides a way to quickly and easily create copies of PostgreSQL databases. In this talk we’ll show how this can be used to make sure your database migrations don’t fail.

Today we know very well how to start a new project on a greenfield and how to build a good architecture. But most of us work in projects that have been around for a long time and whose architecture (to put it mildly) is not quite so beautiful. “Monolith” and “Big Ball of Mud” are the unflattering labels put on such systems.

This talk will show how we can introduce (or bring back) structure. Every system is different here, so it’s important to first understand where you are. Then the right steps have to be taken. I present a catalog of refactorings to choose from and heuristics which are the right choices.

The catalog contains refactorings that help to cure: BBOM architecture, anemic domain models, and badly organized teams.

Developers creating websites need to know how to build RESTful APIs correctly. This session will help you plan and model your APIs and understand the six REST design constraints that help guide your architecture. I will start with a simple overview, including advice on identifying the users or “participants” of your system and the activities they might perform with it. I’ll help you paper test your model, validating the design before you build it. You’ll then explore the HTTP concepts and REST constraints needed to build your API.

Topics include The three approaches to adding an API, Modeling tips, Creating and grouping API methods, Mapping activities to verbs and actions, Validating your API, Working with HTTP headers and response codes, Caching, Layered systems, Creating a uniform interface, Security, Versioning, Deprecation, and Optimization, and documentation.

Examples will provide all those explanations topics to clear up the idea and demonstrate the concept.

Monoliths, macroservices, microservices, cloud-native and serverless... Where do we even start? If you are a Java developer, you will likely have to work with one, some, or even all of these deployment approaches. Does this mean learning multiple frameworks, tools and methods? It certainly looks that way, based on the many deployment-specific solutions being proposed to the Java development community.

In this presentation, we will look into these solutions, weighing their strengths and weaknesses. We will also contrast this with one-size-fits-all solutions being offered by modern open-source cloud-native Java runtimes like Open Liberty. Does it have the right technology to compete in microservice and serverless environments - can one runtime really do it all?

According to the Cloud Native Computing Foundation (CNCF) Cloud Native annual survey, security remains a top challenge in using and deploying workloads in Kubernetes. Oracle Container Engine for Kubernetes (OKE) provides secure and easy-to-use managed Kubernetes clusters. With OKE, you get the peace of mind to run mission-critical applications on Kubernetes, knowing that your clusters and applications are protected with advanced security features. We cover best practices to run secure applications in Kubernetes and discuss some security features you can leverage.

The Saga Design Pattern is commonly used in distributed systems to manage data consistency with microservices. However implementing the pattern and managing state, events, and compensation code is all enough to give you a headache! In this talk, Emily will first review situations requiring the saga pattern and then propose an alternative method of implementing sagas that ensures your code will run to completion and will simplify your saga pattern implementation. Then they will live-code a hypothetical trip planning app on top of one such implementation of this architecture, showing failure resilience and business logic can indeed be lightweight.

Spring-Boot bietet mit den Startern eine Funktionalität, wie man ein neues Software-Projekt mit wenig Aufwand aufsetzen und gleich mit Programmieren loslegen kann. Um die Abhängigkeiten muss man sich nicht kümmern, da die «richtigen» bereits vorkonfiguriert sind. Doch wie kann man z.B. die Start-up-Zeiten optimieren und den Memory-Footprint reduzieren und so die Applikation besser für die Cloud zu rüsten?

In diesem Vortrag gehen wir auf Spring-Boot Features wie "spring-context-indexer", Classpath Exclusions, Lazy Spring Beans, und Actuator ein. Daneben betrachten wir auch den Wechsel auf eine andere JVM und auch weitere Tools an.

Let's make Spring Boot great again!