Starting with Quarkus

Quarkus delivers supersonic Java with rapid development and tiny native binaries, a Kubernetes-native, open source toolkit with extensions for microservices, REST endpoints, and reactive applications.

Quarkus delivers supersonic startup and subatomic memory, starting under one second on HotSpot and 0.01 seconds on GraalVM, with memory as low as 20–40 MB.

Quarkus pushes Java to the cloud by delivering fast startup, high density, and low resource use, enabling many microservice instances to run on a single server and move across nodes.

Explore Quarkus as a Java toolkit optimized for the cloud, boasting fast startup and low memory usage, with slide-based theory; next, bootstrap a Quarkus application and compile tests.

Check and configure your development environment for Quarkus by installing Java 11, GraalVM, Maven, and Docker, and set up the pom.xml with the Quarkus BOM for native images and Docker.

Set up your quarkus development environment by confirming Java is installed (prefer Java 11), configuring GraalVM home and native image, installing Maven and Docker, and using an IDE like IntelliJ.

Bootstrap a Quarkus application with the Maven plugin to create a rest endpoint, explore generated code and tests, and view Docker files, using RESTEasy with JSON-B for /api/books.

Bootstrap your quarkus application with bootstrap.sh, generating a rest-book project via the quarkus maven plugin. Explore the rest-book structure, including pom.xml, docker files, and native vs JVM setup.

Experience developer joy with Quarkus through hot reload in development mode, unified configuration in application.properties, seamless integrated development environment debugging, and fast testing on ports 8080 and 8081.

Start Quarkus in development mode with mvn quarkus:dev to experience on the fly updates on port 8080, using RESTEasy, JSON-B, and CDI with arc; curl /api/books to see updates instantly.

We bootstrapped a Quarkus application with a rest endpoint that currently returns text. Next we inject beans, create a book entity, return json, and update tests for the evolving api.

Expose the book rest endpoint in Quarkus using JAX-RS and JSON-B, returning a list of books, a single book by id, and a book count via JSON.

Expose a book rest endpoint in quarkus dev mode by creating a Book class and a Books resource that returns JSON for all books, counts, and individual lookups.

Inject a bean using cdi in quarkus by creating a book repository with application scope, then inject it into book resource with @Inject to handle http get and json responses.

Refactor your Quarkus app by injecting a bean and a repository with application scope, log messages, and test via curl, while leveraging hot reload for seamless updates.

Discover how a Quarkus app uses a book repository and endpoint to enforce separation of concerns, using JAX-RS, CDI, and JSON-B.

Explore how to test the book rest endpoint with Quarkus, using JUnit 5 and RestAssured in both JVM and native modes, covering integration tests, endpoint verification, and Maven test execution.

Demonstrates testing the book REST endpoint in Quarkus with RestAssured and JUnit, validating all books, count endpoint, and a single-book response with JSON field checks.

Explore configuring your Quarkus project with profiles for development, testing, and production, building on existing Java class tests and preparing for native tests.

Inject configuration into your Quarkus app using MicroProfile configuration, injecting values with ConfigProperty annotations from application properties or overrides from command line, environment variables, or databases, with ConfigSource and converters.

Explore injecting configurable values in a Quarkus app by introducing a genre key, providing defaults, and overriding at runtime and in tests using application properties and command line options.

Quarkus offers extensive configurability via application.properties, including listening ports and log level, with overrides for extensions. Explore config on quarkus.io, adjust banner, and set logging for io.quarkus and org.dot agoncal.

Configure a Quarkus app by using configuration properties, adjusting logging with quarkus.log, and editing runtime values via the dev UI configuration editor.

Explains adding configuration profiles in a Quarkus app using the %profile syntax, including dev, test, prod, and custom profiles. Demonstrates prefixing properties like books.genre and quarkus.log.console.level to switch environments.

Explore Quarkus profiles by adjusting the logging level and properties across dev, test, and prod, and create a custom staging profile to demonstrate profile-based behavior.

Prepare the production profile to deploy your Quarkus app by building executable jars and a native executable with GraalVM, then run native tests after previously running the JVM tests.

Package your Quarkus application into executable jars with Maven, combining business code, dependencies, and runtime in default, legacy, or Uber-JAR formats, and compare dev versus prod performance with -D properties.

Learn to start quarkus in dev mode, package with maven skipping tests to produce a fat Uber-JAR, run with java -jar quarkus-run, and compare startup times in dev and prod.

Build native executables with GraalVM, producing small binaries that bundle the JVM and include only the code you use, via Maven package -P native to create the binary.

Explore building native executables with Quarkus using GraalVM, replacing Uber-JAR with a native binary, achieving startup in 0.02 seconds and a 31 MB executable.

Run native tests against Quarkus native binaries to validate compatibility with GraalVM optimizations. Extend JVM tests for native mode and execute them via maven verify with the native profile.

Learn to run native tests in Quarkus with mvn verify -P native, compare JVM and native tests, and fix property mismatches by overriding expectations so both pass.

Package Java classes into jars with the Quarkus runtime, convert to a GraalVM native binary, test natively, then deploy via Docker using Maven.

Create a Docker image from a Quarkus executable jar by using the generated Dockerfile, the Docker extension or JIB, and Maven packaging with the Quarkus container image build property.

Enable the docker extension, containerize a jar via the quarkus maven plugin, update pom.xml, run mvn package build=true, and start docker to expose port 8080.

Create a linux native executable from a Quarkus project and containerize it with Docker using a Dockerfile.native, then run and compare native and JVM images.

Build and run a Linux native executable with Quarkus by packaging as native, tagging the image, and running a dockerized native binary that works on Linux via ubi.

Conclude by recapping how we package a JAR file, build Docker images and containers, create a Linux native executable, and review the commands and technologies used.

Celebrate bootstrapping to dockerising as you start with Quarkus, and note that the course isn't totally finished yet.

Receive guidance on next steps and access external references to deepen your Quarkus knowledge. Review the instructor's own books on Quarkus and articles to help you complete the course.