Chapter 1. Deploying your Red Hat build of Quarkus applications to OpenShift Container Platform
As an application developer, you can deploy your Quarkus applications to Red Hat OpenShift Container Platform by using a single Maven command. This functionality is provided by the quarkus-openshift
extension, which supports multiple deployment options, including the Docker build strategy and the Source-to-Image (S2I) strategy.
Here, you can learn about the preferred workflows to deploy your Quarkus applications to production environments. To learn about other ways to deploy Quarkus applications, see the Deploying on OpenShift guide in the Quarkus community.
Prerequisites
- You have OpenJDK 17 or 21 installed.
-
You have set the
JAVA_HOME
environment variable to the location of the Java SDK. - You have Apache Maven 3.8.6 or later installed.
You have a Quarkus Maven project that includes the
quarkus-openshift
extension.- To add the Quarkus OpenShift extension, see Adding the Quarkus OpenShift extension.
You have access to an OpenShift Container Platform cluster and the latest compatible version of the
oc
tool installed.-
For information about installing the
oc
tool, see CLI tools.
-
For information about installing the
1.1. OpenShift Container Platform build strategies and Red Hat build of Quarkus
Red Hat OpenShift Container Platform is a Kubernetes-based platform for developing and running containerized applications. Although the Kubernetes upstream project provides additional strategies, Red Hat supports only the following strategies in Quarkus:
1.1.1. Overview of OpenShift Container Platform build strategies
- Docker build
- This strategy builds the artifacts outside the OpenShift Container Platform cluster, locally or in a CI environment, and provides them to the OpenShift Container Platform build system together with a Dockerfile. The artifacts include JAR files or a native executable. The container gets built inside the OpenShift Container Platform cluster and is provided as an image stream.
The OpenShift Container Platform Docker build strategy is the preferred build strategy because it supports Quarkus applications targeted for JVM or compiled to native executables. However, for compatibility with earlier Quarkus versions, the default build strategy is S2I. To select the OpenShift Container Platform Docker build strategy, use the quarkus.openshift.build-strategy
property.
- Source to Image (S2I)
- The build process is performed inside the OpenShift Container Platform cluster. Red Hat build of Quarkus fully supports using S2I to deploy Red Hat build of Quarkus as a JVM application.
- Binary S2I
- This strategy uses a JAR file as input to the S2I build process, which speeds up the building and deploying of your application.
1.1.2. Build strategies supported by Quarkus
The following table outlines the build strategies that Red Hat build of Quarkus 3.8 supports:
Build strategy | Support for Red Hat build of Quarkus tools | Support for JVM | Support for native | Support for JVM Serverless | Support for native Serverless |
---|---|---|---|---|---|
Docker build | YES | YES | YES | YES | YES |
S2I Binary | YES | YES | NO | NO | NO |
Source S2I | NO | YES | NO | NO | NO |
1.2. Adding the Red Hat build of Quarkus OpenShift extension
To build and deploy your applications as a container image that runs inside your OpenShift Container Platform cluster, you must add the Red Hat build of Quarkus OpenShift extension quarkus-openshift
as a dependency to your project.
The Quarkus OpenShift extension also generates OpenShift Container Platform resources such as image streams, build configuration, deployment, and service definitions. If your Quarkus application includes the quarkus-smallrye-health
extension, OpenShift Container Platform can access the health endpoint and verify the startup, liveness, and readiness of your application.
From Red Hat build of Quarkus 3.8, the DeploymentConfig
object, deprecated in OpenShift, is also deprecated in Red Hat build of Quarkus. Deployment
is the default and preferred deployment kind for the Quarkus OpenShift extension.
If you redeploy applications that you deployed before by using DeploymentConfig
, by default, those applications use Deployment
but do not remove the previous DeploymentConfig
.
This leads to a deployment of both new and old applications, so, you must remove the old DeploymentConfig
manually. However, if you want to continue to use DeploymentConfig
, it is still possible to do so by explicitly setting quarkus.openshift.deployment-kind
to DeploymentConfig
.
Prerequisites
You have a Quarkus Maven project.
- For information about how to create a Quarkus project with Maven, see Developing and compiling your Red Hat build of Quarkus applications with Apache Maven.
Procedure
To add the
quarkus-openshift
extension to your project, use one of the following methods:Configure the
pom.xml
file:pom.xml
Copy to Clipboard Copied! Toggle word wrap Toggle overflow <dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-openshift</artifactId> </dependency>
<dependency> <groupId>io.quarkus</groupId> <artifactId>quarkus-openshift</artifactId> </dependency>
Enter the following command on the OpenShift Container Platform CLI:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow ./mvnw quarkus:add-extension -Dextensions="io.quarkus:quarkus-openshift"
./mvnw quarkus:add-extension -Dextensions="io.quarkus:quarkus-openshift"
Enter the following command on the Quarkus CLI:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus extension add 'quarkus-openshift'
quarkus extension add 'quarkus-openshift'
1.3. Switching to the required OpenShift Container Platform project
You can use the Red Hat OpenShift Container Platform command-line interface (CLI) to create applications and manage your OpenShift Container Platform projects. Use the information provided to create an OpenShift Container Platform project or to switch to an existing one.
Prerequisites
You have access to an OpenShift Container Platform cluster and the latest compatible version of the
oc
tool installed.-
For information about installing the
oc
tool, see CLI tools.
-
For information about installing the
Procedure
Log in to the
oc
tool:Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc login
oc login
To show the current project space, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc project -q
oc project -q
Use one of the following steps to go to the required OpenShift Container Platform project:
If the project already exists, switch to the project:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc project <project_name>
oc project <project_name>
If the project does not exist, create a new project:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc new-project <project_name>
oc new-project <project_name>
Additional resources
1.4. Deploying Red Hat build of Quarkus Java applications to OpenShift Container Platform
The Red Hat build of Quarkus OpenShift extension enables you to deploy your Quarkus application to OpenShift Container Platform by using the Docker build strategy. The container gets built inside the OpenShift Container Platform cluster and is provided as an image stream.
Your Quarkus project includes pregenerated Dockerfiles with instructions. When you want to use a custom Dockerfile, you must add the file in the src/main/docker
directory or anywhere inside the module. Additionally, you must set the path to your Dockerfile by using the quarkus.openshift.jvm-dockerfile
property.
Prerequisites
-
You have a Red Hat build of Quarkus Maven project that includes the
quarkus-openshift
extension. - You are working in the correct OpenShift project namespace, as outlined in Switching to the required OpenShift Container Platform project.
Procedure
Set the Docker build strategy in your
application.properties
configuration file:Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.build-strategy=docker
quarkus.openshift.build-strategy=docker
Optional: Set the following properties in the
application.properties
file, as required by your environment:If you are using an untrusted certificate, configure the
KubernetesClient
:Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.kubernetes-client.trust-certs=true
quarkus.kubernetes-client.trust-certs=true
Expose the service to create an OpenShift Container Platform route:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.route.expose=true
quarkus.openshift.route.expose=true
Set the path to your custom Dockerfile:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.jvm-dockerfile=<path_to_your_dockerfile>
quarkus.openshift.jvm-dockerfile=<path_to_your_dockerfile>
The following example shows the path to the
Dockerfile.custom-jvm
:Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.jvm-dockerfile=src/main/resources/Dockerfile.custom-jvm
quarkus.openshift.jvm-dockerfile=src/main/resources/Dockerfile.custom-jvm
Package and deploy your Quarkus application to the current OpenShift project:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow ./mvnw clean package -Dquarkus.openshift.deploy=true
./mvnw clean package -Dquarkus.openshift.deploy=true
Verification
The verification steps and related terminal outputs are demonstrated on the openshift-helloworld
example application.
Display the list of pods associated with your current OpenShift project:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc get pods
oc get pods
Copy to Clipboard Copied! Toggle word wrap Toggle overflow NAME READY STATUS RESTARTS AGE openshift-helloworld-1-build 0/1 Completed 0 11m openshift-helloworld-1-deploy 0/1 Completed 0 10m openshift-helloworld-1-gzzrx 1/1 Running 0 10m
NAME READY STATUS RESTARTS AGE openshift-helloworld-1-build 0/1 Completed 0 11m openshift-helloworld-1-deploy 0/1 Completed 0 10m openshift-helloworld-1-gzzrx 1/1 Running 0 10m
To retrieve the log output for your application’s pod, use the
oc logs -f
command with the<pod_name>
value of the pod you are interested in. In this example, we use theopenshift-helloworld-1-gzzrx
pod name that corresponds with the latest pod prefixed with the name of your application:Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc logs -f openshift-helloworld-1-gzzrx
oc logs -f openshift-helloworld-1-gzzrx
Copy to Clipboard Copied! Toggle word wrap Toggle overflow Starting the Java application using /opt/jboss/container/java/run/run-java.sh ... INFO exec -a "java" java -Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager -XX:MaxRAMPercentage=50.0 -XX:+UseParallelGC -XX:MinHeapFreeRatio=10 -XX:MaxHeapFreeRatio=20 -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90 -XX:+ExitOnOutOfMemoryError -cp "." -jar /deployments/quarkus-run.jar __ ____ __ _____ ___ __ ____ ______ --/ __ \/ / / / _ | / _ \/ //_/ / / / __/ -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \ --\___\_\____/_/ |_/_/|_/_/|_|\____/___/ 2024-06-27 17:13:25,254 INFO [io.quarkus] (main) getting-started 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.8.6.SP3-redhat-00002) started in 0.653s. Listening on: http://0.0.0.0:8080 2024-06-27 17:13:25,281 INFO [io.quarkus] (main) Profile prod activated. 2024-06-27 17:13:25,281 INFO [io.quarkus] (main) Installed features: [cdi, kubernetes, resteasy-reactive, smallrye-context-propagation, vertx]
Starting the Java application using /opt/jboss/container/java/run/run-java.sh ... INFO exec -a "java" java -Dquarkus.http.host=0.0.0.0 -Djava.util.logging.manager=org.jboss.logmanager.LogManager -XX:MaxRAMPercentage=50.0 -XX:+UseParallelGC -XX:MinHeapFreeRatio=10 -XX:MaxHeapFreeRatio=20 -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90 -XX:+ExitOnOutOfMemoryError -cp "." -jar /deployments/quarkus-run.jar __ ____ __ _____ ___ __ ____ ______ --/ __ \/ / / / _ | / _ \/ //_/ / / / __/ -/ /_/ / /_/ / __ |/ , _/ ,< / /_/ /\ \ --\___\_\____/_/ |_/_/|_/_/|_|\____/___/ 2024-06-27 17:13:25,254 INFO [io.quarkus] (main) getting-started 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.8.6.SP3-redhat-00002) started in 0.653s. Listening on: http://0.0.0.0:8080 2024-06-27 17:13:25,281 INFO [io.quarkus] (main) Profile prod activated. 2024-06-27 17:13:25,281 INFO [io.quarkus] (main) Installed features: [cdi, kubernetes, resteasy-reactive, smallrye-context-propagation, vertx]
Retrieve a list of services:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc get svc
oc get svc
Copy to Clipboard Copied! Toggle word wrap Toggle overflow NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE openshift-helloworld ClusterIP 172.30.64.57 <none> 80/TCP 14m
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE openshift-helloworld ClusterIP 172.30.64.57 <none> 80/TCP 14m
Get a URL to test your application.
NoteTo create an OpenShift Container Platform route, ensure you have specified
quarkus.openshift.route.expose=true
in theapplication.properties
file.Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc get routes
oc get routes
Copy to Clipboard Copied! Toggle word wrap Toggle overflow NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD openshift-helloworld openshift-helloworld-username-dev.apps.sandbox-m2.ll9k.p1.openshiftapps.com openshift-helloworld http None
NAME HOST/PORT PATH SERVICES PORT TERMINATION WILDCARD openshift-helloworld openshift-helloworld-username-dev.apps.sandbox-m2.ll9k.p1.openshiftapps.com openshift-helloworld http None
NoteBe aware that the route is now listening on port 80 and no longer at port 8080.
You can test the application demonstrated in this example with a web browser or a terminal by using
curl
and the complete URL output fromoc get routes
: http://openshift-helloworld-username-dev.apps.sandbox-m2.ll9k.p1.openshiftapps.com.For example:
curl http://openshift-helloworld-username-dev.apps.sandbox-m2.ll9k.p1.openshiftapps.com
.
1.5. Deploying Red Hat build of Quarkus applications compiled to native executables
You can deploy your native Red Hat build of Quarkus application to OpenShift Container Platform by using the Docker build strategy. You must create a native executable for your application that targets the Linux AMD64 operating system. If your host operating system is different from this, create a native Linux executable using a container runtime, for example, Docker or Podman.
Your Quarkus project includes pregenerated Dockerfiles with instructions. To use a custom Dockerfile, add the file in the src/main/docker
directory or anywhere inside the module, and set the path to your Dockerfile by using the quarkus.openshift.native-dockerfile
property.
Prerequisites
- You have a Linux AMD64 system or an Open Container Initiative (OCI) compatible container runtime, such as Podman or Docker.
-
You have a Quarkus Maven project that includes the
quarkus-openshift
extension. - You are working in the correct OpenShift project namespace, as outlined in Switching to the required OpenShift Container Platform project.
Procedure
Set the Docker build strategy in your
application.properties
configuration file:Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.build-strategy=docker
quarkus.openshift.build-strategy=docker
Set the container runtime:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.native.container-build=true
quarkus.native.container-build=true
Optional: Set the following properties in the
application.properties
file, as required by your environment:If you are using an untrusted certificate, configure the
KubernetesClient
property:Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.kubernetes-client.trust-certs=true
quarkus.kubernetes-client.trust-certs=true
Expose the service to create an OpenShift Container Platform route:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.route.expose=true
quarkus.openshift.route.expose=true
Set the path to your custom Dockerfile:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.native-dockerfile=<path_to_your_dockerfile>
quarkus.openshift.native-dockerfile=<path_to_your_dockerfile>
The following example shows the path to the
Dockerfile.custom-native
:Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.openshift.jvm-dockerfile=src/main/docker/Dockerfile.custom-native
quarkus.openshift.jvm-dockerfile=src/main/docker/Dockerfile.custom-native
Specify the container engine:
To build a native executable with Podman:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.native.container-runtime=podman
quarkus.native.container-runtime=podman
To build a native executable with Docker:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow quarkus.native.container-runtime=docker
quarkus.native.container-runtime=docker
Finally, build a native executable, package, and deploy your application to OpenShift Container Platform:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow ./mvnw clean package -Pnative -Dquarkus.openshift.deploy=true
./mvnw clean package -Pnative -Dquarkus.openshift.deploy=true
Verification
Verify that an image stream and a service resource is created and the Quarkus application is deployed by using the OpenShift web console. Alternatively, you can run the following OpenShift Container Platform command-line interface (CLI) commands:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc get is oc get pods oc get svc
oc get is
1 oc get pods
2 oc get svc
3
To retrieve the log output for your application’s pod, enter the following command where
<pod_name>
is the name of the latest pod prefixed with the name of your application:Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc logs -f <pod_name>
oc logs -f <pod_name>
Additional resources
1.6. Using S2I to deploy Red Hat build of Quarkus applications to OpenShift Container Platform
You can deploy your Red Hat build of Quarkus applications to OpenShift Container Platform by using the Source-to-Image (S2I) method. With S2I, you must provide the source code to the build container through a Git repository or by uploading the source at build time.
S2I is not supported for native deployments. For deploying Quarkus applications compiled to native executables, use the Docker build strategy.
The procedure for deploying your Quarkus applications to OpenShift Container Platform by using S2I differs depending on the Java version you are using.
1.6.1. Using S2I to deploy Red Hat build of Quarkus applications to OpenShift Container Platform with Java 17
You can deploy your Red Hat build of Quarkus applications running on Java 17 to OpenShift Container Platform by using the Source-to-Image (S2I) method.
Prerequisites
- You have a Quarkus application built with Java 17. For Java 17 applications, see Using S2I to deploy Red Hat build of Quarkus applications to OpenShift Container Platform with Java 17.
-
(Optional): You have a Quarkus Maven project that includes the
quarkus-openshift
extension. - You are working in the correct OpenShift project namespace, as outlined in Switching to the required OpenShift Container Platform project.
- Your Quarkus Maven project is hosted in a Git repository.
Procedure
Open the
pom.xml
file, and change the Java configuration to version 17, as follows:Copy to Clipboard Copied! Toggle word wrap Toggle overflow <maven.compiler.source>17</maven.compiler.source> <maven.compiler.target>17</maven.compiler.target>
<maven.compiler.source>17</maven.compiler.source> <maven.compiler.target>17</maven.compiler.target>
To package your Java 17 application, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow ./mvnw clean package
./mvnw clean package
-
Create a directory called
.s2i
at the same level as thepom.xml
file. Create a file called
environment
in the.s2i
directory and add the following content:Copy to Clipboard Copied! Toggle word wrap Toggle overflow MAVEN_S2I_ARTIFACT_DIRS=target/quarkus-app S2I_SOURCE_DEPLOYMENTS_FILTER=app lib quarkus quarkus-run.jar JAVA_OPTIONS=-Dquarkus.http.host=0.0.0.0 AB_JOLOKIA_OFF=true JAVA_APP_JAR=/deployments/quarkus-run.jar
MAVEN_S2I_ARTIFACT_DIRS=target/quarkus-app S2I_SOURCE_DEPLOYMENTS_FILTER=app lib quarkus quarkus-run.jar JAVA_OPTIONS=-Dquarkus.http.host=0.0.0.0 AB_JOLOKIA_OFF=true JAVA_APP_JAR=/deployments/quarkus-run.jar
- Commit and push your changes to the remote Git repository.
To import the supported OpenShift Container Platform image, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc import-image ubi8/openjdk-17 --from=registry.access.redhat.com/ubi8/openjdk-17 --confirm
oc import-image ubi8/openjdk-17 --from=registry.access.redhat.com/ubi8/openjdk-17 --confirm
Note- If you are using the OpenShift image registry and pulling from image streams in the same project, your pod service account should already have the correct permissions.
- If you are pulling images across other OpenShift Container Platform projects or from secured registries, additional configuration steps might be required.
For more information, see Using image pull secrets in Red Hat OpenShift Container Platform documentation.
To build the project, create the application, and deploy the OpenShift Container Platform service, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc new-app registry.access.redhat.com/ubi8/openjdk-17~<git_path> --name=<project_name>
oc new-app registry.access.redhat.com/ubi8/openjdk-17~<git_path> --name=<project_name>
Where:
<git_path> is the path to the Git repository that hosts your Quarkus project. For example,
oc new-app registry.access.redhat.com/ubi8/openjdk-17~https://github.com/johndoe/code-with-quarkus.git --name=code-with-quarkus
.If you do not have SSH keys configured for the Git repository, when specifying the Git path, use the HTTPS URL instead of the SSH URL.
- <project_name> is the name of your application.
To deploy an updated version of the project, push any updates to the Git repository then enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc start-build <project_name>
oc start-build <project_name>
To expose a route to the Quarkus application, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc expose svc <project_name>
oc expose svc <project_name>
Verification
To view a list of pods associated with your current OpenShift project, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc get pods
oc get pods
To retrieve the log output for your application’s pod, enter the following command where
<pod_name>
is the name of the latest pod prefixed with the name of your application:Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc logs -f <pod_name>
oc logs -f <pod_name>
Additional resources
1.6.2. Using S2I to deploy Red Hat build of Quarkus applications to OpenShift Container Platform with Java 21
You can deploy your Red Hat build of Quarkus applications running on Java 21 to OpenShift Container Platform by using the Source-to-Image (S2I) method.
Prerequisites
- You have a Quarkus application built with Java 21. For Java 21 applications, see Using S2I to deploy Red Hat build of Quarkus applications to OpenShift Container Platform with Java 21.
-
(Optional): You have a Quarkus Maven project that includes the
quarkus-openshift
extension. - You are working in the correct OpenShift Container Platform project namespace, as outlined in Switching to the required OpenShift Container Platform project.
- Your Quarkus Maven project is hosted in a Git repository.
Procedure
Open the
pom.xml
file, and change the Java configuration to version 21, as follows:Copy to Clipboard Copied! Toggle word wrap Toggle overflow <maven.compiler.source>21</maven.compiler.source> <maven.compiler.target>21</maven.compiler.target>
<maven.compiler.source>21</maven.compiler.source> <maven.compiler.target>21</maven.compiler.target>
To package your Java 21 application, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow ./mvnw clean package
./mvnw clean package
-
Create a directory called
.s2i
at the same level as thepom.xml
file. Create a file called
environment
in the.s2i
directory and add the following content:Copy to Clipboard Copied! Toggle word wrap Toggle overflow MAVEN_S2I_ARTIFACT_DIRS=target/quarkus-app S2I_SOURCE_DEPLOYMENTS_FILTER=app lib quarkus quarkus-run.jar JAVA_OPTIONS=-Dquarkus.http.host=0.0.0.0 AB_JOLOKIA_OFF=true JAVA_APP_JAR=/deployments/quarkus-run.jar
MAVEN_S2I_ARTIFACT_DIRS=target/quarkus-app S2I_SOURCE_DEPLOYMENTS_FILTER=app lib quarkus quarkus-run.jar JAVA_OPTIONS=-Dquarkus.http.host=0.0.0.0 AB_JOLOKIA_OFF=true JAVA_APP_JAR=/deployments/quarkus-run.jar
- Commit and push your changes to the remote Git repository.
To import the supported OpenShift Container Platform image, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc import-image ubi8/openjdk-21 --from=registry.access.redhat.com/ubi8/openjdk-21 --confirm
oc import-image ubi8/openjdk-21 --from=registry.access.redhat.com/ubi8/openjdk-21 --confirm
Note- If you are using the OpenShift image registry and pulling from image streams in the same project, your pod service account should already have the correct permissions.
If you are pulling images across other OpenShift Container Platform projects or from secured registries, additional configuration steps might be required.
For more information, see Using image pull secrets in Red Hat OpenShift Container Platform documentation.
-
If you are deploying on IBM Z infrastructure, enter
oc import-image ubi8/openjdk-21 --from=registry.redhat.io/ubi8/openjdk-21 --confirm
instead. For information about this image, see the Red Hat build of OpenJDK 21 page.
To build the project, create the application, and deploy the OpenShift Container Platform service, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc new-app registry.access.redhat.com/ubi8/openjdk-21~<git_path> --name=<project_name>
oc new-app registry.access.redhat.com/ubi8/openjdk-21~<git_path> --name=<project_name>
Where:
<git_path> is the path to the Git repository that hosts your Quarkus project. For example,
oc new-app registry.access.redhat.com/ubi8/openjdk-21~https://github.com/johndoe/code-with-quarkus.git --name=code-with-quarkus
.If you do not have SSH keys configured for the Git repository, when specifying the Git path, use the HTTPS URL instead of the SSH URL.
<project_name> is the name of your application.
NoteIf you are deploying on IBM Z infrastructure, enter
oc new-app ubi8/openjdk-21~<git_path> --name=<project_name>
instead.
To deploy an updated version of the project, push any updates to the Git repository then enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc start-build <project_name>
oc start-build <project_name>
To expose a route to the Quarkus application, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc expose svc <project_name>
oc expose svc <project_name>
Verification
To view a list of pods, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc get pods
oc get pods
To retrieve the log output for your application’s pod, enter the following command:
Copy to Clipboard Copied! Toggle word wrap Toggle overflow oc logs -f <pod_name>
oc logs -f <pod_name>
Additional resources
1.7. Red Hat build of Quarkus configuration properties for customizing deployments on OpenShift Container Platform
You can customize your deployments on OpenShift Container Platform by defining optional configuration properties. You can configure your Red Hat build of Quarkus project in your applications.properties
file or from the command line.
Property | Description | Default |
---|---|---|
|
The container image group. Must be set if the OpenShift Container Platform |
|
| The container registry to use. | |
| Kubernetes client certificate authentication. | |
|
Deployment target platform. For example, | |
| Builds a native Linux executable by using a container runtime. Docker is used by default. |
|
| The container runtime used to build the image, for example, Docker. | |
| The deployment strategy. |
|
| Exposes a route for the Quarkus application. |
|
|
Enables debugging and generates debug symbols in a separate |
|
1.8. Additional resources
Revised on 2025-02-28 13:38:59 UTC