Make a Better WORLD, If You Cannot to Do So, Make a Better YOU: Build cloud Native Application With Quarkus ---- Session 1

Basic Quarkus Hands-on Lab (Version 2021-02-10)

2Getting Started with Quarkus

In this step, you will create a straightforward application serving a hello endpoint. To demonstrate dependency injection this endpoint uses a greeting bean.

This IDE is based on Eclipse Che (which is in turn based on MicroSoft VS Code editor).

You can see icons on the left for navigating between project explorer, search, version control (e.g. Git), debugging, and other plugins. You’ll use these during the course of this workshop. Feel free to click on them and see what they do:

If things get weird or your browser appears, you can simply reload the browser tab to refresh the view.

Many features of CodeReady Workspaces are accessed via Commands. You can see a few of the commands listed with links on the home page (e.g. New File.., Git Clone.., and others).

If you ever need to run commands that you don’t see in a menu, you can press F1 to open the command window, or the more traditional Control+SHIFT+P (or Command+SHIFT+P on Mac OS X).

Import Project

Let’s import our project. Click on Git Clone.. (or type F1, enter 'git' and click on the auto-completed Git Clone.. )

Step through the prompts, using the following value for Repository URL. If you use FireFox, it may end up pasting extra spaces at the end, so just press backspace after pasting:

https://github.com/RedHat-Middleware-Workshops/quarkus-workshop-m1m2-labs

Click on Select Repository Location then click on Open in New Window. It will reload your web browser immediately:

The project is imported into your workspace and is visible in the project explorer (click on the top-most icon for project explorer):

The Terminal window in CodeReady Workspaces. You can open a terminal window for any of the containers running in your Developer workspace. For the rest of these labs, anytime you need to run a command in a terminal, you can use the >_ New Terminal command on the right:

IMPORTANT: Check out proper Git branch

To make sure you’re using the right version of the project files, run this command in a CodeReady Terminal:

cd $CHE_PROJECTS_ROOT/quarkus-workshop-m1m2-labs && git checkout ocp-4.6

The project has

The Maven structure
An org.acme.people.rest.GreetingResource resource exposed on /hello, along with a simple test
A landing page that is accessible on http://localhost:8080 after starting the application
The application configuration file
Other source files we’ll use later

Navigate to src → main → java → org.acme.people.rest in the project tree and double click on GreetingResource.java.

This class has a very simple RESTful endpoint definition:

@Path("/hello")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "hello";
    }
}

It’s a very simple REST endpoint, returning "hello" to requests on /hello.

Compared to vanilla JAX-RS, with Quarkus there is no need to create an Application class. It’s supported but not required. In addition, only one instance of the resource is created and not one per request. You can configure this using the different Scoped annotations (ApplicationScoped, RequestScoped, etc).

Running the Application in Live Coding Mode

Live Coding (also referred to as dev mode) allows us to run the app and make changes on the fly. Quarkus will automatically re-compile and reload the app when changes are made. This is a powerful and efficient style of developing that you will use throughout the lab.

You can always use the mvn (Maven) commands to run Quarkus apps, but we’ve created a few helpful shortcuts on the right to run various Maven commands.

Start the app by clicking on Live Coding:

This will compile and run the app using mvn compile quarkus:dev in a Terminal window. Leave this terminal window open throughout the lab! You will complete the entire lab without shutting down Quarkus Live Coding mode, so be careful not to close the tab (if you do, you re-run it). This is very useful for quick expermentation.

The first time you build the app, new dependencies may be downloaded via maven. This should only happen once, after that things will go even faster

You may see WARNINGs like Unrecognized configuration key or Duplicate entry. These are configuration values that will take effect later on and can be safely ignored for now.

You should see:

2020-11-03 14:27:00,102 INFO  [io.quarkus] (Quarkus Main Thread) people 1.0-SNAPSHOT on JVM (powered by Quarkus x.x.x) started in 0.972s. Listening on: http://0.0.0.0:8080
2020-11-03 14:27:00,102 INFO  [io.quarkus] (Quarkus Main Thread) Profile dev activated. Live Coding activated.
2020-11-03 14:27:00,103 INFO  [io.quarkus] (Quarkus Main Thread) Installed features: [cdi, resteasy]

Note the amazingly fast startup time! The app is now running "locally" (within the Che container in which the workspace is also running). localhost refers to the Kubernetes pod, not "your" laptop (so therefore opening localhost:8080 in your browser will not do anything).

CodeReady will also detect that the Quarkus app opens port 5005 (for debugging) and 8080 (for web requests). Do not open port 5005, but when prompted, open the port 8080, which opens a small web browser in CodeReady:

You should see the default Quarkus welcome page (you may need to click the reload icon):

Open a new CodeReady Workspaces Terminal:

and invoke the hello endpoint using the following curl command:

curl http://localhost:8080/hello

You can also click on the URL link at the upper right to open the same default page in a separate browser tab:

Add /hello in your browser to see the same result as the curl command:

Now, let’s exercise the live reload capabilities of Quarkus. In CodeReady, open the GreetingResource.java file (in src/main/java/org/acme/people/rest) and change return "hello"; to return "hola"; in the editor. After making this change, reload the same brower tab that was showing hello. It should now show hola.

Wow, how cool is that? Supersonic Subatomic live reload! Go ahead and change it a few more times and access the endpoint again. And we’re just getting started. Leave the app running so we can continue to change it on the fly in the next section.

quarkus:dev runs Quarkus in development mode. This enables live reload with background compilation, which means that when you modify your Java files your resource files and refresh your browser these changes will automatically take effect.

This will also listen for a debugger on port 5005. If you want to wait for the debugger to attach before running you can pass -Ddebug on the command line. If you don’t want the debugger at all you can use -Ddebug=false. We’ll use this later.

Package the app

Quarkus apps can be packaged as an executable JAR file or a native binary. We’ll cover native binaries later, so for now, let’s package as an executable JAR.

Click on 'Package app for OpenShift':

This produces an executable jar file in the target/ directory:

people-1.0-SNAPSHOT-runner.jar - being an executable jar. Be aware that it’s not an über-jar as the dependencies are copied into the target/lib directory.

Run the executable JAR

Run the packaged application. In a Terminal, run the following command:

java -Dquarkus.http.port=8081 -jar $CHE_PROJECTS_ROOT/quarkus-workshop-m1m2-labs/target/*-runner.jar

We use -Dquarkus.http.port=8081 to avoid conflicting with port 8080 used for Live Coding mode

With the app running, open a separate terminal window, and ensure the app is running by executing a curl command:

curl http://localhost:8081/hello

You should see:

hola

Cleanup

Go back to the terminal in which you ran the app with java -jar and stop the app by pressing CTRL+C. Be sure not to close the "Live Coding" terminal!

Congratulations!

You’ve seen how to build a basic app, package it as an executable JAR and start it up very quickly. The JAR file can be used like any other executable JAR file (e.g. running it as-is, packaging as a Linux container, etc.)

In the next step we’ll inject a custom bean to showcase Quarkus' CDI capabilities.

Make a Better WORLD, If You Cannot to Do So, Make a Better YOU

Tuesday, March 23, 2021

Build cloud Native Application With Quarkus ---- Session 1