Microservices on foojay.io - Friends of OpenJDK

What's New In The June 2026 Azul Payara Release?

Wed, 24 Jun 2026 11:28:52 +0000

The June 2026 cycle ships the first regular monthly release of the Payara 7 line, plus a critical security fix that lands across every supported branch. Azul Payara 7.1.0 continues the Jakarta EE 11 line that went generally available in May, and is joined by Azul Payara Community 7.2026.6, Azul Payara 6.39.0, Azul Payara 5.88.0, and Azul Payara 4.1.2.191.56.

A single security fix, backported from Payara 7 down to Payara 4, runs through every release in this cycle. Two supported lines, 5.88.0 and 6.39.0, also carry a behaviour change to the server “ready” signal that a minority of deployments will want to read before upgrading.

Quarkus Unpacked: Insights from the Foojay Podcast

Tue, 23 Jun 2026 12:36:54 +0000

I recently had the pleasure of joining the Foojay podcast to talk about Quarkus in depth. The conversation covered a lot of ground, from what makes Quarkus different to the practical trade-offs between JVM and native mode. This post captures the key questions and answers from that discussion, lightly edited for readability.{#_quarkus_unpacked_insights_from_the_foojay_podcast}

If you have been following this blog series, note that the third installment on building your own stack with Quarkus is coming next. Consider this a bonus entry that distills the podcast conversation into a format you can read, reference, and share.

Jakarta EE is Ready for AI – Five Talks from OCX26 That Prove It

Tue, 02 Jun 2026 11:41:01 +0000

Back in April I had the pleasure of attending Open Community Experience 2026 in Brussels - the Eclipse Foundation’s flagship open source conference. It’s always good to be in a room (or a few rooms 😉 ) with people who really care about the technology they work with. Several of my colleagues and friends were speaking - watching them present work they’ve spent serious time on is one of the better parts of this community.

AWS Nitro and CPU Graviton Meets Unikernels

Fri, 10 Apr 2026 16:26:25 +0000

AWS Nitro and CPU Graviton Meets Unikernels: Java and Quarkus on ARM64 AWS Graviton with Nanos Unikernel

Java and Jakarta EE Truly Meet Unikernels

The key message of this article is simple and strong:

any Java or Jakarta EE application is already ready to benefit from the advantages of unikernels.

Java and Jakarta EE, including modern frameworks such as Quarkus, can immediately take advantage of the unikernel model without waiting for new languages, new runtimes, or radical rewrites.

Spring Boot Actuator Health for MicroProfile Developers

Thu, 26 Mar 2026 09:30:00 +0000

If you worked with MicroProfile Health, you already understand the value of exposing application health information through standardized endpoints. You know about liveness, readiness and startup probes. You implemented the HealthCheck interface and annotated your procedures with @Liveness, @Readiness and @Startup. Spring Boot Actuator follows a similar philosophy but takes a different architectural approach. This post will help you map your MicroProfile Health knowledge to Spring’s world.

The Conceptual BridgeThe Conceptual Bridge

At its core, Spring Boot Actuator serves the same purpose as MicroProfile Health: it provides a mechanism for validating the availability and status of your application in containerized environments. Both specifications recognize that modern cloud platforms like Kubernetes need machine-readable health information to make decisions about pod lifecycle management.

Introducing the BoxLang Spring Boot Starter: Dynamic JVM Templating for Spring

Thu, 19 Mar 2026 14:20:02 +0000

Spring Boot developers know the pain of evaluating view technologies. Thymeleaf is great — until you need more expressiveness. FreeMarker is powerful — until the syntax fights you. What if you could write templates in a dynamic JVM language that gives you the full power of the platform, feels natural, and requires zero setup to integrate?

Meet the BoxLang Spring Boot Starter.

TL;DR: Drop one dependency into your Spring Boot 3 app and start writing dynamic .bxm templates powered by BoxLang — a modern, expressive JVM language. Zero configuration. Full web scopes. 100% Java interoperable. Not only that, you get full access to BoxLang’s framework capabilities so you can integrate tons of features into your Spring Boot applications:

JC-AI Newsletter #13

Thu, 05 Feb 2026 21:12:12 +0000

Two weeks have passed, and it is time to present a new collection of readings that may shape developments, utilization or ideas in the field of artificial intelligence in 2026.

While significant activity characterizes the AI field, many unresolved research, design, and implementation challenges continue to impact progress. Future advancement depends heavily on understanding the nature of these challenges to approach probabilistic problems from the appropriate directions. This JC-AI newsletter features insightful interviews with key figures in the field, enabling readers to ask the right questions and compare visions of an ‘uncertain future’ against current capabilities to maintain a grounded perspective.

BoxLang 1.10.0: Functional Arrays, Elegant Loops & Distributed Locking

Wed, 04 Feb 2026 10:46:22 +0000

We’re excited to announce BoxLang 1.10.0, a feature-packed release that brings powerful functional programming capabilities, elegant loop syntax, and enterprise-grade distributed locking to the BoxLang runtime. This release represents a significant leap forward in developer productivity and application scalability.

🎯 What’s New

Nine New Array Methods for Functional Programming

BoxLang 1.10.0 introduces nine powerful array methods that bring modern functional programming patterns to your collections. These methods enable cleaner, more expressive code while reducing the need for verbose iteration patterns.

Enterprise Java in Practice

Thu, 29 Jan 2026 10:11:40 +0000

Enterprise Java has matured into one of the most stable and widely adopted ecosystems in software development. Yet for many teams, the biggest challenges no longer come from the language itself, but from the complexity of the environments built around it.

Modern enterprise Java teams are dealing with a mix of legacy Java EE applications, Jakarta EE runtimes, microservices, container platforms, cloud-native deployments, and increasingly sophisticated DevOps pipelines. The result is an ecosystem that is powerful, but often fragmented across frameworks, runtimes, tooling, and operational models.

Not a Lucid Web3 Dream Anymore: x402, ERC-8004, A2A, and The Next Wave of AI Commerce

Fri, 09 Jan 2026 16:05:58 +0000

This article is for technically savvy readers, especially developers, protocol designers, and product teams working with AI agents, APIs, or crypto rails, who want a clear view of how these areas connect.
It explains how x402, ERC-8004, and agent discovery layers turn APIs and agents into small usage-based businesses, and what that means for real systems over the next 1–3 years.

Vocabulary for this article

In this article, I use the term micro business for a very small overall business, and nano business for a single x402-priced endpoint or agent that earns on its own from per-call payments in stablecoins.

AP2 (Agent Payment Protocol): AP2 defines how agents pay each other. It standardizes how a service quotes a price, how payment is confirmed, and how both sides record what was bought, so payments fit directly into automated agent workflows. In practice, it is a protocol that lets one machine pay another machine for work, without a human in the loop.

A2A (Agent-to-Agent communication): A2A covers how agents talk, pass context, and coordinate work. It lets agents call each other, exchange structured messages, and chain tasks instead of acting as isolated scripts.

x402: x402 is an HTTP-based payment protocol for APIs. A server responds with status 402 Payment Required, the price, and a payment route, and the client pays by using stablecoins on-chain and then retries the request to get the result.

ERC-8004 (8004): ERC-8004 standard is an on-chain registry for agents. It gives each agent an identity and a place to store reputation data, so other agents and tools can decide whom to trust and which services to call.

Foreword

x402 and ERC-8004 .

Optimizing Java for the Cloud-Native Era with Quarkus

Tue, 06 Jan 2026 21:09:00 +0000

This article explores how Quarkus can help organizations reduce costs, streamline development, and modernize their Java applications for today’s cloud-native environments. It outlines the real-world benefits of adopting Quarkus and highlights how its core features address the performance and scalability challenges commonly associated with traditional Java frameworks.

Quarkus is already being adopted across industries. One example is Orange, a global telecom provider that selected Quarkus to support its 5G API initiative, and benefited from fast startup times, a lightweight footprint, and seamless integration with Kubernetes.

Java and Jakarta EE and the Evolution of the Cloud with Nanos Unikernel

Tue, 06 Jan 2026 20:51:09 +0000

The evolution of the Java and Jakarta Enterprise ecosystem is converging toward an increasingly simple, efficient, and scalable architecture that improves security, delivers higher performance, and reduces hardware and infrastructure costs.

For years, Kubernetes has been considered the de‑facto standard for modernizing Java applications in a cloud‑native direction. However, Kubernetes is not the only way to achieve scalability, continuous upgrades, and isolation. An alternative approach — often underestimated — is to leverage the hypervisors already included and fully managed by major cloud providers , using Unikernel images based on Nanos .

Scalable Enterprise Java for the Cloud

Thu, 18 Dec 2025 11:41:51 +0000

We’re excited to introduce Scalable Enterprise Java for the Cloud, a new free eBook created through a close collaboration between Payara , Java Champion Otavio Santana , and the Oracle NoSQL team Dario Vega & Michael Brey. This project brings together different parts of the Java ecosystem with a shared goal, helping developers build modern, cloud-native enterprise applications using open standards.

Download the free eBook here (no form fill necessary).

Spring Boot 4 - OpenTelemetry Guide

Wed, 10 Dec 2025 09:09:58 +0000

In my previous article , I outlined a comprehensive list of features introduced in Spring Framework 7 and Spring Boot 4.

In this series of articles, we will explore these features in detail using a pragmatic approach. In this second article, I will dive deep into integration of Observability framework i.e., OpenTelemetry with SpringBoot.

As an architect and developer, when I engage in system design—whether it involves monolithic architecture, microservices, or contemporary cloud-native applications—I have made the integration of observability patterns utilizing open-telemetry tools a standard practice. Through observability, we can monitor application behavior via metrics, logs, and traces that we trigger

Micrometer & Prometheus in Spring Boot: Kafka Burger Orders

Fri, 14 Nov 2025 10:13:03 +0000

👨‍💻 GitHub: https://github.com/vinny59200/dukeburger

🔵⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪⚪

This guide shows how to use Micrometer and Prometheus in Spring Boot to track a custom metric for a Kafka-driven Burger Orders app. You’ll post a burger order to a REST endpoint, publish it to Kafka, consume the topic, and increment a counter for all “DukeBurger” orders. Copy the snippets, run, and you’ll see your metric on /actuator/prometheus.

Monolith vs Microservices in 2025

Mon, 04 Aug 2025 13:45:09 +0000

In recent years, the tech world has been buzzing with debates about architecture choices. However, 2025 offers a more balanced perspective.

Simplicity, developer experience, and maintainability are reshaping how teams design software.

From Infrastructure as Code (IaC) to “vibecoding” culture, and from startups to enterprises, many rethink their position on the monolith vs microservices 2025 spectrum.

So, what has actually changed?

🔵⚪⚪⚪⚪⚪

🔁 Terraform and IaC: Changing Architecture with Confidence

How Infrastructure as Code helps teams adapt architecture efficiently

Infrastructure as Code tools like Terraform make architecture changes easier. Nevertheless, the process is not effortless.

Spring Cloud Stream for Real-Time Event-Driven Systems

Mon, 21 Jul 2025 13:33:34 +0000

Envision operating a successful e-commerce platform where every moment is crucial. Customers make purchases, adjust inventory levels, process payments, and dispatch shipping alerts—all in real time. In the background, microservices diligently function to guarantee seamless operations. However, how do these services interact effectively, particularly during peak traffic occurrences such as flash sales or holiday shopping events?

An efficient method to execute this use case involves utilizing Spring Cloud Stream (SCS) as the messaging infrastructure. SCS facilitates seamless interaction among microservices, enhancing the system’s responsiveness and scalability. A significant benefit of SCS is that it provides an abstraction layer, allowing developers to transition between messaging technologies such as Kafka or RabbitMQ or Pulsar or Amazon Kinesis without altering their fundamental business logic.

Spring Cloud Stream: Demystifying Event-Driven Architecture

Fri, 28 Feb 2025 08:34:32 +0000

Consider a bustling restaurant environment. The kitchen receives a flood of orders, waitstaff dart between tables, and patrons anxiously glance at their watches. Each time a waiter takes an order, he or she must verify it with the kitchen and wait for the kitchen to prepare the meal before attending to another table. This cumbersome method hampers efficiency, leaving the restaurant unable to meet customer demand.

Now envision an alternative situation. Instead of enduring delays, waitstaff enter orders into a centralized system, prompting the kitchen to begin meal preparation immediately upon receipt. As soon as the kitchen prepares the food, waiters receive instant notifications, enabling them to serve customers promptly without any delays. This exemplifies event-driven architecture: a fluid, real-time system where they exchange information asynchronously, promoting scalability and quick responsiveness.

Event-Driven Architecture and Change Data Capture Made Easy

Tue, 18 Feb 2025 16:44:14 +0000

Hello again! In this article (Part 1), we will discuss two common ways to build modern software systems : Event-Driven Architecture (EDA) and Change Data Capture (CDC). They serve different purposes but can work well together in some situations.

we’ll explain EDA and CDC, discuss their use cases, and explain when to use them and when not to. Using plain language and relatable examples, we’ll also explore how they work together.

Warp: the new CRaC engine

Wed, 18 Dec 2024 16:04:48 +0000

Many regular Foojay readers are already familiar with project CRaC - a technology that can checkpoint (suspend) running Java application into a snapshot image and later restore it to the already warmed-up state. The most common motivation for this is significantly faster startup than if the application (and JVM) started normally. Traditionally this was supported by CRIU (Checkpoint and Restore in Userspace), coming with the burden of root privileges required for execution. Since Azul Zulu October 2024 release, this pain-point can be gone: meet Warp.

Run a Java Lambda Function From a Docker image

Wed, 11 Dec 2024 16:16:36 +0000

Have you ever wanted to deploy a Java Serverless function, but package it with a Docker Image? That is possible now with AWS new Container support. This guide will show you how to try it yourself, step by step!

The Hello Lambda Function project contains an AWS Lambda maven application with AWS Java SDK 2.x dependencies.

Here follows instructions from AWS Document on building Lambda for Java .

The sample code seen below can be found in my GitHub repository: hello-lambda .

GlassFish is rolling forward. What’s New?

Tue, 26 Nov 2024 15:11:17 +0000

The Evolution Continues. GlassFish, which used to be a popular application server, free to use and reliable, is evolving again. If you’ve been holding onto your old GlassFish instances, there’s good news—things have gotten a lot more exciting recently.

Since we created the OmniFish company and started improving GlassFish in 2022 (read about that story in Oh, What Did You Do to GlassFish?! ), a lot has happened around GlassFish. We joined the Eclipse GlassFish project and joined the Jakarta EE Working Group as well.

Get recognized for your cloud-native Java development skills

Thu, 29 Aug 2024 16:08:34 +0000

In a world where in-demand skills are critical for job success, security, and progression, it’s vital that we, as developers, ensure we are showcasing our skills to the wider world. This can include qualifications, courses, and badges, all of which help us to advertise our skills and highlight our professional experiences and expertise.

So, to help make this easier (and free!) for Java developers, the Open Liberty team created the first-ever Liberty badge: Liberty Developer Essentials !

Creating 12-factor cloud-native Java apps with open source

Fri, 23 Aug 2024 05:30:51 +0000

Learn how you could create cloud-native Java apps that are portable, scalable, and reliable with the 12 factor app methodology and open source Java frameworks.

Created in 2012, the 12-factor app methodology was designed to provide a set of guidelines for helping developers and organizations to design and build cloud-native applications. We’ll explore how you can take advantage of each of these 12 factors to create applications, utilizing open source technologies, that thrive in the cloud.

Run AI-enabled JakartaEE/MicroProfile apps with LangChain4j

Mon, 12 Aug 2024 22:14:36 +0000

Artificial Intelligence (AI) is an exciting and disruptive field that is already transforming businesses, and even entire industries, by enabling automation, improving decision-making and unlocking new insights from data.

With the rise in large language models (LLMs) such as ChatGPT, there is a significant shift in the performance of AI and its potential to drive enterprise value. So, how will this impact on software development and the creation of cloud-native Java applications for enterprises?

Identify Dependencies in Codebases During Microservice Migration

Fri, 07 Jun 2024 07:17:58 +0000

Migration from a monolithic architecture to microservices presents challenges, particularly in identifying and managing dependencies within the codebase. By analyzing the application’s training data, we can uncover the seams and threads that bind the application together, discovering a safer, more iterative path to refactor our code.

Table of Contents

Collecting tracing data to understand code dependencies
Using Digma Analytic Insights to identify dependencies in your codebase:
Code Nexus Point Insight
Top Usage Insight
Discovering Dead Code
Duration Breakdown Insight
Conclusion: Identifying Dependencies in Your Codebase During Microservices Migration

Migration from a monolithic architecture to microservices can be crucial for scalability, flexibility, and development velocity. However, this transformation has challenges, particularly when trying to identify and manage dependencies within the codebase. Many teams optimistically embark on an application-wide modernization epic, thinking of making short work of refactoring their codebase to be more modular. Unfortunately, many of these initiatives quickly lose the initial momentum, as it becomes apparent that untangling the Gordian monolith knot is proving to be an uphill struggle.

Foojay Podcast #51: Persistence, Evolving your Career, Jakarta EE, GlassFish, Messaging via Telegram

Mon, 03 Jun 2024 08:03:53 +0000

This is part 3 of the JCON interviews.

Frank meets Otavio Santana, who recently wrote the book “Mastering the Java Virtual Machine.” At JCON, he talked about the persistence layer and how you can evolve your career.

You’ll also learn more about Jakarta EE, GlassFish, and a PET project with messaging via Telegram.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Exploring Cost-Effective Solutions for Stateful Rest Services

Mon, 27 May 2024 13:13:02 +0000

A Case Study with IBM Cloud Code Engine, EclipseStore, and IBM Cloud Object Storage

In the dynamic realm of cloud computing, finding cost-effective solutions for stateful rest services that don’t necessarily require scaling can be a nuanced challenge.

In this article, we’ll take a pragmatic look at a use case leveraging IBM Cloud Code Engine , EclipseStore , and IBM Cloud Object Storage (COS) . The goal is to shed light on how this can be a practical and economical alternative, particularly when scalability is not a primary concern.

Calling Microservices in Java: Part 1

Fri, 17 May 2024 19:41:44 +0000

When building applications that need to call other parts of the system (microservices ), Java programmers have access to a variety of tools and techniques that they can use for their development tasks.

This article guides you through different ways of calling Microservices in Java, from basic methods to more advanced ones, and will share tips on best practices and common mistakes.

1. Basic HTTP Requests with HttpURLConnection

The simplest way to calling a microservice in Java is using the HttpURLConnection class. This lets your application send HTTP requests and receive responses directly.

A Modern Approach to Middleware with Chronicle

Fri, 17 May 2024 09:46:40 +0000

Financial institutions today face significant challenges in updating their legacy middleware systems which are crucial for supporting millions of lines of code serving critical business functions. Prior to multicast support in modern switching hardware that became prevalent in the early 2000s, message middleware was largely done via proprietary protocols that converged onto TCP/IP. IBM’s Websphere MQ was a leader in this space.

Point to point middleware based on TCP/IP requires extra processing power and network bandwidth proportional to the number of consumers, and unreliable or slow consumers can negatively impact performance of the publisher. To combat these challenges, software vendors utilized IP multicast to create messaging platforms that supported topic based publish/subscribe networks.

The High Availability Features of Microservices using Chronicle Services

Thu, 25 Apr 2024 13:36:34 +0000

In low-latency microservices, ensuring system resilience without compromising performance is vital.

This article explores how Chronicle Services , a Java-based framework optimised for low-latency microservices, meets these critical requirements by integrating HA, performance, and data persistence.

Stateful and Stateless Services

A Chronicle Service application consists of a number of processing units known as Services, which interact with each other using events posted on Chronicle Queues . The Chronicle Queue is an extremely fast shared memory inter-process communication; it also has an enterprise version that facilitates replication of queues over the network.

Spring Framework – Internals of RestClient

Mon, 25 Mar 2024 11:32:54 +0000

As a developer and architect, my constant pursuit is to achieve simplicity and elegance when constructing resilient and intricate enterprise applications. With my affinity for the Spring Framework, I have witnessed firsthand the simplicity and modernization it brings to the Spring Ecosystem.

This framework enables the creation of complex enterprise applications in a more streamlined and refined manner, boasting a sophisticated diffusion and transformer architecture.

Spring RestClient

Spring Boot 3.2 launched and introduced a range of captivating functionalities. Notably, the release includes the RestClient feature, which offers a contemporary approach to developing REST endpoints.

Microservices Design Principles

Wed, 06 Mar 2024 10:48:38 +0000

Introduction to Microservices Design Principles

Welcome back to the second part of our Microservice Journey series! In this edition, we will delve into the core principles of microservice design principles, including the important topics of coupling and cohesion in Object-Oriented Programming (OOP).

This innovative approach to software system development prioritizes modularity and scalability, and understanding coupling and cohesion is essential for improving coding skills and designing architecture.

If you missed the first part, you can catch up here: The Evolution of Microservices with SOA

Evolution of Microservices & SOA -- the Architectural Landscape

Fri, 09 Feb 2024 09:30:18 +0000

The Evolution of Microservices with SOA: Navigating the Architectural Landscape 🗺️

Microservices represent a paradigm shift in the way we construct distributed systems. This comprehensive guide dives into the heart of microservices and service-oriented architecture (SOA), comparing their roles in current development ecosystems.

By understanding the evolution and the modern application of microservices, developers can harness their full potential for creating flexible, scalable, and resilient applications. 🚀

Microservices and SOA: A Comprehensive Guide 📚

Microservices and service-oriented architecture (SOA) are two popular architectural styles for building distributed systems. Both approaches share the goal of breaking down a large, complex system into smaller, more manageable components. However, there are some key differences between the two approaches. 🤔

Microservices Architecture: Navigating the Buzz

Wed, 24 Jan 2024 20:05:53 +0000

Lately I’ve been exploring what all the talk around ‘microservices architecture ’ is really about. From it popping up in every other social media debate to it increasingly becoming a must-have skill on job listings, what is it that has caused this strong divide between the proponents of the traditional monolithic approach and those who have embraced the microservices paradigm.

In this article I’m here to break it down for you as I outline the benefits, some common challenges, and offer some insights from microservices experts for those considering this approach.

When Should we Move to Microservices?

Thu, 28 Dec 2023 14:08:28 +0000

Sometime ago I wrote about modular Monoliths and the value of modern Monolithic architecture . One of the more interesting discussions that came out of that post (and video ) is the inverse discussion: when is it right to still pick Microservices?

Like any design choice, the answer is subjective and depends on many things. But there are still general rules of thumb and global metrics we can use.

Before we get into these problems, we need to understand what it means to have a Microservice architecture. Then we can gauge the benefit and price of having such an architecture.

Foojay Podcast #38: Java in the Cloud

Mon, 25 Dec 2023 12:02:46 +0000

Java was born in 1995, when the internet as we know it today didn’t exist yet.

Cloud servers, Docker, Kubernetes, distributed systems, scaling up and down… these things are now part of our daily job, but Java wasn’t originally designed for it.

In this episode, we want to learn if the recent evolutions in OpenJDK, and ongoing related projects, will make Java a full Cloud member.

Video

Podcast Apps

You can listen and subscribe to the Foojay Podcast on:

Chopping the monolith in a smarter way

Thu, 07 Dec 2023 07:40:55 +0000

In my previous post Chopping the Monolith , I explained that some parts of a monolith are pretty stable and only the fast-changing parts are worth being “chopped.”

I turned the post into a talk and presented it at several conferences. I think it’s pretty well received; I believe it’s because most developers understand, or have direct experience, that microservices are not a good fit for traditional organizations, as per Conway’s Law .

Strategies for Managing State in Chronicle Services

Fri, 01 Dec 2023 08:41:44 +0000

Introduction

In distributed, microservice-based applications, the management of state is one of the most important, yet difficult aspects of design.

Ensuring the accuracy and consistency of state without introducing excessive complexity that affects performance or flexibility to support evolving requirements requires careful thought.

This article discusses issues around state management and shows how the Chronicle Services framework provides support to deal with these in ways that maintain a resilient and high performing microservices architecture.

Preserving Software Continuity: Empowering Failover Strategies for Uninterrupted Operations

Thu, 16 Nov 2023 07:53:49 +0000

In today’s ever-changing and fast-paced digital landscape, maintaining uninterrupted business continuity is of utmost importance.

Enter Chronicle Services , a robust mechanism dedicated to upholding application integrity even in the face of service disruptions.

Let’s examine the world of failover strategies and explore how they safeguard software continuity.

Stateless vs. Stateful Services

It’s important to appreciate the difference between stateless and stateful services. Your choice of failover approach is highly influenced by this understanding, especially if the aim is to resume services seamlessly from where they were interrupted.

Patterns For The Design Of Microservices – Part 3

Thu, 16 Nov 2023 04:35:02 +0000

In part1 , part2 , we discussed several design patterns that aid in the development of microservices.

This blog post will cover the subsequent design patterns.

Observability Patterns
Cross-cutting Concern Patterns

Microservice Architecture Patterns

Undoubtedly, the logging mechanism benefits troubleshooting issues that arise when executing operations or transactions on multiple deployed microservices.

We can further categorize the observability patterns into six distinct patterns.

Log Aggregation
Application Metrics
Audit Logging
Distrubuted Tracing
Exception Tracking
Health Check API

In the subsequent segment, we will discuss each topic separately.

Patterns For The Design Of Microservices – Part 2

Mon, 30 Oct 2023 08:58:06 +0000

In the previous article , we discussed some of the design patterns employed in the creation of microservices. In this subsequent article, we will delve into the remaining patterns that are commonly utilized in the realm of microservices.

Database Patterns

There are seven distinct patterns that further categorize the data management.

Database per Service
Shared Database
Saga Pattern
Command-Query Responsiblity Segregation (CQRS)
API Composition
Domain Event
Event Sourcing

In the next section, let’s discuss each pattern individually.

Patterns For The Design of Microservices

Wed, 11 Oct 2023 06:11:03 +0000

Design patterns plays a pivotal role in designing and solving the commonly occurring problems in software application. It is guiding principle or template to the solve any designing problems.

It applies to the Microservices architectural style as well. These patterns provide a structured approach to designing and implementing Microservice architectures, ensuring scalability , maintainability , and reusability. By adhering to these design patterns, developers can proficiently tackle the common challenges encountered during Microservices development.

Book Review: Get Your Hands Dirty on Clean Architecture

Sat, 23 Sep 2023 12:00:31 +0000

I recently completed reading “Get Your Hands Dirty on Clean Architecture” authored by Tom Hombergs and I deem it an indispensable resource for developers aspiring to produce clean code and implement the Hexagonal Architecture. Consequently, I have resolved to compose a review to aid numerous individuals who harbor a fervent interest in technology!

Title: Get Your Hands Dirty on Clean Architecture
Author: Tom Hombergs
Genre: Technical, Software Architecture

In the constantly changing realm of software development, architectural principles hold a crucial position in determining the triumph and sustainability of a project. The book authored by Tom Hombergs, titled “Get Your Hands Dirty on Clean Architecture: A hands-on guide to creating clean web applications with code examples in Java,” is an exceptional guide that illuminates the importance of clean architecture, while also offering practical perspectives on its implementation through the Java programming language.

Building Real-Time Applications to Process Wikimedia Streams

Fri, 15 Sep 2023 14:33:16 +0000

In this tutorial, developers, solution architects, and data engineers can learn how to build high-performance, scalable, and fault-tolerant applications that react to real-time data using Kafka and Hazelcast.

We will be using Wikimedia as a real-time data source. Wikimedia provides various streams and APIs (Application Programming Interfaces) to access real-time data about edits and changes made to their projects.

For example, this source provides a continuous stream of updates on recent changes, such as new edits or additions to Wikipedia articles. Developers and solution architects often use such streams to monitor and analyze the activity on Wikimedia projects in real-time or to build applications that rely on this data, like this tutorial.

How we developed the Eclipse OpenJ9 CRIU Support for fast Java start-up

Wed, 19 Jul 2023 15:33:39 +0000

Checkpointing and restoring the JVM makes applications run faster because all the startup work is done before deployment. This means that in serverless cloud applications, the end-user of the application perceives no delay when the application starts. You can try it out now with your own apps on Open Liberty with Eclipse OpenJ9. But if you want to know more, here’s how we tackled the technical challenges of developing the Eclipse OpenJ9 CRIU Support.

Journeys in Java, Level 10: Service Discovery with Eureka

Thu, 13 Jul 2023 06:39:06 +0000

Gaining complexity in a microservices system certainly isn’t for the faint of heart (though neither is complexity in monoliths!).

When there are many services that need to communicate with one another, we might need to coordinate multiple services communicating with multiple other services.

We also might code for varying environments such as local, development server, or the cloud.

How do services know where to find one another?
How can we avoid problems when a service is unavailable?
How do we handle requests when we scale up or down certain parts of our system?

This is where something like Spring Cloud Netflix Eureka comes into play.

Foojay Podcast #26: The Future of Source Control and CI/CD

Mon, 26 Jun 2023 08:35:21 +0000

As developers, we like to automate the boring parts of our job. This automation includes the source control system, build pipelines, and code analysis tools.

In recent decades, we have seen evolutions from CVS to Subversion to Git. Is this the endpoint? Did we find the holy grail in version control? Or what evolutions are waiting for us?

Let’s find out together with these fantastic guests…

This is the final episode of season 2 of the Foojay Podcast. See you in September for the start of our new season with more JUGs, the launch of Java 21, and much more!

Foojay Podcast #23: Java Profiling and Performance

Mon, 22 May 2023 10:23:52 +0000

How do you get the maximum performance out of your Java application?

And how to use profiling to find the bottlenecks?

Let’s learn all about it in this podcast, with Heinz Kabutz, Marcus Lagergren, Chris Newland, and Frank Delporte!

Java profiling is a crucial technique for measuring and improving the performance of applications.

It helps identify bottlenecks, memory leaks, and other application performance issues.

There are various challenges with using Java profiling, and the need for profiling depends on the complexity of the application and the performance requirements.

Managing Data Residency: Concepts & Theory

Tue, 16 May 2023 09:18:20 +0000

Cloud computing has opened a Pandora’s Box of many original issues compared to sound old on-premise systems. I believe that chief among them is Data Residency, or Data Location.

Data localization or data residency law requires data about a nation’s citizens or residents to be collected, processed, and/or stored inside the country, often before being transferred internationally. Such data is usually transferred only after meeting local privacy or data protection laws, such as giving the user notice of how the information will be used and obtaining their consent.

Developer vs. ChatGPT Part I: Writing a Spring Boot Microservice

Thu, 27 Apr 2023 15:25:12 +0000

We pit a seasoned Java developer against the all-knowing generative AI to find out once and for all: Can an AI generate a Java microservice end-to-end?

There’s a lot of buzz around Generative AI tools for code generation. It’s no secret that the future of developer productivity goes alongside tools such as GitHub Copilot and OpenAI’s ChatGPT to enable us, developers, to produce code better and faster. These tools can learn from our existing code and suggest new code based on the desired functionality, most importantly, they can even write documentation and tests!

How to Automatically Create Microservices Architecture Diagrams

Thu, 20 Apr 2023 08:01:21 +0000

In application development, microservices is an architectural style where larger applications are structured as a collection of smaller, independent, yet interconnected services.

While this allows for highly maintainable and testable applications (as each service can be maintained independent of the larger application), the problem with this method is the inherent complexity of interactions between microservices.

It can be difficult for developers and team members to visualise how these microservices are connected to each other. We have been looking for ways to produce architectural diagrams that illustrate these interactions.

Event Driven Hello World Program

Thu, 02 Mar 2023 16:34:35 +0000

Event-driven microservices can be straightforward to describe before they are implemented, tested and maintained.

They are also highly responsive to new information in real time, with latencies in Java of below 10 microseconds 99.99% of the time depending on the functionality of the small independently deployable microservice.

In this introductory article, we use an example event-driven Hello World program (a programming paradigm where the program flow is determined by events) to step through behaviour-driven development , where we describe the behaviour the business needs first as test data, and writing a very simple microservice which turns input events like this:

Journeys in Java, Level 9: Docker compose all the things

Sun, 26 Feb 2023 10:02:15 +0000

Our microservices project contains quite a few pieces now.

We have two databases, three API services, a user-view service for books, and a service to host our configuration.

With so many pieces to manage, it would be nice to have something that orchestrates the individual services into a system, such as Docker Compose.

Back in our Level 5 rendition, we did exactly this for our smaller version of the project.

Now that we have expanded our services, we need to add those new pieces into the existing Docker Compose management umbrella.

The evolution of APIs: From RESTful to Event-Driven

Thu, 23 Feb 2023 08:23:25 +0000

History of Services and APIs

Enterprise application landscapes consist of inter-connected and inter-related applications.

The world of application integrations has been constantly evolving over several years.

Over time, we’ve observed a trend towards more modular and data model-focused integration components, and an increased emphasis on real-time processing.

Beginning with EJBs in the 90s, progressing to Webservices and Service-Oriented Architecture (SOA) in the early 2000s, and finally evolving to domain-specific microservices, we are seeing a continual progression towards more efficient and effective integration solutions.

Journeys in Java, Level 8: Add MongoDB to Spring Cloud Config

Thu, 09 Feb 2023 16:56:28 +0000

In our last article , we used Spring Cloud Config to provide database credentials to a microservice application connecting to a cloud-hosted Neo4j database. This post will backport this concept to our existing MongoDB database instance and its related microservices.

We will add our MongoDB credentials to the config server, so that it will be the central place for both our Neo4j and MongoDB database access. However, each service only has access to the credentials that it needs to operate, which provides some level of security through “separation of concerns” (versus universal access).

How to Run a Java Application with CRaC in a Docker Container

Wed, 01 Feb 2023 09:41:11 +0000

CRaC (Coordinated Restore at Checkpoint) is an OpenJDK project that was developed by Azul to solve the problem of “slow” startup times of the Java Virtual Machine in a microservice environment.

The most up-to-date guidelines can be found on “Coordinated Restore at Checkpoint Usage Guidelines ” in the Azul Docs.

When the JVM runs your application code, it does things like interpreting, compiling and optimizing code to make your application run as fast as possible under the given workload. This is great but can take some time and especially when you run short lived microservices you don’t want to wait until the JVM has produced the most optimized code.

Journeys in Java, Level 7: Externalize Microservice Configuration

Mon, 30 Jan 2023 15:43:16 +0000

Our decided next step for this project takes us in a new direction by adding externalized configuration for our applications.

We already saw how to do something similar with MongoDB database credentials in Docker Compose to access a local database container, but what do we do when the database is hosted on public cloud or contains sensitive data?

We probably don’t want to publish our credentials anywhere or even prevent accidental publishing.

Spring Boot Annotation Reference-01/b

Fri, 06 Jan 2023 09:54:05 +0000

In the second part of my article series on Spring Boot Annotations, we focus on REST and Spring Stereotype Annotations.

In continuation of part 01/a of this article , let’s continue our Spring Boot Annotations journey.

What percentage (depth and extent) of Spring Boot Annotations do you think you really know? This includes annotations in all their glory and the power that they bring via all of their options. I am sure whatever your answer may be, you will appreciate this quote from Albert Einstein: “The more I learn, the more I realize how much I don’t know.”

Spring Modulith: Have We Reached Modularity Maturity?

Thu, 29 Dec 2022 07:07:29 +0000

One of the main reasons to design microservices is that they enforce strong module boundaries .

However, the cons of microservices are so huge that it’s like chopping off your right hand to learn to write with the left one; there are more manageable (and less painful!) ways to achieve the same result.

Even since the microservices craze started, some cooler heads have prevailed.

In particular, Oliver Drotbohm , a developer on the Spring framework, has been a long-time proponent of the moduliths alternative.

Spring Boot Annotation Reference - 01/a

Thu, 22 Dec 2022 09:57:33 +0000

In 2018, I was introduced to the topic of Microservices and Spring Boot via a formal training, during my brief stint as a Senior Architect in Manila, Philippines.

Though I had worked on a ‘similar architecture’ way back in 2007-‘08 while working as a Software Engineer at Symantec - I found the idea of the Uber JAR really exciting. Also, since it will now be enforced via the most popular framework brings in more possibilities.

EJB support in Piranha via CDI

Tue, 15 Nov 2022 14:14:42 +0000

Enterprise Beans was once the face of Java EE, but as we discussed in the previous article , is currently de-emphasised in Jakarta EE.

However, since there’s so much existing code using Enterprise Beans, a certain level of support is still desired.

Piranha Cloud , a relatively new runtime supporting Jakarta EE, takes a somewhat novel approach to Enterprise Beans. Instead of implementing a separate container, Piranha Cloud, via the OmniBeans project, maps Enterprise Beans annotations to equivalent functionality in CDI itself, or to technologies in Jakarta EE leveraging CDI (such as Jakarta Transactions).

Low Latency Crypto Trading Systems with Java and Chronicle

Tue, 18 Oct 2022 14:59:37 +0000

Cryptocurrency trading is an emerging market with its own rules.

However, when it comes to the need for low-latency arbitrage , that is, being able to react rapidly to changing market prices and placing orders ahead of the competition, there are lessons we can learn from optimizing classic trading systems.

Chronicle Software has a successful track record of designing low-latency trading products. This background enables it to provide optimum performance solutions for Crypto trading systems.

MicroProfile Config for Java SE

Thu, 13 Oct 2022 16:10:31 +0000

The MicroProfile Config specification is one of those attempts to create a specification around application configuration for the Java Enterprise world. In the past, there were already some other attempts within Java EE to define this specification for Java EE, but they were never finalised.

Currently, another attempt is in progress with Jakarta EE Config but since MicroProfile is closely related to Jakarta EE, it is the best available solution today. That is the reason why almost all Jakarta EE runtimes also support MicroProfile Config and the other specifications of the MicroProfile umbrella.

Unified Event-Driven Architecture for the Cloud Native Enterprise

Thu, 06 Oct 2022 19:58:06 +0000

CTOs and enterprise architects have long recognized the importance of event-driven architectures (EDA). While once considered purely a technology concern, the foresight of organizations that have invested in EDA has become readily apparent as the world has shifted around us. In the past decade, we’ve witnessed changes in nearly every aspect of our technological worlds, and the vast majority of those have been affected in some way by a move toward event-driven, real-time processing.

Starting Docker Desktop with Spring Boot

Fri, 30 Sep 2022 05:37:53 +0000

I came across Docker Desktop for the first time about three years ago, when I was working as a Principal Architect (Strategic R & D) on the Microservices Reference Architecture for a product development organization.

At that time, when I was working on my corporate laptop - It became a tedious task to configure virtualization and settings to get it to work. Once I got it running smoothly, I realized that the memory requirements required to run it is quite high. At times, I found it tough to use my laptop for daily development with it running. It was also because I was working on microservices and had almost 6+ spring boot applications running.

Reclaiming Persistent Volumes in Kubernetes

Wed, 28 Sep 2022 09:55:19 +0000

Kubernetes is a widely used open-source container management platform for running stateless, containerized applications at scale. In recent years, Kubernetes has been extended to also support stateful workloads, including databases and key-value stores.{#43de}

There are three important API resources when it comes to managing stateful applications in Kubernetes:{#8e8a}

STSs schedule stateful pods, which can claim PVs through PVCs and mount them as volumes. Once a PV is claimed by an STS replica, Kubernetes will make sure that the volume stays with the replica, even if the pod gets rescheduled.{#e855}

What is MicroProfile?

Thu, 22 Sep 2022 09:03:08 +0000

The Java programming language can be enhanced with specifications. An specification is a baseline platform definition - a framework - to guide concrete implementations.

One of these specifications is called MicroProfile.

But what is MicroProfile specification, what is it used for and why might you need it?

This article explains all!

What Is MicroProfile?

The MicroProfile specification is a set of Enterprise Java APIs and technologies, designed to help with the challenge of building microservices architectures in Java.

Multi-cluster Cassandra with Google Kubernetes Engine (Pt. 2)

Thu, 08 Sep 2022 17:20:08 +0000

This is the second in a series of posts examining patterns for using K8ssandra to create Cassandra clusters with different deployment topologies.

In the first article in this series, we looked at how you could create a Cassandra cluster with two datacenters in a single cloud region, using separate Kubernetes namespaces in order to isolate workloads. For example, you might want to create a secondary Cassandra datacenter to isolate a read-heavy analytics workload from the datacenter supporting your main application.

Running your Database on OpenShift and CodeReady Containers

Tue, 06 Sep 2022 09:43:57 +0000

Let’s take an introductory run-through of setting up your database on OpenShift, using your own hardware and RedHat’s CodeReady Containers.

CodeReady Containers is a great way to run OpenShift K8s locally, ideal for development and testing. The steps in this blog post will require a machine, laptop or desktop, of decent capability; preferably quad CPUs and 16GB+ RAM.

Download and Install RedHat’s CodeReady Containers

Download and install RedHat’s CodeReady Containers as described in Red Hat OpenShift 4 on your laptop: Introducing Red Hat CodeReady Containers

Can Java/Jakarta EE do Microservices?

Thu, 01 Sep 2022 12:43:12 +0000

In this myth-busting webinar, Steve Millidge (founder of Payara ), demonstrates that Java/Jakarta EE can do microservices.

In this video, Steve explains:

What are microservices?
How JAX-RS API makes it easy to develop applications that use the REST architecture
Deployment models for microservices
How to use MicroProfile with Jakarta EE
12 factor apps with Jakarta EE

If you’ve been hearing that Java/Jakarta EE is only for monolithic architecture, watch this video to see why that’s not true and how you can continue using your existing development skills to modernize your application development with microservices.

Google Remote Procedure Call (gRPC) Example in Payara Server

Thu, 25 Aug 2022 10:09:21 +0000

Google Remote Procedure Call, or gRPC, is an open source Remote Procedure Call (RPC) framework focused on high performance and is portable to any environment.

It is an alternative to REST, deemed by many as more efficient.

After one of our customers requested it, the extension became available in our April 2022 Payara Community and Enterprise releases: 5.2022.2 and 5.38.0.

After providing a brief overview of the gRPC extension in Payara in our April release blog, here we provide more technical details about how to use it in Payara Community, where you will build the module yourself and place it in the modules directory.

Backend-for-Frontend: The Demo

Mon, 15 Aug 2022 18:29:48 +0000

In one of my earlier posts , I described the Backend-for-Frontend pattern.

In short, it offers a single facade over multiple backend parts.

Moreover, it provides each client type, e.g., desktop or mobile, exactly the data that it needs and not more in the format required by this client type.

The use-case

Imagine the following use-case.

In an e-commerce shop, the home page should display multiple unrelated data at once.

Products: The business could configure which items are shown on the home page. They could be generic, “hero” products, or personalized, products that the customer ordered previously.
News: Again, the newsfeed could be generic or personalized.
Profile-related information
Cart content
Non-business related information, such as build number, build timestamp, version, etc.

Depending on the client, we want more or less data. For example, on a client with limited display size, we probably want to limit a product to its name and its image. On the other hand, on desktop, we are happy to display both the above, plus a catch phrase (or a more catchy - and longer - name) and the full description.

Deploy a Multi-Datacenter Cassandra Cluster in Kubernetes

Wed, 10 Aug 2022 08:27:59 +0000

The Get Started examples on the K8ssandra site are primarily concerned with spinning up a single Apache Cassandra datacenter in a single Kubernetes cluster.

However, there are many situations that can benefit from other deployment options.

In this series of articles, we’ll examine different deployment patterns and show how to implement them using K8ssandra.

Flexible topologies with Cassandra

From its earliest days, Cassandra has included the ability to assign nodes to datacenters and racks. A rack was originally conceived as mapping to a single rack of servers connected to shared resources, like power, network, and cooling.

Write Your Own Service Discovery Client for Apache APISIX

Mon, 01 Aug 2022 10:27:42 +0000

API Gateways in general, and Apache APISIX in particular, provide a single entry point into one’s information system.

This architecture allows for managing load balancing and failover over similar nodes.

For example, here’s how you can create a route balanced over two nodes in Apache APISIX:

curl http://localhost:9080/apisix/admin/routes/1 -H 'X-API-KEY: edd1c9f034335f136f87ad84b625c8f1' -X PUT -i -d '{
 "uri": "/*",
 "upstream": {
 "type": "roundrobin",
 "nodes": {
 "192.168.0.1:80": 1, # 1
 "192.168.0.2:80": 1 # 1
 }
 }
}'

Every request has a 50/50 chance of being sent to either node

It worked for a long time, but in this day and age, nodes are probably not pets but cattle: they come, and they go. Hence, it’s essential to dynamically update the nodes list when it happens.

Discussing Backend For Front-end

Mon, 25 Jul 2022 14:49:18 +0000

In the good old days, applications were simple. A browser sent a request to a webapp endpoint; the latter fetched data from a database and returned the response.

The rise of mobile clients and integrations with other apps upset this simplicity. I want to discuss one solution to handle the complexity in this post.

The increased complexity of system architecture

Let’s first model the above simple architecture.

Mobile clients changed this approach. The display area of mobile clients is smaller: just smaller for tablets and much smaller for phones.

Kubernetes and the Data Centre: Is Full Scale Migration Possible?

Thu, 21 Jul 2022 13:48:13 +0000

Data centres used to be exactly that - the centres of our data worlds, where all information, files and records would be kept and controlled.

Today, that is no longer the case. More companies are moving to cloud services, whether this is dialling down on their traditional on-premises environments or never setting them up in the first place.

This is not to say that data centres will be wholly abandoned for cloud, but the mix will continue to evolve and be very different to today. Gartner predicts that by 2025, 85% of infrastructure strategies will take a more hybrid approach, integrating on-premises, colocation, cloud and edge delivery options, compared with 20% in 2020.

Why a Cloud-Native Database Must Run on K8s

Tue, 19 Jul 2022 17:44:09 +0000

We’ve been talking about migrating workloads to the cloud for a long time, but a look at the application portfolios of many IT organizations demonstrates that there’s still a lot of work to be done. In many cases, challenges with persisting and moving data in clouds continue to be the key limiting factor slowing cloud adoption, despite the fact that databases in the cloud have been available for years.

For this reason, there has been a surge of recent interest in data infrastructure that is designed to take maximum advantage of the benefits that cloud computing provides. A cloud-native database is one that achieves the goals of scalability, elasticity, resiliency, observability and automation; the K8ssandra project is a great example. It packages Apache Cassandra and supporting tools into a production-ready Kubernetes deployment.

Journeys in Java, Level 6: Build a Neo4j Microservice

Wed, 13 Jul 2022 15:13:43 +0000

For our next adventure in Java microservices, we want to expand our system for book review data.

While books and authors are well-suited for a document database such as MongoDB, once you add reviews to the mix, the importance of the relationships makes this project better suited for a graph database.

This way, we can utilize relationships between the different entities to improve analysis based on the structure of the connections.

Available Now - gRPC for Apache Cassandra

Thu, 07 Jul 2022 07:38:47 +0000

Build microservices easily with the NoSQL standard database

If you are like most developers, you are embracing applications built using microservices and a NoSQL database. There are many good reasons: faster time to market, lower total cost of ownership, better performance, less downtime, and easy scalability.

Creating cloud-native applications is hard because microservices are often written in different languages, database drivers have a maintenance burden, or familiar HTTP APIs lack the performance needed.

K8ssandra ramps up security features to match Kubernetes’ best practices

Thu, 23 Jun 2022 19:54:58 +0000

New security features are coming to the open-source data platform: K8ssandra. The goal? To align even more with the security best practices of Kubernetes. Here’s an introduction to the platform’s security mission and an update on current initiatives.{#e3b8}

The security defaults applied by K8ssandra are about to get even more aligned withKubernetes’ security practices . In an upcoming release of K8ssandra, pod and container security configurations give users full customization capabilities and default values out of the box.{#c373}

Managing Distributed Applications in Kubernetes Using Cilium and Istio with Helm and Operator for Deployment

Tue, 07 Jun 2022 14:51:03 +0000

This post will show you the benefits of managing your distributed applications with Kubernetes in cross-cloud, multi-cloud, and hybrid cloud scenarios using Cilium and Istio with Helm and Operator for deployment.{#6864}

In our recent post on The New Stack , we showed you how you can leverage Kubernetes (K8s) and Apache Cassandra TM to manage distributed applications at scale, with thousands of nodes across both on-premises and in the cloud. In that example, we used K8ssandra and Google Cloud Platform (GCP) to illustrate some of the challenges you might expect to encounter as you grow into a multi-cloud environment, upgrade to another K8s version, or begin working with different distributions and complimentary tooling. In this post, we’ll explore a few alternative approaches to using K8s to help you more easily manage distributed applications.{#fec3}

Journeys in Java, Level 5: Building an Empire of Microservices

Thu, 02 Jun 2022 05:08:28 +0000

We continue building our microservices system by adding a coordination layer to handle spinning multiple services up and down.

In previous articles, we grew from two Spring Boot applications to three applications + a database container.

As we continue to scale and broaden our system, we will need something to coordinate service and ensure consistent communication (avoid human error).

We will do this through docker-compose , an orchestration tool that manages containerized applications.

Book Review: Monolith to Microservices (Part 2)

Wed, 25 May 2022 09:09:08 +0000

This is the second article of the first one I wrote the other day , “Monolith to Microservices: Evolutionary Patterns to Transform Your Monolith ” by Sam Newman.

In this article, I will summarize chapter two.

Chapter #2: Planning to Migration

In this chapter, the book discusses the goal and mindset. When we are looking for a Microservices, what should be our goal.

It argues that our goal shouldn’t be the Microservices. Something worked for Netflix or Amazon, which means it will work for me as well. This thought process has a major flaw. It makes you fall into a cargo cult mentality.

Chopping the Monolith: The Demo

Mon, 23 May 2022 12:53:49 +0000

In my previous blog post Chopping the Monolith , I explained my stance on microservices and why it shouldn’t be your golden standard.

However, I admitted that some parts of the codebase were less stable than others and had to change more frequently.

I proposed “chopping” these few parts to cope with this requirement while keeping the monolith intact.

As Linus Torvalds once wrote:

Talk is cheap, show me the code!

Why Developers Should Use Apache Pulsar

Thu, 19 May 2022 15:10:49 +0000

Apache Pulsar is an open source streaming platform that addresses some important limitations in Kafka, particularly for cloud-native applications.
SPainter VFX / Getty Images

If you are building applications today, you are probably familiar with the microservices model: Rather than building big monolithic applications, we break services down into isolated components that we can independently update or change over time.

Microservices deployments then can use a message bus to decouple and manage the communication between services, which makes it easier to replay requests, handle errors, and deal with load spikes and rapid increases in requests while maintaining the serialized order.

Let's Compile Java Code in the Cloud!

Wed, 18 May 2022 12:03:34 +0000

Across the industry, companies are trying to rein in runaway cloud costs by squeezing more carrying capacity out of the instances they run in the cloud.

Especially in the Java space, developers are trying to fit workloads into smaller and smaller instances and utilize server resources with maximum efficiency.

Relying on elastic horizontal scaling to deal with spikes in traffic means that Java workloads must start fast and stay fast.

Book Review: Monolith to Microservices (Part 1)

Wed, 18 May 2022 07:43:41 +0000

I have just finished reading “Monolith to Microservices: Evolutionary Patterns to Transform Your Monolith ” by Sam Newman.

This book is undoubtedly great. It explains the critical aspects applicable when moving away from a monolith to a microservices architecture.

In this article, I will try to summarize some of the key elements from the book that impacted me.

This book contains five chapters, each of which has a great deal of context and explanation.

5 More Reasons to Choose Apache Pulsar Over Apache Kafka

Thu, 05 May 2022 18:11:20 +0000

Author’s note: I originally published this blog post in 2019, while I was CEO of Kesque, a real-time messaging service built on Apache Pulsar , the cloud-native distributed messaging and streaming platform. It’s a follow-up to an earlier post, “ 7 Reasons to Choose Apache Pulsar over Apache Kafka .” A lot of big changes have happened since these two posts went live, including Kesque’s acquisition , in January 2021, by DataStax. The reasons to choose Pulsar, however, haven’t changed.

Bring Streaming to Apache Cassandra with Apache Pulsar

Thu, 05 May 2022 18:10:42 +0000

Twitch, YouTube, Instagram, Facebook — virtually every major brand nowadays uses live streaming to connect and engage their audience.{#2544}

For enterprises and developers building cloud-native applications , this growing trend creates a need for streaming technologies that can reliably handle the rush of massive amounts of data, while also being flexible and easy to manage for developers.{#2544}

One such technology is Apache Pulsar ® — an open-source, distributed messaging and streaming platform that’s easy to deploy, simple to scale, and packed with developer-friendly APIs.{#8b5a}

Journeys in Java, Level 4: Building an Empire of Microservices

Wed, 27 Apr 2022 07:22:03 +0000

This article is the fourth iteration in a series of posts about building microservices in Java.

The initial post started with a single string message passed between two locally-running applications, and we are gradually adding services and functionality along the way.

In this level 4 instalment, we will add a new service that will manage book authors. It will call a database containing a data domain of books and retrieve authors and their information. This will entail creating a new, separate service from our previously written service1 and service2.

Chopping the Monolith: Foojay.io Today

Mon, 25 Apr 2022 19:06:50 +0000

If you attend conferences or read technical articles, you could think that microservices are the correct and only way to build a system at the moment.

Despite some pushback from cooler heads, the default architecture is microservices.

In this post, I’d like to argue why it’s wrong.

I’ll first get back to the origin of microservices and the fundamental reason to use them.

Then, I’ll describe why microservices don’t fit most organizations’ structures.

Full Stream Ahead: Astra Streaming, Powered by Apache Pulsar

Thu, 24 Mar 2022 09:22:15 +0000

With a serverless architecture, multi-region geo replication, and Apache Cassandra’s legendary performance, DataStax Astra DB makes it easy for developers and enterprises to start small with their applications and grow them to infinite scale without constant performance tuning and optimization exercises.

However, cloud app developers also face significant challenge`s beyond data at rest. Modern data apps require high-scale streaming technologies that can deliver the reactive engagement at the point of interaction that end users have come to expect. That’s why today, we’re excited to announce that these capabilities have been added to DataStax Astra.

Journeys in Java, Level 3: Building an Empire of Microservices

Fri, 04 Mar 2022 16:23:40 +0000

We are still in the beginning stages of building microservices with Java, but we have already seen how to send and receive communications between two Spring Boot applications. In the first blog post of this series, our two applications transmitted a message string of "Hello, World!". In the second blog post , we took it one step further by embedding a MongoDB database into our service1, added a data domain (books) with four pre-populated entries, and transmitted the Book information between the two applications.

The Serverless Database You Really Want

Thu, 03 Mar 2022 20:43:05 +0000

The dreaded part of every site reliability engineer’s (SRE) job eventually: capacity planning. You know, the dance between all the stakeholders when deploying your applications. Did engineering really simulate the right load and do we understand how the application scales? Did product managers accurately estimate the amount of usage? Did we make architectural decisions that will keep us from meeting our SLA goals? And then the question that everyone will have to answer eventually: how much is this going to cost? This forces SREs to assume the roles of engineer, accountant and fortune teller.

Why Pulsar Beats Kafka for a Scalable, Distributed Data Architecture

Thu, 03 Mar 2022 14:10:45 +0000

The leading open source event streaming platforms are Apache Kafka and Apache Pulsar. For enterprise architects and application developers, choosing the right event streaming approach is critical, as these technologies will help their apps scale up around data to support operations in production.

Everyone wants results faster. We want applications that know what we want, even before we know ourselves. We want systems that constantly check for fraud or security issues to protect our data. We want applications that are smart enough to react and change plans when faced with the unexpected. And we want those services to be continuously available.

OSS Debugging Toolkits for Kubernetes

Mon, 28 Feb 2022 12:27:18 +0000

KoolKits (K ubernetes toolkits) are highly-opinionated, language-specific, batteries-included debug container images for Kubernetes. In practice, they’re what you would’ve installed on your production pods if you were stuck during a tough debug session in an unfamiliar shell.

To briefly give some background, note that these container images are intended for use with the new kubectl debug feature , which spins up Ephemeral containers for interactive troubleshooting. A KoolKit will be pulled by kubectl debug, spun up as a container in your pod, and have the ability to access the same process namespace as your original container.

Save Hours on your Setup of K8ssandra with the New Config Builder

Thu, 24 Feb 2022 19:36:47 +0000

Setting up K8ssandra in your workflow just got a whole lot easier. With the new Config Builder you can be running Apache Cassandra® on Kubernetes in a matter of minutes.

The purpose of K8ssandra is to make it easy to run Apache Cassandra® on Kubernetes. We recently took another big step in that direction by releasing the K8ssandra config builder .

Even if you’ve created thousands of nodes or integrated K8ssandra in your stack, you’ll probably want to give the config builder a try. Walk through the interactive wizard defining the shape of your cluster, resource requirements, and toggle features to fit your needs. This is great for smoothing out the on-ramp for a production ready environment of K8ssandra.

Why we decided to build a K8ssandra Operator - Part 4

Tue, 22 Feb 2022 17:04:28 +0000

In the first , second , and third posts in this series, we’ve shared conversations with K8ssandra core team members on our journey to build a Kubernetes operator for K8ssandra. We’ve discussed the virtues of the Helm package manager versus Kubernetes operators for deploying and managing infrastructure in Kubernetes and some of our implementation choices for the operator.

In this final post of the series, we pick up from the previous post with a discussion of how we decided to structure our projects in GitHub, how we test the K8ssandra operator, and our hopes for how the operator will expand the K8ssandra developer community.

The Critical Role Streaming Plays in a Data Stack

Fri, 18 Feb 2022 17:20:13 +0000

Why Apache Pulsar is the right choice for multi-datacenter, geo-distributed deployments.

Building applications today requires companies and teams to be familiar with data flows (including streaming data flows) and how to transform them into compelling user experiences. Data fuels companies’ ability to understand their customers, move faster than competitors, and provide compelling products that the market wants. According to research by DataStax and Clearpath Strategies, almost all companies (96%) now have a formal strategy for how they will work with data, but only 38% think they’re doing a good job using data in their applications.

Journeys in Java, Level 2: Building an Empire of Microservices

Wed, 16 Feb 2022 15:29:33 +0000

Let’s dive into the world of microservices find out the complexities, best practices, and troubles. I will share all my learnings, as well!

In my last blog post , we began building microservices in Java with two Spring Boot applications, passing a “Hello, World!” string from one application to the other. We focused on reduced complexity, minimum previous knowledge, and few components. Next, we can slowly add pieces that simulate microservices projects in the real world.

Cassandra Database Migration to Kubernetes with Zero Downtime

Tue, 15 Feb 2022 15:22:15 +0000

K8ssandra is a cloud-native distribution of the Apache Cassandra® database that runs on Kubernetes, with a suite of tools to ease and automate operational tasks. In this post, we’ll walk you through a database migration from a Cassandra cluster running in AWS EC2 to a K8ssandra cluster running in Kubernetes on AWS EKS, with zero downtime.

As an Apache Cassandra user, your expectation should be that migrating to K8ssandra would happen without downtime. To make that happen with “classic” clusters running on virtual machines or bare metal instances, you will use the datacenter (DC) switch technique which is commonly used in the Cassandra community to transfer clusters to different hardware or environments. The good news is that it’s not very different for clusters running in Kubernetes as most Container Network Interfaces (CNI) will provide routable pod IPs.

Building Scalable Streaming Applications with DataStax Astra Streaming

Wed, 09 Feb 2022 19:09:28 +0000

This post introduces developers to DataStax Astra Streaming with a step-by-step tutorial that illustrates how it can be used to easily build scalable, streaming applications.{#39ae}

Astra Streaming enables developers to build streaming applications on top of an elastically scalable, multi-cloud messaging and event streaming platform powered by Apache Pulsar . DataStax Astra Streaming is currently in beta, and we’ll be releasing a full demo soon. In the meantime, this article will walk you through a short demo that will provide a great starting point for familiarizing yourself with this powerful new streaming service.{#a6cf}

Deploying to Multiple Kubernetes Clusters with the K8ssandra Operator

Fri, 04 Feb 2022 22:10:56 +0000

We built the new K8ssandra Operator to simplify deploying multiple Apache Cassandra data centers in different regions and across multiple Kubernetes (K8s) clusters. We’re not at the finish line just yet, but we’ve hit the first major milestone. Now, it’s easier than ever to run Apache Cassandra® across multiple K8s clusters in multiple regions with the K8ssandraCluster!

The K8ssandraCluster is a new custom resource for K8ssandra that covers all the bases necessary for installing a production-ready, multi-cluster K8ssandra deployment. Head over to the DataStax Tech blog to learn more about how to specify your remote clusters with the K8ssandraCluster, its deployment architecture, and what’s coming next in our continued development of the K8ssandra operator.

Backing up K8ssandra with MinIO

Thu, 03 Feb 2022 22:50:09 +0000

K8ssandra includes Medusa for Apache Cassandra® to handle backup and restore for your Cassandra nodes. Recently Medusa was upgraded to introduce support for all S3 compatible backends, including MinIO , the popular k8s-native object storage suite. Let’s see how to set up K8ssandra and MinIO to backup Cassandra in just a few steps.

Deploy MinIO

Similar to K8ssandra, MinIO can be simply deployed through Helm.

First, add the MinIO repository to your local list:

Four Reasons Why Apache Pulsar is Essential to the Modern Data Stack

Tue, 01 Feb 2022 22:14:58 +0000

Messaging has been on DataStax’s radar for several years. A significant motivator for this is the increasing popularity of microservices-based architectures. Briefly, microservices architectures use a message bus to decouple communication between services and to simplify replay, error handling, and load spikes.

With Apache Cassandra™ and DataStax Astra Cassandra-as-a-service, developers and architects have a database ecosystem that is:

Based on open source
Well-suited for hybrid- and multi-cloud deployments
Available in a cloud-native, consumption-priced service

There is no current messaging solution that satisfies these requirements, so we’re building one. We started by evaluating the most popular option, Apache Kafka. We found that it came up short in four areas:

Unboxing K8ssandra: The Data Layer For Your Kubernetes-Powered Applications

Tue, 01 Feb 2022 17:51:35 +0000

A Complimentary Live Webinar, Sponsored by DataStax

Kubernetes made it easy to deploy and scale out your cloud-native applications. With K8ssandra , you can now scale application data with the same simplicity and high availability. Join us as we unbox K8ssandra a cloud native data layer for Kubernetes and explore how you can deploy it alongside your applications.

Install k8ssandra
Authenticate with Stargate
Query your data via a convenient API (REST, document, or graphql)

Not familiar with Cassandra? Astra DB is a great (free) place to learn without any of the infrastructure setup, or management headaches.

Journeys in Java, Level 1: Building an Empire of Microservices

Fri, 28 Jan 2022 14:21:37 +0000

Microservices have been used and deployed in businesses and projects for awhile, and there is plenty of content available for architecting them into a system. For my next project, I want to dive into the world of microservices and begin building my own little virtual empire from different kinds of services to find out the complexities, best practices, power, and trouble that comes with them. I will share all my learnings along the way, as well.

Taking Your Database Beyond a Single Kubernetes Cluster

Wed, 19 Jan 2022 10:31:47 +0000

By Christopher Bradford and Ty Morton {#31db}

Global applications need a data layer that is as distributed as the users they serve. Apache Cassandra has risen to this challenge, handling data needs for the likes of Apple, Netflix and Sony. Traditionally, managing data layers for a distributed application was handled with dedicated teams to manage the deployment and operations of thousands of nodes — both on-premises and in the cloud.

Kubernetes and Apache Cassandra: What Works (and What Doesn’t)

Fri, 14 Jan 2022 16:30:50 +0000

“I need it now and I need it reliable”

– ANYONE WHO HASN’T DEPLOYED APPLICATION INFRASTRUCTURE

If you’re on the receiving end of this statement, we understand you here in the K8ssandra community . Although we do have reason for hope. Recent surveys have shown that Kubernetes (K8s) is growing in popularity, not only because it’s powerful technology, but because it actually delivers on reducing the toil of deployment.

How to Put a Database in Kubernetes?

Thu, 13 Jan 2022 09:18:38 +0000

Learn the key steps of deploying databases and stateful workloads in Kubernetes and meet the cloud-native technologies, like K8ssandra, that can streamline Apache Cassandra for K8s.{#95cc}

The idea of running a stateful workload in Kubernetes (K8s) can be intimidating, especially if you haven’t done it before. How do you deploy a database? Where is the actual storage? How is the storage mapped to the database or the application using it?{#6cde}

Monitoring Spring Boot Applications (Part 1)

Wed, 12 Jan 2022 16:34:53 +0000

In part 1 of this series, we will learn about JDK Flight Recorder and how we can use it to monitor a Spring Boot application.

Introduction

Application monitoring is one thing that we as developers cannot overlook. It doesn’t matter if you run a monolith or microservices application because application monitoring is a must for production workloads to know what’s happening with your application. If you are using Spring Boot, there are different ways to monitor an application. The most popular way to monitor a Spring Boot application is to enable the spring-boot-actuator module to achieve the desired result.

A Tentative Comparison of Fault Tolerance Libraries on the JVM

Tue, 11 Jan 2022 09:31:19 +0000

If you’re implementing microservices or not, chances are that you’re calling HTTP endpoints. With HTTP calls, a lot of things can go wrong.

Experienced developers plan for this and design beyond just the happy path. In general, fault tolerance encompasses the following features:

Retry
Timeout
Circuit Breaker
Fallback
Rate Limiter to avoid server-side 429 responses
Bulkhead: Rate Limiter limits the number of calls in a determined timeframe, while Bulkhead limits the number of concurrent calls

A couple of libraries implement these features on the JVM. In this post, we will look at Microprofile Fault Tolerance, Failsafe and Resilience4J.

Requirements for Running K8ssandra for Development

Thu, 06 Jan 2022 12:15:27 +0000

The K8ssandra Quick start is a excellent guide for doing a full installation of K8ssandra on a dev laptop and trying out the various components of the K8ssandra stack. While this is a great way to get your first hands-on experience with K8ssandra, let’s state the obvious: running K8ssandra locally on a dev laptop is not aimed at performance. In this blog post, we will start Apache Cassandra® locally then explain how to run benchmarks to help evaluate what level of performance (especially throughput) you can expect from a dev laptop deployment.

Why K8ssandra?

Thu, 06 Jan 2022 12:10:09 +0000

The problem: scalable data persistence for cloud-native applications

The past decade and a half has brought tremendous change in how we in the software industry think about building and delivering internet applications. With the launch of Amazon Web Services (AWS) in 2006, companies of any size could access cloud computing infrastructure. The burst of creativity that followed gave birth to concepts like cloud-native in 2010, and methodologies such as the twelve-factor app in 2011.

Simplify Migrating from Kafka to Pulsar with Kafka Connect Support

Wed, 05 Jan 2022 11:30:09 +0000

Large-scale implementations of any system, such as the event-streaming platform Apache Kafka, often involve customizations and tools and plugins developed in-house. When it’s time to transition from one system to another, the task can become complicated, drawn-out, and error-prone. Often the benefits of an alternative system (which can include significant cost savings and other efficiencies) are outweighed by the risks and costs of migration. As a result, an organization can end up locked into a suboptimal situation, footing a bigger bill than necessary and missing out on modern features that help move the business forward faster.

Building Stateful Microservices in the Cloud Native World

Tue, 04 Jan 2022 09:34:13 +0000

Cloud Native computing is all about working with stateless data and serverless systems. But we all live in a stateful world, in which data flows through systems interconnected with one another through complex networks.

So how can systems be able to manage and track the flow of data in a coherent fashion and in a stateless world?

We will first iron out a few terminologies that some folks appear to be using almost interchangeably in the current cloud computing era:

New Survey Finds Data on Kubernetes Is No Longer a Pipe Dream

Thu, 30 Dec 2021 15:52:00 +0000

For people that work in infrastructure and application development, the pace of change is quick. Finish one project and it’s on to the next. Each iteration requires an evaluation asking if the right technology is being used and if it provides a new advantage. Kubernetes has been on the fast track of continuous evaluation. New projects and methodologies are continuously emerging and it can be hard to keep up. Then there is the question of running stateful services. The Data on Kubernetes community has released a report titled “Data on Kubernetes 2021” to give us a snapshot of where our industry sits with stateful workloads. Over 500 executives and tech leaders were asked some very direct and insightful questions about how they use Kubernetes. It turns out that there were a lot of surprising finds. Some that I would have never predicted. Let’s dig into some of the highlights that stood out to me.

7 Reasons to Choose Apache Pulsar over Apache Kafka

Wed, 15 Dec 2021 10:03:13 +0000

I wrote an earlier version of this article in 2019, while I was CEO of Kesque, a real-time messaging service built on Apache Pulsar , the cloud-native distributed messaging and streaming platform. A lot of big changes have happened in the interim; perhaps the most significant of these is the fact that the company I founded in early 2019 was acquired , in January, by DataStax. One thing that hasn’t changed, however, is the rationale behind our choice of Apache Pulsar.

Fast JMS for Apache Pulsar: Blazing Performance

Fri, 10 Dec 2021 08:54:44 +0000

DataStax recently announced the availability of Fast JMS for Apache Pulsar , a JMS 2.0 API. By combining the industry-standard Java Messaging Service (JMS) API with the cloud-native and horizontally scalable Apache Pulsar™ streaming platform, DataStax is providing a powerful way to modernize your JMS infrastructure, improve performance, and reduce costs. Fast JMS is open source and is included in DataStax’s Luna Streaming Enterprise support of Apache Pulsar.

What is JMS?

Java Message Service (JMS), or Jakarta Messaging as it is now known, is a standard messaging API that is part of the Java Enterprise Edition (now Jakarta EE ) ecosystem. It defines how to create, send, receive, and read messages between loosely coupled producers and consumers.

Why a Serverless Data API Might be Your Next Database

Wed, 01 Dec 2021 14:53:44 +0000

App development stacks have been improving so rapidly and effectively that today there are a number of easy, straightforward paths to push code to production, on the cloud platform of your choice. But what use are applications without the data that users interact with? Persistent data is such an indispensable piece of the IT puzzle that it’s perhaps the reason the other pieces even exist.

Enter cloud and internet scale requirements, essentially mandating that back-end services must be independently scalable / modular subsystems to succeed. Traditionally, this requirement has been difficult in the extreme for stateful systems. No doubt, database as-a-service (DBaaS) has made provisioning, operations, and security easier. But as anyone who has tried to run databases on Kubernetes will tell you: auto scaling databases, especially ones that are easy for developers to use, remain out of reach for mere mortals.

Enterprise-Level Apache Cassandra Sink Connector for Apache Pulsar

Wed, 24 Nov 2021 19:16:16 +0000

When DataStax started investing in streaming with Apache Pulsar ™, we knew that one of the first things people would want to do was connect existing enterprise data sources to Apache Cassandra™ using Pulsar.

Apache Pulsar has a powerful framework called Pulsar IO to enable this kind of use case, and at DataStax we already had a best-in-class Kafka Connect Sink that enables you to store structured data coming from one or more Kafka topics into DataStax Enterprise, Apache Cassandra, and Astra.

K8ssandra: Production-Ready Platform for Cassandra on Kubernetes

Wed, 24 Nov 2021 09:45:12 +0000

K8ssandra , an open-source distribution of Apache Cassandra for Kubernetes, aims to provide a “production-ready platform”, and this includes automation for operational tasks such as repairs, backups, and monitoring. Cassandra is a distributed NoSQL database designed for global scale and fault tolerance for the most demanding applications on the planet, written in Java.

K8ssandra is deployed using Helm and supports stateful workloads out of the box, which enables database administrators (DBAs) and site reliability engineers (SREs) to set up and operate Cassandra clusters using best practices in a Kubernetes environment.

Lights, Camera, Action: GitHub Actions with Java (Part 2)

Mon, 15 Nov 2021 14:35:43 +0000

Introduction

Have you ever been given too many choices resulting in the feeling of indifference (“not a big deal, doesn’t really matter either way”)? However, when given two choices, somehow you feel torn or become more critical of one versus the other.

In this short overview, you will learn how to create a GitHub Action workflow that allows you to choose a particular OpenJDK build distribution.

And welcome back to the series of articles on GitHub Actions with Java Part 2 . If you didn’t catch Part 1 head over here: https://foojay.io/today/github-actions-with-java-part-1 .

Lights, Camera, Action: GitHub Actions with Java (Part 1)

Thu, 28 Oct 2021 12:36:19 +0000

Have you ever heard of Jenkins , Travis , TeamCity or Bamboo ?

"Github smoothie" Acarlos1000

For those who do not know, these are build infrastructure software services that manage and schedule (notify) the building of software artifacts (yours).

Often, you might hear the term “CI/CD pipelines”, which refers to the concept of Continuous Integration and/or Continuous Delivery. In layman’s terms, it’s all about building, testing and deploying software in an automated fashion.

Thorntail Fat, Thin and Skinny Approach for Java Microservices

Wed, 22 Sep 2021 16:25:45 +0000

Thorntail , originally WildFly Swarm , is most suitable for packaging applications as JAR , WAR, or EAR files. The most important value is in the functional agility the Thorntail provides. You can start with the stripped down version of Thorntail, adding the required parts and application code on top.

Below we will describe how to build and deploy Thorntail based applications using Fat, Thin and Skinny approaches. The application will be packaged in the Jar/War format automatically with the help of Builder add-ons prepared by Jelastic. The topology will consist of Maven build node and JVM containers for running microservices.

Is the Java/Jakarta EE Deployment Model Out of Date?

Wed, 25 Aug 2021 13:05:59 +0000

In this myth-busting webinar, Steve Millidge, founder of Payara , will show you why the Java EE/Jakarta EE deployment model is not old fashioned or out of date.

In this webinar, learn the following:

Benefits of using thin WARs over fat JARs:
- Do you know what’s in your Spring fat JAR?
- Do you know who’s tracking security issues with Spring?
Security benefits of patched runtimes
Advantages of building container images to build applications, not infrastructure messaging

If you think you have to switch to Spring for a modern deployment model, this video will show you how the Jakarta EE deployment model using thin WARs allows you to modernize your application development, today!

Is Java/Jakarta EE Cloud-Native?

Wed, 18 Aug 2021 09:14:45 +0000

In this myth-busting webinar, Steve Millidge (founder of Payara ), shows you that Java/Jakarta EE IS Cloud-native and can handle microservices and containers in the Cloud.

In this webinar, learn:

What is Cloud-Native?
How Jakarta EE (Java EE) applications run securely in the Cloud
Why you should build applications, not runtimes
How to keep your runtime easily up-to-date
Learn about an upcoming project,Payara Cloud , that separates the deployment from the runtime to make running Jakarta EE applications on the cloud even easier

If you’ve been hearing that Java/Jakarta EE is not Cloud-native or it’s difficult to get your Java/Jakarta EE applications running in the Cloud, watch this webinar to see why that’s not true and how you can continue using your existing Java/Jakarta EE development skills to modernize your application development!

SKP's Primer: Failures, Pitfalls, and Disadvantages of Microservices

Mon, 02 Aug 2021 09:35:44 +0000

[About SKP’s Definitive Microservices Primer]
Series of Articles on Microservices Architecture. They Revolve Around Microservices Strategy, Decision Making, Monolithic vs Microservices, Microservices Infrastructure, Failures & Pitfalls of Microservices, Microservices Design Patterns, Database Design, Security, Logging, Messaging, Containerization, Cloud Providers and Everything that is Microservices and More!

Intro to Microservices Adoption in Real World

Microservices Adoption is almost becoming the normal in almost all software product and it services organizations. Hereby, i am taking this opportunity to make you aware of the Real-World Issues (Case Studies) that are faced by organizations (small, mid, large) of all sizes in migrating or adopting microservices. Since learning from other’s mistakes and knowing the pitfalls upfront help us prepare and plan better - this article will be helpful for those planning a shift to the Microservices Strategy organization-wide or simply making a move from Monolithic to Microservices Architecture.

Getting Started with Jakarta EE 9: Context & Dependency Injection

Wed, 26 May 2021 06:56:27 +0000

In the next part of the “Getting Started with Jakarta EE ” series, we discuss Context and Dependency Injection (CDI) and the CDI specification.

The CDI specification is an important backbone of Jakarta EE as it brings several specifications together. Over the years, it has become more and more important as an increasing number of specifications started using CDI as the basis for it.

We will also tell you a bit about the different scopes, the interceptor mechanism, and the Event system.

Announcement: Jakarta EE 9.1 Has Been Released!

Tue, 25 May 2021 14:57:35 +0000

Join us in celebrating a new release of Jakarta EE!

The Jakarta EE Working Group Releases Jakarta EE 9.1 as Industry Continues to Embrace Open Source Enterprise Java ! Jakarta EE 9.1 adds support for Java SE 11 runtimes to the foundational Jakarta EE 9 release.

This gives developers more flexibility when migrating from previous Jakarta EE releases.

In order to upgrade to the new version, simply change the dependency version in your pom.xml to 9.1.0. If you are upgrading from a version prior to Jakarta EE 9, follow the migration steps for the namespace change from javax.* to jakarta.*.

Why Java Developers Continue to Rely on Jakarta EE

Wed, 05 May 2021 07:53:59 +0000

Over the past year, the Eclipse Foundation spoke to leading Java developers around the world to discuss why they rely onJakarta EE and the unique benefits of using Jakarta EE technologies. Their input is captured in our white paper, which describes the important advantages Jakarta EE offers today and for the future.

Download the Jakarta EE white paper!

They’re Looking Ahead, Not Back

With Jakarta EE’s long history as Java EE, it’s sometimes easy for developers to dismiss the technology as yesterday’s approach. But Jakarta EE technologies are embedded, and relied upon, in a way no other technologies are. Here are some examples you might not be aware of:

Take the 2021 Jakarta EE Developer Survey

Mon, 26 Apr 2021 07:47:29 +0000

The annual 2021Jakarta EE Developer Survey is out. Make sure to use this opportunity to make your voice heard!

This is the fourth Jakarta EE Developer Survey, so it is safe to say that it has become an annual tradition and is your chance to influence the direction of the Jakarta EE working group.

The survey last year had more than 2000 responses from individuals around the World. Let’s beat that number this year!

Building Microservices with Spring Boot Fat (Uber) Jar

Wed, 21 Apr 2021 09:28:43 +0000

In most minds,microservices is an approach to make a traditional monolithic system more structured, dividing it into logical components that correspond to different functional areas of application. Thus, acting as a microservice, each component becomes self-contained, easily scaled, maintained and even upgraded without affecting the overall system. Also, with microservice architecture, you can use a software written in different programming languages, including Java. Such freedom attracts but may frighten at the same time.

Payara Platform 2021 Survey Ready For You!

Tue, 23 Feb 2021 08:22:13 +0000

The Payara Platform 2021 Survey is underway and we’re inviting everyone to answer a few questions about your use of the Payara Platform and ecosystem components.

We want to know what you like, what you want to see improved, and we’re giving you the opportunity to vote on new features you’d like to see added to the Payara Platform.

Your survey answers help drive future development efforts for the Payara Platform.

Introduction to MicroProfile OpenTracing with Jaeger

Thu, 18 Feb 2021 09:41:19 +0000

In this short video, Rudy de Busscher demonstrates how to use MicroProfile OpenTracing with Jaeger in combination with Payara Micro.

The MicroProfile OpenTracing specification defines behaviours and an API for accessing an OpenTracing compliant Tracer object within your JAX-RS application. The behaviours specify how incoming and outgoing requests will have OpenTracing Spans automatically created. The API defines how to explicitly disable or enable tracing for given endpoints.

Jaeger , inspired by Dapper and OpenZipkin, is a distributed tracing system released as open source by Uber Technologies. It is used for monitoring and troubleshooting microservices-based distributed systems, including:

How To Bring Your Java Microservices To The Cloud

Fri, 08 Jan 2021 11:20:46 +0000

All companies are software companies, and businesses will always experience the challenge of keeping integrations between users and applications scalable, productive, fast, and of high quality. To combat this, cloud, microservices, and other modern solutions come up more and more in architectural decisions.

Here is the question—is Java prepared to deal with these diverse concepts in a corporate environment?

Yes, and to demonstrate how Jakarta EE and Eclipse MicroProfile work very well and in the cloud, Payara and Platform.sh collaborated together on this webinar. You can watch the video presentation by Otavio Santana and Rudy de Busscher below:

What Are Your Java Predictions for 2021: Jakarta EE

Mon, 28 Dec 2020 09:30:18 +0000

To celebrate the world of Java and predict our highlights for 2021, several key Foojay participants will share their thoughts and hopes during the coming days on Foojay, starting with Frank Delporte, Foojay Community Manager for the Raspberry Pi , and now continuing with Jadon Ortlepp, Foojay Community Manager for Microservices, who here provides the predictions of his Payara colleagues on Jakarta EE in 2021.

“Jakarta EE will start driving improvements in APIs and Project Loom will drive new releases of many frameworks.

Java developers may stop having to worry about Kubernetes as it is abstracted away as ‘just infrastructure’.

As ever, the death of Java is predicted but Java is set to remain a top 3 programming language in 2021.”

Steve Millidge, Payara CEO and Founder

Cloud Myth: Ahead of Time Compilation Will Save You Money

Mon, 21 Dec 2020 14:54:19 +0000

There is a lot of interest in the server-side Java community around using ahead of time (AOT) native compilation provided by Graal Substrate VM to drive down memory usage and cold start times of Java microservices.

While these frameworks are technically interesting, the claim is if you spend time rewriting your Jakarta EE applications to utilise these new frameworks, then you will substantially reduce your cloud operational costs.

MicroProfile Metrics with Prometheus and Grafana

Wed, 02 Dec 2020 09:11:30 +0000

In a distributed microservices architecture, it is important to have an overview of your systems in terms of CPU, memory management and other important metrics.

This is called Observability, measuring the internal state of a system, in this case, the micro-services instances.

These metrics are gathered centrally, so that you can instantly have an overview of all the values and it allows the determination (mostly automated based on some rules) of the health of the instances.

Getting Started Quickly and Easily with Payara Server

Tue, 10 Nov 2020 09:39:02 +0000

The following four short videos will take you step-by-step through installing, writing, and deploying an application to Payara Server , even if you’ve never used the application server before:

{#more-36262}

Introduction to Payara Server

Learn how to write a simple Hello World application and deploy it to Payara Server.

Install Software

Securing Microservices with Auth0 and MicroProfile in Kubernetes

Tue, 03 Nov 2020 15:38:00 +0000

In this day and age, securing enterprise platforms is a challenge that developers and consultants tackle in an uninformed manner, producing subpar solutions in most cases.

To combat this pattern, third-party security services such as Auth0 have been devised to externalize the security of services, and they focus on stable implementations of common enterprise use cases (identity management, OAuth compatibility, and so on), and platforms such as Eclipse MicroProfile allow for their easy integration with enterprise Java microservices.

Evolution of the Growth in Interest in Microservices

Fri, 23 Oct 2020 07:35:11 +0000

For some time now, there has been an undeniable growth in interest for Microservices. The core concept itself, however, is not that new.

CORBA

As early as 1996, we talked about distributed objects, mainly in the context of an early and now mostly forgotten technology called CORBA . CORBA promised to deliver business objects, for which the network and their exact implementation was mostly abstracted away.

In a CORBA world, these business objects representing a service that focused on a single thing could essentially live anywhere. If an application was the aggregation of a number of these distributed objects, each of them living on their own server, one could be updated or restarted without having to take down the entire application.

What's New in the Payara Platform October Release?

Thu, 15 Oct 2020 14:19:00 +0000

We’re happy to announce that Payara Platform Community 5.2020.5 (direct download here ) and Payara Platform Enterprise 5.22.0 (request here ) Editions are out!

With this major release of Payara Platform Enterprise, we’re introducing Payara InSight: a new and improved version of the Community Edition’s Monitoring Console. Enterprise Edition also features some tooling enhancements including IntelliJ support and NetBeans Community Tooling.

Meanwhile, the Payara Community Edition introduces support for the Jakarta EE 9 Platform as a Tech Preview feature and a major Notifier API Update.

5 Minute Azure Survey: Java EE, Jakarta EE, and MicroProfile

Thu, 01 Oct 2020 12:55:57 +0000

The Azure team at Microsoft has been strengthening its commitment and outreach to the Jakarta EE , Java EE , and MicroProfile communities.

Tools, Workshops, and More

This effort includes guidance, tools, scripts, workshops, and talks to help migrate workloads to virtual machines, Kubernetes, OpenShift, and managed service (PaaS) offerings.

We are working with key industry partners such as Oracle, IBM, Payara, and the Eclipse Foundation to better support runtimes such as WebLogic, WebSphere Traditional, Open/WebSphere Liberty, JBoss EAP, WildFly, Payara, and GlassFish on Azure.