Red Hat Summit Red Hat Summit지원콘솔개발자평가판 시작연락처

이 콘텐츠는 선택한 언어로 제공되지 않습니다.

Chapter 1. Deploying your 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 learn the recommended workflows to deploy your Quarkus applications to production environments. To learn about other ways to deploy Quarkus applications, see the Quarkus community documentation.

Prerequisites

  • You have OpenJDK 11 or 17 installed.
  • You have set the JAVA_HOME environment variable to the location of the Java SDK.
  • You have Apache Maven 3.8.x, where x is 6 or later installed.

  • You have a Quarkus Maven project that includes the quarkus-openshift extension.

  • You have access to an OpenShift Container Platform cluster and the latest compatible version of the oc tool installed.

1.1. OpenShift Container Platform build strategies and 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.
Note

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 building and deploying your application.

1.1.2. Build strategies supported by Quarkus
링크 복사

The following table outlines the build strategies that Red Hat build of Quarkus 2.13 supports:

Expand
Build strategySupport for Quarkus toolsSupport for JVMSupport for nativeSupport for JVM ServerlessSupport 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 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 configuration, and service definitions. If your Quarkus application includes the quarkus-smallrye-health extension, OpenShift Container Platform can access the health endpoint and verify the liveness and readiness of your application.

Prerequisites

Procedure

  1. Log in to OpenShift by using the oc tool, then change to the directory that has your Quarkus Maven project.

  2. To add the quarkus-openshift extension to your project, use one of the following methods:

    • Configure the pom.xml file:

      pom.xml

      <dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-openshift</artifactId>
</dependency>
      Copy to Clipboard Toggle word wrap

    • Enter the following command on the OpenShift Container Platform CLI: 

      ./mvnw quarkus:add-extension -Dextensions="io.quarkus:quarkus-openshift"
      Copy to Clipboard Toggle word wrap

    • Enter the following command on the Quarkus CLI: 

      quarkus extension add 'quarkus-openshift'
      Copy to Clipboard Toggle word wrap

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

Procedure

  1. Log in to the oc tool: 

    oc login
    Copy to Clipboard Toggle word wrap

  2. To, show the current project space, enter the following command: 

    oc project -q
    Copy to Clipboard Toggle word wrap

  3. Use one of the following steps to go to the required OpenShift Container Platform project:

    1. If the project already exists, switch to the project: 

      oc project <project_name>
      Copy to Clipboard Toggle word wrap

    2. If the project does not exist, create a new project: 

      oc new-project <project_name>
      Copy to Clipboard Toggle word wrap

1.4. Deploying 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 need to set the path to your Dockerfile by using the quarkus.openshift.jvm-dockerfile property.

Prerequisites

Procedure

  1. Log in to OpenShift Container Platform by using the oc tool, then change to the directory that has your Quarkus Maven project.

  2. Set the Docker build strategy in your application.properties configuration file: 

    quarkus.openshift.build-strategy=docker
    Copy to Clipboard Toggle word wrap

  3. (Optional) Set the following properties in the application.properties file, as required by your environment:

    1. If you are using an untrusted certificate, configure the KubernetesClient: 

      quarkus.kubernetes-client.trust-certs=true
      Copy to Clipboard Toggle word wrap

    2. Expose the service to create an OpenShift Container Platform route: 

      quarkus.openshift.route.expose=true
      Copy to Clipboard Toggle word wrap

    3. Set the path to your custom Dockerfile: 

      quarkus.openshift.jvm-dockerfile=<path_to_your_dockerfile>
      Copy to Clipboard Toggle word wrap

      The following example shows the path to the Dockerfile.custom-jvm: 

      quarkus.openshift.jvm-dockerfile=src/main/resources/Dockerfile.custom-jvm
      Copy to Clipboard Toggle word wrap

  4. Package and deploy your Quarkus application to the current OpenShift project: 

    ./mvnw clean package -Dquarkus.kubernetes.deploy=true
    Copy to Clipboard Toggle word wrap

Verification

The verification steps and related terminal outputs are demonstrated on the openshift-helloworld example application.

  1. Display the list of pods associated with your current OpenShift project: 

    oc get pods
    Copy to Clipboard Toggle word wrap 
    NAME                            READY   STATUS      RESTARTS   AGE
getting-started-1-build         0/1     Completed   0          96m
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
    Copy to Clipboard Toggle word wrap

  2. 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 the openshift-helloworld-1-gzzrx pod name that corresponds with the latest pod prefixed with the name of your application: 

    oc logs -f openshift-helloworld-1-gzzrx
    Copy to Clipboard Toggle word wrap 
    Starting the Java application using /opt/jboss/container/java/run/run-java.sh ...
INFO exec  java -Xms125m -Xmx500m -XX:+UseParallelGC -XX:MinHeapFreeRatio=10 -XX:MaxHeapFreeRatio=20 -XX:GCTimeRatio=4 -XX:AdaptiveSizePolicyWeight=90 -XX:+ExitOnOutOfMemoryError -cp "." -jar /deployments/quarkus-run.jar

2023-02-10 11:58:49,077 INFO  [io.quarkus] (main) openshift-helloworld 1.0.0-SNAPSHOT on JVM (powered by Quarkus 2.13.9.Final) started in 1.399s. Listening on: http://0.0.0.0:8080
2023-02-10 11:58:49,168 INFO  [io.quarkus] (main) Profile prod activated.
2023-02-10 11:58:49,168 INFO  [io.quarkus] (main) Installed features: [cdi, kubernetes, resteasy-reactive, smallrye-context-propagation, vertx]
    Copy to Clipboard Toggle word wrap

  3. Retrieve a list of services: 

    oc get svc
    Copy to Clipboard Toggle word wrap 
    NAME                   TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)                               AGE
getting-started        ClusterIP   172.30.178.154   <none>        80/TCP                                98m
modelmesh-serving      ClusterIP   None             <none>        8033/TCP,8008/TCP,8443/TCP,2112/TCP   25h
openshift-helloworld   ClusterIP   172.30.64.57     <none>        80/TCP                                14m
    Copy to Clipboard Toggle word wrap

  4. Get a URL to test your application: 

    oc get routes
    Copy to Clipboard Toggle word wrap 
    NAME                   HOST/PORT                                                                   PATH   SERVICES               PORT   TERMINATION   WILDCARD
openshift-helloworld   openshift-helloworld-mmaler-dev.apps.sandbox-m2.ll9k.p1.openshiftapps.com          openshift-helloworld   http                 None
    Copy to Clipboard Toggle word wrap
    Note

    Be aware that the route is now listening on port 80 and no longer at port 8080.

    The application demonstrated in this example can be tested with a web browser or a terminal by using curl and the complete URL output from oc get routes:

    • http://openshift-helloworld-mmaler-dev.apps.sandbox-m2.ll9k.p1.openshiftapps.com
    • curl http://openshift-helloworld-mmaler-dev.apps.sandbox-m2.ll9k.p1.openshiftapps.com

1.5. Deploying 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 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

  1. Log in to OpenShift Container Platform by using the oc tool, and change to the directory that has your Quarkus Maven project.

  2. Configure the following properties in your application.properties file:

    1. Set the Docker build strategy: 

      quarkus.openshift.build-strategy=docker
      Copy to Clipboard Toggle word wrap

    2. Set the container runtime: 

      quarkus.native.container-build=true
      Copy to Clipboard Toggle word wrap

    3. Optional: If you are using an untrusted certificate, configure the KubernetesClient property: 

      quarkus.kubernetes-client.trust-certs=true
      Copy to Clipboard Toggle word wrap

    4. Optional: Expose the service to create an OpenShift Container Platform route: 

      quarkus.openshift.route.expose=true
      Copy to Clipboard Toggle word wrap

    5. Optional: Set the path to your custom Dockerfile: 

      quarkus.openshift.native-dockerfile=<path_to_your_dockerfile>
      Copy to Clipboard Toggle word wrap

      The following example shows the path to the Dockerfile.custom-native: 

      quarkus.openshift.jvm-dockerfile=src/main/docker/Dockerfile.custom-native
      Copy to Clipboard Toggle word wrap

    6. (Optional) Specify the container engine:

      • To build a native executable with Podman: 

        quarkus.native.container-runtime=podman
        Copy to Clipboard Toggle word wrap

      • To build a native executable with Docker: 

        quarkus.native.container-runtime=docker
        Copy to Clipboard Toggle word wrap

  3. Build a native executable, package, and deploy your application to OpenShift Container Platform: 

    ./mvnw clean package -Pnative -Dquarkus.kubernetes.deploy=true
    Copy to Clipboard Toggle word wrap

Verification

  1. To view a list of pods associated with your current OpenShift project, enter the following command: 

    oc get pods
    Copy to Clipboard Toggle word wrap

  2. 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: 

    oc logs -f <pod_name>
    Copy to Clipboard Toggle word wrap

1.6. Deploying Quarkus applications as an OpenShift Serverless service
링크 복사

You can deploy your Quarkus applications to OpenShift Serverless by using the Docker build strategy. With the Knative Serving feature of OpenShift Serverless, you can scale services up and down depending on the load size. Scaling down services that are currently not requested improves memory capabilities.

Your Quarkus project includes pregenerated Dockerfiles with instructions. When you want to use a custom Dockerfile, you need to add the file in the src/main/docker directory or anywhere inside the module. Additionally, you need to set the path to your Dockerfile by using the quarkus.openshift.jvm-dockerfile property for JVM mode and quarkus.openshift.native-dockerfile property for native mode.

To deploy a Serverless Quarkus Java application or a Serverless application compiled to a native executable by using the Quarkus OpenShift extension, complete the following procedure:

Prerequisites

  • 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.
  • You have installed OpenShift Serverless Operator.
  • You have installed and verified OpenShift Knative Serving. For more information, see Installing Knative Serving.
  • For native compilation, you have a Linux AMD64 operating system or an Open Container Initiative (OCI) compatible container runtime, for example, Podman or Docker.

Procedure

  1. Log in to OpenShift Container Platform by using the oc tool, and change to the directory that has your Quarkus Maven project.

  2. Configure the following properties in your application.properties file:

    1. Set Knative as a deployment target: 

      quarkus.kubernetes.deployment-target=knative
      Copy to Clipboard Toggle word wrap

    2. Set the Docker build strategy: 

      quarkus.openshift.build-strategy=docker
      Copy to Clipboard Toggle word wrap

    3. Direct OpenShift Serverless to pull your container image from the OpenShift internal registry: 

      quarkus.container-image.registry=image-registry.openshift-image-registry.svc:5000
      Copy to Clipboard Toggle word wrap
      Note

      If your OpenShift Container Platform <project_name> is different from the username of the host system, set the group for the container image otherwise Quarkus cannot pull the image from the image registry. 

      quarkus.container-image.group=<project_name>
      Copy to Clipboard Toggle word wrap

    4. (Optional) If you are using an untrusted certificate, configure the KubernetesClient: 

      quarkus.kubernetes-client.trust-certs=true
      Copy to Clipboard Toggle word wrap

    5. (Optional) Expose the service to create an OpenShift Container Platform route: 

      quarkus.openshift.route.expose=true
      Copy to Clipboard Toggle word wrap

    6. (Optional) Set the path to your custom Dockerfile: 

      quarkus.openshift.jvm-dockerfile=<path_to_your_dockerfile>
      Copy to Clipboard Toggle word wrap

      The following example shows the path to the Dockerfile.custom-jvm: 

      quarkus.openshift.jvm-dockerfile=src/main/resources/Dockerfile.custom-jvm
      Copy to Clipboard Toggle word wrap

  3. Optional: To deploy a Serverless application compiled to a native executable, configure the following properties:

    1. Set the container runtime: 

      quarkus.native.container-build=true
      Copy to Clipboard Toggle word wrap

    2. Specify the container engine:

      • To build a native executable with Podman: 

        quarkus.native.container-runtime=podman
        Copy to Clipboard Toggle word wrap

      • To build a native executable with Docker: 

        quarkus.native.container-runtime=docker
        Copy to Clipboard Toggle word wrap

    3. (Optional) Set the path to your custom Dockerfile: 

      quarkus.openshift.native-dockerfile=<path_to_your_dockerfile>
      Copy to Clipboard Toggle word wrap

  4. Package and deploy your Serverless application to OpenShift Container Platform using one of the following options:

    1. Deploy a Quarkus Java application: 

      ./mvnw clean package -Dquarkus.kubernetes.deploy=true
      Copy to Clipboard Toggle word wrap

    2. Deploy a Quarkus native application: 

      ./mvnw clean package -Pnative -Dquarkus.kubernetes.deploy=true
      Copy to Clipboard Toggle word wrap

Verification

  1. To view a list of pods associated with your current OpenShift project: 

    oc get pods
    Copy to Clipboard Toggle word wrap

  2. 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: 

    oc logs -f <pod_name>
    Copy to Clipboard Toggle word wrap

1.7. Using S2I to deploy Quarkus applications to OpenShift Container Platform
링크 복사

You can deploy your Red Hat build of Quarkus applications to OpenShift Container Platform 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.

Important

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.

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

Procedure

  1. Open the pom.xml file, and change the Java configuration to version 17, as follows: 

    <maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
    Copy to Clipboard Toggle word wrap
  2. Log in to OpenShift Container Platform by using the oc tool, then change to the directory that contains your Quarkus Maven project.

  3. To package your Java 17 application, enter the following command: 

    ./mvnw clean package
    Copy to Clipboard Toggle word wrap
  4. Create a directory called .s2i at the same level as the pom.xml file.

  5. Create a file called environment in the .s2i directory and add the following content: 

    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
    Copy to Clipboard Toggle word wrap
  6. Commit and push your changes to the remote Git repository.

  7. To import the supported OpenShift Container Platform image, enter the following command: 

    oc import-image --confirm ubi8/openjdk-17 --from=registry.access.redhat.com/ubi8/openjdk-17
    Copy to Clipboard Toggle word wrap

  8. To build the project on OpenShift Container Platform, enter the following command: 

    oc new-app ubi8/openjdk-17 <git_path> --name=<project_name>
    Copy to Clipboard Toggle word wrap

    Where:

    • <git_path> is the path to the Git repository that hosts your Quarkus project
    • <project_name> is the OpenShift project that you created.

  9. To begin the deployment to OpenShift Container Platform, enter the following command: 

    oc start-build <project_name>
    Copy to Clipboard Toggle word wrap

Verification

  1. To view a list of pods associated with your current OpenShift project: 

    oc get pods
    Copy to Clipboard Toggle word wrap

  2. 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: 

    oc logs -f <pod_name>
    Copy to Clipboard Toggle word wrap

You can deploy your Red Hat build of Quarkus applications running on Java 11 to OpenShift Container Platform by using the Source-to-Image (S2I) method.

Prerequisites

Procedure

  1. Log in to OpenShift Container Platform by using the oc tool, then change to the directory that contains your Quarkus Maven project.

  2. To package your Java 11 application, enter the following command: 

    ./mvnw clean package
    Copy to Clipboard Toggle word wrap
  3. Create a directory called .s2i at the same level as the pom.xml file.

  4. Create a file called environment in the .s2i directory and add the following content: 

    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
    Copy to Clipboard Toggle word wrap
  5. Commit and push your changes to the remote Git repository.

  6. To import the supported OpenShift Container Platform image, enter the following command: 

    oc import-image --confirm ubi8/openjdk-11 --from=ubi8/openjdk-11
    Copy to Clipboard Toggle word wrap
    Note

    If you are deploying on IBM Z infrastructure, enter oc import-image --confirm ubi8/openjdk-11 --from=registry.redhat.io/ubi8/openjdk-11 instead. For information about this image, see the Red Hat OpenJDK 11 page.

  7. To build the project, create the application, and deploy the OpenShift Container Platform service, enter the following command: 

    oc new-app ubi8/openjdk-11 <git_path> --name=<project_name>
    Copy to Clipboard Toggle word wrap
    Note

    If you are deploying on IBM Z infrastructure, enter oc new-app ubi8/openjdk-11 <git_path> --name=<project_name> instead.

  8. To deploy an updated version of the project, push any updates to the Git repository then enter the following command: 

    oc start-build <project_name>
    Copy to Clipboard Toggle word wrap

Verification

  1. To view a list of pods, enter the following command: 

    oc get pods
    Copy to Clipboard Toggle word wrap

  2. To retrieve the log output for your application’s pod, enter the following command: 

    oc logs -f <pod_name>
    Copy to Clipboard Toggle word wrap

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.

Expand
Table 1.1. Quarkus configuration properties and their default values:
PropertyDescriptionDefault

quarkus.container-image.group

The container image group. Must be set if the OpenShift Container Platform <project_name> is different from the username of the host system.

${user.name}

quarkus.container-image.registry

The container registry to use.

 

quarkus.kubernetes-client.trust-certs

Kubernetes client certificate authentication.

 

quarkus.kubernetes.deployment-target

Deployment target platform. For example, openshift or knative.

 

quarkus.native.container-build

Builds a native Linux executable by using a container runtime. Docker is used by default.

false

quarkus.native.container-runtime

The container runtime used to build the image, for example, Docker.

 

quarkus.openshift.build-strategy

The deployment strategy.

s2i

quarkus.openshift.route.expose

Exposes a route for the Quarkus application.

false

quarkus.native.debug.enabled

Enables debugging and generates debug symbols in a separate .debug file. When this property is used with quarkus.native.container-build=true, Red Hat build of Quarkus only supports Red Hat Enterprise Linux or other Linux distributions. The Red Hat Enterprise Linux and other Linux distributions contain the binutils package, which installs the objcopy utility to split the debug information from the native image.

false

맨 위로 이동
Red Hat logoGithubredditYoutubeTwitter

자세한 정보

평가판, 구매 및 판매

커뮤니티

Red Hat 문서 정보

Red Hat을 사용하는 고객은 신뢰할 수 있는 콘텐츠가 포함된 제품과 서비스를 통해 혁신하고 목표를 달성할 수 있습니다. 최신 업데이트를 확인하세요.

보다 포괄적 수용을 위한 오픈 소스 용어 교체

Red Hat은 코드, 문서, 웹 속성에서 문제가 있는 언어를 교체하기 위해 최선을 다하고 있습니다. 자세한 내용은 다음을 참조하세요.Red Hat 블로그.

Red Hat 소개

Red Hat은 기업이 핵심 데이터 센터에서 네트워크 에지에 이르기까지 플랫폼과 환경 전반에서 더 쉽게 작업할 수 있도록 강화된 솔루션을 제공합니다.

Theme

© 2026 Red Hat