Building Images in Podman Desktop

For this exercise, we’ll be using a basic Java web application based on the SuperSonic, Subatomic Quarkus stack. Quarkus is a Kubernetes-native Java framework designed for building high-performance and scalable microservices. The application uses a Redis cache to store the number of times we’ve visited the webpage. This is a simple microservice, but it’s a good example of a multi-container application.

Let’s start off with downloading the source code for the demo application, found here on GitHub.

While you could clone the repository to a local machine using GitHub Desktop, today let’s use the command line to clone the repository. Open up the terminal (click on activities in the top left, then type 'terminal'), and then use the noVNC menu to copy these commands to your clipboard, and paste/execute them in the terminal.

Since this is a Java application, we’ll need to install a Java OpenJDK version. Copy and paste the following commands to install SDKMAN! and then the Eclipse Adoptium Temurin build of OpenJDK 21, for which Red Hat provides Enterprise Support. If you’re interested in reading more about Red Hat’s involvement in Java, there are a wealth of resources on developers.redhat.com/java.

Let’s install SDKMAN and OpenJDK. Copy & paste the following set of commands and let them run their course.

If everything went well, you will see a message saying "Done installing!" and your installed version of Java is set as the default.

Now, let’s open up the project in our VS Code instance and take a look at the source code of the demo application, found in the podify-quarkus-redis directory.

Once you’re ready, go to the file explorer (top option in the left menu). If you’re familiar with Java and Maven, you’ll see a standard file structure (src/main/java) and a pom.xml. Feel free to explore the code to familiarize yourself with the project structure. The back-end logic can be found in the src/main/java/ folder. The front-end resources are located in the src/main/resources/templates and src/main/resources/META-INF/resources folders.

The typical developer workflow starts by testing the application locally, so let’s start there. With Quarkus, Java development with rapid feedback loops becomes much easier. It allows you to start the application in "Dev Mode", enabling testing without having to compile, package, and deploy the app.

Let’s go ahead and start Dev Mode. In the same terminal we were using previously, type (or copy) the following command:

Wait a few moments for the application to start up. You’ll see logs scroll on the screen and eventually a log message that says something like "Live Coding activated" and "Listening on: http://localhost:8080".

Open up a Firefox instance and navigate to http://localhost:8080. Fantastic! Our app is already running. Feel free to modify the code and refresh the browser, and you’ll see the changes being picked up on the fly without recompilation, thanks to the Quarkus Dev Mode.

We can verify that this really happened. Open the Podman Desktop application and go to the Containers view. You should see the Redis container with a randomly assigned container name, and docker.io/library/redis:7 in the Images column.

Great! We’re done developing our application, so let’s stop the Dev Mode and proceed with containerizing it. Go back to your terminal and use the shortcut Ctrl+C to stop the process.

Let’s build our application first with Maven:

Meanwhile, go back to Podman Desktop. You’ll notice that the Dev Services containers have disappeared. As expected, the Quarkus Dev Services / TestContainers functionality cleans up after itself when the containers are no longer needed.

Quarkus projects come with a few opinionated Dockerfiles by default. You can find them in the src/main/docker folder.

Go ahead and open Dockerfile.jvm and scroll down past the commented out initial section. Let’s examine the Dockerfile.jvm instructions:

Now that we’ve taken a look at the source code and the Containerfile, in our case called Dockerfile.jvm, let’s build the container image from within Podman Desktop. From the Images section, click the Build button in the top right corner.

This will open a new window where we can specify the Containerfile, the build context, and image name. For the Containerfile Path, browse to the Dockerfile.jvm (home/student/podify-quarkus-redis/src/main/docker/Dockerfile.jvm) and select it. Set the build directory to the path of the podify-quarkus-redis directory: /home/student/podify-quarkus-redis, and set quarkus-app for the image name.

After clicking Build, Podman Desktop will start building the container image, and you can view the build logs in the bottom pane. This will take a few minutes, as it’s downloading the base image, installing dependencies, copying the source code, etc.

Once the build is complete, you should see the new quarkus-app image in the Images section of Podman Desktop. You’ll see the default image short name here, which we’ll retag for our registry in the next section.

As we’ve seen from the previous section, our application uses Redis for caching the visit counter. Redis is a popular choice for caching in containerized applications. The Quarkus application has a hard dependency on the Redis service, so if the Redis service isn’t available, the app would misbehave as you can see in the startup logs below when the Redis container isn’t running.

Fortunately we can run a Redis container next to our Quarkus application. Let’s pull a pre-built Redis image from Quay.io by clicking the Pull button from the top right corner menu. We’ll be pulling Redis image that has been built with the Red Hat UBI base image with Redis installed on top.

Fantastic! We’ve built the container image for the Quarkus web application, and pulled the Redis image for caching. In the next tutorial, we’ll start the container and test out the web application.