Learn Quarkus - Pre-Requisites Skills & Environment Setup

#Introduction

Welcome to the Learn Quarkus series! This series will take you to mastery of Quarkus — the cloud-native Java framework famous for its super-fast startup, small memory footprint, and GraalVM native image support — from the foundations all the way to production readiness. There are 24 episodes in total, organized into six phases.

But before you write your first line of Quarkus code, there are some basic skills and software you must have. Why do these prerequisites matter? Because Quarkus is built on top of the Jakarta EE and CDI ecosystem. If you don't yet understand the concept of dependency injection or how REST works, the entire series will feel confusing.

Episode 0 is your roadmap: we'll confirm the basic skills, prepare the development environment, install the main tools, and run the first verification. Once this episode is done, you can follow the whole series comfortably.

#Core Skills You Must Master

#Understanding Java and OOP

Quarkus is a framework for the Java language, so you need to be comfortable with modern Java syntax. Make sure your understanding of classes, interfaces, inheritance, and polymorphism is solid. You'll also need to know lambdas and the Stream API, because they're used extensively in Quarkus code.

Example of commonly used modern Java

import java.util.List;
 
public class Main {
    public static void main(String[] args) {
        List<String> nama = List.of("Andi", "Budi", "Cici");
        nama.stream().map(String::toUpperCase).forEach(System.out::println);
    }
}

If the lines above still feel unfamiliar, take some time to practice basic Java before moving on to the next episode.

#Dependency Injection and CDI

Quarkus uses CDI (Contexts and Dependency Injection) as the heart of its dependency injection. You need to understand the core concepts: beans, the container, and injection. Don't worry if you're not deep into it yet — episode 4 covers CDI thoroughly. For now, it's enough to understand that DI lets a class avoid creating its own dependencies, receiving them from the container instead.

#HTTP, REST, and Request/Response Model Fundamentals

Most episodes will build REST APIs. You need to understand HTTP methods such as GET, POST, PUT, and DELETE, the concept of resources, status codes like 200 and 404, and the difference between a request and a response. A quick practice with curl will help a lot:

curl -X GET https://api.github.com/users/octocat
curl -X POST https://httpbin.org/post -d 'halo=world'

#Software You Need to Prepare

#JDK 21 LTS or Newer

Quarkus 3.x supports Java 21 as the recommended LTS. Install a JDK in a manageable way. On Linux or macOS, SDKMAN! is the most convenient option because it allows several Java versions to coexist:

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install java 21.0.5-tem

#An IDE That Supports Quarkus

The best options are IntelliJ IDEA with the Quarkus plugin, or VS Code with the Quarkus Tools extension. Both provide autocomplete, debugging, and dev mode integration. Eclipse is also supported through the Quarkus Tools for Eclipse plugin. Use whichever IDE is most comfortable — what matters is that you can run and debug Java applications.

#Quarkus CLI, Maven, and Gradle

You'll need Maven (the most common in the Quarkus ecosystem) or Gradle, plus the Quarkus CLI for convenience. The Quarkus CLI can be installed via SDKMAN:

sdk install quarkus
quarkus --version

If you use Maven, make sure it's at least version 3.8.1. Check it with mvn -v. Every Quarkus project also ships with the Maven wrapper (mvnw), so a global installation isn't strictly required.

#Docker and a Local Database

Docker is required for Dev Services — the Quarkus feature that automatically spins up databases and middleware in containers while in dev mode. For databases, Quarkus natively supports PostgreSQL, MySQL, and MariaDB, plus H2 as an in-memory database for fast development. Make sure Docker is running:

docker --version
docker info

#Hardware and OS Specifications

Quarkus runs well on Windows, macOS, or Linux. For comfortably running dev mode, an IDE, and Docker at the same time, a minimum of 8GB of RAM is recommended. An SSD storage drive helps a lot, since building applications and containers is quite disk-intensive.

#Verifying Your Environment

Before moving on to episode 1, run a quick verification to make sure everything is ready:

java -version
mvn -v
quarkus --version
docker --version
git --version

Make sure java -version shows 21 or newer, quarkus --version shows a 3.x version, and git is installed for versioning your code. If anything errors out, fix it before continuing.

One more habit to build: every command in this series will use ./mvnw to invoke Maven. The command ./mvnw quarkus:dev is the standard way to run your application in development mode. This habit is used consistently starting from episode 3.

#Wrap-Up

In episode 0 you've laid the foundation for the entire series: understanding the basic Java, CDI, HTTP and REST skills, installing the JDK 21, an IDE, the Quarkus CLI, Maven, and Docker, as well as verifying all the tools.

Key takeaways:

• Quarkus is a cloud-native Java framework: master modern Java and OOP.
• CDI is the heart of dependency injection in Quarkus.
• Install the JDK 21 LTS, Quarkus CLI, Maven, and Docker.
• Docker is required for Dev Services in the database episodes.
• Make sure java -version and quarkus --version return the correct versions.
• Get into the habit of using ./mvnw quarkus:dev to run your application.

In episode 1 we'll cover history, background, and why you need Quarkus — from the slow startup time problem of Java, the birth of Quarkus at Red Hat, to its position against Spring Boot and classic Jakarta EE. Make sure your environment is ready, because the Learn Quarkus journey has only just begun!