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.

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.

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.

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.

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.

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.

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.

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.

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.