Starting with Quarkus

Name: Starting with Quarkus
Rating: 4.6 (3798 reviews)

Start using Quarkus: the Supersonic Subatomic Java toolkit

Highest Rated

Created byAntonio Goncalves

Last updated 7/2021

English

German [Auto],Greek [Auto],

What you'll learn

Understand the Quarkus ecosystem, where it comes from, its performance benefits
Bootstrap a REST application with Quarkus
Test it with JUnit and RestAssured
Use injection with CDI
Configure the application and Quarkus itself
Use the dev/test/prod Quarkus profiles
Package a Quarkus application in several JAR formats
Generate a native binary thanks to GraalVM
Build and execute a Docker container out of the application

Course content

10 sections • 54 lectures • 3h 17m total length

Course Overview8:17
Learn about the course, its structure, who can attend it, what are the goals and what are the prerequisites.
What Will You Build in This Course?4:02
Lean about the application you will be building in this course.
Next0:27

Lesson Overview1:44
This section is about making sure your environment is correctly setup so we can bootstrap the application.
Checking up the Development Environment5:19
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.
Activity: Checking up the Development Environment2:56
Bootstrapping the Application8:25
Activity: Bootstrapping the Application5:00
Developer Joy3:21
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.
Activity: First Hands on Quarkus3:40
Next0:33

Lesson Overview1:14
This section is about adding some code to the generated application.
Exposing the Book REST Endpoint8:41
Activity: Exposing the Book REST Endpoint6:20
Injecting a Bean6:24
Activity: Injecting a Bean4:00
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.
Next1:32
Discover how a Quarkus app uses a book repository and endpoint to enforce separation of concerns, using JAX-RS, CDI, and JSON-B.

Lesson Overview1:17
This section is about testing the application we've developed.
Testing the Book REST Endpoint8:12
Activity: Testing the Book REST Endpoint6:55
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.
Next1:01
Explore configuring your Quarkus project with profiles for development, testing, and production, building on existing Java class tests and preparing for native tests.

Lesson Overview1:36
This section is about configuration the application and configuring Quarkus its self.
Injecting Configuration4:33
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.
Activity: Injecting Configuration4:20
Configuring Quarkus2:32
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.
Activity: Configuring Quarkus4:45
Adding Profiles4:03
Activity: Adding Profiles2:39
Next0:53

Lesson Overview1:47
This section is about package the application into executable JARs as well as generating a native binary with GraalVM.
Building Executable JARs4:50
Activity: Building Executable JARs5:45
Building Native Executables3:50
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.
Activity: Building Native Executables2:54
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.
Testing Native Executables3:52
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.
Activity: Testing Native Executables2:45
Next1:22

Lesson Overview1:54
This section is about generating a Linux native binary and package it into a Docker image and execute it.
Containerizing Executable JARs7:40
Activity: Containerizing Executable JARs4:26
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.
Containerizing Linux Native Executables3:31
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.
Activity: Containerizing Linux Native Executables3:38
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.
Next0:56

Requirements

A recent Windows / Mac / Linux machine
Knowledge of the Java language and the Java ecosystem (Maven, JUnit, GraalVM)
Basic knowledge of RESTful Web Services
Basic knowledge of Docker

Description

This course is for Java developers who want to discover Quarkus. It’s a mixture of slides and code so you can “Understand and Practice” at the same time. This way, you learn the theory, and then put it into practice by developing an application step by step.

In this course you will go through an entire development cycle. After introducing Quarkus, you will make sure your development environment is set up, and you will go from bootstrapping a Quarkus application, to running it as a Docker container. The different steps you’ll go through are:

Understand Quarkus,
Check your development environment,
Get your hands on Quarkus,
Expose a REST endpoint using JAX-RS,
Inject beans with CDI,
Test the REST endpoint with JUnit and RESTAssured,
Configure the application with MicroProfile Configuration
Configure Quarkus,
Add profiles to the configuration,
Build executable JARs
Build a native executable and a Linux executable with GraalVM,
Check the performances of a Quarkus application,
Containerize the application with Docker and execute it.

At the end of the course you’ll get a good understanding of Quarkus. You will be able to bootstrap, develop, package and execute a REST application, but most important, take Quarkus to your next project.

Good luck for the course, and please reach out if you need any help or if you have any request: I’m here to help!

Who this course is for:

Java developers curious about Quarkus
Back-end Java developers willing to move their application to the cloud
Spring or Java EE developers who need to compare their toolkit with Quarkus

Starting with Quarkus

What you'll learn

Explore related topics

Course content