Red Hat Summit Red Hat SummitSupportConsoleDevelopersStart a trialContact

Deploying your Red Hat build of Quarkus applications to OpenShift Container Platform

Red Hat build of Quarkus 3.20

Red Hat Customer Content Services

Abstract

This guide describes how to deploy Red Hat build of Quarkus applications to OpenShift Container Platform.

Providing feedback on Red Hat build of Quarkus documentation

To report an error or to improve our documentation, log in to your Red Hat Jira account and submit an issue. If you do not have a Red Hat Jira account, then you will be prompted to create an account.

Procedure

  1. Click the following link to create a ticket.
  2. Enter a brief description of the issue in the Summary.
  3. Provide a detailed description of the issue or enhancement in the Description. Include a URL to where the issue occurs in the documentation.
  4. Clicking Submit creates and routes the issue to the appropriate documentation team.

Chapter 1. Deploying Red Hat build of Quarkus applications to OpenShift Container Platform

Red Hat OpenShift Container Platform is a Kubernetes-based platform for developing and running containerized applications. Quarkus offers the ability to automatically generate OpenShift Container Platform resources based on sane defaults and user-supplied configuration.

As an application developer, you can deploy your Red Hat build of Quarkus applications to Red Hat OpenShift Container Platform. This functionality is provided by the quarkus-openshift extension, which supports multiple deployment options:

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

1.1.1. Build strategies supported by Quarkus

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

Build strategySupport for Red Hat build of 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. Bootstrapping the project

First, you need a new project that contains the OpenShift extension. Then, before you build and deploy our application, you must log into an OpenShift cluster.

1.2.1. Adding the 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.

This extension also generates OpenShift Container Platform resources such as image streams, build configuration, deployment, and service definitions. If your 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.

Important

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.

Procedure

  1. 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

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

      ./mvnw quarkus:add-extension -Dextensions="io.quarkus:quarkus-openshift"
      Copy to clipboard

    • Enter the following command on the Quarkus CLI: 

      quarkus extension add 'quarkus-openshift'
      Copy to clipboard

1.3. Logging in to an OpenShift Container Platform cluster

You can log in to an OpenShift Container Platform cluster by using the OpenShift CLI (oc). For more information, see Getting started with the OpenShift CLI:

Example: Log in by using the OpenShift CLI

oc login -u myUsername 1
Copy to clipboard

1
You are prompted for the required information such as server URL, password, and so on.

Alternatively, you can log in by using the API token:

Example: Log in by using the OpenShift CLI with API token

oc login --token=myToken --server=myServerUrl
Copy to clipboard

Tip

You can request the token by using the Copy Login Command link in the OpenShift web console.

Finally, you do not need to use the OpenShift CLI at all. Instead, set the quarkus.kubernetes-client.api-server-url config property and authenticate with the quarkus.kubernetes-client.token, or quarkus.kubernetes-client.username and quarkus.kubernetes-client.password respectively:

  • Using the Quarkus CLI: 

    quarkus build quarkus deploy openshift
    Copy to clipboard

  • Using Maven: 

    ./mvnw install -Dquarkus.kubernetes-client.api-server-url=myServerUrl -Dquarkus.kubernetes-client.token=myToken
    Copy to clipboard

  • Using Gradle: 

    ./gradlew build -Dquarkus.kubernetes-client.api-server-url=myServerUrl -Dquarkus.kubernetes-client.token=myToken
    Copy to clipboard

1.3.1. Switching to the required OpenShift Container Platform project

You can use the Red Hat OpenShift Container Platform 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.

Procedure

  1. Log in to the oc tool: 

    oc login
    Copy to clipboard

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

    oc project -q
    Copy to clipboard

  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

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

      oc new-project <project_name>
      Copy to clipboard

1.4. Building and deploying

You can build and deploy by using any of the following deployment options:

1.4.1. Non-S2I builds

The OpenShift extension is configured to use container-image-s2i. However, it is still possible to use other container image extensions, such as:

When a non-s2i container image extension is used, an ImageStream is created that is pointing to an external dockerImageRepository. The image is built and pushed to the registry and the ImageStream populates the tags that are available in the dockerImageRepository.

To select which extension will be used for building the image: 

quarkus.container-image.builder=docker
Copy to clipboard

or 

quarkus.container-image.builder=jib
Copy to clipboard

1.5. Customizing

All available customization options are available in the OpenShift configuration options.

Some examples are provided in the sections below:

1.5.1. Exposing routes

To expose a Route for the Quarkus application: 

quarkus.openshift.route.expose=true
Copy to clipboard
Tip

You do not need to add this property in the application.properties file. Instead, you can pass it as a command-line argument: 

./mvnw clean package -Dquarkus.openshift.route.expose=true
Copy to clipboard

The same applies to all properties listed below.

1.5.1.1. Securing the Route resource

To secure the incoming connections, OpenShift provides several types of TLS termination to serve certifications.

For more information about how to secure routes, see OpenShift Container Platform documentation.

The following example shows how to configure a secured Route by using passthrough termination by adding the "quarkus.openshift.route.tls" properties: 

quarkus.openshift.route.expose=true
quarkus.openshift.route.target-port=https
## Route TLS configuration:
quarkus.openshift.route.tls.termination=passthrough
quarkus.openshift.route.tls.insecure-edge-termination-policy=None
Copy to clipboard

1.5.2. Labels

To add a label in the generated resources: 

quarkus.openshift.labels.foo=bar
Copy to clipboard

1.5.3. Annotations

To add an annotation in the generated resources: 

quarkus.openshift.annotations.foo=bar
Copy to clipboard

1.5.4. Environment variables

OpenShift Container Platform provides multiple ways of defining environment variables:

  • Key/value pairs
  • Import all values from a Secret or ConfigMap
  • Interpolate a single value identified by a given field in a Secret or ConfigMap
  • Interpolate a value from a field within the same resource
1.5.4.1. Environment variables from key/value pairs

To add a key/value pair as an environment variable in the generated resources: 

quarkus.openshift.env.vars.my-env-var=foobar
Copy to clipboard

The above command adds MY_ENV_VAR=foobar as an environment variable. The key my-env-var will convert to uppercase and dashes will be replaced by underscores resulting in MY_ENV_VAR.

1.5.4.2. Environment variables from Secret

To add all key/value pairs of Secret as environment variables, apply the following configuration, separating each Secret to be used as source by a comma (,): 

quarkus.openshift.env.secrets=my-secret,my-other-secret
Copy to clipboard

which generates the following in the container definition: 

envFrom:
  - secretRef:
      name: my-secret
      optional: false
  - secretRef:
      name: my-other-secret
      optional: false
Copy to clipboard

The following code extracts a value identified by the keyName field from the my-secret Secret into a foo environment variable: 

quarkus.openshift.env.mapping.foo.from-secret=my-secret
quarkus.openshift.env.mapping.foo.with-key=keyName
Copy to clipboard

which generates the following in the env section of your container: 

- env:
  - name: FOO
    valueFrom:
      secretKeyRef:
        key: keyName
        name: my-secret
        optional: false
Copy to clipboard
1.5.4.3. Environment variables from ConfigMap

To add all key/value pairs from ConfigMap as environment variables, apply the following configuration, separating each ConfigMap to be used as source by a comma (,): 

quarkus.openshift.env.configmaps=my-config-map,another-config-map
Copy to clipboard

which generates the following in the container definition: 

envFrom:
  - configMapRef:
      name: my-config-map
      optional: false
  - configMapRef:
      name: another-config-map
      optional: false
Copy to clipboard

The following extracts a value identified by the keyName field from the my-config-map ConfigMap into a foo environment variable: 

quarkus.openshift.env.mapping.foo.from-configmap=my-configmap
quarkus.openshift.env.mapping.foo.with-key=keyName
Copy to clipboard

which generates the following in the env section of your container: 

- env:
  - name: FOO
    valueFrom:
      configMapKeyRef:
        key: keyName
        name: my-configmap
        optional: false
Copy to clipboard
1.5.4.4. Environment variables from fields

You can also use the value from another field to add a new environment variable by specifying the path of the field to be used as a source. For example: 

quarkus.openshift.env.fields.foo=metadata.name
Copy to clipboard
1.5.4.5. Changing the generated deployment resource

Beside generating a Deployment resource, you can also choose to get either a DeploymentConfig, StatefulSet, Job, or a CronJob resource instead by using application.properties: 

quarkus.openshift.deployment-kind=StatefulSet
Copy to clipboard
1.5.4.5.1. Generating Job resources

If you want to generate a Job resource, you need to add the following property by using the application.properties: 

quarkus.openshift.deployment-kind=Job
Copy to clipboard
Important

If you are using the Picocli extension, by default the Job resource will be generated.

You can provide the arguments that Kubernetes Job uses through the quarkus.openshift.arguments property. For example, adding the property quarkus.openshift.arguments=A,B.

Finally, the Kubernetes job will be launched every time that it is installed in OpenShift. For more information about how to run Kubernetes jobs, see Running an example job.

You can configure the rest of the Kubernetes Job configuration by using the properties under quarkus.openshift.job.xxx. For more information, see quarkus.openshift.job.parallelism.

1.5.4.5.2. Generating CronJob resources

If you want to generate a CronJob resource, you need to add the following property by using the application.properties file: 

quarkus.openshift.deployment-kind=CronJob
# Cron expression to run the job every hour
quarkus.openshift.cron-job.schedule=0 * * * *
Copy to clipboard
Important

CronJob resources require the Cron expression to specify when to launch the job through the quarkus.openshift.cron-job.schedule property. If thet are not provided, the build fails.

You can configure the rest of the Kubernetes CronJob configuration by using the properties under quarkus.openshift.cron-job.xxx (for more information, see quarkus.openshift.cron-job.parallelism).

1.5.4.6. Validation

A conflict between two definitions, for example, mistakenly assigning both a value and specifying that a variable is derived from a field, results in an error being thrown at build time. You can fix the issue before you deploy your application to your cluster, where it might be more difficult to diagnose the source of the issue.

Similarly, two redundant definitions, for example, defining an injection from the same secret twice, does not cause an issue but reports a warning to inform you that you might not have intended to duplicate that definition.

1.5.4.6.1. Backwards compatibility

Previous versions of the OpenShift extension supported a different syntax to add environment variables. The older syntax is still supported but is deprecated, and it is advised that you migrate to the new syntax.

Table 1.1. Old syntax versus new syntax
 

Old

New

 

Plain variable

quarkus.openshift.env-vars.my-env-var.value=foobar

quarkus.openshift.env.vars.my-env-var=foobar

 

From field

quarkus.openshift.env-vars.my-env-var.field=foobar

quarkus.openshift.env.fields.my-env-var=foobar

 

All from ConfigMap

quarkus.openshift.env-vars.xxx.configmap=foobar

quarkus.openshift.env.configmaps=foobar

 

All from Secret

quarkus.openshift.env-vars.xxx.secret=foobar

quarkus.openshift.env.secrets=foobar

 

From one Secret field

quarkus.openshift.env-vars.foo.secret=foobar

quarkus.openshift.env.mapping.foo.from-secret=foobar

 
 

quarkus.openshift.env-vars.foo.value=field

quarkus.openshift.env.mapping.foo.with-key=field

 

From one ConfigMap field

quarkus.openshift.env-vars.foo.configmap=foobar

quarkus.openshift.env.mapping.foo.from-configmap=foobar

 
 

quarkus.openshift.env-vars.foo.value=field

quarkus.openshift.env.mapping.foo.with-key=field

 
Note
If you redefine the same variable by using the new syntax while keeping the old syntax, only the new version is kept, and a warning will be issued to alert you of the problem.
For example, if you define both `quarkus.openshift.env-vars.my-env-var.value=foobar` and `quarkus.openshift.env.vars.my-env-var=newValue`, the extension generates an environment variable `MY_ENV_VAR=newValue` and issues a warning.
Copy to clipboard

1.5.5. Mounting volumes

The OpenShift extension allows you to configure both volumes and mounts for the application. You can mount any volume with a simple configuration: 

quarkus.openshift.mounts.my-volume.path=/where/to/mount
Copy to clipboard

This will add a mount to my pod for volume my-volume to path /where/to/mount. You can configure the volumes themselves as shown in the sections below:

1.5.5.1. Secret volumes
quarkus.openshift.secret-volumes.my-volume.secret-name=my-secret
Copy to clipboard
1.5.5.2. ConfigMap volumes
quarkus.openshift.config-map-volumes.my-volume.config-map-name=my-config-map
Copy to clipboard
1.5.5.3. Persistent volume claims
quarkus.openshift.pvc-volumes.my-pvc.claim-name=my-pvc
Copy to clipboard

1.6. Configuration Reference

lock Configuration property fixed at build time - All other configuration properties are overridable at runtime

Configuration property

Type

Default

lock quarkus.openshift.env.secrets

The optional list of Secret names to load environment variables from.

Environment variable: QUARKUS_OPENSHIFT_ENV_SECRETS

list of string

 

lock quarkus.openshift.env.configmaps

The optional list of ConfigMap names to load environment variables from.

Environment variable: QUARKUS_OPENSHIFT_ENV_CONFIGMAPS

list of string

 

lock quarkus.openshift.env.fields."environment-variable-name"

The map associating environment variable names to their associated field references they take their value from.

Environment variable: QUARKUS_OPENSHIFT_ENV_FIELDS__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

 

lock quarkus.openshift.env.vars."vars"

The environment variable value

Environment variable: QUARKUS_OPENSHIFT_ENV_VARS__VARS_

string

 

lock quarkus.openshift.env.mapping."mapping".from-secret

The optional name of the Secret from which a value is to be extracted. Mutually exclusive with from-configmap.

Environment variable: QUARKUS_OPENSHIFT_ENV_MAPPING__MAPPING__FROM_SECRET

string

 

lock quarkus.openshift.env.mapping."mapping".from-configmap

The optional name of the ConfigMap from which a value is to be extracted. Mutually exclusive with from-secret.

Environment variable: QUARKUS_OPENSHIFT_ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

 

lock quarkus.openshift.env.mapping."mapping".with-key

The key identifying the field from which the value is extracted.

Environment variable: QUARKUS_OPENSHIFT_ENV_MAPPING__MAPPING__WITH_KEY

string

required exclamation circle

lock quarkus.openshift.env.using-prefix."prefixes".for-secret

The optional prefix to use when adding the environment variable to the container.

Environment variable: QUARKUS_OPENSHIFT_ENV_USING_PREFIX__PREFIXES__FOR_SECRET

string

 

lock quarkus.openshift.env.using-prefix."prefixes".for-configmap

The optional prefix to use when adding the environment variable to the container.

Environment variable: QUARKUS_OPENSHIFT_ENV_USING_PREFIX__PREFIXES__FOR_CONFIGMAP

string

 

lock quarkus.openshift.part-of

The name of the group this component belongs too.

Environment variable: QUARKUS_OPENSHIFT_PART_OF

string

 

lock quarkus.openshift.name

The name of the application. This value will be used for naming Kubernetes resources like: - Deployment - Service and so on …​

Environment variable: QUARKUS_OPENSHIFT_NAME

string

 

lock quarkus.openshift.version

The version of the application.

Environment variable: QUARKUS_OPENSHIFT_VERSION

string

 

lock quarkus.openshift.namespace

The namespace the generated resources should belong to. If not value is set, then the 'namespace' field will not be added to the 'metadata' section of the generated manifests. This in turn means that when the manifests are applied to a cluster, the namespace will be resolved from the current Kubernetes context (see organize-cluster-access-kubeconfig for more details).

Environment variable: QUARKUS_OPENSHIFT_NAMESPACE

string

 

lock quarkus.openshift.labels."label-name"

Custom labels to add to all resources.

Environment variable: QUARKUS_OPENSHIFT_LABELS__LABEL_NAME_

Map<String,String>

 

lock quarkus.openshift.annotations."annotation-name"

Custom annotations to add to all resources.

Environment variable: QUARKUS_OPENSHIFT_ANNOTATIONS__ANNOTATION_NAME_

Map<String,String>

 

lock quarkus.openshift.service-type

The type of service that will be generated for the application

Environment variable: QUARKUS_OPENSHIFT_SERVICE_TYPE

cluster-ip, node-port, load-balancer, external-name

cluster-ip

lock quarkus.openshift.add-build-timestamp

Whether to add the build timestamp to the Kubernetes annotations This is a very useful way to have manifests of successive builds of the same application differ - thus ensuring that Kubernetes will apply the updated resources.

Environment variable: QUARKUS_OPENSHIFT_ADD_BUILD_TIMESTAMP

boolean

true

lock quarkus.openshift.add-version-to-label-selectors

If true, the 'app.kubernetes.io/version' label will be part of the selectors of Service and Deployment.

Environment variable: QUARKUS_OPENSHIFT_ADD_VERSION_TO_LABEL_SELECTORS

boolean

true

lock quarkus.openshift.add-name-to-label-selectors

If true, the 'app.kubernetes.io/name' label will be part of the selectors of Service and Deployment.

Environment variable: QUARKUS_OPENSHIFT_ADD_NAME_TO_LABEL_SELECTORS

boolean

true

lock quarkus.openshift.working-dir

Working directory.

Environment variable: QUARKUS_OPENSHIFT_WORKING_DIR

string

 

lock quarkus.openshift.command

The commands.

Environment variable: QUARKUS_OPENSHIFT_COMMAND

list of string

 

lock quarkus.openshift.arguments

The arguments.

Environment variable: QUARKUS_OPENSHIFT_ARGUMENTS

list of string

 

lock quarkus.openshift.service-account

The service account.

Environment variable: QUARKUS_OPENSHIFT_SERVICE_ACCOUNT

string

 

lock quarkus.openshift.container-name

If set, it will change the name of the container according to the configuration.

Environment variable: QUARKUS_OPENSHIFT_CONTAINER_NAME

string

 

lock quarkus.openshift.ports."ports".container-port

The port number. Refers to the container port.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__CONTAINER_PORT

int

 

lock quarkus.openshift.ports."ports".host-port

The host port.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__HOST_PORT

int

 

lock quarkus.openshift.ports."ports".path

The application path (refers to web application path).

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__PATH

string

/

lock quarkus.openshift.ports."ports".protocol

The protocol.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__PROTOCOL

tcp, udp, sctp, http, proxy

tcp

lock quarkus.openshift.ports."ports".node-port

The nodePort to which this port should be mapped to. This only takes affect when the serviceType is set to node-port.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__NODE_PORT

int

 

lock quarkus.openshift.ports."ports".tls

If enabled, the port will be configured to use the schema HTTPS.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__TLS

boolean

false

lock quarkus.openshift.image-pull-policy

Image pull policy.

Environment variable: QUARKUS_OPENSHIFT_IMAGE_PULL_POLICY

always, if-not-present, never

always

lock quarkus.openshift.image-pull-secrets

The image pull secret.

Environment variable: QUARKUS_OPENSHIFT_IMAGE_PULL_SECRETS

list of string

 

lock quarkus.openshift.generate-image-pull-secret

Enable generation of image pull secret, when the container image username and password are provided.

Environment variable: QUARKUS_OPENSHIFT_GENERATE_IMAGE_PULL_SECRET

boolean

false

lock quarkus.openshift.liveness-probe.http-action-port

The port number to use when configuring the http get action. If not configured, the port corresponding to the httpActionPortName will be used.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_HTTP_ACTION_PORT

int

 

lock quarkus.openshift.liveness-probe.http-action-port-name

The port name for selecting the port of the HTTP get action.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_HTTP_ACTION_PORT_NAME

string

 

lock quarkus.openshift.liveness-probe.http-action-path

The http path to use for the probe. For this to work, the container port also needs to be set.

Assuming the container port has been set (as per above comment), if execAction or tcpSocketAction are not set, an HTTP probe will be used automatically even if no path is set (which will result in the root path being used). If Smallrye Health is used, the path will automatically be set according to the health check path.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_HTTP_ACTION_PATH

string

 

lock quarkus.openshift.liveness-probe.http-action-scheme

The scheme of the HTTP get action. Can be either "HTTP" or "HTTPS".

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_HTTP_ACTION_SCHEME

string

 

lock quarkus.openshift.liveness-probe.exec-action

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_EXEC_ACTION

string

 

lock quarkus.openshift.liveness-probe.tcp-socket-action

The tcp socket to use for the probe (the format is host:port).

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_TCP_SOCKET_ACTION

string

 

lock quarkus.openshift.liveness-probe.grpc-action

The gRPC port to use for the probe (the format is either port or port:service).

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_GRPC_ACTION

string

 

lock quarkus.openshift.liveness-probe.grpc-action-enabled

If enabled and grpc-action is not provided, it will use the generated service name and the gRPC port.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_GRPC_ACTION_ENABLED

boolean

false

lock quarkus.openshift.liveness-probe.initial-delay

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_INITIAL_DELAY

Duration  question circle

5S

lock quarkus.openshift.liveness-probe.period

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_PERIOD

Duration  question circle

10S

lock quarkus.openshift.liveness-probe.timeout

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_TIMEOUT

Duration  question circle

10S

lock quarkus.openshift.liveness-probe.success-threshold

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

lock quarkus.openshift.liveness-probe.failure-threshold

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

lock quarkus.openshift.readiness-probe.http-action-port

The port number to use when configuring the http get action. If not configured, the port corresponding to the httpActionPortName will be used.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_HTTP_ACTION_PORT

int

 

lock quarkus.openshift.readiness-probe.http-action-port-name

The port name for selecting the port of the HTTP get action.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_HTTP_ACTION_PORT_NAME

string

 

lock quarkus.openshift.readiness-probe.http-action-path

The http path to use for the probe. For this to work, the container port also needs to be set.

Assuming the container port has been set (as per above comment), if execAction or tcpSocketAction are not set, an HTTP probe will be used automatically even if no path is set (which will result in the root path being used). If Smallrye Health is used, the path will automatically be set according to the health check path.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_HTTP_ACTION_PATH

string

 

lock quarkus.openshift.readiness-probe.http-action-scheme

The scheme of the HTTP get action. Can be either "HTTP" or "HTTPS".

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_HTTP_ACTION_SCHEME

string

 

lock quarkus.openshift.readiness-probe.exec-action

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_EXEC_ACTION

string

 

lock quarkus.openshift.readiness-probe.tcp-socket-action

The tcp socket to use for the probe (the format is host:port).

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_TCP_SOCKET_ACTION

string

 

lock quarkus.openshift.readiness-probe.grpc-action

The gRPC port to use for the probe (the format is either port or port:service).

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_GRPC_ACTION

string

 

lock quarkus.openshift.readiness-probe.grpc-action-enabled

If enabled and grpc-action is not provided, it will use the generated service name and the gRPC port.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_GRPC_ACTION_ENABLED

boolean

false

lock quarkus.openshift.readiness-probe.initial-delay

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_INITIAL_DELAY

Duration  question circle

5S

lock quarkus.openshift.readiness-probe.period

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_PERIOD

Duration  question circle

10S

lock quarkus.openshift.readiness-probe.timeout

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_TIMEOUT

Duration  question circle

10S

lock quarkus.openshift.readiness-probe.success-threshold

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_SUCCESS_THRESHOLD

int

1

lock quarkus.openshift.readiness-probe.failure-threshold

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_FAILURE_THRESHOLD

int

3

lock quarkus.openshift.startup-probe.http-action-port

The port number to use when configuring the http get action. If not configured, the port corresponding to the httpActionPortName will be used.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_HTTP_ACTION_PORT

int

 

lock quarkus.openshift.startup-probe.http-action-port-name

The port name for selecting the port of the HTTP get action.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_HTTP_ACTION_PORT_NAME

string

 

lock quarkus.openshift.startup-probe.http-action-path

The http path to use for the probe. For this to work, the container port also needs to be set.

Assuming the container port has been set (as per above comment), if execAction or tcpSocketAction are not set, an HTTP probe will be used automatically even if no path is set (which will result in the root path being used). If Smallrye Health is used, the path will automatically be set according to the health check path.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_HTTP_ACTION_PATH

string

 

lock quarkus.openshift.startup-probe.http-action-scheme

The scheme of the HTTP get action. Can be either "HTTP" or "HTTPS".

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_HTTP_ACTION_SCHEME

string

 

lock quarkus.openshift.startup-probe.exec-action

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_EXEC_ACTION

string

 

lock quarkus.openshift.startup-probe.tcp-socket-action

The tcp socket to use for the probe (the format is host:port).

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_TCP_SOCKET_ACTION

string

 

lock quarkus.openshift.startup-probe.grpc-action

The gRPC port to use for the probe (the format is either port or port:service).

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_GRPC_ACTION

string

 

lock quarkus.openshift.startup-probe.grpc-action-enabled

If enabled and grpc-action is not provided, it will use the generated service name and the gRPC port.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_GRPC_ACTION_ENABLED

boolean

false

lock quarkus.openshift.startup-probe.initial-delay

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_INITIAL_DELAY

Duration  question circle

5S

lock quarkus.openshift.startup-probe.period

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_PERIOD

Duration  question circle

10S

lock quarkus.openshift.startup-probe.timeout

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_TIMEOUT

Duration  question circle

10S

lock quarkus.openshift.startup-probe.success-threshold

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_SUCCESS_THRESHOLD

int

1

lock quarkus.openshift.startup-probe.failure-threshold

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_STARTUP_PROBE_FAILURE_THRESHOLD

int

3

lock quarkus.openshift.prometheus.annotations

When true (the default), emit a set of annotations to identify services that should be scraped by prometheus for metrics.

In configurations that use the Prometheus operator with ServiceMonitor, annotations may not be necessary.

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_ANNOTATIONS

boolean

true

lock quarkus.openshift.prometheus.generate-service-monitor

When true (the default), emit a set of annotations to identify services that should be scraped by prometheus for metrics.

In configurations that use the Prometheus operator with ServiceMonitor, annotations may not be necessary.

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_GENERATE_SERVICE_MONITOR

boolean

true

lock quarkus.openshift.prometheus.prefix

Define the annotation prefix used for scrape values, this value will be used as the base for other annotation name defaults. Altering the base for generated annotations can make it easier to define re-labeling rules and avoid unexpected knock-on effects. The default value is prometheus.io See Prometheus example

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_PREFIX

string

prometheus.io

lock quarkus.openshift.prometheus.scrape

Define the annotation used to indicate services that should be scraped. By default, /scrape will be appended to the defined prefix.

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_SCRAPE

string

 

lock quarkus.openshift.prometheus.path

Define the annotation used to indicate the path to scrape. By default, /path will be appended to the defined prefix.

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_PATH

string

 

lock quarkus.openshift.prometheus.port

Define the annotation used to indicate the port to scrape. By default, /port will be appended to the defined prefix.

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_PORT

string

 

lock quarkus.openshift.prometheus.scheme

Define the annotation used to indicate the scheme to use for scraping By default, /scheme will be appended to the defined prefix.

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_SCHEME

string

 

lock quarkus.openshift.mounts."mounts".name

The name of the volumeName to mount.

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__NAME

string

 

lock quarkus.openshift.mounts."mounts".path

The path to mount.

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__PATH

string

 

lock quarkus.openshift.mounts."mounts".sub-path

Path within the volumeName from which the container’s volumeName should be mounted.

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__SUB_PATH

string

 

lock quarkus.openshift.mounts."mounts".read-only

ReadOnly.

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__READ_ONLY

boolean

false

lock quarkus.openshift.secret-volumes."secret-volumes".secret-name

The name of the secret to mount.

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__SECRET_NAME

string

required exclamation circle

lock quarkus.openshift.secret-volumes."secret-volumes".default-mode

Default mode. When specifying an octal number, leading zero must be present.

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__DEFAULT_MODE

string

0600

lock quarkus.openshift.secret-volumes."secret-volumes".items."items".path

The path where the file will be mounted.

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__ITEMS__ITEMS__PATH

string

required exclamation circle

lock quarkus.openshift.secret-volumes."secret-volumes".items."items".mode

It must be a value between 0000 and 0777. If not specified, the volume defaultMode will be used.

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__ITEMS__ITEMS__MODE

int

-1

lock quarkus.openshift.secret-volumes."secret-volumes".optional

Optional

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__OPTIONAL

boolean

false

lock quarkus.openshift.config-map-volumes."config-map-volumes".config-map-name

The name of the ConfigMap to mount.

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__CONFIG_MAP_NAME

string

required exclamation circle

lock quarkus.openshift.config-map-volumes."config-map-volumes".default-mode

Default mode. When specifying an octal number, leading zero must be present.

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__DEFAULT_MODE

string

0600

lock quarkus.openshift.config-map-volumes."config-map-volumes".items."items".path

The path where the file will be mounted.

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__ITEMS__ITEMS__PATH

string

required exclamation circle

lock quarkus.openshift.config-map-volumes."config-map-volumes".items."items".mode

It must be a value between 0000 and 0777. If not specified, the volume defaultMode will be used.

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__ITEMS__ITEMS__MODE

int

-1

lock quarkus.openshift.config-map-volumes."config-map-volumes".optional

Optional

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__OPTIONAL

boolean

false

lock quarkus.openshift.empty-dir-volumes

EmptyDir volumes.

Environment variable: QUARKUS_OPENSHIFT_EMPTY_DIR_VOLUMES

list of string

 

lock quarkus.openshift.git-repo-volumes."git-repo-volumes".repository

Git repository URL.

Environment variable: QUARKUS_OPENSHIFT_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REPOSITORY

string

required exclamation circle

lock quarkus.openshift.git-repo-volumes."git-repo-volumes".directory

The directory of the repository to mount.

Environment variable: QUARKUS_OPENSHIFT_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__DIRECTORY

string

 

lock quarkus.openshift.git-repo-volumes."git-repo-volumes".revision

The commit hash to use.

Environment variable: QUARKUS_OPENSHIFT_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REVISION

string

 

lock quarkus.openshift.pvc-volumes."pvc-volumes".claim-name

The name of the claim to mount.

Environment variable: QUARKUS_OPENSHIFT_PVC_VOLUMES__PVC_VOLUMES__CLAIM_NAME

string

required exclamation circle

lock quarkus.openshift.pvc-volumes."pvc-volumes".default-mode

Default mode. When specifying an octal number, leading zero must be present.

Environment variable: QUARKUS_OPENSHIFT_PVC_VOLUMES__PVC_VOLUMES__DEFAULT_MODE

string

0600

lock quarkus.openshift.pvc-volumes."pvc-volumes".optional

Optional

Environment variable: QUARKUS_OPENSHIFT_PVC_VOLUMES__PVC_VOLUMES__OPTIONAL

boolean

false

lock quarkus.openshift.aws-elastic-block-store-volumes."aws-elastic-block-store-volumes".volume-id

The name of the disk to mount.

Environment variable: QUARKUS_OPENSHIFT_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__VOLUME_ID

string

required exclamation circle

lock quarkus.openshift.aws-elastic-block-store-volumes."aws-elastic-block-store-volumes".partition

The partition.

Environment variable: QUARKUS_OPENSHIFT_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__PARTITION

int

 

lock quarkus.openshift.aws-elastic-block-store-volumes."aws-elastic-block-store-volumes".fs-type

Filesystem type.

Environment variable: QUARKUS_OPENSHIFT_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__FS_TYPE

string

ext4

lock quarkus.openshift.aws-elastic-block-store-volumes."aws-elastic-block-store-volumes".read-only

Whether the volumeName is read only or not.

Environment variable: QUARKUS_OPENSHIFT_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__READ_ONLY

boolean

false

lock quarkus.openshift.azure-file-volumes."azure-file-volumes".share-name

The share name.

Environment variable: QUARKUS_OPENSHIFT_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SHARE_NAME

string

required exclamation circle

lock quarkus.openshift.azure-file-volumes."azure-file-volumes".secret-name

The secret name.

Environment variable: QUARKUS_OPENSHIFT_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SECRET_NAME

string

required exclamation circle

lock quarkus.openshift.azure-file-volumes."azure-file-volumes".read-only

Whether the volumeName is read only or not.

Environment variable: QUARKUS_OPENSHIFT_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__READ_ONLY

boolean

false

lock quarkus.openshift.azure-disk-volumes."azure-disk-volumes".disk-name

The name of the disk to mount.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__DISK_NAME

string

required exclamation circle

lock quarkus.openshift.azure-disk-volumes."azure-disk-volumes".disk-uri

The URI of the vhd blob object OR the resourceID of an Azure managed data disk if Kind is Managed

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__DISK_URI

string

required exclamation circle

lock quarkus.openshift.azure-disk-volumes."azure-disk-volumes".kind

Kind of disk.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__KIND

managed, shared

managed

lock quarkus.openshift.azure-disk-volumes."azure-disk-volumes".caching-mode

Disk caching mode.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__CACHING_MODE

read-write, read-only, none

read-write

lock quarkus.openshift.azure-disk-volumes."azure-disk-volumes".fs-type

File system type.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__FS_TYPE

string

ext4

lock quarkus.openshift.azure-disk-volumes."azure-disk-volumes".read-only

Whether the volumeName is read only or not.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__READ_ONLY

boolean

false

lock quarkus.openshift.init-containers."init-containers".env.secrets

The optional list of Secret names to load environment variables from.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_SECRETS

list of string

 

lock quarkus.openshift.init-containers."init-containers".env.configmaps

The optional list of ConfigMap names to load environment variables from.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_CONFIGMAPS

list of string

 

lock quarkus.openshift.init-containers."init-containers".env.fields."environment-variable-name"

The map associating environment variable names to their associated field references they take their value from.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_FIELDS__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

 

lock quarkus.openshift.init-containers."init-containers".env.vars."vars"

The environment variable value

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_VARS__VARS_

string

 

lock quarkus.openshift.init-containers."init-containers".env.mapping."mapping".from-secret

The optional name of the Secret from which a value is to be extracted. Mutually exclusive with from-configmap.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__FROM_SECRET

string

 

lock quarkus.openshift.init-containers."init-containers".env.mapping."mapping".from-configmap

The optional name of the ConfigMap from which a value is to be extracted. Mutually exclusive with from-secret.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

 

lock quarkus.openshift.init-containers."init-containers".env.mapping."mapping".with-key

The key identifying the field from which the value is extracted.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__WITH_KEY

string

required exclamation circle

lock quarkus.openshift.init-containers."init-containers".env.using-prefix."prefixes".for-secret

The optional prefix to use when adding the environment variable to the container.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_USING_PREFIX__PREFIXES__FOR_SECRET

string

 

lock quarkus.openshift.init-containers."init-containers".env.using-prefix."prefixes".for-configmap

The optional prefix to use when adding the environment variable to the container.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_USING_PREFIX__PREFIXES__FOR_CONFIGMAP

string

 

lock quarkus.openshift.init-containers."init-containers".image

The container image.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE

string

 

lock quarkus.openshift.init-containers."init-containers".working-dir

Working directory.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__WORKING_DIR

string

 

lock quarkus.openshift.init-containers."init-containers".command

The commands

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__COMMAND

list of string

 

lock quarkus.openshift.init-containers."init-containers".arguments

The arguments

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ARGUMENTS

list of string

 

lock quarkus.openshift.init-containers."init-containers".service-account

The service account.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__SERVICE_ACCOUNT

string

 

lock quarkus.openshift.init-containers."init-containers".host

The host under which the application is going to be exposed.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__HOST

string

 

lock quarkus.openshift.init-containers."init-containers".ports."ports".container-port

The port number. Refers to the container port.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__CONTAINER_PORT

int

 

lock quarkus.openshift.init-containers."init-containers".ports."ports".host-port

The host port.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__HOST_PORT

int

 

lock quarkus.openshift.init-containers."init-containers".ports."ports".path

The application path (refers to web application path).

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PATH

string

/

lock quarkus.openshift.init-containers."init-containers".ports."ports".protocol

The protocol.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PROTOCOL

tcp, udp, sctp, http, proxy

tcp

lock quarkus.openshift.init-containers."init-containers".ports."ports".node-port

The nodePort to which this port should be mapped to. This only takes affect when the serviceType is set to node-port.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__NODE_PORT

int

 

lock quarkus.openshift.init-containers."init-containers".ports."ports".tls

If enabled, the port will be configured to use the schema HTTPS.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__TLS

boolean

false

lock quarkus.openshift.init-containers."init-containers".image-pull-policy

Image pull policy.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_POLICY

always, if-not-present, never

always

lock quarkus.openshift.init-containers."init-containers".image-pull-secrets

The image pull secrets.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_SECRETS

list of string

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.http-action-port

The port number to use when configuring the http get action. If not configured, the port corresponding to the httpActionPortName will be used.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_PORT

int

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.http-action-port-name

The port name for selecting the port of the HTTP get action.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_PORT_NAME

string

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.http-action-path

The http path to use for the probe. For this to work, the container port also needs to be set.

Assuming the container port has been set (as per above comment), if execAction or tcpSocketAction are not set, an HTTP probe will be used automatically even if no path is set (which will result in the root path being used). If Smallrye Health is used, the path will automatically be set according to the health check path.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.http-action-scheme

The scheme of the HTTP get action. Can be either "HTTP" or "HTTPS".

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_SCHEME

string

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.exec-action

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_EXEC_ACTION

string

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.tcp-socket-action

The tcp socket to use for the probe (the format is host:port).

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_TCP_SOCKET_ACTION

string

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.grpc-action

The gRPC port to use for the probe (the format is either port or port:service).

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_GRPC_ACTION

string

 

lock quarkus.openshift.init-containers."init-containers".liveness-probe.grpc-action-enabled

If enabled and grpc-action is not provided, it will use the generated service name and the gRPC port.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_GRPC_ACTION_ENABLED

boolean

false

lock quarkus.openshift.init-containers."init-containers".liveness-probe.initial-delay

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_INITIAL_DELAY

Duration  question circle

5S

lock quarkus.openshift.init-containers."init-containers".liveness-probe.period

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_PERIOD

Duration  question circle

10S

lock quarkus.openshift.init-containers."init-containers".liveness-probe.timeout

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_TIMEOUT

Duration  question circle

10S

lock quarkus.openshift.init-containers."init-containers".liveness-probe.success-threshold

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

lock quarkus.openshift.init-containers."init-containers".liveness-probe.failure-threshold

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

lock quarkus.openshift.init-containers."init-containers".readiness-probe.http-action-port

The port number to use when configuring the http get action. If not configured, the port corresponding to the httpActionPortName will be used.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_HTTP_ACTION_PORT

int

 

lock quarkus.openshift.init-containers."init-containers".readiness-probe.http-action-port-name

The port name for selecting the port of the HTTP get action.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_HTTP_ACTION_PORT_NAME

string

 

lock quarkus.openshift.init-containers."init-containers".readiness-probe.http-action-path

The http path to use for the probe. For this to work, the container port also needs to be set.

Assuming the container port has been set (as per above comment), if execAction or tcpSocketAction are not set, an HTTP probe will be used automatically even if no path is set (which will result in the root path being used). If Smallrye Health is used, the path will automatically be set according to the health check path.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_HTTP_ACTION_PATH

string

 

lock quarkus.openshift.init-containers."init-containers".readiness-probe.http-action-scheme

The scheme of the HTTP get action. Can be either "HTTP" or "HTTPS".

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_HTTP_ACTION_SCHEME

string

 

lock quarkus.openshift.init-containers."init-containers".readiness-probe.exec-action

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_EXEC_ACTION

string

 

lock quarkus.openshift.init-containers."init-containers".readiness-probe.tcp-socket-action

The tcp socket to use for the probe (the format is host:port).

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_TCP_SOCKET_ACTION

string

 

lock quarkus.openshift.init-containers."init-containers".readiness-probe.grpc-action

The gRPC port to use for the probe (the format is either port or port:service).

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_GRPC_ACTION

string

 

lock quarkus.openshift.init-containers."init-containers".readiness-probe.grpc-action-enabled

If enabled and grpc-action is not provided, it will use the generated service name and the gRPC port.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_GRPC_ACTION_ENABLED

boolean

false

lock quarkus.openshift.init-containers."init-containers".readiness-probe.initial-delay

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_INITIAL_DELAY

Duration  question circle

5S

lock quarkus.openshift.init-containers."init-containers".readiness-probe.period

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_PERIOD

Duration  question circle

10S

lock quarkus.openshift.init-containers."init-containers".readiness-probe.timeout

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_TIMEOUT

Duration  question circle

10S

lock quarkus.openshift.init-containers."init-containers".readiness-probe.success-threshold

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

lock quarkus.openshift.init-containers."init-containers".readiness-probe.failure-threshold

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

lock quarkus.openshift.init-containers."init-containers".mounts."mounts".name

The name of the volumeName to mount.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__NAME

string

 

lock quarkus.openshift.init-containers."init-containers".mounts."mounts".path

The path to mount.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__PATH

string

 

lock quarkus.openshift.init-containers."init-containers".mounts."mounts".sub-path

Path within the volumeName from which the container’s volumeName should be mounted.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__SUB_PATH

string

 

lock quarkus.openshift.init-containers."init-containers".mounts."mounts".read-only

ReadOnly.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

lock quarkus.openshift.init-containers."init-containers".resources.limits.cpu

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_CPU

string

 

lock quarkus.openshift.init-containers."init-containers".resources.limits.memory

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_MEMORY

string

 

lock quarkus.openshift.init-containers."init-containers".resources.requests.cpu

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_CPU

string

 

lock quarkus.openshift.init-containers."init-containers".resources.requests.memory

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_MEMORY

string

 

lock quarkus.openshift.sidecars."sidecars".env.secrets

The optional list of Secret names to load environment variables from.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_SECRETS

list of string

 

lock quarkus.openshift.sidecars."sidecars".env.configmaps

The optional list of ConfigMap names to load environment variables from.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_CONFIGMAPS

list of string

 

lock quarkus.openshift.sidecars."sidecars".env.fields."environment-variable-name"

The map associating environment variable names to their associated field references they take their value from.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_FIELDS__ENVIRONMENT_VARIABLE_NAME_

Map<String,String>

 

lock quarkus.openshift.sidecars."sidecars".env.vars."vars"

The environment variable value

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_VARS__VARS_

string

 

lock quarkus.openshift.sidecars."sidecars".env.mapping."mapping".from-secret

The optional name of the Secret from which a value is to be extracted. Mutually exclusive with from-configmap.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_MAPPING__MAPPING__FROM_SECRET

string

 

lock quarkus.openshift.sidecars."sidecars".env.mapping."mapping".from-configmap

The optional name of the ConfigMap from which a value is to be extracted. Mutually exclusive with from-secret.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

 

lock quarkus.openshift.sidecars."sidecars".env.mapping."mapping".with-key

The key identifying the field from which the value is extracted.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_MAPPING__MAPPING__WITH_KEY

string

required exclamation circle

lock quarkus.openshift.sidecars."sidecars".env.using-prefix."prefixes".for-secret

The optional prefix to use when adding the environment variable to the container.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_USING_PREFIX__PREFIXES__FOR_SECRET

string

 

lock quarkus.openshift.sidecars."sidecars".env.using-prefix."prefixes".for-configmap

The optional prefix to use when adding the environment variable to the container.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_USING_PREFIX__PREFIXES__FOR_CONFIGMAP

string

 

lock quarkus.openshift.sidecars."sidecars".image

The container image.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE

string

 

lock quarkus.openshift.sidecars."sidecars".working-dir

Working directory.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__WORKING_DIR

string

 

lock quarkus.openshift.sidecars."sidecars".command

The commands

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__COMMAND

list of string

 

lock quarkus.openshift.sidecars."sidecars".arguments

The arguments

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ARGUMENTS

list of string

 

lock quarkus.openshift.sidecars."sidecars".service-account

The service account.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__SERVICE_ACCOUNT

string

 

lock quarkus.openshift.sidecars."sidecars".host

The host under which the application is going to be exposed.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__HOST

string

 

lock quarkus.openshift.sidecars."sidecars".ports."ports".container-port

The port number. Refers to the container port.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__CONTAINER_PORT

int

 

lock quarkus.openshift.sidecars."sidecars".ports."ports".host-port

The host port.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__HOST_PORT

int

 

lock quarkus.openshift.sidecars."sidecars".ports."ports".path

The application path (refers to web application path).

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__PATH

string

/

lock quarkus.openshift.sidecars."sidecars".ports."ports".protocol

The protocol.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__PROTOCOL

tcp, udp, sctp, http, proxy

tcp

lock quarkus.openshift.sidecars."sidecars".ports."ports".node-port

The nodePort to which this port should be mapped to. This only takes affect when the serviceType is set to node-port.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__NODE_PORT

int

 

lock quarkus.openshift.sidecars."sidecars".ports."ports".tls

If enabled, the port will be configured to use the schema HTTPS.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__TLS

boolean

false

lock quarkus.openshift.sidecars."sidecars".image-pull-policy

Image pull policy.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE_PULL_POLICY

always, if-not-present, never

always

lock quarkus.openshift.sidecars."sidecars".image-pull-secrets

The image pull secrets.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE_PULL_SECRETS

list of string

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.http-action-port

The port number to use when configuring the http get action. If not configured, the port corresponding to the httpActionPortName will be used.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_HTTP_ACTION_PORT

int

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.http-action-port-name

The port name for selecting the port of the HTTP get action.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_HTTP_ACTION_PORT_NAME

string

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.http-action-path

The http path to use for the probe. For this to work, the container port also needs to be set.

Assuming the container port has been set (as per above comment), if execAction or tcpSocketAction are not set, an HTTP probe will be used automatically even if no path is set (which will result in the root path being used). If Smallrye Health is used, the path will automatically be set according to the health check path.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.http-action-scheme

The scheme of the HTTP get action. Can be either "HTTP" or "HTTPS".

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_HTTP_ACTION_SCHEME

string

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.exec-action

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_EXEC_ACTION

string

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.tcp-socket-action

The tcp socket to use for the probe (the format is host:port).

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_TCP_SOCKET_ACTION

string

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.grpc-action

The gRPC port to use for the probe (the format is either port or port:service).

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_GRPC_ACTION

string

 

lock quarkus.openshift.sidecars."sidecars".liveness-probe.grpc-action-enabled

If enabled and grpc-action is not provided, it will use the generated service name and the gRPC port.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_GRPC_ACTION_ENABLED

boolean

false

lock quarkus.openshift.sidecars."sidecars".liveness-probe.initial-delay

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_INITIAL_DELAY

Duration  question circle

5S

lock quarkus.openshift.sidecars."sidecars".liveness-probe.period

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_PERIOD

Duration  question circle

10S

lock quarkus.openshift.sidecars."sidecars".liveness-probe.timeout

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_TIMEOUT

Duration  question circle

10S

lock quarkus.openshift.sidecars."sidecars".liveness-probe.success-threshold

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

lock quarkus.openshift.sidecars."sidecars".liveness-probe.failure-threshold

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

lock quarkus.openshift.sidecars."sidecars".readiness-probe.http-action-port

The port number to use when configuring the http get action. If not configured, the port corresponding to the httpActionPortName will be used.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_HTTP_ACTION_PORT

int

 

lock quarkus.openshift.sidecars."sidecars".readiness-probe.http-action-port-name

The port name for selecting the port of the HTTP get action.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_HTTP_ACTION_PORT_NAME

string

 

lock quarkus.openshift.sidecars."sidecars".readiness-probe.http-action-path

The http path to use for the probe. For this to work, the container port also needs to be set.

Assuming the container port has been set (as per above comment), if execAction or tcpSocketAction are not set, an HTTP probe will be used automatically even if no path is set (which will result in the root path being used). If Smallrye Health is used, the path will automatically be set according to the health check path.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_HTTP_ACTION_PATH

string

 

lock quarkus.openshift.sidecars."sidecars".readiness-probe.http-action-scheme

The scheme of the HTTP get action. Can be either "HTTP" or "HTTPS".

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_HTTP_ACTION_SCHEME

string

 

lock quarkus.openshift.sidecars."sidecars".readiness-probe.exec-action

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_EXEC_ACTION

string

 

lock quarkus.openshift.sidecars."sidecars".readiness-probe.tcp-socket-action

The tcp socket to use for the probe (the format is host:port).

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_TCP_SOCKET_ACTION

string

 

lock quarkus.openshift.sidecars."sidecars".readiness-probe.grpc-action

The gRPC port to use for the probe (the format is either port or port:service).

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_GRPC_ACTION

string

 

lock quarkus.openshift.sidecars."sidecars".readiness-probe.grpc-action-enabled

If enabled and grpc-action is not provided, it will use the generated service name and the gRPC port.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_GRPC_ACTION_ENABLED

boolean

false

lock quarkus.openshift.sidecars."sidecars".readiness-probe.initial-delay

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_INITIAL_DELAY

Duration  question circle

5S

lock quarkus.openshift.sidecars."sidecars".readiness-probe.period

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_PERIOD

Duration  question circle

10S

lock quarkus.openshift.sidecars."sidecars".readiness-probe.timeout

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_TIMEOUT

Duration  question circle

10S

lock quarkus.openshift.sidecars."sidecars".readiness-probe.success-threshold

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

lock quarkus.openshift.sidecars."sidecars".readiness-probe.failure-threshold

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

lock quarkus.openshift.sidecars."sidecars".mounts."mounts".name

The name of the volumeName to mount.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__NAME

string

 

lock quarkus.openshift.sidecars."sidecars".mounts."mounts".path

The path to mount.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__PATH

string

 

lock quarkus.openshift.sidecars."sidecars".mounts."mounts".sub-path

Path within the volumeName from which the container’s volumeName should be mounted.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__SUB_PATH

string

 

lock quarkus.openshift.sidecars."sidecars".mounts."mounts".read-only

ReadOnly.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

lock quarkus.openshift.sidecars."sidecars".resources.limits.cpu

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_LIMITS_CPU

string

 

lock quarkus.openshift.sidecars."sidecars".resources.limits.memory

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_LIMITS_MEMORY

string

 

lock quarkus.openshift.sidecars."sidecars".resources.requests.cpu

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_REQUESTS_CPU

string

 

lock quarkus.openshift.sidecars."sidecars".resources.requests.memory

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_REQUESTS_MEMORY

string

 

lock quarkus.openshift.hostaliases."host-aliases".ip

The ip address.

Environment variable: QUARKUS_OPENSHIFT_HOSTALIASES__HOST_ALIASES__IP

string

 

lock quarkus.openshift.hostaliases."host-aliases".hostnames

The hostnames to resolve to the ip.

Environment variable: QUARKUS_OPENSHIFT_HOSTALIASES__HOST_ALIASES__HOSTNAMES

list of string

 

lock quarkus.openshift.node-selector.key

The key of the nodeSelector.

Environment variable: QUARKUS_OPENSHIFT_NODE_SELECTOR_KEY

string

required exclamation circle

lock quarkus.openshift.node-selector.value

The value of the nodeSelector.

Environment variable: QUARKUS_OPENSHIFT_NODE_SELECTOR_VALUE

string

required exclamation circle

lock quarkus.openshift.resources.limits.cpu

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_LIMITS_CPU

string

 

lock quarkus.openshift.resources.limits.memory

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_LIMITS_MEMORY

string

 

lock quarkus.openshift.resources.requests.cpu

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_REQUESTS_CPU

string

 

lock quarkus.openshift.resources.requests.memory

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_REQUESTS_MEMORY

string

 

lock quarkus.openshift.app-secret

If set, the secret will mounted to the application container and its contents will be used for application configuration.

Environment variable: QUARKUS_OPENSHIFT_APP_SECRET

string

 

lock quarkus.openshift.app-config-map

If set, the config map will be mounted to the application container and its contents will be used for application configuration.

Environment variable: QUARKUS_OPENSHIFT_APP_CONFIG_MAP

string

 

lock quarkus.openshift.rbac.roles."roles".name

The name of the role.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__NAME

string

 

lock quarkus.openshift.rbac.roles."roles".namespace

The namespace of the role.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__NAMESPACE

string

 

lock quarkus.openshift.rbac.roles."roles".labels."label-name"

Labels to add into the Role resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__LABELS__LABEL_NAME_

Map<String,String>

 

lock quarkus.openshift.rbac.roles."roles".policy-rules."policy-rules".api-groups

API groups of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__POLICY_RULES__POLICY_RULES__API_GROUPS

list of string

 

lock quarkus.openshift.rbac.roles."roles".policy-rules."policy-rules".non-resource-urls

Non resource URLs of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__POLICY_RULES__POLICY_RULES__NON_RESOURCE_URLS

list of string

 

lock quarkus.openshift.rbac.roles."roles".policy-rules."policy-rules".resource-names

Resource names of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__POLICY_RULES__POLICY_RULES__RESOURCE_NAMES

list of string

 

lock quarkus.openshift.rbac.roles."roles".policy-rules."policy-rules".resources

Resources of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__POLICY_RULES__POLICY_RULES__RESOURCES

list of string

 

lock quarkus.openshift.rbac.roles."roles".policy-rules."policy-rules".verbs

Verbs of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__POLICY_RULES__POLICY_RULES__VERBS

list of string

 

lock quarkus.openshift.rbac.cluster-roles."cluster-roles".name

The name of the cluster role.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLES__CLUSTER_ROLES__NAME

string

 

lock quarkus.openshift.rbac.cluster-roles."cluster-roles".labels."label-name"

Labels to add into the ClusterRole resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLES__CLUSTER_ROLES__LABELS__LABEL_NAME_

Map<String,String>

 

lock quarkus.openshift.rbac.cluster-roles."cluster-roles".policy-rules."policy-rules".api-groups

API groups of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLES__CLUSTER_ROLES__POLICY_RULES__POLICY_RULES__API_GROUPS

list of string

 

lock quarkus.openshift.rbac.cluster-roles."cluster-roles".policy-rules."policy-rules".non-resource-urls

Non resource URLs of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLES__CLUSTER_ROLES__POLICY_RULES__POLICY_RULES__NON_RESOURCE_URLS

list of string

 

lock quarkus.openshift.rbac.cluster-roles."cluster-roles".policy-rules."policy-rules".resource-names

Resource names of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLES__CLUSTER_ROLES__POLICY_RULES__POLICY_RULES__RESOURCE_NAMES

list of string

 

lock quarkus.openshift.rbac.cluster-roles."cluster-roles".policy-rules."policy-rules".resources

Resources of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLES__CLUSTER_ROLES__POLICY_RULES__POLICY_RULES__RESOURCES

list of string

 

lock quarkus.openshift.rbac.cluster-roles."cluster-roles".policy-rules."policy-rules".verbs

Verbs of the policy rule.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLES__CLUSTER_ROLES__POLICY_RULES__POLICY_RULES__VERBS

list of string

 

lock quarkus.openshift.rbac.service-accounts."service-accounts".name

The name of the service account.

Environment variable: QUARKUS_OPENSHIFT_RBAC_SERVICE_ACCOUNTS__SERVICE_ACCOUNTS__NAME

string

 

lock quarkus.openshift.rbac.service-accounts."service-accounts".namespace

The namespace of the service account.

Environment variable: QUARKUS_OPENSHIFT_RBAC_SERVICE_ACCOUNTS__SERVICE_ACCOUNTS__NAMESPACE

string

 

lock quarkus.openshift.rbac.service-accounts."service-accounts".labels."label-name"

Labels of the service account.

Environment variable: QUARKUS_OPENSHIFT_RBAC_SERVICE_ACCOUNTS__SERVICE_ACCOUNTS__LABELS__LABEL_NAME_

Map<String,String>

 

lock quarkus.openshift.rbac.service-accounts."service-accounts".use-as-default

If true, this service account will be used in the generated Deployment resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_SERVICE_ACCOUNTS__SERVICE_ACCOUNTS__USE_AS_DEFAULT

boolean

 

lock quarkus.openshift.rbac.role-bindings."role-bindings".name

Name of the RoleBinding resource to be generated. If not provided, it will use the application name plus the role ref name.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__NAME

string

 

lock quarkus.openshift.rbac.role-bindings."role-bindings".labels."label-name"

Labels to add into the RoleBinding resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__LABELS__LABEL_NAME_

Map<String,String>

 

lock quarkus.openshift.rbac.role-bindings."role-bindings".role-name

The name of the Role resource to use by the RoleRef element in the generated Role Binding resource. By default, it’s "view" role name.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__ROLE_NAME

string

 

lock quarkus.openshift.rbac.role-bindings."role-bindings".cluster-wide

If the Role sets in the role-name property is cluster wide or not.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__CLUSTER_WIDE

boolean

 

lock quarkus.openshift.rbac.role-bindings."role-bindings".subjects."subjects".name

The "name" resource to use by the Subject element in the generated Role Binding resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__SUBJECTS__SUBJECTS__NAME

string

 

lock quarkus.openshift.rbac.role-bindings."role-bindings".subjects."subjects".kind

The "kind" resource to use by the Subject element in the generated Role Binding resource. By default, it uses the "ServiceAccount" kind.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__SUBJECTS__SUBJECTS__KIND

string

ServiceAccount

lock quarkus.openshift.rbac.role-bindings."role-bindings".subjects."subjects".api-group

The "apiGroup" resource that matches with the "kind" property. By default, it’s empty.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__SUBJECTS__SUBJECTS__API_GROUP

string

 

lock quarkus.openshift.rbac.role-bindings."role-bindings".subjects."subjects".namespace

The "namespace" resource to use by the Subject element in the generated Role Binding resource. By default, it will use the same as provided in the generated resources.

Environment variable: QUARKUS_OPENSHIFT_RBAC_ROLE_BINDINGS__ROLE_BINDINGS__SUBJECTS__SUBJECTS__NAMESPACE

string

 

lock quarkus.openshift.rbac.cluster-role-bindings."cluster-role-bindings".name

Name of the ClusterRoleBinding resource to be generated. If not provided, it will use the application name plus the role ref name.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLE_BINDINGS__CLUSTER_ROLE_BINDINGS__NAME

string

 

lock quarkus.openshift.rbac.cluster-role-bindings."cluster-role-bindings".labels."label-name"

Labels to add into the RoleBinding resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLE_BINDINGS__CLUSTER_ROLE_BINDINGS__LABELS__LABEL_NAME_

Map<String,String>

 

lock quarkus.openshift.rbac.cluster-role-bindings."cluster-role-bindings".role-name

The name of the ClusterRole resource to use by the RoleRef element in the generated ClusterRoleBinding resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLE_BINDINGS__CLUSTER_ROLE_BINDINGS__ROLE_NAME

string

required exclamation circle

lock quarkus.openshift.rbac.cluster-role-bindings."cluster-role-bindings".subjects."subjects".name

The "name" resource to use by the Subject element in the generated Role Binding resource.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLE_BINDINGS__CLUSTER_ROLE_BINDINGS__SUBJECTS__SUBJECTS__NAME

string

 

lock quarkus.openshift.rbac.cluster-role-bindings."cluster-role-bindings".subjects."subjects".kind

The "kind" resource to use by the Subject element in the generated Role Binding resource. By default, it uses the "ServiceAccount" kind.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLE_BINDINGS__CLUSTER_ROLE_BINDINGS__SUBJECTS__SUBJECTS__KIND

string

ServiceAccount

lock quarkus.openshift.rbac.cluster-role-bindings."cluster-role-bindings".subjects."subjects".api-group

The "apiGroup" resource that matches with the "kind" property. By default, it’s empty.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLE_BINDINGS__CLUSTER_ROLE_BINDINGS__SUBJECTS__SUBJECTS__API_GROUP

string

 

lock quarkus.openshift.rbac.cluster-role-bindings."cluster-role-bindings".subjects."subjects".namespace

The "namespace" resource to use by the Subject element in the generated Role Binding resource. By default, it will use the same as provided in the generated resources.

Environment variable: QUARKUS_OPENSHIFT_RBAC_CLUSTER_ROLE_BINDINGS__CLUSTER_ROLE_BINDINGS__SUBJECTS__SUBJECTS__NAMESPACE

string

 

lock quarkus.openshift.security-context.se-linux-options.level

The SELinux level label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_LEVEL

string

 

lock quarkus.openshift.security-context.se-linux-options.role

The SELinux role label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_ROLE

string

 

lock quarkus.openshift.security-context.se-linux-options.type

The SELinux type label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_TYPE

string

 

lock quarkus.openshift.security-context.se-linux-options.user

The SELinux user label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_USER

string

 

lock quarkus.openshift.security-context.windows-options.gmsa-credential-spec-name

The name of the GMSA credential spec to use.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_WINDOWS_OPTIONS_GMSA_CREDENTIAL_SPEC_NAME

string

 

lock quarkus.openshift.security-context.windows-options.gmsa-credential-spec

GMSACredentialSpec is where the GMSA admission webhook (windows-gsma) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_WINDOWS_OPTIONS_GMSA_CREDENTIAL_SPEC

string

 

lock quarkus.openshift.security-context.windows-options.run-as-user-name

The UserName in Windows to run the entrypoint of the container process.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_WINDOWS_OPTIONS_RUN_AS_USER_NAME

string

 

lock quarkus.openshift.security-context.windows-options.host-process

HostProcess determines if a container should be run as a 'Host Process' container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_WINDOWS_OPTIONS_HOST_PROCESS

boolean

 

lock quarkus.openshift.security-context.run-as-user

The UID to run the entrypoint of the container process.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_RUN_AS_USER

long

 

lock quarkus.openshift.security-context.run-as-group

The GID to run the entrypoint of the container process.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_RUN_AS_GROUP

long

 

lock quarkus.openshift.security-context.run-as-non-root

Indicates that the container must run as a non-root user.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_RUN_AS_NON_ROOT

boolean

 

lock quarkus.openshift.security-context.supplemental-groups

A list of groups applied to the first process run in each container, in addition to the container’s primary GID. If unspecified, no groups will be added to any container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SUPPLEMENTAL_GROUPS

list of long

 

lock quarkus.openshift.security-context.fs-group

A special supplemental group that applies to all containers in a pod.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_FS_GROUP

long

 

lock quarkus.openshift.security-context.sysctls."sysctl-name"

Sysctls hold a list of namespaced sysctls used for the pod.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SYSCTLS__SYSCTL_NAME_

Map<String,String>

 

lock quarkus.openshift.security-context.fs-group-change-policy

It holds policies that will be used for applying fsGroup to a volume when volume is mounted. Values: OnRootMismatch, Always

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_FS_GROUP_CHANGE_POLICY

on-root-mismatch: It indicates that volume’s ownership and permissions will be changed only when permission and ownership of root directory does not match with expected permissions on the volume.

always: It indicates that volume’s ownership and permissions should always be changed whenever volume is mounted inside a Pod. This the default behavior.

 

lock quarkus.openshift.idempotent

Switch used to control whether non-idempotent fields are included in generated kubernetes resources to improve git-ops compatibility.

Environment variable: QUARKUS_OPENSHIFT_IDEMPOTENT

boolean

false

lock quarkus.openshift.vcs-uri.enabled

Whether the vcs-uri annotation should be added to the generated configuration.

Environment variable: QUARKUS_OPENSHIFT_VCS_URI_ENABLED

boolean

true

lock quarkus.openshift.vcs-uri.override

Optional override of the vcs-uri annotation.

Environment variable: QUARKUS_OPENSHIFT_VCS_URI_OVERRIDE

string

 

lock quarkus.openshift.flavor

The OpenShift flavor / version to use. Older versions of OpenShift have minor differences in the labels and fields they support. This option allows users to have their manifests automatically aligned to the OpenShift 'flavor' they use.

Environment variable: QUARKUS_OPENSHIFT_FLAVOR

v3, v4

v4

lock quarkus.openshift.deployment-kind

The kind of the deployment resource to use. Supported values are 'Deployment', 'StatefulSet', 'Job', 'CronJob' and 'DeploymentConfig'. Defaults to 'DeploymentConfig' if flavor == v3, or 'Deployment' otherwise. DeploymentConfig is deprecated as of OpenShift 4.14. See https://access.redhat.com/articles/7041372 for details.

Environment variable: QUARKUS_OPENSHIFT_DEPLOYMENT_KIND

deployment, deployment-config, stateful-set, job, cron-job, knative-service

 

lock quarkus.openshift.replicas

The number of desired pods

Environment variable: QUARKUS_OPENSHIFT_REPLICAS

int

1

lock quarkus.openshift.node-port

The nodePort to set when serviceType is set to nodePort

Environment variable: QUARKUS_OPENSHIFT_NODE_PORT

int

 

lock quarkus.openshift.route.expose

If true, the service will be exposed

Environment variable: QUARKUS_OPENSHIFT_ROUTE_EXPOSE

boolean

false

lock quarkus.openshift.route.host

The host under which the application is going to be exposed

Environment variable: QUARKUS_OPENSHIFT_ROUTE_HOST

string

 

lock quarkus.openshift.route.target-port

The target named port. If not provided, it will be deducted from the Service resource ports. Options are: "http" and "https".

Environment variable: QUARKUS_OPENSHIFT_ROUTE_TARGET_PORT

string

http

lock quarkus.openshift.route.annotations."annotation-name"

Custom annotations to add to exposition (route or ingress) resources

Environment variable: QUARKUS_OPENSHIFT_ROUTE_ANNOTATIONS__ANNOTATION_NAME_

Map<String,String>

 

lock quarkus.openshift.route.labels."label-name"

Custom labels to add to exposition (route or ingress) resources

Environment variable: QUARKUS_OPENSHIFT_ROUTE_LABELS__LABEL_NAME_

Map<String,String>

 

lock quarkus.openshift.route.tls.ca-certificate

The cert authority certificate contents.

Environment variable: QUARKUS_OPENSHIFT_ROUTE_TLS_CA_CERTIFICATE

string

 

lock quarkus.openshift.route.tls.certificate

The certificate contents.

Environment variable: QUARKUS_OPENSHIFT_ROUTE_TLS_CERTIFICATE

string

 

lock quarkus.openshift.route.tls.destination-ca-certificate

The contents of the ca certificate of the final destination.

Environment variable: QUARKUS_OPENSHIFT_ROUTE_TLS_DESTINATION_CA_CERTIFICATE

string

 

lock quarkus.openshift.route.tls.insecure-edge-termination-policy

The desired behavior for insecure connections to a route.

Environment variable: QUARKUS_OPENSHIFT_ROUTE_TLS_INSECURE_EDGE_TERMINATION_POLICY

string

 

lock quarkus.openshift.route.tls.key

The key file contents.

Environment variable: QUARKUS_OPENSHIFT_ROUTE_TLS_KEY

string

 

lock quarkus.openshift.route.tls.termination

The termination type.

Environment variable: QUARKUS_OPENSHIFT_ROUTE_TLS_TERMINATION

string

 

lock quarkus.openshift.job.parallelism

Specifies the maximum desired number of pods the job should run at any given time.

Environment variable: QUARKUS_OPENSHIFT_JOB_PARALLELISM

int

 

lock quarkus.openshift.job.completions

Specifies the desired number of successfully finished pods the job should be run with.

Environment variable: QUARKUS_OPENSHIFT_JOB_COMPLETIONS

int

 

lock quarkus.openshift.job.completion-mode

CompletionMode specifies how Pod completions are tracked.

Environment variable: QUARKUS_OPENSHIFT_JOB_COMPLETION_MODE

non-indexed, indexed

non-indexed

lock quarkus.openshift.job.backoff-limit

Specifies the number of retries before marking this job failed.

Environment variable: QUARKUS_OPENSHIFT_JOB_BACKOFF_LIMIT

int

 

lock quarkus.openshift.job.active-deadline-seconds

Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer.

Environment variable: QUARKUS_OPENSHIFT_JOB_ACTIVE_DEADLINE_SECONDS

long

 

lock quarkus.openshift.job.ttl-seconds-after-finished

Limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted.

Environment variable: QUARKUS_OPENSHIFT_JOB_TTL_SECONDS_AFTER_FINISHED

int

 

lock quarkus.openshift.job.suspend

Suspend specifies whether the Job controller should create Pods or not.

Environment variable: QUARKUS_OPENSHIFT_JOB_SUSPEND

boolean

false

lock quarkus.openshift.job.restart-policy

Restart policy when the job container fails.

Environment variable: QUARKUS_OPENSHIFT_JOB_RESTART_POLICY

on-failure, never

on-failure

lock quarkus.openshift.cron-job.schedule

The schedule in Cron format, see Cron.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_SCHEDULE

string

 

lock quarkus.openshift.cron-job.time-zone

The time zone for the job schedule. The default value is the local time of the kube-controller-manager.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_TIME_ZONE

string

 

lock quarkus.openshift.cron-job.concurrency-policy

ConcurrencyPolicy describes how the job will be handled.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_CONCURRENCY_POLICY

allow, forbid, replace

allow

lock quarkus.openshift.cron-job.starting-deadline-seconds

Deadline in seconds for starting the job if it misses scheduled time for any reason. Missed jobs executions will be counted as failed ones.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_STARTING_DEADLINE_SECONDS

long

 

lock quarkus.openshift.cron-job.failed-jobs-history-limit

The number of failed finished jobs to retain. The default value is 1.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_FAILED_JOBS_HISTORY_LIMIT

int

 

lock quarkus.openshift.cron-job.successful-jobs-history-limit

The number of successful finished jobs to retain. The default value is 3.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_SUCCESSFUL_JOBS_HISTORY_LIMIT

int

 

lock quarkus.openshift.cron-job.parallelism

Specifies the maximum desired number of pods the job should run at any given time.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_PARALLELISM

int

 

lock quarkus.openshift.cron-job.completions

Specifies the desired number of successfully finished pods the job should be run with.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_COMPLETIONS

int

 

lock quarkus.openshift.cron-job.completion-mode

CompletionMode specifies how Pod completions are tracked.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_COMPLETION_MODE

non-indexed, indexed

non-indexed

lock quarkus.openshift.cron-job.backoff-limit

Specifies the number of retries before marking this job failed.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_BACKOFF_LIMIT

int

 

lock quarkus.openshift.cron-job.active-deadline-seconds

Specifies the duration in seconds relative to the startTime that the job may be continuously active before the system tries to terminate it; value must be positive integer.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_ACTIVE_DEADLINE_SECONDS

long

 

lock quarkus.openshift.cron-job.ttl-seconds-after-finished

Limits the lifetime of a Job that has finished execution (either Complete or Failed). If this field is set, ttlSecondsAfterFinished after the Job finishes, it is eligible to be automatically deleted.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_TTL_SECONDS_AFTER_FINISHED

int

 

lock quarkus.openshift.cron-job.suspend

Suspend specifies whether the Job controller should create Pods or not.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_SUSPEND

boolean

false

lock quarkus.openshift.cron-job.restart-policy

Restart policy when the job container fails.

Environment variable: QUARKUS_OPENSHIFT_CRON_JOB_RESTART_POLICY

on-failure, never

on-failure

lock quarkus.openshift.remote-debug.enabled

If true, the debug mode in pods will be enabled.

Environment variable: QUARKUS_OPENSHIFT_REMOTE_DEBUG_ENABLED

boolean

false

lock quarkus.openshift.remote-debug.transport

The transport to use.

Environment variable: QUARKUS_OPENSHIFT_REMOTE_DEBUG_TRANSPORT

string

dt_socket

lock quarkus.openshift.remote-debug.suspend

If enabled, it means the JVM will wait for the debugger to attach before executing the main class. If false, the JVM will immediately execute the main class, while listening for the debugger connection.

Environment variable: QUARKUS_OPENSHIFT_REMOTE_DEBUG_SUSPEND

string

n

lock quarkus.openshift.remote-debug.address-port

It specifies the address at which the debug socket will listen.

Environment variable: QUARKUS_OPENSHIFT_REMOTE_DEBUG_ADDRESS_PORT

int

5005

lock quarkus.openshift.init-tasks."task-name".enabled

If true, the init task will be generated. Otherwise, the init task resource generation will be skipped.

Environment variable: QUARKUS_OPENSHIFT_INIT_TASKS__TASK_NAME__ENABLED

boolean

true

lock quarkus.openshift.init-tasks."task-name".wait-for-container.image

The init task image to use by the init container.

Environment variable: QUARKUS_OPENSHIFT_INIT_TASKS__TASK_NAME__WAIT_FOR_CONTAINER_IMAGE

string

groundnuty/k8s-wait-for:no-root-v1.7

lock quarkus.openshift.init-tasks."task-name".wait-for-container.image-pull-policy

Image pull policy.

Environment variable: QUARKUS_OPENSHIFT_INIT_TASKS__TASK_NAME__WAIT_FOR_CONTAINER_IMAGE_PULL_POLICY

always, if-not-present, never

always

lock quarkus.openshift.init-task-defaults.enabled

If true, the init task will be generated. Otherwise, the init task resource generation will be skipped.

Environment variable: QUARKUS_OPENSHIFT_INIT_TASK_DEFAULTS_ENABLED

boolean

true

lock quarkus.openshift.init-task-defaults.wait-for-container.image

The init task image to use by the init container.

Environment variable: QUARKUS_OPENSHIFT_INIT_TASK_DEFAULTS_WAIT_FOR_CONTAINER_IMAGE

string

groundnuty/k8s-wait-for:no-root-v1.7

lock quarkus.openshift.init-task-defaults.wait-for-container.image-pull-policy

Image pull policy.

Environment variable: QUARKUS_OPENSHIFT_INIT_TASK_DEFAULTS_WAIT_FOR_CONTAINER_IMAGE_PULL_POLICY

always, if-not-present, never

always

lock quarkus.openshift.deploy

If set to true, Quarkus will attempt to deploy the application to the target Kubernetes cluster

Environment variable: QUARKUS_OPENSHIFT_DEPLOY

boolean

false

lock quarkus.openshift.deploy-strategy

If deploy is enabled, it will follow this strategy to update the resources to the target Kubernetes cluster.

Environment variable: QUARKUS_OPENSHIFT_DEPLOY_STRATEGY

create-or-update, create, replace, server-side-apply

create-or-update

About the Duration format

To write duration values, use the standard java.time.Duration format. See the Duration#parse() Java API documentation for more information.

You can also use a simplified format, starting with a number:

  • If the value is only a number, it represents time in seconds.
  • If the value is a number followed by ms, it represents time in milliseconds.

In other cases, the simplified format is translated to the java.time.Duration format for parsing:

  • If the value is a number followed by h, m, or s, it is prefixed with PT.
  • If the value is a number followed by d, it is prefixed with P.

Chapter 2. Deploying Red Hat build of Quarkus applications to OpenShift Container Platform in a single step

As an application developer, you build and deploy your Red Hat build of Quarkus applications to OpenShift Container Platform in a single step. Complete one of the following commands:

  • Using the Quarkus CLI: 

    quarkus build quarkus deploy openshift
    Copy to clipboard

  • Using Maven: 

    ./mvnw install -Dquarkus.openshift.deploy=true
    Copy to clipboard

  • Using Gradle: 

    ./gradlew build -Dquarkus.openshift.deploy=true
    Copy to clipboard

With these commands, you build your application locally, trigger a container image build, and apply the generated OpenShift Container Platform resources automatically.

The generated resources use a Kubernetes Deployment, but still make use of OpenShift-specific resources, such as Route, BuildConfig, and so on.

2.1. Prerequisites

  • You have OpenJDK 17 or later installed.
  • You have set the JAVA_HOME environment variable to the location of the Java SDK.
  • You have access to an OpenShift Container Platform cluster and the latest compatible version of the oc CLI tool installed.
  • You are working in the correct OpenShift project namespace.
Note

To run this deployment, it is not necessary to have the quarkus-openshift extension included in your Red Hat build of Quarkus project.

2.2. Procedure

  1. Trigger a build and deployment in a single step:

  • Using the Quarkus CLI: 

    quarkus build quarkus deploy openshift
    Copy to clipboard

  • Using Maven: 

    ./mvnw install -Dquarkus.openshift.deploy=true
    Copy to clipboard

  • Using Gradle: 

    ./gradlew build -Dquarkus.openshift.deploy=true
    Copy to clipboard
Tip

If you want to test your application immediately, set the quarkus.openshift.route.expose configuration property to true to expose the service automatically.

For example, add -Dquarkus.openshift.route.expose=true to the above command. For more information, see Exposing routes.

Note

As of OpenShift Container Platform 4.14, the DeploymentConfig object is deprecated. Deployment is now the default and preferred deployment kind for the quarkus-openshift extension.

Because of this change, consider the following:

  • If you redeploy applications that you previously deployed 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. If you want to continue to use DeploymentConfig, it is still possible to do so by explicitly setting quarkus.openshift.deployment-kind to DeploymentConfig.
  • Deployment is a Kubernetes resource and not OpenShift specific, so it cannot leverage ImageStream resources, as is the case with DeploymentConfig. Therefore, the image references must include the container image registry that hosts the image.

For more information about the deprecation, how to set up and use automatic rollbacks, triggers, lifecycle hooks, and custom strategies, see the Red Hat Knowledgebase article DeploymentConfig API is being deprecated in Red Hat OpenShift Container Platform 4.14.

2.3. Verification

  1. Verify that an image stream and a service resource are created and the application is deployed by using the OpenShift Container Platform web console. 

    quarkus.container-image.group=<project/namespace name>
    Copy to clipboard

    Alternatively, run the following OpenShift Container Platform command-line interface (CLI) commands: 

    oc get is 1
oc get pods 2
oc get svc 3
    Copy to clipboard
    1
    List the image streams created.
    2
    List the pods associated with your current OpenShift project.
    3
    List the Kubernetes services.

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

    oc logs -f <pod_name>
    Copy to clipboard

    By default, the service is not exposed to the outside world. Therefore, if you did not expose the created service automatically by setting the quarkus.openshift.route.expose=true property before building the application, you can expose the service manually. 

    oc expose svc/openshift-quickstart 1
oc get routes 2
curl http://<route>/hello 3
    Copy to clipboard
    1
    Expose the service.
    2
    Get the list of exposed routes.
    3
    Access your application.

2.4. References

Chapter 3. Deploying Red Hat build of Quarkus Java applications to OpenShift Container Platform by using a Docker build strategy

As an application developer, you can deploy your applications to OpenShift Container Platform by using the Docker build strategy as a deployment option.

This stategy 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 OpenShift Container Platform cluster builds the container and provides it as an image stream.

This functionality is provided by the quarkus-openshift extension. If you want to use a custom Dockerfile, add the file to the src/main/docker directory or any location inside the module. Additionally, set the path to your Dockerfile by using the quarkus.openshift.jvm-dockerfile property.

3.1. 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 project that includes the quarkus-openshift extension.
  • You have access to a OpenShift Container Platform cluster and the latest compatible version of the oc CLI tool installed.
  • You are working in the correct OpenShift project namespace.

3.2. Procedure

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

    quarkus.openshift.build-strategy=docker
    Copy to clipboard

  2. Optional: Set the following properties in the application.properties file, based on your environment:

    • If you are using an untrusted certificate, enable certificate trust for the KubernetesClient: 

      quarkus.kubernetes-client.trust-certs=true
      Copy to clipboard

    • To expose the service and create an OpenShift Container Platform route, set the following property: 

      quarkus.openshift.route.expose=true
      Copy to clipboard

    • To use a custom Dockerfile instead of the pregenerated Dockerfiles, set the path to your Dockerfile: 

      quarkus.openshift.jvm-dockerfile=<path_to_your_dockerfile>
      Copy to clipboard

      For example, to specify a custom Dockerfile named Dockerfile.custom-jvm: 

      quarkus.openshift.jvm-dockerfile=src/main/resources/Dockerfile.custom-jvm
      Copy to clipboard

  3. Package and deploy your application to the current OpenShift Container Platform project: 

    ./mvnw clean package -Dquarkus.openshift.deploy=true
    Copy to clipboard

3.3. Verification

The following verification steps use the openshift-helloworld example application.

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

    oc get pods
    Copy to clipboard
    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
    Copy to clipboard

  2. To get the log output for your application’s pod, use the oc logs -f command with its name. The following example uses the openshift-helloworld-1-gzzrx pod name, which corresponds to the latest pod prefixed with the name of your application: 

    oc logs -f openshift-helloworld-1-gzzrx
    Copy to clipboard
    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-09-17 10:23:25,254 INFO  [io.quarkus] (main) getting-started 1.0.0-SNAPSHOT on JVM (powered by Quarkus 3.20.0.redhat-00002) started in 0.653s. Listening on: http://0.0.0.0:8080
2024-09-17 10:23:25,281 INFO  [io.quarkus] (main) Profile prod activated.
2024-09-17 10:23:25,281 INFO  [io.quarkus] (main) Installed features: [cdi, kubernetes, rest, smallrye-context-propagation, vertx]
    Copy to clipboard

  3. Get a list of services: 

    oc get svc
    Copy to clipboard
    NAME                   TYPE        CLUSTER-IP       EXTERNAL-IP   PORT(S)                               AGE
openshift-helloworld   ClusterIP   172.30.64.57     <none>        80/TCP                                14m
    Copy to clipboard

  4. Get a URL to test your application. To do so, ensure you have exposed an OpenShift Container Platform route by setting the quarkus.openshift.route.expose=true property in the application.properties file before building the application. 

    oc get routes
    Copy to clipboard
    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
    Copy to clipboard
    Note

    Be aware that the route is now listening on port 80 and is no longer on 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 from oc get routes, that is, "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.

3.4. References

Chapter 4. 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 Red Hat 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 code at build time.

The deployment procedure differs based on the Java version your Red Hat build of Quarkus application uses.

4.1. Deploying Red Hat build of Quarkus applications to OpenShift Container Platform with Java 17

You can deploy Red Hat build of Quarkus applications that run Java 17 to OpenShift Container Platform by using the S2I method.

4.1.1. Prerequisites

  • You have a Quarkus application built with Java 17.
  • Optional: You have a Quarkus project that includes the quarkus-openshift extension.
  • You are working in the correct OpenShift project namespace.
  • Your project is hosted in a Git repository.

4.1.2. Procedure

  1. Open the pom.xml file, and set the Java version to 17: 

    <maven.compiler.source>17</maven.compiler.source>
<maven.compiler.target>17</maven.compiler.target>
    Copy to clipboard

  2. Package your Java 17 application, by entering the following command: 

    ./mvnw clean package
    Copy to clipboard
  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
  5. Commit and push your changes to the remote Git repository.

  6. Import the supported OpenShift Container Platform image by entering the following command: 

    oc import-image ubi9/openjdk-17 --from=registry.access.redhat.com/ubi9/openjdk-17 --confirm
    Copy to clipboard
    Note
    • If you are using the OpenShift image registry and pulling from image streams in the same project, your pod service account must 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 the Red Hat Openshift Container Platform documentation.

  7. Build the project, create the application, and deploy the OpenShift Container Platform service: 

    oc new-app registry.access.redhat.com/ubi9/openjdk-17~<git_path> --name=<project_name>
    Copy to clipboard

    • Replace <git_path> with the path of the Git repository that hosts your Quarkus project. For example, oc new-app registry.access.redhat.com/ubi9/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.

    • Replace <project_name> with the name of your application.

  8. To deploy an updated version of the project, push changes to the Git repository, and then run: 

    oc start-build <project_name>
    Copy to clipboard

  9. To expose a route to the application, run the following command: 

    oc expose svc <project_name>
    Copy to clipboard

4.1.3. Verification

  1. List the pods associated with your current OpenShift Container Platform project: 

    oc get pods
    Copy to clipboard

  2. To get the log output for your application’s pod, run the following command, replacing <pod_name> with the name of the latest pod prefixed by your application name: 

    oc logs -f <pod_name>
    Copy to clipboard

4.2. Deploying Red Hat build of Quarkus applications to OpenShift Container Platform with Java 21

You can deploy Red Hat build of Quarkus applications that run Java 21 to OpenShift Container Platform by using the S2I method.

4.2.1. Prerequisites

  • Optional: You have a Quarkus Maven project that includes the quarkus-openshift extension.
  • You are working in the correct OpenShift Container Platform project namespace.
  • Your project is hosted in a Git repository.

4.2.2. Procedure

  1. Open the pom.xml file, and set the Java version to 21: 

    <maven.compiler.source>21</maven.compiler.source>
<maven.compiler.target>21</maven.compiler.target>
    Copy to clipboard

  2. Package your Java 21 application, by entering the following command: 

    ./mvnw clean package
    Copy to clipboard
  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
  5. Commit and push your changes to the remote Git repository.

  6. Import the supported OpenShift Container Platform image by entering the following command: 

    oc import-image ubi9/openjdk-21 --from=registry.access.redhat.com/ubi9/openjdk-21 --confirm
    Copy to clipboard
    Note
    • If you are using the OpenShift image registry and pulling from image streams in the same project, your pod service account must 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 the Red Hat Openshift Container Platform documentation.
    • If you are deploying on IBM Z infrastructure, enter oc import-image ubi9/openjdk-21 --from=registry.redhat.io/ubi9/openjdk-21 --confirm instead. For information about this image, see Red Hat build of OpenJDK 21.

  7. Build the project, create the application, and deploy the OpenShift Container Platform service: 

    oc new-app registry.access.redhat.com/ubi9/openjdk-21~<git_path> --name=<project_name>
    Copy to clipboard

    • Replace <git_path> with the path of the Git repository that hosts your Quarkus project. For example, oc new-app registry.access.redhat.com/ubi9/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.

    • Replace <project_name> with the name of your application.

      Note

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

  8. To deploy an updated version of the project, push changes to the Git repository, and then run: 

    oc start-build <project_name>
    Copy to clipboard

  9. To expose a route to the application, run the following command: 

    oc expose svc <project_name>
    Copy to clipboard

4.2.3. Verification

  1. List the pods associated with your current OpenShift Container Platform project: 

    oc get pods
    Copy to clipboard

  2. To get the log output for your application’s pod, run the following command, replacing <pod_name> with the name of the latest pod prefixed by your application name: 

    oc logs -f <pod_name>
    Copy to clipboard

4.3. References

Chapter 5. Deploying Red Hat build of Quarkus applications compiled to native executables

You can deploy your native Red Hat build of Quarkus applications to OpenShift Container Platform compiled to native executables by using the Docker build strategy.

You must create a native executable for your application that targets a supported operating system and match the architecture. This means, if you are building on Windows, you create a native Linux executable by using a container runtime, for example, Docker or Podman.

Your Quarkus project includes pregenerated Dockerfiles with instructions. If you want to use a custom Dockerfile, add the file to the src/main/docker directory or any location inside the module. Additionally, if you want to have multiple Docker files and switch between them, set the path to your preferred Dockerfile by using the quarkus.openshift.native-dockerfile property.

Note

This guide describes this strategy by using a Quarkus project with Maven as the example project.

5.1. Prerequisites

  • A supported operating 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 have access to an OpenShift Container Platform cluster and the latest compatible version of the oc CLI tool installed.
  • You are working in the correct OpenShift project namespace.

5.2. Procedure

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

    quarkus.openshift.build-strategy=docker
    Copy to clipboard

  2. Enable container-based native builds: 

    quarkus.native.container-build=true
    Copy to clipboard

  3. Optional: Set the following properties in the application.properties file based on your environment:

    • If you are using an untrusted certificate, enable certificate trust for the KubernetesClient: 

      quarkus.kubernetes-client.trust-certs=true
      Copy to clipboard

    • To expose the service and create an OpenShift Container Platform route, set the following property: 

      quarkus.openshift.route.expose=true
      Copy to clipboard

    • To use a custom Dockerfile instead of the pregenerated Dockerfiles, set the path to your custom Dockerfile: 

      quarkus.openshift.native-dockerfile=<path_to_your_dockerfile>
      Copy to clipboard

      For example, to specify a custom Dockerfile named Dockerfile.custom-native: 

      quarkus.openshift.native-dockerfile=src/main/docker/Dockerfile.custom-native
      Copy to clipboard

    • Specify the container engine:

      • To build a native executable with Podman: 

        quarkus.native.container-runtime=podman
        Copy to clipboard

      • To build a native executable with Docker: 

        quarkus.native.container-runtime=docker
        Copy to clipboard

  4. Finally, build the native executable, package, and deploy your application to OpenShift Container Platform: 

    ./mvnw clean package -Pnative -Dquarkus.openshift.deploy=true
    Copy to clipboard

5.3. Verification

  1. Verify that an image stream and a service resource are created, and that the application is deployed. Use the OpenShift Container Platform web console or the following OpenShift Container Platform command-line interface (CLI) commands: 

    oc get is 1
oc get pods 2
oc get svc 3
    Copy to clipboard
    1
    List the image streams created.
    2
    List the pods associated with your current OpenShift project.
    3
    List the Kubernetes services.

  1. To get the log output for your application’s pod, run 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

5.4. References

Legal Notice

Copyright © 2025 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
Back to top
Red Hat logoGithubredditYoutubeTwitter

Learn

Try, buy, & sell

Communities

About Red Hat Documentation

We help Red Hat users innovate and achieve their goals with our products and services with content they can trust. Explore our recent updates.

Making open source more inclusive

Red Hat is committed to replacing problematic language in our code, documentation, and web properties. For more details, see the Red Hat Blog.

About Red Hat

We deliver hardened solutions that make it easier for enterprises to work across platforms and environments, from the core datacenter to the network edge.

Theme

© 2025 Red Hat, Inc.