# Deploying Quarkus applications to OpenShift

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

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

- With a single step

- By using a Docker build strategy

- By using a Source-to-Image (S2I) strategy

- Compiled to native executables

## 1. Overview of OpenShift build strategies

Docker build

  This strategy builds the artifacts outside the OpenShift cluster, locally or in a CI environment, and provides them to the OpenShift build system together with a Dockerfile. The artifacts include JAR files or a native executable. The container gets built inside the OpenShift cluster and is provided as an image stream.

| The OpenShift 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 Docker build strategy, use the `quarkus.openshift.build-strategy` property.

Source to Image (S2I)

  The build process is performed inside the OpenShift cluster. Quarkus fully supports using S2I to deploy 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. Build strategies supported by Quarkus

The following table outlines the build strategies that Quarkus supports:

Build strategy | Support for Quarkus tools | Support for JVM | Support for native | Support for JVM Serverless | Support for native Serverless
--- | --- | --- | --- | --- | ---
Docker build | YES | YES | YES | YES | YES
S2I Binary | YES | YES | NO | NO | NO
Source S2I | NO | YES | NO | NO | NO

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

### 2.1. Adding the OpenShift extension

To build and deploy your applications as a container image that runs inside your OpenShift cluster, you must add the Quarkus OpenShift extension `quarkus-openshift` as a dependency to your project.

This extension also generates OpenShift resources such as image streams, build configuration, deployment, and service definitions. If your application includes the `quarkus-smallrye-health` extension, OpenShift can access the health endpoint and verify the startup, liveness, and readiness of your application.

| From Quarkus 3.8, the `DeploymentConfig` object, deprecated in OpenShift, is also deprecated in 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>

   - Enter the following command on the OpenShift CLI:

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

   - Enter the following command on the Quarkus CLI:

         quarkus extension add 'quarkus-openshift'

## 3. Logging in to an OpenShift cluster

You can log in to an OpenShift 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)

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

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

CLI

    quarkus build quarkus deploy openshift

Maven

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

Gradle

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

### 3.1. Switching to the required OpenShift project

You can use the OpenShift CLI to create applications and manage your OpenShift projects. Use the information provided to create an OpenShift project or to switch to an existing one.

Prerequisites

- You have access to an OpenShift cluster and the latest compatible version of the `oc` tool installed.

Procedure

1. Log in to the `oc` tool:

       oc login

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

       oc project -q

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

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

          oc project <project_name>

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

          oc new-project <project_name>

## 4. Building and deploying

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

- With a single step

- By using a Docker build strategy

- By using a Source-to-Image (S2I) strategy

- Compiled to native executables

### 4.1. Configuring the OpenShift application manually

If you need more control over the deployment configuration, you can build the container image first and then configure the OpenShift application manually.

To trigger a container image build:

    ./mvnw clean package -Dquarkus.container-image.build=true

The build that is performed is a s2i binary build. The input of the build is the JAR file that has been built locally and the build output is an `ImageStream` that is configured to automatically trigger a deployment. The base or builder image is specified by using `base-jvm-image` and `base-native-image` for JVM and native mode respectively. An `ImageStream` for the image is automatically generated, unless these properties are used to reference an existing `ImageStreamTag` in the internal openshift registry. For example:

    quarkus.openshift.base-jvm-image=image-registry.openshift-image-registry.svc:5000/some-project/openjdk-11:17.1.16.

| During the build you might find the `Caused by: javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path building failed` exception due to self-signed certificate. To solve this, add the following line to your `application.properties` file:
    quarkus.kubernetes-client.trust-certs=true
For more information, see deploying to Kubernetes.

After the build is finished, you can create a new application from the relevant `ImageStream`.

    oc get is (1)
    oc new-app --name=greeting <project>/openshift-quickstart:1.0.0-SNAPSHOT (2)
    oc get svc
    oc expose svc/greeting (3)
    oc get routes (4)
    curl http://<route>/hello (5)

1 | Lists the image streams created. The image stream of our application should be tagged as <project>/openshift-quickstart:1.0.0-SNAPSHOT.
2 | Create a new application from the image source.
3 | Expose the service to the outside world.
4 | Get the list of exposed routes.
5 | Access your application.

After this setup the next time the container image is built a deployment to OpenShift is triggered automatically. In other words, you do not need to repeat the above steps.

### 4.2. 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:

- container-image-docker

- container-image-jib

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

or

    quarkus.container-image.builder=jib

## 5. Customizing

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

Some examples are provided in the sections below:

### 5.1. Exposing routes

To expose a `Route` for the Quarkus application:

    quarkus.openshift.route.expose=true

| 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
The same applies to all properties listed below.

#### 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

### 5.2. Labels

To add a label in the generated resources:

    quarkus.openshift.labels.foo=bar

### 5.3. Annotations

To add an annotation in the generated resources:

    quarkus.openshift.annotations.foo=bar

### 5.4. Environment variables

OpenShift 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

#### 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

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

#### 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

which generates the following in the container definition:

    envFrom:
      - secretRef:
          name: my-secret
          optional: false
      - secretRef:
          name: my-other-secret
          optional: false

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

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

    - env:
      - name: FOO
        valueFrom:
          secretKeyRef:
            key: keyName
            name: my-secret
            optional: false

#### 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

which generates the following in the container definition:

    envFrom:
      - configMapRef:
          name: my-config-map
          optional: false
      - configMapRef:
          name: another-config-map
          optional: false

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

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

    - env:
      - name: FOO
        valueFrom:
          configMapKeyRef:
            key: keyName
            name: my-configmap
            optional: false

#### 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

#### 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

##### 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

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

##### 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 * * * *

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

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

##### 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. 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` |

    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.

### 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

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:

#### 5.5.1. Secret volumes

    quarkus.openshift.secret-volumes.my-volume.secret-name=my-secret

#### 5.5.2. ConfigMap volumes

    quarkus.openshift.config-map-volumes.my-volume.config-map-name=my-config-map

#### 5.5.3. Persistent volume claims

    quarkus.openshift.pvc-volumes.my-pvc.claim-name=my-pvc

## 6. Knative - OpenShift Serverless

OpenShift also provides the ability to use Knative by using the OpenShift Serverless functionality.

First, you instruct Quarkus to generate Knative resources:

    quarkus.kubernetes.deployment-target=knative

To leverage OpenShift S2I to build the container image on the cluster and use the resulting container image for the Knative application, set the following configuration properties:

    # set the Kubernetes namespace which will be used to run the application
    quarkus.container-image.group=geoand
    # set the container image registry - this is the standard URL used to refer to the internal OpenShift registry
    quarkus.container-image.registry=image-registry.openshift-image-registry.svc:5000

You can then deploy the application to OpenShift Serverless by enabling the standard `quarkus.kubernetes.deploy=true` property.

## 7. Configuration Reference

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

Configuration property | Type | Default
--- | --- | ---
`quarkus.openshift.env.secrets` The optional list of Secret names to load environment variables from. Environment variable: `QUARKUS_OPENSHIFT_ENV_SECRETS` | list of string |
`quarkus.openshift.env.configmaps` The optional list of ConfigMap names to load environment variables from. Environment variable: `QUARKUS_OPENSHIFT_ENV_CONFIGMAPS` | list of string |
`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> |
`quarkus.openshift.env.vars."vars"` The environment variable value Environment variable: `QUARKUS_OPENSHIFT_ENV_VARS__VARS_` | string |
`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 |
`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 |
`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
`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 |
`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 |
`quarkus.openshift.part-of` The name of the group this component belongs too. Environment variable: `QUARKUS_OPENSHIFT_PART_OF` | string |
`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 |
`quarkus.openshift.version` The version of the application. Environment variable: `QUARKUS_OPENSHIFT_VERSION` | string |
`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 |
`quarkus.openshift.labels."label-name"` Custom labels to add to all resources. Environment variable: `QUARKUS_OPENSHIFT_LABELS__LABEL_NAME_` | Map<String,String> |
`quarkus.openshift.annotations."annotation-name"` Custom annotations to add to all resources. Environment variable: `QUARKUS_OPENSHIFT_ANNOTATIONS__ANNOTATION_NAME_` | Map<String,String> |
`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`
`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`
`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`
`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`
`quarkus.openshift.working-dir` Working directory. Environment variable: `QUARKUS_OPENSHIFT_WORKING_DIR` | string |
`quarkus.openshift.command` The commands. Environment variable: `QUARKUS_OPENSHIFT_COMMAND` | list of string |
`quarkus.openshift.arguments` The arguments. Environment variable: `QUARKUS_OPENSHIFT_ARGUMENTS` | list of string |
`quarkus.openshift.service-account` The service account. Environment variable: `QUARKUS_OPENSHIFT_SERVICE_ACCOUNT` | string |
`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 |
`quarkus.openshift.ports."ports".container-port` The port number. Refers to the container port. Environment variable: `QUARKUS_OPENSHIFT_PORTS__PORTS__CONTAINER_PORT` | int |
`quarkus.openshift.ports."ports".host-port` The host port. Environment variable: `QUARKUS_OPENSHIFT_PORTS__PORTS__HOST_PORT` | int |
`quarkus.openshift.ports."ports".path` The application path (refers to web application path). Environment variable: `QUARKUS_OPENSHIFT_PORTS__PORTS__PATH` | string | `/`
`quarkus.openshift.ports."ports".protocol` The protocol. Environment variable: `QUARKUS_OPENSHIFT_PORTS__PORTS__PROTOCOL` | `tcp`, `udp`, `sctp`, `http`, `proxy` | `tcp`
`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 |
`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`
`quarkus.openshift.image-pull-policy` Image pull policy. Environment variable: `QUARKUS_OPENSHIFT_IMAGE_PULL_POLICY` | `always`, `if-not-present`, `never` | `always`
`quarkus.openshift.image-pull-secrets` The image pull secret. Environment variable: `QUARKUS_OPENSHIFT_IMAGE_PULL_SECRETS` | list of string |
`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`
`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 |
`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 |
`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 |
`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 |
`quarkus.openshift.liveness-probe.exec-action` The command to use for the probe. Environment variable: `QUARKUS_OPENSHIFT_LIVENESS_PROBE_EXEC_ACTION` | string |
`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 |
`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 |
`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`
`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 | `5S`
`quarkus.openshift.liveness-probe.period` The period in which the action should be called. Environment variable: `QUARKUS_OPENSHIFT_LIVENESS_PROBE_PERIOD` | Duration | `10S`
`quarkus.openshift.liveness-probe.timeout` The amount of time to wait for each action. Environment variable: `QUARKUS_OPENSHIFT_LIVENESS_PROBE_TIMEOUT` | Duration | `10S`
`quarkus.openshift.liveness-probe.success-threshold` The success threshold to use. Environment variable: `QUARKUS_OPENSHIFT_LIVENESS_PROBE_SUCCESS_THRESHOLD` | int | `1`
`quarkus.openshift.liveness-probe.failure-threshold` The failure threshold to use. Environment variable: `QUARKUS_OPENSHIFT_LIVENESS_PROBE_FAILURE_THRESHOLD` | int | `3`
`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 |
`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 |
`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 |
`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 |
`quarkus.openshift.readiness-probe.exec-action` The command to use for the probe. Environment variable: `QUARKUS_OPENSHIFT_READINESS_PROBE_EXEC_ACTION` | string |
`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 |
`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 |
`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`
`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 | `5S`
`quarkus.openshift.readiness-probe.period` The period in which the action should be called. Environment variable: `QUARKUS_OPENSHIFT_READINESS_PROBE_PERIOD` | Duration | `10S`
`quarkus.openshift.readiness-probe.timeout` The amount of time to wait for each action. Environment variable: `QUARKUS_OPENSHIFT_READINESS_PROBE_TIMEOUT` | Duration | `10S`
`quarkus.openshift.readiness-probe.success-threshold` The success threshold to use. Environment variable: `QUARKUS_OPENSHIFT_READINESS_PROBE_SUCCESS_THRESHOLD` | int | `1`
`quarkus.openshift.readiness-probe.failure-threshold` The failure threshold to use. Environment variable: `QUARKUS_OPENSHIFT_READINESS_PROBE_FAILURE_THRESHOLD` | int | `3`
`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 |
`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 |
`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 |
`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 |
`quarkus.openshift.startup-probe.exec-action` The command to use for the probe. Environment variable: `QUARKUS_OPENSHIFT_STARTUP_PROBE_EXEC_ACTION` | string |
`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 |
`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 |
`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`
`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 | `5S`
`quarkus.openshift.startup-probe.period` The period in which the action should be called. Environment variable: `QUARKUS_OPENSHIFT_STARTUP_PROBE_PERIOD` | Duration | `10S`
`quarkus.openshift.startup-probe.timeout` The amount of time to wait for each action. Environment variable: `QUARKUS_OPENSHIFT_STARTUP_PROBE_TIMEOUT` | Duration | `10S`
`quarkus.openshift.startup-probe.success-threshold` The success threshold to use. Environment variable: `QUARKUS_OPENSHIFT_STARTUP_PROBE_SUCCESS_THRESHOLD` | int | `1`
`quarkus.openshift.startup-probe.failure-threshold` The failure threshold to use. Environment variable: `QUARKUS_OPENSHIFT_STARTUP_PROBE_FAILURE_THRESHOLD` | int | `3`
`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`
`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`
`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`
`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 |
`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 |
`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 |
`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 |
`quarkus.openshift.mounts."mounts".name` The name of the volumeName to mount. Environment variable: `QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__NAME` | string |
`quarkus.openshift.mounts."mounts".path` The path to mount. Environment variable: `QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__PATH` | string |
`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 |
`quarkus.openshift.mounts."mounts".read-only` ReadOnly. Environment variable: `QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__READ_ONLY` | boolean | `false`
`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
`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`
`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
`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`
`quarkus.openshift.secret-volumes."secret-volumes".optional` Optional Environment variable: `QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__OPTIONAL` | boolean | `false`
`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
`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`
`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
`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`
`quarkus.openshift.config-map-volumes."config-map-volumes".optional` Optional Environment variable: `QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__OPTIONAL` | boolean | `false`
`quarkus.openshift.empty-dir-volumes` EmptyDir volumes. Environment variable: `QUARKUS_OPENSHIFT_EMPTY_DIR_VOLUMES` | list of string |
`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
`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 |
`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 |
`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
`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`
`quarkus.openshift.pvc-volumes."pvc-volumes".optional` Optional Environment variable: `QUARKUS_OPENSHIFT_PVC_VOLUMES__PVC_VOLUMES__OPTIONAL` | boolean | `false`
`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
`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 |
`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`
`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`
`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
`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
`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`
`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
`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
`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`
`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`
`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`
`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`
`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 |
`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 |
`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> |
`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 |
`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 |
`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 |
`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
`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 |
`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 |
`quarkus.openshift.init-containers."init-containers".image` The container image. Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE` | string |
`quarkus.openshift.init-containers."init-containers".working-dir` Working directory. Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__WORKING_DIR` | string |
`quarkus.openshift.init-containers."init-containers".command` The commands Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__COMMAND` | list of string |
`quarkus.openshift.init-containers."init-containers".arguments` The arguments Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ARGUMENTS` | list of string |
`quarkus.openshift.init-containers."init-containers".service-account` The service account. Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__SERVICE_ACCOUNT` | string |
`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 |
`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 |
`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 |
`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 | `/`
`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`
`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 |
`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`
`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`
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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`
`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 | `5S`
`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 | `10S`
`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 | `10S`
`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`
`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`
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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`
`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 | `5S`
`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 | `10S`
`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 | `10S`
`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`
`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`
`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 |
`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 |
`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 |
`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`
`quarkus.openshift.init-containers."init-containers".resources.limits.cpu` CPU Requirements Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_CPU` | string |
`quarkus.openshift.init-containers."init-containers".resources.limits.memory` Memory Requirements Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_MEMORY` | string |
`quarkus.openshift.init-containers."init-containers".resources.requests.cpu` CPU Requirements Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_CPU` | string |
`quarkus.openshift.init-containers."init-containers".resources.requests.memory` Memory Requirements Environment variable: `QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_MEMORY` | string |
`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 |
`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 |
`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> |
`quarkus.openshift.sidecars."sidecars".env.vars."vars"` The environment variable value Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_VARS__VARS_` | string |
`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 |
`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 |
`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
`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 |
`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 |
`quarkus.openshift.sidecars."sidecars".image` The container image. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE` | string |
`quarkus.openshift.sidecars."sidecars".working-dir` Working directory. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__WORKING_DIR` | string |
`quarkus.openshift.sidecars."sidecars".command` The commands Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__COMMAND` | list of string |
`quarkus.openshift.sidecars."sidecars".arguments` The arguments Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ARGUMENTS` | list of string |
`quarkus.openshift.sidecars."sidecars".service-account` The service account. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__SERVICE_ACCOUNT` | string |
`quarkus.openshift.sidecars."sidecars".host` The host under which the application is going to be exposed. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__HOST` | string |
`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 |
`quarkus.openshift.sidecars."sidecars".ports."ports".host-port` The host port. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__HOST_PORT` | int |
`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 | `/`
`quarkus.openshift.sidecars."sidecars".ports."ports".protocol` The protocol. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__PROTOCOL` | `tcp`, `udp`, `sctp`, `http`, `proxy` | `tcp`
`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 |
`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`
`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`
`quarkus.openshift.sidecars."sidecars".image-pull-secrets` The image pull secrets. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE_PULL_SECRETS` | list of string |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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`
`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 | `5S`
`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 | `10S`
`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 | `10S`
`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`
`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`
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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`
`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 | `5S`
`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 | `10S`
`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 | `10S`
`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`
`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`
`quarkus.openshift.sidecars."sidecars".mounts."mounts".name` The name of the volumeName to mount. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__NAME` | string |
`quarkus.openshift.sidecars."sidecars".mounts."mounts".path` The path to mount. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__PATH` | string |
`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 |
`quarkus.openshift.sidecars."sidecars".mounts."mounts".read-only` ReadOnly. Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__READ_ONLY` | boolean | `false`
`quarkus.openshift.sidecars."sidecars".resources.limits.cpu` CPU Requirements Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_LIMITS_CPU` | string |
`quarkus.openshift.sidecars."sidecars".resources.limits.memory` Memory Requirements Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_LIMITS_MEMORY` | string |
`quarkus.openshift.sidecars."sidecars".resources.requests.cpu` CPU Requirements Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_REQUESTS_CPU` | string |
`quarkus.openshift.sidecars."sidecars".resources.requests.memory` Memory Requirements Environment variable: `QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_REQUESTS_MEMORY` | string |
`quarkus.openshift.hostaliases."host-aliases".ip` The ip address. Environment variable: `QUARKUS_OPENSHIFT_HOSTALIASES__HOST_ALIASES__IP` | string |
`quarkus.openshift.hostaliases."host-aliases".hostnames` The hostnames to resolve to the ip. Environment variable: `QUARKUS_OPENSHIFT_HOSTALIASES__HOST_ALIASES__HOSTNAMES` | list of string |
`quarkus.openshift.node-selector.key` The key of the nodeSelector. Environment variable: `QUARKUS_OPENSHIFT_NODE_SELECTOR_KEY` | string | required
`quarkus.openshift.node-selector.value` The value of the nodeSelector. Environment variable: `QUARKUS_OPENSHIFT_NODE_SELECTOR_VALUE` | string | required
`quarkus.openshift.resources.limits.cpu` CPU Requirements Environment variable: `QUARKUS_OPENSHIFT_RESOURCES_LIMITS_CPU` | string |
`quarkus.openshift.resources.limits.memory` Memory Requirements Environment variable: `QUARKUS_OPENSHIFT_RESOURCES_LIMITS_MEMORY` | string |
`quarkus.openshift.resources.requests.cpu` CPU Requirements Environment variable: `QUARKUS_OPENSHIFT_RESOURCES_REQUESTS_CPU` | string |
`quarkus.openshift.resources.requests.memory` Memory Requirements Environment variable: `QUARKUS_OPENSHIFT_RESOURCES_REQUESTS_MEMORY` | string |
`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 |
`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 |
`quarkus.openshift.rbac.roles."roles".name` The name of the role. Environment variable: `QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__NAME` | string |
`quarkus.openshift.rbac.roles."roles".namespace` The namespace of the role. Environment variable: `QUARKUS_OPENSHIFT_RBAC_ROLES__ROLES__NAMESPACE` | string |
`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> |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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> |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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> |
`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 |
`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 |
`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> |
`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 |
`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 |
`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 |
`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`
`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 |
`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 |
`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 |
`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> |
`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
`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 |
`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`
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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 |
`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> |
`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`, `always` |
`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`
`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`
`quarkus.openshift.vcs-uri.override` Optional override of the vcs-uri annotation. Environment variable: `QUARKUS_OPENSHIFT_VCS_URI_OVERRIDE` | string |
`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`
`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` |
`quarkus.openshift.replicas` The number of desired pods Environment variable: `QUARKUS_OPENSHIFT_REPLICAS` | int | `1`
`quarkus.openshift.node-port` The nodePort to set when serviceType is set to nodePort Environment variable: `QUARKUS_OPENSHIFT_NODE_PORT` | int |
`quarkus.openshift.route.expose` If true, the service will be exposed Environment variable: `QUARKUS_OPENSHIFT_ROUTE_EXPOSE` | boolean | `false`
`quarkus.openshift.route.host` The host under which the application is going to be exposed Environment variable: `QUARKUS_OPENSHIFT_ROUTE_HOST` | string |
`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`
`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> |
`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> |
`quarkus.openshift.route.tls.ca-certificate` The cert authority certificate contents. Environment variable: `QUARKUS_OPENSHIFT_ROUTE_TLS_CA_CERTIFICATE` | string |
`quarkus.openshift.route.tls.certificate` The certificate contents. Environment variable: `QUARKUS_OPENSHIFT_ROUTE_TLS_CERTIFICATE` | string |
`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 |
`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 |
`quarkus.openshift.route.tls.key` The key file contents. Environment variable: `QUARKUS_OPENSHIFT_ROUTE_TLS_KEY` | string |
`quarkus.openshift.route.tls.termination` The termination type. Environment variable: `QUARKUS_OPENSHIFT_ROUTE_TLS_TERMINATION` | string |
`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 |
`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 |
`quarkus.openshift.job.completion-mode` CompletionMode specifies how Pod completions are tracked. Environment variable: `QUARKUS_OPENSHIFT_JOB_COMPLETION_MODE` | `non-indexed`, `indexed` | `non-indexed`
`quarkus.openshift.job.backoff-limit` Specifies the number of retries before marking this job failed. Environment variable: `QUARKUS_OPENSHIFT_JOB_BACKOFF_LIMIT` | int |
`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 |
`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 |
`quarkus.openshift.job.suspend` Suspend specifies whether the Job controller should create Pods or not. Environment variable: `QUARKUS_OPENSHIFT_JOB_SUSPEND` | boolean | `false`
`quarkus.openshift.job.restart-policy` Restart policy when the job container fails. Environment variable: `QUARKUS_OPENSHIFT_JOB_RESTART_POLICY` | `on-failure`, `never` | `on-failure`
`quarkus.openshift.cron-job.schedule` The schedule in Cron format, see Cron. Environment variable: `QUARKUS_OPENSHIFT_CRON_JOB_SCHEDULE` | string |
`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 |
`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`
`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 |
`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 |
`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 |
`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 |
`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 |
`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`
`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 |
`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 |
`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 |
`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`
`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`
`quarkus.openshift.remote-debug.enabled` If true, the debug mode in pods will be enabled. Environment variable: `QUARKUS_OPENSHIFT_REMOTE_DEBUG_ENABLED` | boolean | `false`
`quarkus.openshift.remote-debug.transport` The transport to use. Environment variable: `QUARKUS_OPENSHIFT_REMOTE_DEBUG_TRANSPORT` | string | `dt_socket`
`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`
`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`
`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`
`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`
`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`
`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`
`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`
`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`
`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`
`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`.