The English version of quarkus.io is the official project site. Translated sites are community supported on a best-effort basis.

Kubernetes extension

Quarkus offers the ability to automatically generate Kubernetes resources based on sane defaults and user-supplied configuration using dekorate. It currently supports generating resources for vanilla Kubernetes, OpenShift and Knative. Furthermore, Quarkus can deploy the application to a target Kubernetes cluster by applying the generated manifests to the target cluster’s API Server. Finally, when either one of container image extensions is present (see the container image guide for more details), Quarkus has the ability to create a container image and push it to a registry before deploying the application to the target platform.

Prerequisites

要完成这个指南,你需要:

  • 大概15分钟

  • 编辑器

  • 安装JDK 11以上版本并正确配置了 JAVA_HOME

  • Apache Maven 3.8.1+

  • 如果你愿意的话,还可以选择使用Quarkus CLI

  • Access to a Kubernetes cluster (Minikube is a viable option)

Kubernetes

Let’s create a new project that contains both the Kubernetes and Jib extensions:

CLI
quarkus create app org.acme:kubernetes-quickstart \
    --extension=resteasy-reactive,kubernetes,jib
cd kubernetes-quickstart

创建Grade项目,请添加 --gradle 或者 --gradle-kotlin-dsl 参数。

关于如何安装并使用Quarkus CLI的更多信息,请参考Quarkus CLI指南

Maven
mvn io.quarkus.platform:quarkus-maven-plugin:2.11.2.Final:create \
    -DprojectGroupId=org.acme \
    -DprojectArtifactId=kubernetes-quickstart \
    -Dextensions="resteasy-reactive,kubernetes,jib"
cd kubernetes-quickstart

创建Grade项目,请添加 -DbuildTool=gradle 或者 -DbuildTool=gradle-kotlin-dsl 参数。

This added the following dependencies to the build file:

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-resteasy-reactive</artifactId>
</dependency>
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-kubernetes</artifactId>
</dependency>
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-container-image-jib</artifactId>
</dependency>
build.gradle
implementation("io.quarkus:quarkus-resteasy-reactive")
implementation("io.quarkus:quarkus-kubernetes")
implementation("io.quarkus:quarkus-container-image-jib")

By adding these dependencies, we enable the generation of Kubernetes manifests each time we perform a build while also enabling the build of a container image using Jib. For example, following the execution of:

CLI
quarkus build
Maven
./mvnw clean package
Gradle
./gradlew build

you will notice amongst the other files that are created, two files named kubernetes.json and kubernetes.yml in the target/kubernetes/ directory.

If you look at either file you will see that it contains both a Kubernetes Deployment and a Service.

The full source of the kubernetes.json file looks something like this:

{
  {
    "apiVersion" : "apps/v1",
    "kind" : "Deployment",
    "metadata" : {
      "annotations": {
       "app.quarkus.io/vcs-url" : "<some url>",
       "app.quarkus.io/commit-id" : "<some git SHA>",
      },
      "labels" : {
        "app.kubernetes.io/name" : "test-quarkus-app",
        "app.kubernetes.io/version" : "1.0.0-SNAPSHOT",
      },
      "name" : "test-quarkus-app"
    },
    "spec" : {
      "replicas" : 1,
      "selector" : {
        "matchLabels" : {
          "app.kubernetes.io/name" : "test-quarkus-app",
          "app.kubernetes.io/version" : "1.0.0-SNAPSHOT",
        }
      },
      "template" : {
        "metadata" : {
          "labels" : {
            "app.kubernetes.io/name" : "test-quarkus-app",
            "app.kubernetes.io/version" : "1.0.0-SNAPSHOT"
          }
        },
        "spec" : {
          "containers" : [ {
            "env" : [ {
              "name" : "KUBERNETES_NAMESPACE",
              "valueFrom" : {
                "fieldRef" : {
                  "fieldPath" : "metadata.namespace"
                }
              }
            } ],
            "image" : "yourDockerUsername/test-quarkus-app:1.0.0-SNAPSHOT",
            "imagePullPolicy" : "Always",
            "name" : "test-quarkus-app"
          } ]
        }
      }
    }
  },
  {
  "apiVersion" : "v1",
  "kind" : "Service",
    "metadata" : {
      "annotations": {
       "app.quarkus.io/vcs-url" : "<some url>",
       "app.quarkus.io/commit-id" : "<some git SHA>",
      },
      "labels" : {
        "app.kubernetes.io/name" : "test-quarkus-app",
        "app.kubernetes.io/version" : "1.0.0-SNAPSHOT",
      },
      "name" : "test-quarkus-app"
    },
  "spec" : {
    "ports" : [ {
      "name" : "http",
      "port" : 8080,
      "targetPort" : 8080
    } ],
    "selector" : {
      "app.kubernetes.io/name" : "test-quarkus-app",
      "app.kubernetes.io/version" : "1.0.0-SNAPSHOT"
    },
    "type" : "ClusterIP"
  }
 }
}

Beside generating a Deployment resource, you can also choose to get a StatefulSet instead via application.properties:

quarkus.kubernetes.deployment-kind=StatefulSet

The generated manifest can be applied to the cluster from the project root using kubectl:

kubectl apply -f target/kubernetes/kubernetes.json

An important thing to note about the Deployment (or StatefulSet) is that is uses yourDockerUsername/test-quarkus-app:1.0.0-SNAPSHOT as the container image of the Pod. The name of the image is controlled by the Jib extension and can be customized using the usual application.properties.

For example with a configuration like:

quarkus.container-image.group=quarkus #optional, default to the system username
quarkus.container-image.name=demo-app #optional, defaults to the application name
quarkus.container-image.tag=1.0       #optional, defaults to the application version

The image that will be used in the generated manifests will be quarkus/demo-app:1.0

Namespace

By default, Quarkus omits the namespace in the generated manifests, rather than enforce the default namespace. That means that you can apply the manifest to your chosen namespace when using kubectl, which in the example below is test:

kubectl apply -f target/kubernetes/kubernetes.json -n=test

To specify the namespace in your manifest customize with the following property in your application.properties:

quarkus.kubernetes.namespace=mynamespace

Defining a Docker registry

The Docker registry can be specified with the following property:

quarkus.container-image.registry=my.docker-registry.net

By adding this property along with the rest of the container image properties of the previous section, the generated manifests will use the image my.docker-registry.net/quarkus/demo-app:1.0. The image is not the only thing that can be customized in the generated manifests, as will become evident in the following sections.

Labels and Annotations

Labels

The generated manifests use the Kubernetes recommended labels. These labels can be customized using quarkus.kubernetes.name, quarkus.kubernetes.version and quarkus.kubernetes.part-of. For example by adding the following configuration to your application.properties:

quarkus.kubernetes.part-of=todo-app
quarkus.kubernetes.name=todo-rest
quarkus.kubernetes.version=1.0-rc.1

As is described in detail in the OpenShift section, customizing OpenShift (or Knative) properties is done in the same way, but replacing kubernetes with openshift (or knative). The previous example for OpenShift would look like this:

quarkus.openshift.part-of=todo-app
quarkus.openshift.name=todo-rest
quarkus.openshift.version=1.0-rc.1

The labels in generated resources will look like:

  "labels" : {
    "app.kubernetes.io/part-of" : "todo-app",
    "app.kubernetes.io/name" : "todo-rest",
    "app.kubernetes.io/version" : "1.0-rc.1"
  }

You can also remove the app.kubernetes.io/version label by applying the following configuration:

quarkus.kubernetes.add-version-to-label-selectors=false

Custom Labels

To add additional custom labels, for example foo=bar just apply the following configuration:

quarkus.kubernetes.labels.foo=bar
When using the quarkus-container-image-jib extension to build a container image, then any label added via the aforementioned property will also be added to the generated container image.

Annotations

Out of the box, the generated resources will be annotated with version control related information that can be used either by tooling, or by the user for troubleshooting purposes.

  "annotations": {
    "app.quarkus.io/vcs-url" : "<some url>",
    "app.quarkus.io/commit-id" : "<some git SHA>",
   }

Custom Annotations

Custom annotations can be added in a way similar to labels.For example to add the annotation foo=bar and app.quarkus/id=42 just apply the following configuration:

quarkus.kubernetes.annotations.foo=bar
quarkus.kubernetes.annotations."app.quarkus/id"=42

Environment variables

Kubernetes 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

Environment variables from key/value pairs

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

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

The command above will add MY_ENV_VAR=foobar as an environment variable. Please note that the key my-env-var will be converted to uppercase and dashes will be replaced by underscores resulting in MY_ENV_VAR.

Environment variables from Secret

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

quarkus.kubernetes.env.secrets=my-secret,my-other-secret

which would generate the following in the container definition:

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

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

quarkus.kubernetes.env.mapping.foo.from-secret=my-secret
quarkus.kubernetes.env.mapping.foo.with-key=keyName

This would generate the following in the env section of your container:

- env:
  - name: FOO
    valueFrom:
      secretKeyRef:
        key: keyName
        name: my-secret
        optional: false
Environment variables from ConfigMap

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

quarkus.kubernetes.env.configmaps=my-config-map,another-config-map

which would generate 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.kubernetes.env.mapping.foo.from-configmap=my-configmap
quarkus.kubernetes.env.mapping.foo.with-key=keyName

This would generate the following in the env section of your container:

- env:
  - name: FOO
    valueFrom:
      configMapRefKey:
        key: keyName
        name: my-configmap
        optional: false
Environment variables from fields

It’s also possible to 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, as follows:

quarkus.kubernetes.env.fields.foo=metadata.name

As is described in detail in the OpenShift section, customizing OpenShift properties is done in the same way, but replacing kubernetes with openshift. The previous example for OpenShift would look like this:

quarkus.openshift.env.fields.foo=metadata.name
Validation

A conflict between two definitions, e.g. mistakenly assigning both a value and specifying that a variable is derived from a field, will result in an error being thrown at build time so that you get the opportunity to 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, e.g. defining an injection from the same secret twice, will not cause an issue but will indeed report a warning to let you know that you might not have intended to duplicate that definition.

Backwards compatibility

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

Table 1. Old vs. new syntax

Old

New

Plain variable

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

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

From field

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

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

All from ConfigMap

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

quarkus.kubernetes.env.configmaps=foobar

All from Secret

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

quarkus.kubernetes.env.secrets=foobar

From one Secret field

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

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

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

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

From one ConfigMap field

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

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

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

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

If you redefine the same variable using the new syntax while keeping the old syntax, ONLY the new version will be kept and a warning will be issued to alert you of the problem.For example, if you define both quarkus.kubernetes.env-vars.my-env-var.value=foobar and quarkus.kubernetes.env.vars.my-env-var=newValue, the extension will only generate an environment variable MY_ENV_VAR=newValue and issue a warning.

Mounting volumes

The Kubernetes extension allows the user to configure both volumes and mounts for the application. Any volume can be mounted with a simple configuration:

quarkus.kubernetes.mounts.my-volume.path=/where/to/mount

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

Secret volumes
quarkus.kubernetes.secret-volumes.my-volume.secret-name=my-secret
ConfigMap volumes
quarkus.kubernetes.config-map-volumes.my-volume.config-map-name=my-secret

Passing application configuration

Quarkus supports passing configuration from external locations (via Smallrye Config). This usually requires setting an additional environment variable or system property. When you need to use a secret or a config map for the purpose of application configuration, you need to:

  • define a volume

  • mount the volume

  • create an environment variable for SMALLRYE_CONFIG_LOCATIONS

To simplify things, quarkus provides single step alternative:

quarkus.kubernetes.app-secret=<name of the secret containing the configuration>

or

quarkus.kubernetes.app-config-map=<name of the config map containing the configuration>

When these properties are used, the generated manifests will contain everything required. The application config volumes will be created using path: /mnt/app-secret and /mnt/app-config-map for secrets and configmaps respectively.

Note: Users may use both properties at the same time.

Changing the number of replicas:

To change the number of replicas from 1 to 3:

quarkus.kubernetes.replicas=3

Add readiness and liveness probes

By default, the Kubernetes resources do not contain readiness and liveness probes in the generated Deployment. Adding them however is just a matter of adding the SmallRye Health extension like so:

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-smallrye-health</artifactId>
</dependency>
build.gradle
implementation("io.quarkus:quarkus-smallrye-health")

The values of the generated probes will be determined by the configured health properties: quarkus.smallrye-health.root-path, quarkus.smallrye-health.liveness-path and quarkus.smallrye-health.readiness-path. More information about the health extension can be found in the relevant guide.

Customizing the readiness probe:

To set the initial delay of the probe to 20 seconds and the period to 45:

quarkus.kubernetes.readiness-probe.initial-delay=20s
quarkus.kubernetes.readiness-probe.period=45s

Add hostAliases

To add entries to a Pod’s /etc/hosts file (more information can be found in Kubernetes documentation), just apply the following configuration:

quarkus.kubernetes.hostaliases."10.0.0.0".hostnames=foo.com,bar.org

This would generate the following hostAliases section in the deployment definition:

kind: Deployment
spec:
  template:
    spec:
      hostAliases:
      - hostnames:
        - foo.com
        - bar.org
        ip: 10.0.0.0

Container Resources Management

CPU & Memory limits and requests can be applied to a Container (more info in Kubernetes documentation) using the following configuration:

quarkus.kubernetes.resources.requests.memory=64Mi
quarkus.kubernetes.resources.requests.cpu=250m
quarkus.kubernetes.resources.limits.memory=512Mi
quarkus.kubernetes.resources.limits.cpu=1000m

This would generate the following entry in the container section:

containers:
  resources:
    limits:
      cpu: 1000m
      memory: 512Mi
    requests:
      cpu: 250m
      memory: 64Mi

Using the Kubernetes client

Applications that are deployed to Kubernetes and need to access the API server will usually make use of the kubernetes-client extension:

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-kubernetes-client</artifactId>
</dependency>
build.gradle
implementation("io.quarkus:quarkus-kubernetes-client")

To access the API server from within a Kubernetes cluster, some RBAC related resources are required (e.g. a ServiceAccount, a RoleBinding). So, when the kubernetes-client extension is present, the kubernetes extension is going to create those resources automatically, so that application will be granted the view role. If more roles are required, they will have to be added manually.

You can disable the RBAC resources generation using the property quarkus.kubernetes-client.generate-rbac=false.

Deploying to Minikube

Minikube is quite popular when a Kubernetes cluster is needed for development purposes. To make the deployment to Minikube experience as frictionless as possible, Quarkus provides the quarkus-minikube extension. This extension can be added to a project like so:

pom.xml
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-minikube</artifactId>
</dependency>
build.gradle
implementation("io.quarkus:quarkus-minikube")

The purpose of this extension is to generate Kubernetes manifests (minikube.yaml and minikube.json) that are tailored to Minikube. This extension assumes a couple of things:

  • Users won’t be using an image registry and will instead make their container image accessible to the Kubernetes cluster by building it directly into Minikube’s Docker daemon. To use Minikube’s Docker daemon you must first execute:

    eval $(minikube -p minikube docker-env)
  • Applications deployed to Kubernetes won’t be accessed via a Kubernetes Ingress, but rather as a NodePort Service. The advantage of doing this is that the URL of an application can be retrieved trivially by executing:

    minikube service list

To control the nodePort that is used in this case, users can set quarkus.kubernetes.node-port. Note however that this configuration is entirely optional because Quarkus will automatically use a proper (and non-changing) value if none is set.

It is highly discouraged to use the manifests generated by the Minikube extension when deploying to production as these manifests are intended for development purposes only. When deploying to production, consider using the vanilla Kubernetes manifests (or the OpenShift ones when targeting OpenShift).
If the assumptions the Minikube extension makes don’t fit your workflow, nothing prevents you from using the regular Kubernetes extension to generate Kubernetes manifests and apply those to your Minikube cluster.

Deploying to Kind

Kind is another popular tool used as a Kubernetes cluster for development purposes. To make the deployment to Kind experience as frictionless as possible, Quarkus provides the quarkus-kind extension. This extension can be added to a project like so:

<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-kind</artifactId>
</dependency>

The purpose of this extension is to generate Kubernetes manifests (kind.yaml and kind.json) that are tailored to Kind and also to automate the process of loading images to the cluster when performing container image builds. The tailor made manifests will be pretty similar (they share the same rules) with Minikube (see above).

Tuning the generated resources using application.properties

The Kubernetes extension allows tuning the generated manifest, using the application.properties file. Here are some examples:

Configuration options

The table below describe all the available configuration options.

Kubernetes

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

Configuration property

类型

默认

The name of the group this component belongs too

Environment variable: QUARKUS_KUBERNETES_PART_OF

string

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

Environment variable: QUARKUS_KUBERNETES_NAME

string

${quarkus.container-image.name}

The version of the application.

Environment variable: QUARKUS_KUBERNETES_VERSION

string

${quarkus.container-image.tag}

The kind of the deployment resource to use. Supported values are 'Deployment' and 'StatefulSet' defaulting to the first.

Environment variable: QUARKUS_KUBERNETES_DEPLOYMENT_KIND

deployment, stateful-set

deployment

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 https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#context for more details).

Environment variable: QUARKUS_KUBERNETES_NAMESPACE

string

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_KUBERNETES_ADD_BUILD_TIMESTAMP

boolean

true

Working directory

Environment variable: QUARKUS_KUBERNETES_WORKING_DIR

string

The commands

Environment variable: QUARKUS_KUBERNETES_COMMAND

list of string

The arguments

Environment variable: QUARKUS_KUBERNETES_ARGUMENTS

list of string

The service account

Environment variable: QUARKUS_KUBERNETES_SERVICE_ACCOUNT

string

The host under which the application is going to be exposed

Environment variable: QUARKUS_KUBERNETES_HOST

string

The number of desired pods

Environment variable: QUARKUS_KUBERNETES_REPLICAS

int

1

The type of service that will be generated for the application

Environment variable: QUARKUS_KUBERNETES_SERVICE_TYPE

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

cluster-ip

The nodePort to set when serviceType is set to node-port.

Environment variable: QUARKUS_KUBERNETES_NODE_PORT

int

Image pull policy

Environment variable: QUARKUS_KUBERNETES_IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_KUBERNETES_IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KUBERNETES_LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KUBERNETES_READINESS_PROBE_FAILURE_THRESHOLD

int

3

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_KUBERNETES_PROMETHEUS_ANNOTATIONS

boolean

true

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: https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml

Environment variable: QUARKUS_KUBERNETES_PROMETHEUS_PREFIX

string

prometheus.io

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

Environment variable: QUARKUS_KUBERNETES_PROMETHEUS_SCRAPE

string

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

Environment variable: QUARKUS_KUBERNETES_PROMETHEUS_PATH

string

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

Environment variable: QUARKUS_KUBERNETES_PROMETHEUS_PORT

string

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_KUBERNETES_PROMETHEUS_SCHEME

string

The target deployment platform. Defaults to kubernetes. Can be kubernetes, openshift, knative, minikube etc., or any combination of the above as comma separated list.

Environment variable: QUARKUS_KUBERNETES_DEPLOYMENT_TARGET

list of string

CPU Requirements

Environment variable: QUARKUS_KUBERNETES_RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KUBERNETES_RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_KUBERNETES_RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KUBERNETES_RESOURCES_REQUESTS_MEMORY

string

If true, a Kubernetes Ingress will be created

Environment variable: QUARKUS_KUBERNETES_EXPOSE

boolean

false

If true, the service will be exposed

Environment variable: QUARKUS_KUBERNETES_INGRESS_EXPOSE

boolean

false

The host under which the application is going to be exposed

Environment variable: QUARKUS_KUBERNETES_INGRESS_HOST

string

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

Environment variable: QUARKUS_KUBERNETES_ADD_VERSION_TO_LABEL_SELECTORS

boolean

true

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

Environment variable: QUARKUS_KUBERNETES_DEPLOY

boolean

false

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

Environment variable: QUARKUS_KUBERNETES_APP_SECRET

string

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

Environment variable: QUARKUS_KUBERNETES_APP_CONFIG_MAP

string

The SELinux level label that applies to the container.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_SE_LINUX_OPTIONS_LEVEL

string

The SELinux role label that applies to the container.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_SE_LINUX_OPTIONS_ROLE

string

The SELinux type label that applies to the container.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_SE_LINUX_OPTIONS_TYPE

string

The SELinux user label that applies to the container.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_SE_LINUX_OPTIONS_USER

string

The name of the GMSA credential spec to use.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_WINDOWS_OPTIONS_GMSA_CREDENTIAL_SPEC_NAME

string

GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_WINDOWS_OPTIONS_GMSA_CREDENTIAL_SPEC

string

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

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_WINDOWS_OPTIONS_RUN_AS_USER_NAME

string

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

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_WINDOWS_OPTIONS_HOST_PROCESS

boolean

The UID to run the entrypoint of the container process.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_RUN_AS_USER

long

The GID to run the entrypoint of the container process.

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_RUN_AS_GROUP

long

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

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_RUN_AS_NON_ROOT

boolean

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_KUBERNETES_SECURITY_CONTEXT_SUPPLEMENTAL_GROUPS

list of long

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

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_FS_GROUP

long

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

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_SYSCTLS

string

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

Environment variable: QUARKUS_KUBERNETES_SECURITY_CONTEXT_FS_GROUP_CHANGE_POLICY

on-root-mismatchIt indicates that volume’s ownership and permissions will be changed only when permission and ownership of root directory does not match with expected permissions on the volume., alwaysIt indicates that volume’s ownership and permissions should always be changed whenever volume is mounted inside a Pod. This the default behavior.

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

Environment variable: QUARKUS_KUBERNETES_CONTAINER_NAME

string

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

Environment variable: QUARKUS_KUBERNETES_REMOTE_DEBUG_ENABLED

boolean

false

The transport to use.

Environment variable: QUARKUS_KUBERNETES_REMOTE_DEBUG_TRANSPORT

string

dt_socket

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_KUBERNETES_REMOTE_DEBUG_SUSPEND

string

n

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

Environment variable: QUARKUS_KUBERNETES_REMOTE_DEBUG_ADDRESS_PORT

int

5005

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

Environment variable: QUARKUS_KUBERNETES_ENV_SECRETS

list of string

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

Environment variable: QUARKUS_KUBERNETES_ENV_CONFIGMAPS

list of string

Custom labels to add to all resources

Environment variable: QUARKUS_KUBERNETES_LABELS

Map<String,String>

Custom annotations to add to all resources

Environment variable: QUARKUS_KUBERNETES_ANNOTATIONS

Map<String,String>

The port number. Refers to the container port.

Environment variable: QUARKUS_KUBERNETES_PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_KUBERNETES_PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_KUBERNETES_PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_KUBERNETES_PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_KUBERNETES_PORTS__PORTS__NODE_PORT

int

The name of the volumeName to mount.

Environment variable: QUARKUS_KUBERNETES_MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_KUBERNETES_MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_KUBERNETES_MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_KUBERNETES_MOUNTS__MOUNTS__READ_ONLY

boolean

false

The name of the secret to mount.

Environment variable: QUARKUS_KUBERNETES_SECRET_VOLUMES__SECRET_VOLUMES__SECRET_NAME

string

required

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

Environment variable: QUARKUS_KUBERNETES_SECRET_VOLUMES__SECRET_VOLUMES__DEFAULT_MODE

string

0600

The path where the file will be mounted.

Environment variable: QUARKUS_KUBERNETES_SECRET_VOLUMES__SECRET_VOLUMES__ITEMS__ITEMS__PATH

string

required

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

Environment variable: QUARKUS_KUBERNETES_SECRET_VOLUMES__SECRET_VOLUMES__ITEMS__ITEMS__MODE

int

-1

Optional

Environment variable: QUARKUS_KUBERNETES_SECRET_VOLUMES__SECRET_VOLUMES__OPTIONAL

boolean

false

The name of the ConfigMap to mount.

Environment variable: QUARKUS_KUBERNETES_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__CONFIG_MAP_NAME

string

required

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

Environment variable: QUARKUS_KUBERNETES_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__DEFAULT_MODE

string

0600

The path where the file will be mounted.

Environment variable: QUARKUS_KUBERNETES_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__ITEMS__ITEMS__PATH

string

required

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

Environment variable: QUARKUS_KUBERNETES_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__ITEMS__ITEMS__MODE

int

-1

Optional

Environment variable: QUARKUS_KUBERNETES_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__OPTIONAL

boolean

false

Git repository URL.

Environment variable: QUARKUS_KUBERNETES_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REPOSITORY

string

required

The directory of the repository to mount.

Environment variable: QUARKUS_KUBERNETES_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__DIRECTORY

string

The commit hash to use.

Environment variable: QUARKUS_KUBERNETES_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REVISION

string

The name of the claim to mount.

Environment variable: QUARKUS_KUBERNETES_PVC_VOLUMES__PVC_VOLUMES__CLAIM_NAME

string

required

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

Environment variable: QUARKUS_KUBERNETES_PVC_VOLUMES__PVC_VOLUMES__DEFAULT_MODE

string

0600

Optional

Environment variable: QUARKUS_KUBERNETES_PVC_VOLUMES__PVC_VOLUMES__OPTIONAL

boolean

false

The name of the disk to mount.

Environment variable: QUARKUS_KUBERNETES_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__VOLUME_ID

string

required

The partition.

Environment variable: QUARKUS_KUBERNETES_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__PARTITION

int

Filesystem type.

Environment variable: QUARKUS_KUBERNETES_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__FS_TYPE

string

ext4

Whether the volumeName is read only or not.

Environment variable: QUARKUS_KUBERNETES_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__READ_ONLY

boolean

false

The share name.

Environment variable: QUARKUS_KUBERNETES_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SHARE_NAME

string

required

The secret name.

Environment variable: QUARKUS_KUBERNETES_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SECRET_NAME

string

required

Whether the volumeName is read only or not.

Environment variable: QUARKUS_KUBERNETES_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__READ_ONLY

boolean

false

The name of the disk to mount.

Environment variable: QUARKUS_KUBERNETES_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__DISK_NAME

string

required

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

Environment variable: QUARKUS_KUBERNETES_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__DISK_URI

string

required

Kind of disk.

Environment variable: QUARKUS_KUBERNETES_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__KIND

managed, shared

managed

Disk caching mode.

Environment variable: QUARKUS_KUBERNETES_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__CACHING_MODE

read-write, read-only, none

read-write

File system type.

Environment variable: QUARKUS_KUBERNETES_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__FS_TYPE

string

ext4

Whether the volumeName is read only or not.

Environment variable: QUARKUS_KUBERNETES_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__READ_ONLY

boolean

false

The container image.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE

string

Working directory.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__WORKING_DIR

string

The commands

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__COMMAND

list of string

The arguments

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ARGUMENTS

list of string

The service account.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__SERVICE_ACCOUNT

string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__HOST

string

The port number. Refers to the container port.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__NODE_PORT

int

Image pull policy.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

The name of the volumeName to mount.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

CPU Requirements

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ENV_SECRETS

list of string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ENV_CONFIGMAPS

list of string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ENV_VARS

Map<String,String>

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__FROM_SECRET

string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

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

Environment variable: QUARKUS_KUBERNETES_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__WITH_KEY

string

required

The container image.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__IMAGE

string

Working directory.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__WORKING_DIR

string

The commands

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__COMMAND

list of string

The arguments

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ARGUMENTS

list of string

The service account.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__SERVICE_ACCOUNT

string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__HOST

string

The port number. Refers to the container port.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__PORTS__PORTS__NODE_PORT

int

Image pull policy.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

The name of the volumeName to mount.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

CPU Requirements

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ENV_SECRETS

list of string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ENV_CONFIGMAPS

list of string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ENV_VARS

Map<String,String>

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ENV_MAPPING__MAPPING__FROM_SECRET

string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

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

Environment variable: QUARKUS_KUBERNETES_SIDECARS__SIDECARS__ENV_MAPPING__MAPPING__WITH_KEY

string

required

The ip address

Environment variable: QUARKUS_KUBERNETES_HOSTALIASES__HOST_ALIASES__IP

string

The hostnames to resolve to the ip

Environment variable: QUARKUS_KUBERNETES_HOSTALIASES__HOST_ALIASES__HOSTNAMES

list of string

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

Environment variable: QUARKUS_KUBERNETES_INGRESS_ANNOTATIONS

Map<String,String>

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

Environment variable: QUARKUS_KUBERNETES_ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_KUBERNETES_ENV_VARS

Map<String,String>

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

Environment variable: QUARKUS_KUBERNETES_ENV_MAPPING__MAPPING__FROM_SECRET

string

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

Environment variable: QUARKUS_KUBERNETES_ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

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

Environment variable: QUARKUS_KUBERNETES_ENV_MAPPING__MAPPING__WITH_KEY

string

required

Properties that use non-standard types, can be referenced by expanding the property. For example to define a kubernetes-readiness-probe which is of type Probe:

quarkus.kubernetes.readiness-probe.initial-delay=20s
quarkus.kubernetes.readiness-probe.period=45s

In this example initial-delay and period are fields of the type Probe. Below you will find tables describing all available types.

Client Connection Configuration

You may need to configure the connection to your Kubernetes cluster. By default, it automatically uses the active context used by kubectl.

For instance, if your cluster API endpoint uses a self-signed SSL Certificate you need to explicitly configure the client to trust it. You can achieve this by defining the following property:

quarkus.kubernetes-client.trust-certs=true

The full list of the Kubernetes client configuration properties is provided below.

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

Configuration property

类型

默认

Whether the client should trust a self-signed certificate if so presented by the API server

Environment variable: QUARKUS_KUBERNETES_CLIENT_TRUST_CERTS

boolean

URL of the Kubernetes API server

Environment variable: QUARKUS_KUBERNETES_CLIENT_MASTER_URL

string

Default namespace to use

Environment variable: QUARKUS_KUBERNETES_CLIENT_NAMESPACE

string

CA certificate file

Environment variable: QUARKUS_KUBERNETES_CLIENT_CA_CERT_FILE

string

CA certificate data

Environment variable: QUARKUS_KUBERNETES_CLIENT_CA_CERT_DATA

string

Client certificate file

Environment variable: QUARKUS_KUBERNETES_CLIENT_CLIENT_CERT_FILE

string

Client certificate data

Environment variable: QUARKUS_KUBERNETES_CLIENT_CLIENT_CERT_DATA

string

Client key file

Environment variable: QUARKUS_KUBERNETES_CLIENT_CLIENT_KEY_FILE

string

Client key data

Environment variable: QUARKUS_KUBERNETES_CLIENT_CLIENT_KEY_DATA

string

Client key algorithm

Environment variable: QUARKUS_KUBERNETES_CLIENT_CLIENT_KEY_ALGO

string

Client key passphrase

Environment variable: QUARKUS_KUBERNETES_CLIENT_CLIENT_KEY_PASSPHRASE

string

Kubernetes auth username

Environment variable: QUARKUS_KUBERNETES_CLIENT_USERNAME

string

Kubernetes auth password

Environment variable: QUARKUS_KUBERNETES_CLIENT_PASSWORD

string

Kubernetes oauth token

Environment variable: QUARKUS_KUBERNETES_CLIENT_TOKEN

string

Watch reconnect interval

Environment variable: QUARKUS_KUBERNETES_CLIENT_WATCH_RECONNECT_INTERVAL

Duration

PT1S

Maximum reconnect attempts in case of watch failure By default there is no limit to the number of reconnect attempts

Environment variable: QUARKUS_KUBERNETES_CLIENT_WATCH_RECONNECT_LIMIT

int

-1

Maximum amount of time to wait for a connection with the API server to be established

Environment variable: QUARKUS_KUBERNETES_CLIENT_CONNECTION_TIMEOUT

Duration

PT10S

Maximum amount of time to wait for a request to the API server to be completed

Environment variable: QUARKUS_KUBERNETES_CLIENT_REQUEST_TIMEOUT

Duration

PT10S

Maximum amount of time in milliseconds to wait for a rollout to be completed

Environment variable: QUARKUS_KUBERNETES_CLIENT_ROLLING_TIMEOUT

Duration

PT15M

HTTP proxy used to access the Kubernetes API server

Environment variable: QUARKUS_KUBERNETES_CLIENT_HTTP_PROXY

string

HTTPS proxy used to access the Kubernetes API server

Environment variable: QUARKUS_KUBERNETES_CLIENT_HTTPS_PROXY

string

Proxy username

Environment variable: QUARKUS_KUBERNETES_CLIENT_PROXY_USERNAME

string

Proxy password

Environment variable: QUARKUS_KUBERNETES_CLIENT_PROXY_PASSWORD

string

IP addresses or hosts to exclude from proxying

Environment variable: QUARKUS_KUBERNETES_CLIENT_NO_PROXY

list of string

Enable the generation of the RBAC manifests.

Environment variable: QUARKUS_KUBERNETES_CLIENT_GENERATE_RBAC

boolean

true

OpenShift

One way to deploy an application to OpenShift is to use s2i (source to image) to create an image stream from the source and then deploy the image stream:

CLI
quarkus extension remove kubernetes,jib
quarkus extension add openshift

oc new-project quarkus-project
quarkus build -Dquarkus.container-image.build=true

oc new-app --name=greeting  quarkus-project/kubernetes-quickstart:1.0.0-SNAPSHOT
oc expose svc/greeting
oc get route
curl <route>/greeting
Maven
./mvnw quarkus:remove-extension -Dextensions="kubernetes, jib"
./mvnw quarkus:add-extension -Dextensions="openshift"

oc new-project quarkus-project
./mvnw clean package -Dquarkus.container-image.build=true

oc new-app --name=greeting  quarkus-project/kubernetes-quickstart:1.0.0-SNAPSHOT
oc expose svc/greeting
oc get route
curl <route>/greeting
Gradle
./gradlew removeExtension --extensions="kubernetes, jib"
./gradlew addExtension --extensions="openshift"

oc new-project quarkus-project
./gradlew build -Dquarkus.container-image.build=true

oc new-app --name=greeting  quarkus-project/kubernetes-quickstart:1.0.0-SNAPSHOT
oc expose svc/greeting
oc get route
curl <route>/greeting

See further information in Deploying to OpenShift.

A description of OpenShift resources and customisable properties is given below alongside Kubernetes resources to show similarities where applicable. This includes an alternative to oc new-app …​ above, i.e. oc apply -f target/kubernetes/openshift.json .

To enable the generation of OpenShift resources, you need to include OpenShift in the target platforms:

quarkus.kubernetes.deployment-target=openshift

If you need to generate resources for both platforms (vanilla Kubernetes and OpenShift), then you need to include both (comma separated).

quarkus.kubernetes.deployment-target=kubernetes,openshift

Following the execution of ./mvnw package -Dquarkus.container-image.build=true you will notice amongst the other files that are created, two files named openshift.json and openshift.yml in the target/kubernetes/ directory.

These manifests can be deployed as is to a running cluster, using kubectl:

kubectl apply -f target/kubernetes/openshift.json

OpenShift’s users might want to use oc rather than kubectl:

oc apply -f target/kubernetes/openshift.json
Quarkus also provides the OpenShift extension. This extension is basically a wrapper around the Kubernetes extension and relieves OpenShift users of the necessity of setting the deployment-target property to openshift

The OpenShift resources can be customized in a similar approach with Kubernetes.

OpenShift

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

Configuration property

类型

默认

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

The kind of the deployment resource to use. Supported values are 'Deployment' and 'DeploymentConfig' defaulting to the latter.

Environment variable: QUARKUS_OPENSHIFT_DEPLOYMENT_KIND

deployment, deployment-config, stateful-set

The name of the group this component belongs too

Environment variable: QUARKUS_OPENSHIFT_PART_OF

string

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.container-image.name}

The version of the application.

Environment variable: QUARKUS_OPENSHIFT_VERSION

string

${quarkus.container-image.tag}

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 https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#context for more details).

Environment variable: QUARKUS_OPENSHIFT_NAMESPACE

string

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

Working directory

Environment variable: QUARKUS_OPENSHIFT_WORKING_DIR

string

The commands

Environment variable: QUARKUS_OPENSHIFT_COMMAND

list of string

The arguments

Environment variable: QUARKUS_OPENSHIFT_ARGUMENTS

list of string

The service account

Environment variable: QUARKUS_OPENSHIFT_SERVICE_ACCOUNT

string

The host under which the application is going to be exposed

Environment variable: QUARKUS_OPENSHIFT_HOST

string

The number of desired pods

Environment variable: QUARKUS_OPENSHIFT_REPLICAS

int

1

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

The nodePort to set when serviceType is set to nodePort

Environment variable: QUARKUS_OPENSHIFT_NODE_PORT

int

Image pull policy

Environment variable: QUARKUS_OPENSHIFT_IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_OPENSHIFT_IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_READINESS_PROBE_FAILURE_THRESHOLD

int

3

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

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: https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml

Environment variable: QUARKUS_OPENSHIFT_PROMETHEUS_PREFIX

string

prometheus.io

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

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

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

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

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_OPENSHIFT_CONTAINER_NAME

string

If true, an Openshift Route will be created

Environment variable: QUARKUS_OPENSHIFT_EXPOSE

boolean

false

If true, the service will be exposed

Environment variable: QUARKUS_OPENSHIFT_ROUTE_EXPOSE

boolean

false

The host under which the application is going to be exposed

Environment variable: QUARKUS_OPENSHIFT_ROUTE_HOST

string

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

Environment variable: QUARKUS_OPENSHIFT_ADD_VERSION_TO_LABEL_SELECTORS

boolean

true

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

Environment variable: QUARKUS_OPENSHIFT_ENV_SECRETS

list of string

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

Environment variable: QUARKUS_OPENSHIFT_ENV_CONFIGMAPS

list of string

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

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

Environment variable: QUARKUS_OPENSHIFT_APP_CONFIG_MAP

string

The SELinux level label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_LEVEL

string

The SELinux role label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_ROLE

string

The SELinux type label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_TYPE

string

The SELinux user label that applies to the container.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SE_LINUX_OPTIONS_USER

string

The name of the GMSA credential spec to use.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_WINDOWS_OPTIONS_GMSA_CREDENTIAL_SPEC_NAME

string

GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) 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

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

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

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_WINDOWS_OPTIONS_HOST_PROCESS

boolean

The UID to run the entrypoint of the container process.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_RUN_AS_USER

long

The GID to run the entrypoint of the container process.

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_RUN_AS_GROUP

long

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

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_RUN_AS_NON_ROOT

boolean

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

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

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_FS_GROUP

long

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

Environment variable: QUARKUS_OPENSHIFT_SECURITY_CONTEXT_SYSCTLS

string

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-mismatchIt indicates that volume’s ownership and permissions will be changed only when permission and ownership of root directory does not match with expected permissions on the volume., alwaysIt indicates that volume’s ownership and permissions should always be changed whenever volume is mounted inside a Pod. This the default behavior.

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

Environment variable: QUARKUS_OPENSHIFT_REMOTE_DEBUG_ENABLED

boolean

false

The transport to use.

Environment variable: QUARKUS_OPENSHIFT_REMOTE_DEBUG_TRANSPORT

string

dt_socket

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

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

Environment variable: QUARKUS_OPENSHIFT_REMOTE_DEBUG_ADDRESS_PORT

int

5005

Custom labels to add to all resources

Environment variable: QUARKUS_OPENSHIFT_LABELS

Map<String,String>

Custom annotations to add to all resources

Environment variable: QUARKUS_OPENSHIFT_ANNOTATIONS

Map<String,String>

The port number. Refers to the container port.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_OPENSHIFT_PORTS__PORTS__NODE_PORT

int

The name of the volumeName to mount.

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_OPENSHIFT_MOUNTS__MOUNTS__READ_ONLY

boolean

false

The name of the secret to mount.

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__SECRET_NAME

string

required

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

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__DEFAULT_MODE

string

0600

The path where the file will be mounted.

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__ITEMS__ITEMS__PATH

string

required

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

Optional

Environment variable: QUARKUS_OPENSHIFT_SECRET_VOLUMES__SECRET_VOLUMES__OPTIONAL

boolean

false

The name of the ConfigMap to mount.

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__CONFIG_MAP_NAME

string

required

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

The path where the file will be mounted.

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__ITEMS__ITEMS__PATH

string

required

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

Optional

Environment variable: QUARKUS_OPENSHIFT_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__OPTIONAL

boolean

false

Git repository URL.

Environment variable: QUARKUS_OPENSHIFT_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REPOSITORY

string

required

The directory of the repository to mount.

Environment variable: QUARKUS_OPENSHIFT_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__DIRECTORY

string

The commit hash to use.

Environment variable: QUARKUS_OPENSHIFT_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REVISION

string

The name of the claim to mount.

Environment variable: QUARKUS_OPENSHIFT_PVC_VOLUMES__PVC_VOLUMES__CLAIM_NAME

string

required

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

Environment variable: QUARKUS_OPENSHIFT_PVC_VOLUMES__PVC_VOLUMES__DEFAULT_MODE

string

0600

Optional

Environment variable: QUARKUS_OPENSHIFT_PVC_VOLUMES__PVC_VOLUMES__OPTIONAL

boolean

false

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

The partition.

Environment variable: QUARKUS_OPENSHIFT_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__PARTITION

int

Filesystem type.

Environment variable: QUARKUS_OPENSHIFT_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__FS_TYPE

string

ext4

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

The share name.

Environment variable: QUARKUS_OPENSHIFT_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SHARE_NAME

string

required

The secret name.

Environment variable: QUARKUS_OPENSHIFT_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SECRET_NAME

string

required

Whether the volumeName is read only or not.

Environment variable: QUARKUS_OPENSHIFT_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__READ_ONLY

boolean

false

The name of the disk to mount.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__DISK_NAME

string

required

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

Kind of disk.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__KIND

managed, shared

managed

Disk caching mode.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__CACHING_MODE

read-write, read-only, none

read-write

File system type.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__FS_TYPE

string

ext4

Whether the volumeName is read only or not.

Environment variable: QUARKUS_OPENSHIFT_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__READ_ONLY

boolean

false

The container image.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE

string

Working directory.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__WORKING_DIR

string

The commands

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__COMMAND

list of string

The arguments

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ARGUMENTS

list of string

The service account.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__SERVICE_ACCOUNT

string

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

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__HOST

string

The port number. Refers to the container port.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__NODE_PORT

int

Image pull policy.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_EXEC_ACTION

string

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

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_EXEC_ACTION

string

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

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

The name of the volumeName to mount.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__PATH

string

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

ReadOnly

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_SECRETS

list of string

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

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_CONFIGMAPS

list of string

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

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_OPENSHIFT_INIT_CONTAINERS__INIT_CONTAINERS__ENV_VARS

Map<String,String>

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

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

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

The container image.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE

string

Working directory.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__WORKING_DIR

string

The commands

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__COMMAND

list of string

The arguments

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ARGUMENTS

list of string

The service account.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__SERVICE_ACCOUNT

string

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

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__HOST

string

The port number. Refers to the container port.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__PORTS__PORTS__NODE_PORT

int

Image pull policy.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_EXEC_ACTION

string

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

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_EXEC_ACTION

string

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

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

The name of the volumeName to mount.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_SECRETS

list of string

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

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_CONFIGMAPS

list of string

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

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_VARS

Map<String,String>

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

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

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

Environment variable: QUARKUS_OPENSHIFT_SIDECARS__SIDECARS__ENV_MAPPING__MAPPING__WITH_KEY

string

required

The ip address

Environment variable: QUARKUS_OPENSHIFT_HOST_ALIASES__HOST_ALIASES__IP

string

The hostnames to resolve to the ip

Environment variable: QUARKUS_OPENSHIFT_HOST_ALIASES__HOST_ALIASES__HOSTNAMES

list of string

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

Environment variable: QUARKUS_OPENSHIFT_ROUTE_ANNOTATIONS

Map<String,String>

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

Environment variable: QUARKUS_OPENSHIFT_ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_OPENSHIFT_ENV_VARS

Map<String,String>

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

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

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

Environment variable: QUARKUS_OPENSHIFT_ENV_MAPPING__MAPPING__WITH_KEY

string

required

Knative

To enable the generation of Knative resources, you need to include Knative in the target platforms:

quarkus.kubernetes.deployment-target=knative

Following the execution of ./mvnw package you will notice amongst the other files that are created, two files named knative.json and knative.yml in the target/kubernetes/ directory.

If you look at either file you will see that it contains a Knative Service.

The full source of the knative.json file looks something like this:

{
  {
    "apiVersion" : "serving.quarkus.knative.dev/v1alpha1",
    "kind" : "Service",
    "metadata" : {
      "annotations": {
       "app.quarkus.io/vcs-url" : "<some url>",
       "app.quarkus.io/commit-id" : "<some git SHA>"
      },
      "labels" : {
        "app.kubernetes.io/name" : "test-quarkus-app",
        "app.kubernetes.io/version" : "1.0.0-SNAPSHOT"
      },
      "name" : "knative"
    },
    "spec" : {
      "runLatest" : {
        "configuration" : {
          "revisionTemplate" : {
            "spec" : {
              "container" : {
                "image" : "dev.local/yourDockerUsername/test-quarkus-app:1.0.0-SNAPSHOT",
                "imagePullPolicy" : "Always"
              }
            }
          }
        }
      }
    }
  }
}

The generated manifest can be deployed as is to a running cluster, using kubectl:

kubectl apply -f target/kubernetes/knative.json

The generated service can be customized using the following properties:

Knative

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

Configuration property

类型

默认

The name of the group this component belongs too

Environment variable: QUARKUS_KNATIVE_PART_OF

string

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

Environment variable: QUARKUS_KNATIVE_NAME

string

${quarkus.container-image.name}

The version of the application.

Environment variable: QUARKUS_KNATIVE_VERSION

string

${quarkus.container-image.tag}

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 https://kubernetes.io/docs/concepts/configuration/organize-cluster-access-kubeconfig/#context for more details).

Environment variable: QUARKUS_KNATIVE_NAMESPACE

string

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_KNATIVE_ADD_BUILD_TIMESTAMP

boolean

true

Working directory

Environment variable: QUARKUS_KNATIVE_WORKING_DIR

string

The commands

Environment variable: QUARKUS_KNATIVE_COMMAND

list of string

The arguments

Environment variable: QUARKUS_KNATIVE_ARGUMENTS

list of string

The service account

Environment variable: QUARKUS_KNATIVE_SERVICE_ACCOUNT

string

The host under which the application is going to be exposed

Environment variable: QUARKUS_KNATIVE_HOST

string

The type of service that will be generated for the application

Environment variable: QUARKUS_KNATIVE_SERVICE_TYPE

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

cluster-ip

Image pull policy

Environment variable: QUARKUS_KNATIVE_IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_KNATIVE_IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KNATIVE_LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KNATIVE_READINESS_PROBE_FAILURE_THRESHOLD

int

3

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_KNATIVE_PROMETHEUS_ANNOTATIONS

boolean

true

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: https://github.com/prometheus/prometheus/blob/main/documentation/examples/prometheus-kubernetes.yml

Environment variable: QUARKUS_KNATIVE_PROMETHEUS_PREFIX

string

prometheus.io

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

Environment variable: QUARKUS_KNATIVE_PROMETHEUS_SCRAPE

string

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

Environment variable: QUARKUS_KNATIVE_PROMETHEUS_PATH

string

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

Environment variable: QUARKUS_KNATIVE_PROMETHEUS_PORT

string

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_KNATIVE_PROMETHEUS_SCHEME

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINER_NAME

string

CPU Requirements

Environment variable: QUARKUS_KNATIVE_RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KNATIVE_RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_KNATIVE_RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KNATIVE_RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_KNATIVE_ENV_SECRETS

list of string

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

Environment variable: QUARKUS_KNATIVE_ENV_CONFIGMAPS

list of string

Whether this service is cluster-local. Cluster local services are not exposed to the outside world. More information in this link.

Environment variable: QUARKUS_KNATIVE_CLUSTER_LOCAL

boolean

false

This value controls the minimum number of replicas each revision should have. Knative will attempt to never have less than this number of replicas at any point in time.

Environment variable: QUARKUS_KNATIVE_MIN_SCALE

int

This value controls the maximum number of replicas each revision should have. Knative will attempt to never have more than this number of replicas running, or in the process of being created, at any point in time.

Environment variable: QUARKUS_KNATIVE_MAX_SCALE

int

The scale-to-zero values control whether Knative allows revisions to scale down to zero, or stops at “1”.

Environment variable: QUARKUS_KNATIVE_SCALE_TO_ZERO_ENABLED

boolean

true

Environment variable: QUARKUS_KNATIVE_REVISION_AUTO_SCALING_AUTO_SCALER_CLASS

kpa, hpa

Environment variable: QUARKUS_KNATIVE_REVISION_AUTO_SCALING_METRIC

concurrency, rps, cpu

Environment variable: QUARKUS_KNATIVE_REVISION_AUTO_SCALING_TARGET

int

Environment variable: QUARKUS_KNATIVE_REVISION_AUTO_SCALING_CONTAINER_CONCURRENCY

int

Environment variable: QUARKUS_KNATIVE_REVISION_AUTO_SCALING_TARGET_UTILIZATION_PERCENTAGE

int

Environment variable: QUARKUS_KNATIVE_GLOBAL_AUTO_SCALING_AUTO_SCALER_CLASS

kpa, hpa

Environment variable: QUARKUS_KNATIVE_GLOBAL_AUTO_SCALING_CONTAINER_CONCURRENCY

int

Environment variable: QUARKUS_KNATIVE_GLOBAL_AUTO_SCALING_TARGET_UTILIZATION_PERCENTAGE

int

Environment variable: QUARKUS_KNATIVE_GLOBAL_AUTO_SCALING_REQUESTS_PER_SECOND

int

Environment variable: QUARKUS_KNATIVE_REVISION_NAME

string

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

Environment variable: QUARKUS_KNATIVE_APP_SECRET

string

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

Environment variable: QUARKUS_KNATIVE_APP_CONFIG_MAP

string

The SELinux level label that applies to the container.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_SE_LINUX_OPTIONS_LEVEL

string

The SELinux role label that applies to the container.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_SE_LINUX_OPTIONS_ROLE

string

The SELinux type label that applies to the container.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_SE_LINUX_OPTIONS_TYPE

string

The SELinux user label that applies to the container.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_SE_LINUX_OPTIONS_USER

string

The name of the GMSA credential spec to use.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_WINDOWS_OPTIONS_GMSA_CREDENTIAL_SPEC_NAME

string

GMSACredentialSpec is where the GMSA admission webhook (https://github.com/kubernetes-sigs/windows-gmsa) inlines the contents of the GMSA credential spec named by the GMSACredentialSpecName field.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_WINDOWS_OPTIONS_GMSA_CREDENTIAL_SPEC

string

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

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_WINDOWS_OPTIONS_RUN_AS_USER_NAME

string

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

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_WINDOWS_OPTIONS_HOST_PROCESS

boolean

The UID to run the entrypoint of the container process.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_RUN_AS_USER

long

The GID to run the entrypoint of the container process.

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_RUN_AS_GROUP

long

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

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_RUN_AS_NON_ROOT

boolean

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_KNATIVE_SECURITY_CONTEXT_SUPPLEMENTAL_GROUPS

list of long

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

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_FS_GROUP

long

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

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_SYSCTLS

string

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

Environment variable: QUARKUS_KNATIVE_SECURITY_CONTEXT_FS_GROUP_CHANGE_POLICY

on-root-mismatchIt indicates that volume’s ownership and permissions will be changed only when permission and ownership of root directory does not match with expected permissions on the volume., alwaysIt indicates that volume’s ownership and permissions should always be changed whenever volume is mounted inside a Pod. This the default behavior.

Custom labels to add to all resources

Environment variable: QUARKUS_KNATIVE_LABELS

Map<String,String>

Custom annotations to add to all resources

Environment variable: QUARKUS_KNATIVE_ANNOTATIONS

Map<String,String>

The port number. Refers to the container port.

Environment variable: QUARKUS_KNATIVE_PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_KNATIVE_PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_KNATIVE_PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_KNATIVE_PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_KNATIVE_PORTS__PORTS__NODE_PORT

int

The name of the volumeName to mount.

Environment variable: QUARKUS_KNATIVE_MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_KNATIVE_MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_KNATIVE_MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_KNATIVE_MOUNTS__MOUNTS__READ_ONLY

boolean

false

The name of the secret to mount.

Environment variable: QUARKUS_KNATIVE_SECRET_VOLUMES__SECRET_VOLUMES__SECRET_NAME

string

required

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

Environment variable: QUARKUS_KNATIVE_SECRET_VOLUMES__SECRET_VOLUMES__DEFAULT_MODE

string

0600

The path where the file will be mounted.

Environment variable: QUARKUS_KNATIVE_SECRET_VOLUMES__SECRET_VOLUMES__ITEMS__ITEMS__PATH

string

required

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

Environment variable: QUARKUS_KNATIVE_SECRET_VOLUMES__SECRET_VOLUMES__ITEMS__ITEMS__MODE

int

-1

Optional

Environment variable: QUARKUS_KNATIVE_SECRET_VOLUMES__SECRET_VOLUMES__OPTIONAL

boolean

false

The name of the ConfigMap to mount.

Environment variable: QUARKUS_KNATIVE_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__CONFIG_MAP_NAME

string

required

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

Environment variable: QUARKUS_KNATIVE_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__DEFAULT_MODE

string

0600

The path where the file will be mounted.

Environment variable: QUARKUS_KNATIVE_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__ITEMS__ITEMS__PATH

string

required

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

Environment variable: QUARKUS_KNATIVE_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__ITEMS__ITEMS__MODE

int

-1

Optional

Environment variable: QUARKUS_KNATIVE_CONFIG_MAP_VOLUMES__CONFIG_MAP_VOLUMES__OPTIONAL

boolean

false

Git repository URL.

Environment variable: QUARKUS_KNATIVE_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REPOSITORY

string

required

The directory of the repository to mount.

Environment variable: QUARKUS_KNATIVE_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__DIRECTORY

string

The commit hash to use.

Environment variable: QUARKUS_KNATIVE_GIT_REPO_VOLUMES__GIT_REPO_VOLUMES__REVISION

string

The name of the claim to mount.

Environment variable: QUARKUS_KNATIVE_PVC_VOLUMES__PVC_VOLUMES__CLAIM_NAME

string

required

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

Environment variable: QUARKUS_KNATIVE_PVC_VOLUMES__PVC_VOLUMES__DEFAULT_MODE

string

0600

Optional

Environment variable: QUARKUS_KNATIVE_PVC_VOLUMES__PVC_VOLUMES__OPTIONAL

boolean

false

The name of the disk to mount.

Environment variable: QUARKUS_KNATIVE_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__VOLUME_ID

string

required

The partition.

Environment variable: QUARKUS_KNATIVE_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__PARTITION

int

Filesystem type.

Environment variable: QUARKUS_KNATIVE_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__FS_TYPE

string

ext4

Whether the volumeName is read only or not.

Environment variable: QUARKUS_KNATIVE_AWS_ELASTIC_BLOCK_STORE_VOLUMES__AWS_ELASTIC_BLOCK_STORE_VOLUMES__READ_ONLY

boolean

false

The share name.

Environment variable: QUARKUS_KNATIVE_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SHARE_NAME

string

required

The secret name.

Environment variable: QUARKUS_KNATIVE_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__SECRET_NAME

string

required

Whether the volumeName is read only or not.

Environment variable: QUARKUS_KNATIVE_AZURE_FILE_VOLUMES__AZURE_FILE_VOLUMES__READ_ONLY

boolean

false

The name of the disk to mount.

Environment variable: QUARKUS_KNATIVE_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__DISK_NAME

string

required

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

Environment variable: QUARKUS_KNATIVE_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__DISK_URI

string

required

Kind of disk.

Environment variable: QUARKUS_KNATIVE_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__KIND

managed, shared

managed

Disk caching mode.

Environment variable: QUARKUS_KNATIVE_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__CACHING_MODE

read-write, read-only, none

read-write

File system type.

Environment variable: QUARKUS_KNATIVE_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__FS_TYPE

string

ext4

Whether the volumeName is read only or not.

Environment variable: QUARKUS_KNATIVE_AZURE_DISK_VOLUMES__AZURE_DISK_VOLUMES__READ_ONLY

boolean

false

The container image.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE

string

Working directory.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__WORKING_DIR

string

The commands

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__COMMAND

list of string

The arguments

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ARGUMENTS

list of string

The service account.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__SERVICE_ACCOUNT

string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__HOST

string

The port number. Refers to the container port.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__PORTS__PORTS__NODE_PORT

int

Image pull policy.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

The name of the volumeName to mount.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

CPU Requirements

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ENV_SECRETS

list of string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ENV_CONFIGMAPS

list of string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ENV_VARS

Map<String,String>

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__FROM_SECRET

string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

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

Environment variable: QUARKUS_KNATIVE_INIT_CONTAINERS__INIT_CONTAINERS__ENV_MAPPING__MAPPING__WITH_KEY

string

required

The container image.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__IMAGE

string

Working directory.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__WORKING_DIR

string

The commands

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__COMMAND

list of string

The arguments

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ARGUMENTS

list of string

The service account.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__SERVICE_ACCOUNT

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__HOST

string

The port number. Refers to the container port.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__PORTS__PORTS__CONTAINER_PORT

int

The host port.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__PORTS__PORTS__HOST_PORT

int

The application path (refers to web application path).

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__PORTS__PORTS__PATH

string

/

The protocol.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__PORTS__PORTS__PROTOCOL

tcp, udp

tcp

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__PORTS__PORTS__NODE_PORT

int

Image pull policy.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__IMAGE_PULL_POLICY

always, if-not-present, never

always

The image pull secret

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__IMAGE_PULL_SECRETS

list of string

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)

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__LIVENESS_PROBE_FAILURE_THRESHOLD

int

3

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)

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_HTTP_ACTION_PATH

string

The command to use for the probe.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_EXEC_ACTION

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_TCP_SOCKET_ACTION

string

The amount of time to wait before starting to probe.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_INITIAL_DELAY

Duration

0S

The period in which the action should be called.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_PERIOD

Duration

30S

The amount of time to wait for each action.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_TIMEOUT

Duration

10S

The success threshold to use.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_SUCCESS_THRESHOLD

int

1

The failure threshold to use.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__READINESS_PROBE_FAILURE_THRESHOLD

int

3

The name of the volumeName to mount.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__MOUNTS__MOUNTS__NAME

string

The path to mount.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__MOUNTS__MOUNTS__PATH

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__MOUNTS__MOUNTS__SUB_PATH

string

ReadOnly

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__MOUNTS__MOUNTS__READ_ONLY

boolean

false

CPU Requirements

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__RESOURCES_LIMITS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__RESOURCES_LIMITS_MEMORY

string

CPU Requirements

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__RESOURCES_REQUESTS_CPU

string

Memory Requirements

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__RESOURCES_REQUESTS_MEMORY

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ENV_SECRETS

list of string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ENV_CONFIGMAPS

list of string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ENV_VARS

Map<String,String>

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ENV_MAPPING__MAPPING__FROM_SECRET

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

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

Environment variable: QUARKUS_KNATIVE_CONTAINERS__CONTAINERS__ENV_MAPPING__MAPPING__WITH_KEY

string

required

The ip address

Environment variable: QUARKUS_KNATIVE_HOST_ALIASES__HOST_ALIASES__IP

string

The hostnames to resolve to the ip

Environment variable: QUARKUS_KNATIVE_HOST_ALIASES__HOST_ALIASES__HOSTNAMES

list of string

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

Environment variable: QUARKUS_KNATIVE_ENV_FIELDS

Map<String,String>

The map associating environment name to its associated value.

Environment variable: QUARKUS_KNATIVE_ENV_VARS

Map<String,String>

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

Environment variable: QUARKUS_KNATIVE_ENV_MAPPING__MAPPING__FROM_SECRET

string

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

Environment variable: QUARKUS_KNATIVE_ENV_MAPPING__MAPPING__FROM_CONFIGMAP

string

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

Environment variable: QUARKUS_KNATIVE_ENV_MAPPING__MAPPING__WITH_KEY

string

required

Tag is optionally used to expose a dedicated url for referencing this target exclusively.

Environment variable: QUARKUS_KNATIVE_TRAFFIC__TRAFFIC__TAG

string

RevisionName of a specific revision to which to send this portion of traffic.

Environment variable: QUARKUS_KNATIVE_TRAFFIC__TRAFFIC__REVISION_NAME

string

LatestRevision may be optionally provided to indicate that the latest ready Revision of the Configuration should be used for this traffic target. When provided LatestRevision must be true if RevisionName is empty.

Environment variable: QUARKUS_KNATIVE_TRAFFIC__TRAFFIC__LATEST_REVISION

boolean

false

Percent indicates that percentage based routing should be used and the value indicates the percent of traffic that is to be routed to this Revision or Configuration. 0 (zero) mean no traffic, 100 means all traffic.

Environment variable: QUARKUS_KNATIVE_TRAFFIC__TRAFFIC__PERCENT

long

100

Deployment targets

Mentioned in the previous sections was the concept of deployment-target. This concept allows users to control which Kubernetes manifests will be generated and deployed to a cluster (if quarkus.kubernetes.deploy has been set to true).

By default, when no deployment-target is set, then only vanilla Kubernetes resources are generated and deployed. When multiple values are set (for example quarkus.kubernetes.deployment-target=kubernetes,openshift) then the resources for all targets are generated, but only the resources that correspond to the first target are applied to the cluster (if deployment is enabled).

In the case of wrapper extensions like OpenShift and Minikube, when these extensions have been explicitly added to the project, the default deployment-target is set by those extensions. For example if quarkus-minikube has been added to a project, then minikube becomes the default deployment target and its resources will be applied to the Kubernetes cluster when deployment via quarkus.kubernetes.deploy has been set. Users can still override the deployment-targets manually using quarkus.kubernetes.deployment-target.

Deprecated configuration

The following categories of configuration properties have been deprecated.

Properties without the quarkus prefix

In earlier versions of the extension, the quarkus. was missing from those properties. These properties are now deprecated.

Docker and S2i properties

The properties for configuring docker and s2i are also deprecated in favor of the new container-image extensions.

Config group arrays

Properties referring to config group arrays (e.g. kubernetes.labels[0], kubernetes.env-vars[0] etc) have been converted to Maps to align with the rest of the Quarkus ecosystem.

The code below demonstrates the change in labels config:

# Old labels config:
kubernetes.labels[0].name=foo
kubernetes.labels[0].value=bar

# New labels
quarkus.kubernetes.labels.foo=bar

The code below demonstrates the change in env-vars config:

# Old env-vars config:
kubernetes.env-vars[0].name=foo
kubernetes.env-vars[0].configmap=my-configmap

# New env-vars
quarkus.kubernetes.env-vars.foo.configmap=myconfigmap

env-vars properties

quarkus.kubernetes.env-vars are deprecated (though still currently supported as of this writing) and the new declaration style should be used instead. See Environment variables and more specifically Backwards compatibility for more details.

Deployment

To trigger building and deploying a container image you need to enable the quarkus.kubernetes.deploy flag (the flag is disabled by default - furthermore it has no effect during test runs or dev mode). This can be easily done with the command line:

./mvnw clean package -Dquarkus.kubernetes.deploy=true

Building a container image

Building a container image is possible, using any of the 3 available container-image extensions:

Each time deployment is requested, a container image build will be implicitly triggered (no additional properties are required when the Kubernetes deployment has been enabled).

Deploying

When deployment is enabled, the Kubernetes extension will select the resources specified by quarkus.kubernetes.deployment-target and deploy them. This assumes that a .kube/config is available in your user directory that points to the target Kubernetes cluster. In other words the extension will use whatever cluster kubectl uses. The same applies to credentials.

At the moment no additional options are provided for further customization.

Remote Debugging

To remotely debug applications that are running on a kubernetes environment, we need to deploy the application as described in the previous section and add as new property: quarkus.kubernetes.remote-debug.enabled=true. This property will automatically configure the Java application to append the java agent configuration (for example: -agentlib:jdwp=transport=dt_socket,server=y,suspend=n,address=5005) and also the service resource to listen using the java agent port.

After your application has been deployed with the debug enabled, next you need to tunnel the traffic from your local host machine to the specified port of the java agent:

kubectl port-forward svc/<application name> 5005:5005

Using this command, you’ll forward the traffic from the "localhost:5005" to the kubernetes service running the java agent using the port "5005" which is the one that the java agent uses by default for remote debugging. You can also configure another java agent port using the property quarkus.kubernetes.remote-debug.address-port.

Finally, all you need to do is to configure your favorite IDE to attach the java agent process that is forwarded to localhost:5005 and start to debug your application. For example, in IntelliJ IDEA, you can follow this tutorial to debug remote applications.

Using existing resources

Sometimes it’s desirable to either provide additional resources (e.g. a ConfigMap, a Secret, a Deployment for a database) or provide custom ones that will be used as a base for the generation process. Those resources can be added under src/main/kubernetes directory and can be named after the target environment (e.g. kubernetes.json, openshift.json, knative.json, or the yml equivalents). The correlation between provided and generated files is done by file name. So, a kubernetes.json/kubernetes.yml file added in src/main/kubernetes will only affect the generated kubernetes.json/kubernetes.yml. An openshift.json/openshift.yml file added in src/main/kubernetes will only affect the generated openshift.json/openshift.yml. A knative.json/knative.yml file added in src/main/kubernetes will only affect the generated knative.json/knative.yml and so on. The provided file may be either in json or yaml format and may contain one or more resources. These resources will end up in both generated formats (json and yaml). For example, a secret added in src/main/kubernetes/kubernetes.yml will be added to both the generated kubernetes.yml and kubernetes.json.

Note: At the time of writing there is no mechanism in place that allows a one-to-many relationship between provided and generated files. Minikube is not an exception to the rule above, so if you want to customize the generated minikube manifests, the file placed under src/main/kubernetes will have to be named minikube.json or minikube.yml (naming it kubernetes.yml or kubernetes.json will result in having only the generated kubernetes.yml and kubernetes.json affected).

Any resource found will be added in the generated manifests. Global modifications (e.g. labels, annotations) will also be applied to those resources. If one of the provided resources has the same name as one of the generated ones, then the generated resource will be created on top of the provided resource, respecting existing content when possible (e.g. existing labels, annotations, environment variables, mounts, replicas etc).

The name of the resource is determined by the application name and may be overridden by quarkus.kubernetes.name, quarkus.openshift.name and quarkus.knative.name.

For example, in the kubernetes-quickstart application, we can add a kubernetes.yml file in the src/main/kubernetes that looks like:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubernetes-quickstart
  labels:
    app: quickstart
spec:
  replicas: 3
  selector:
    matchLabels:
      app: quickstart
  template:
    metadata:
      labels:
        app: quickstart
    spec:
      containers:
      - name: kubernetes-quickstart
        image: someimage:latest
        ports:
        - containerPort: 80
        env:
        - name: FOO
          value: BAR

The generated kubernetes.yml will look like:

apiVersion: "apps/v1"
kind: "Deployment"
metadata:
  annotations:
    app.quarkus.io/build-timestamp: "2020-04-10 - 12:54:37 +0000"
  labels:
    app: "quickstart"
  name: "kubernetes-quickstart"
spec:
  replicas: 3 (1)
  selector:
    matchLabels:
      app.kubernetes.io/name: "kubernetes-quickstart"
      app.kubernetes.io/version: "1.0.0-SNAPSHOT"
  template:
    metadata:
      annotations:
        app.quarkus.io/build-timestamp: "2020-04-10 - 12:54:37 +0000"
      labels:
        app: "quickstart" (2)
    spec:
      containers:
      - env:
        - name: "FOO" (3)
          value: "BAR"
        image: "<<yourDockerUsername>>/kubernetes-quickstart:1.0.0-SNAPSHOT" (4)
        imagePullPolicy: "Always"
        name: "kubernetes-quickstart"
        ports:
        - containerPort: 8080 (5)
          name: "http"
          protocol: "TCP"
      serviceAccount: "kubernetes-quickstart"

The provided replicas <1>, labels <2> and environment variables <3> were retained. However, the image <4> and container port <5> were modified. Moreover, the default annotations have been added.

  • When the resource name does not match the application name (or the overridden name) rather than reusing the resource a new one will be added. Same goes for the container.

  • When the name of the container does not match the application name (or the overridden name), container specific configuration will be ignored.

Service Binding

Quarkus supports the Service Binding Specification for Kubernetes to bind services to applications.

Specifically, Quarkus implements the Workload Projection part of the specification, therefore allowing applications to bind to services, such as a Database or a Broker, without the need for user configuration.

To enable Service Binding for supported extensions, add the quarkus-kubernetes-service-binding extension to the application dependencies.

  • The following extensions can be used with Service Binding and are supported for Workload Projection:

    • quarkus-jdbc-mariadb

    • quarkus-jdbc-mssql

    • quarkus-jdbc-mysql

    • quarkus-jdbc-postgresql

    • quarkus-mongo-client

    • quarkus-kafka-client

    • quarkus-smallrye-reactive-messaging-kafka

Workload Projection

Workload Projection is a process of obtaining the configuration for services from the Kubernetes cluster. This configuration takes the form of directory structures that follow certain conventions and is attached to an application or to a service as a mounted volume. The kubernetes-service-binding extension uses this directory structure to create configuration sources, which allows you to configure additional modules, such as databases or message brokers.

During application development, users can use workload projection to connect their application to a development database, or other locally-run services, without changing the actual application code or configuration.

For an example of a workload projection where the directory structure is included in the test resources and passed to integration test, see the Kubernetes Service Binding datasource GitHub repository.

  • The k8s-sb directory is the root of all service bindings. In this example, only one database called fruit-db is intended to be bound. This binding database has the type file, that indicates postgresql as the database type, while the other files in the directory provide the necessary information to establish the connection.

  • After your Quarkus project obtains information from SERVICE_BINDING_ROOT environment variables that are set by OpenShift, you can locate generated configuration files that are present in the file system and use them to map the configuration-file values to properties of certain extensions.

Introduction to the Service Binding Operator

The Service Binding Operator is an Operator that implements Service Binding Specification for Kubernetes and is meant to simplify the binding of services to an application. Containerized applications that support Workload Projection obtain service binding information in the form of volume mounts. The Service Binding Operator reads binding service information and mounts it to the application containers that need it.

The correlation between application and bound services is expressed through the ServiceBinding resources, which declares the intent of what services are meant to be bound to what application.

The Service Binding Operator watches for ServiceBinding resources, which inform the Operator what applications are meant to be bound with what services. When a listed application is deployed, the Service Binding Operator collects all the binding information that must be passed to the application, then upgrades the application container by attaching a volume mount with the binding information.

The Service Binding Operator completes the following actions:

  • Observes ServiceBinding resources for workloads intended to be bound to a particular service

  • Applies the binding information to the workload using volume mounts

The following chapter describes the automatic and semi-automatic service binding approaches and their use cases. With either approach, the kubernetes-service-binding extension generates a ServiceBinding resource. With the semi-automatic approach, users must provide a configuration for target services manually. With the automatic approach, for a limited set of services generating the ServiceBinding resource, no additional configuration is needed.

Semi-automatic service binding

A service binding process starts with a user specification of required services that will be bound to a certain application. This expression is summarized in the ServiceBinding resource that is generated by the kubernetes-service-binding extension. The use of the kubernetes-service-binding extensions helps users to generate ServiceBinding resources with minimal configuration, therefore simplifying the process overall.

The Service Binding Operator responsible for the binding process then reads the information from the ServiceBinding resource and mounts the required files to a container accordingly.

  • An example of the ServiceBinding resource:

    apiVersion: binding.operators.coreos.com/v1beta1
    kind: ServiceBinding
    metadata:
     name: binding-request
     namespace: service-binding-demo
    spec:
     application:
       name: java-app
       group: apps
       version: v1
       resource: deployments
     services:
     - group: postgres-operator.crunchydata.com
       version: v1beta1
       kind: Database
       name: db-demo
       id: postgresDB
    • The quarkus-kubernetes-service-binding extension provides a more compact way of expressing the same information. For example:

      quarkus.kubernetes-service-binding.services.db-demo.api-version=postgres-operator.crunchydata.com/v1beta1
      quarkus.kubernetes-service-binding.services.db-demo.kind=Database

After adding the earlier configuration properties inside your application.properties, the quarkus-kubernetes, in combination with the quarkus-kubernetes-service-binding extension, automatically generates the ServiceBinding resource.

The earlier mentioned db-demo property-configuration identifier now has a double role and also completes the following actions:

  • Correlates and groups api-version and kind properties together

  • Defines the name property for the custom resource with a possibility for a later edit. For example:

    quarkus.kubernetes-service-binding.services.db-demo.api-version=postgres-operator.crunchydata.com/v1beta1
    quarkus.kubernetes-service-binding.services.db-demo.kind=Database
    quarkus.kubernetes-service-binding.services.db-demo.name=my-db
Additional resources

Automatic service binding

The quarkus-kubernetes-service-binding extension can generate the ServiceBinding resource automatically after detecting that an application requires access to the external services that are provided by available bindable Operators.

Automatic service binding can be generated for a limited number of service types. To be consistent with established terminology for Kubernetes and Quarkus services, this chapter refers to these service types as kinds.
Table 2. Operators that support the service auto-binding

Operator

API Version

Kind

postgresql

CrunchyData Postgres

postgres-operator.crunchydata.com/v1beta1

PostgresCluster

mysql

Percona XtraDB Cluster

pxc.percona.com/v1-9-0

PerconaXtraDBCluster

mongo

Percona Mongo

psmdb.percona.com/v1-9-0

PerconaServerMongoDB

Automatic datasource binding

For traditional databases, automatic binding is initiated whenever a datasource is configured as follows:

quarkus.datasource.db-kind=postgresql

The previous configuration, combined with the presence of quarkus-datasource, quarkus-jdbc-postgresql, quarkus-kubernetes, and quarkus-kubernetes-service-binding properties in the application, results in the generation of the ServiceBinding resource for the postgresql database type.

By using the apiVersion and kind properties of the Operator resource, which matches the used postgresql Operator, the generated ServiceBinding resource binds the service or resource to the application.

When you do not specify a name for your database service, the the value of the db-kind property is used as the default name.

 services:
 - apiVersion: postgres-operator.crunchydata.com/v1beta1
   kind: PostgresCluster
   name: postgresql

Specified the name of the datasource as follows:

quarkus.datasource.fruits-db.db-kind=postgresql

The service in the generated ServiceBinding then displays as follows:

 services:
 - apiVersion: postgres-operator.crunchydata.com/v1beta1
   kind: PostgresCluster
   name: fruits-db

Similarly, if you use mysql, the name of the datasource can be specified as follows:

quarkus.datasource.fruits-db.db-kind=mysql

The generated service contains the following:

 services:
 - apiVersion: pxc.percona.com/v1-9-0
   kind: PerconaXtraDBCluster
   name: fruits-db

Customizing Automatic Service Binding

Even though automatic binding was developed to eliminate as much manual configuration as possible, there are cases where modifying the generated ServiceBinding resource might still be needed. The generation process exclusively relies on information extracted from the application and the knowledge of the supported Operators, which may not reflect what is deployed in the cluster. The generated resource is based purely on the knowledge of the supported bindable Operators for popular service kinds and a set of conventions that were developed to prevent possible mismatches, such as:

  • The target resource name does not match the datasource name

  • A specific Operator needs to be used rather than the default Operator for that service kind

  • Version conflicts that occur when a user needs to use any other version than default or latest

Conventions
  • The target resource coordinates are determined based on the type of Operator and the kind of service.

  • The target resource name is set by default to match the service kind, such as postgresql, mysql, mongo.

  • For named datasources, the name of the datasource is used.

  • For named mongo clients, the name of the client is used.

Example 1 - Name mismatch

For cases in which you need to modify the generated ServiceBinding to fix a name mismatch, use the quarkus.kubernetes-service-binding.services properties and specify the service’s name as the service key.

The service key is usually the name of the service, for example the name of the datasource, or the name of the mongo client. When this value is not available, the datasource type, such as postgresql, mysql, mongo, is used instead.

To avoid naming conflicts between different types of services, prefix the service key with a specific datasource type, such as postgresql-<person>.

The following example shows how to customize the apiVersion property of the PostgresCluster resource:

quarkus.datasource.db-kind=postgresql
quarkus.kubernetes-service-binding.services.postgresql.api-version=postgres-operator.crunchydata.com/v1beta2
Example 2: Application of a custom name for a datasource

In Example 1, the db-kind(postgresql) was used as a service key. In this example, because the datasource is named, according to convention, the datasource name (fruits-db) is used instead.

The following example shows that for a named datasource, the datasource name is used as the name of the target resource:

quarkus.datasource.fruits-db.db-kind=postgresql

This has the same effect as the following configuration:

quarkus.kubernetes-service-binding.services.fruits-db.api-version=postgres-operator.crunchydata.com/v1beta1
quarkus.kubernetes-service-binding.services.fruits-db.kind=PostgresCluster
quarkus.kubernetes-service-binding.services.fruits-db.name=fruits-db
Additional resources
  • For more details about the available properties and how do they work, see the Workload Projection part of the Service Binding specification.