This guide demonstrates how your OpenID Connect (OIDC) application can support multi-tenancy so that you can serve multiple tenants from a single application. Tenants can be distinct realms or security domains within the same OpenID Provider or even distinct OpenID Providers.
When serving multiple customers from the same application (e.g.: SaaS), each customer is a tenant. By enabling multi-tenancy support to your applications you are allowed to also support distinct authentication policies for each tenant even though if that means authenticating against different OpenID Providers, such as Keycloak and Google.
Please read the Using OpenID Connect to Protect Service Applications guide if you need to authorize a tenant using Bearer Token Authorization.
Please read the Using OpenID Connect to Protect Web Applications guide if you need to authenticate and authorize a tenant using OpenId Connect Authorization Code Flow.
Prerequisites
To complete this guide, you need:
-
less than 15 minutes
-
an IDE
-
JDK 11+ installed with
JAVA_HOME
configured appropriately -
Apache Maven 3.8.1
-
Docker
Architecture
In this example, we build a very simple application which offers a single land page:
-
/{tenant}
The land page is served by a JAX-RS Resource and shows information obtained from the OpenID Provider about the authenticated user and the current tenant.
Solution
We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.
Clone the Git repository: git clone https://github.com/quarkusio/quarkus-quickstarts.git
, or download an archive.
The solution is located in the security-openid-connect-multi-tenancy-quickstart
directory.
Creating the Maven Project
First, we need a new project. Create a new project with the following command:
mvn io.quarkus.platform:quarkus-maven-plugin:2.2.1.Final:create \
-DprojectGroupId=org.acme \
-DprojectArtifactId=security-openid-connect-multi-tenancy-quickstart \
-Dextensions="oidc,resteasy-jackson" \
-DnoExamples
cd security-openid-connect-multi-tenancy-quickstart
If you already have your Quarkus project configured, you can add the oidc
extension
to your project by running the following command in your project base directory:
./mvnw quarkus:add-extension -Dextensions="oidc"
This will add the following to your pom.xml
:
<dependency>
<groupId>io.quarkus</groupId>
<artifactId>quarkus-oidc</artifactId>
</dependency>
Writing the application
Let’s start by implementing the /{tenant}
endpoint. As you can see from the source code below it is just a regular JAX-RS resource:
package org.acme.quickstart.oidc;
import javax.inject.Inject;
import javax.ws.rs.GET;
import javax.ws.rs.Path;
import org.eclipse.microprofile.jwt.JsonWebToken;
import io.quarkus.oidc.IdToken;
@Path("/{tenant}")
public class HomeResource {
/**
* Injection point for the ID Token issued by the OpenID Connect Provider
*/
@Inject
@IdToken
JsonWebToken idToken;
/**
* Returns the tokens available to the application. This endpoint exists only for demonstration purposes, you should not
* expose these tokens in a real application.
*
* @return the landing page HTML
*/
@GET
public String getHome() {
StringBuilder response = new StringBuilder().append("<html>").append("<body>");
response.append("<h2>Welcome, ").append(this.idToken.getClaim("email").toString()).append("</h2>\n");
response.append("<h3>You are accessing the application within tenant <b>").append(idToken.getIssuer()).append(" boundaries</b></h3>");
return response.append("</body>").append("</html>").toString();
}
}
In order to resolve the tenant from incoming requests and map it to a specific quarkus-oidc
tenant configuration in application.properties, you need to create an implementation for the io.quarkus.oidc.TenantResolver
interface.
package org.acme.quickstart.oidc;
import javax.enterprise.context.ApplicationScoped;
import io.quarkus.oidc.TenantResolver;
import io.vertx.ext.web.RoutingContext;
@ApplicationScoped
public class CustomTenantResolver implements TenantResolver {
@Override
public String resolve(RoutingContext context) {
String path = context.request().path();
String[] parts = path.split("/");
if (parts.length == 0) {
// resolve to default tenant configuration
return null;
}
return parts[1];
}
}
From the implementation above, tenants are resolved from the request path so that in case no tenant could be inferred, null
is returned to indicate that the default tenant configuration should be used.
===
If you also use Hibernate ORM multitenancy and both OIDC and Hibernate ORM tenant IDs are the same and must be extracted from the Vert.x RoutingContext then you can pass the tenant id from the OIDC Tenant Resolver to the Hibernate ORM Tenant Resolver as a RoutingContext attribute, for example:
|
public class CustomTenantResolver implements TenantResolver {
@Override
public String resolve(RoutingContext context) {
String tenantId = extractTenantId(context);
context.put("tenantId", tenantId);
return tenantId;
}
}
===
Configuring the application
# Default Tenant Configuration
quarkus.oidc.auth-server-url=http://localhost:8180/auth/realms/quarkus
quarkus.oidc.client-id=multi-tenant-client
quarkus.oidc.application-type=web-app
# Tenant A Configuration
quarkus.oidc.tenant-a.auth-server-url=http://localhost:8180/auth/realms/tenant-a
quarkus.oidc.tenant-a.client-id=multi-tenant-client
quarkus.oidc.tenant-a.application-type=web-app
# HTTP Security Configuration
quarkus.http.auth.permission.authenticated.paths=/*
quarkus.http.auth.permission.authenticated.policy=authenticated
The first configuration is the default tenant configuration that should be used when the tenant can not be inferred from the request. This configuration is using a Keycloak instance to authenticate users.
The second configuration is the configuration that will be used when an incoming request is mapped to the tenant tenant-a
.
Note that both configurations map to the same Keycloak server instance while using distinct realms
.
You can define multiple tenants in your configuration file, just make sure they have a unique alias so that you can map them properly when resolving a tenant from your TenantResolver
implementation.
Google OpenID Provider Configuration
In order to set-up the tenant-a
configuration to use Google OpenID Provider, you need to create a project as described here.
Once you create the project and have your project’s client_id
and client_secret
, you can try to configure a tenant as follows:
# Tenant configuration using Google OpenID Provider
quarkus.oidc.tenant-b.auth-server-url=https://accounts.google.com
quarkus.oidc.tenant-b.application-type=web-app
quarkus.oidc.tenant-b.client-id={GOOGLE_CLIENT_ID}
quarkus.oidc.tenant-b.credentials.secret={GOOGLE_CLIENT_SECRET}
quarkus.oidc.tenant-b.token.issuer=https://accounts.google.com
quarkus.oidc.tenant-b.authentication.scopes=email,profile,openid
Starting and Configuring the Keycloak Server
To start a Keycloak Server you can use Docker and just run the following command:
docker run --name keycloak -e KEYCLOAK_USER=admin -e KEYCLOAK_PASSWORD=admin -p 8180:8080 quay.io/keycloak/keycloak:14.0.0
You should be able to access your Keycloak Server at localhost:8180/auth.
Log in as the admin
user to access the Keycloak Administration Console. Username should be admin
and password admin
.
Now, follow the steps below to import the realms for the two tenants:
-
Import the default-tenant-realm.json to create the default realm
-
Import the tenant-a-realm.json to create the realm for the tenant
tenant-a
.
For more details, see the Keycloak documentation about how to create a new realm.
Running and Using the Application
Running in Developer Mode
To run the microservice in dev mode, use ./mvnw clean compile quarkus:dev
.
Running in JVM Mode
When you’re done playing with "dev-mode" you can run it as a standard Java application.
First compile it:
./mvnw package
Then run it:
java -jar target/quarkus-app/quarkus-run.jar
Running in Native Mode
This same demo can be compiled into native code: no modifications required.
This implies that you no longer need to install a JVM on your production environment, as the runtime technology is included in the produced binary, and optimized to run with minimal resource overhead.
Compilation will take a bit longer, so this step is disabled by default;
let’s build again by enabling the native
profile:
./mvnw package -Pnative
After getting a cup of coffee, you’ll be able to run this binary directly:
./target/security-openid-connect-multi-tenancy-quickstart-runner
Testing the Application
To test the application, you should open your browser and access the following URL:
If everything is working as expected, you should be redirected to the Keycloak server to authenticate. Note that the requested path
defines a default
tenant which we don’t have mapped in the configuration file. In this case, the default configuration will be used.
In order to authenticate to the application you should type the following credentials when at the Keycloak login page:
-
Username: alice
-
Password: alice
After clicking the Login
button you should be redirected back to the application.
If you try now to access the application at the following URL:
You should be redirected again to the login page at Keycloak. However, now you are going to authenticate using a different realm
.
In both cases, if the user is successfully authenticated, the landing page will show the user’s name and e-mail. Even though
user alice
exists in both tenants, for the application they are distinct users belonging to different realms/tenants.
Programmatically Resolving Tenants Configuration
If you need a more dynamic configuration for the different tenants you want to support and don’t want to end up with multiple
entries in your configuration file, you can use the io.quarkus.oidc.TenantConfigResolver
.
This interface allows you to dynamically create tenant configurations at runtime:
package io.quarkus.it.keycloak;
import javax.enterprise.context.ApplicationScoped;
import io.quarkus.oidc.OidcTenantConfig;
import io.quarkus.oidc.TenantConfigResolver;
import io.vertx.ext.web.RoutingContext;
@ApplicationScoped
public class CustomTenantConfigResolver implements TenantConfigResolver {
@Override
public OidcTenantConfig resolve(RoutingContext context) {
String path = context.request().path();
String[] parts = path.split("/");
if (parts.length == 0) {
// resolve to default tenant configuration
return null;
}
if ("tenant-c".equals(parts[1])) {
OidcTenantConfig config = new OidcTenantConfig();
config.setTenantId("tenant-c");
config.setAuthServerUrl("http://localhost:8180/auth/realms/tenant-c");
config.setClientId("multi-tenant-client");
OidcTenantConfig.Credentials credentials = new OidcTenantConfig.Credentials();
credentials.setSecret("my-secret");
config.setCredentials(credentials);
// any other setting support by the quarkus-oidc extension
return config;
}
// resolve to default tenant configuration
return null;
}
}
The OidcTenantConfig
returned from this method is the same used to parse the oidc
namespace configuration from the application.properties
. You can populate it using any of the settings supported by the quarkus-oidc
extension.
Tenant Resolution for OIDC 'web-app' applications
Several options are available for selecting the tenant configuration which should be used to secure the current HTTP request for both service
and web-app
OIDC applications, such as:
-
Check URL paths, for example, a
tenant-service
configuration has to be used for the "/service" paths, while atenant-manage
configuration - for the "/management" paths -
Check HTTP headers, for example, with a URL path always being '/service', a header such as "Realm: service" or "Realm: management" can help selecting between the
tenant-service
andtenant-manage
configurations -
Check URL query parameters - it can work similarly to the way the headers are used to select the tenant configuration
All these options can be easily implemented with the custom TenantResolver
and TenantConfigResolver
implementations for the OIDC service
applications.
However, due to an HTTP redirect required to complete the code authentication flow for the OIDC web-app
applications, a custom HTTP cookie may be needed to select the same tenant configuration before and after this redirect request because:
-
URL path may not be the same after the redirect request if a single redirect URL has been registered in the OIDC Provider - the original request path can be restored but after the the tenant configuration is resolved
-
HTTP headers used during the original request are not available after the redirect
-
Custom URL query parameters are restored after the redirect but after the tenant configuration is resolved
One option to ensure the information for resolving the tenant configurations for web-app
applications is available before and after the redirect is to use a cookie, for example:
package org.acme.quickstart.oidc;
import java.util.List;
import javax.enterprise.context.ApplicationScoped;
import io.quarkus.oidc.TenantResolver;
import io.vertx.core.http.Cookie;
import io.vertx.ext.web.RoutingContext;
@ApplicationScoped
public class CustomTenantResolver implements TenantResolver {
@Override
public String resolve(RoutingContext context) {
List<String> tenantIdQuery = context.queryParam("tenantId");
if (!tenantIdQuery.isEmpty()) {
String tenantId = tenantIdQuery.get(0);
context.addCookie(Cookie.cookie("tenant", tenantId));
return tenantId;
} else if (context.cookieMap().containsKey("tenant")) {
return context.getCookie("tenant").getValue();
}
return null;
}
}
Disabling Tenant Configurations
Custom TenantResolver
and TenantConfigResolver
implementations may return null
if no tenant can be inferred from the current request and a fallback to the default tenant configuration is required.
If it is expected that the custom resolvers will always infer a tenant then the default tenant configuration is not needed. One can disable it with the quarkus.oidc.tenant-enabled=false
setting.
Note that tenant specific configurations can also be disabled, for example: quarkus.oidc.tenant-a.tenant-enabled=false
.
Configuration Reference
Configuration property fixed at build time - All other configuration properties are overridable at runtime
Type |
Default |
|
---|---|---|
If DevServices has been explicitly enabled or disabled. When DevServices is enabled Quarkus will attempt to automatically configure and start Keycloak when running in Dev or Test mode and when Docker is running. |
boolean |
|
The container image name to use, for container based DevServices providers. |
string |
|
The class or file system path to a Keycloak realm file which will be used to initialize Keycloak. |
string |
|
The Keycloak realm. This property will be used to create the realm if the realm file pointed to by the 'realm-path' property does not exist. Setting this property is recommended even if realm file exists for |
string |
|
Grant type which will be used to acquire a token to test the OIDC 'service' applications |
|
|
Optional fixed port the dev service will listen to. If not defined, the port will be chosen randomly. |
int |
|
The WebClient timeout. Use this property to configure how long an HTTP client will wait for a response when requesting tokens from Keycloak and sending them to the service endpoint. |
|
|
The Keycloak users map containing the user name and password pairs. If this map is empty then two users, 'alice' and 'bob' with the passwords matching their names will be created. This property will be used to create the Keycloak users if the realm file pointed to by the 'realm-path' property does not exist. |
|
|
The Keycloak user roles. If this map is empty then a user named 'alice' will get 'admin' and 'user' roles and all other users will get a 'user' role. This property will be used to create the Keycloak roles if the realm file pointed to by the 'realm-path' property does not exist. |
|
|
If the OIDC extension is enabled. |
boolean |
|
The base URL of the OpenID Connect (OIDC) server, for example, |
string |
|
Enables OIDC discovery. If the discovery is disabled then the 'token-path' property must be configured. |
boolean |
|
Relative path of the OIDC token endpoint which issues access and refresh tokens using either 'client_credentials' or 'password' grants |
string |
|
The client-id of the application. Each application has a client-id that is used to identify the application |
string |
|
The maximum amount of time connecting to the currently unavailable OIDC server will be attempted for. The number of times the connection request will be repeated is calculated by dividing the value of this property by 2. For example, setting it to |
||
The number of times an attempt to re-establish an already available connection will be repeated for. Note this property is different to the |
int |
|
The amount of time after which the current OIDC connection request will time out. |
|
|
The maximum size of the connection pool used by the WebClient |
int |
|
Client secret which is used for a |
string |
|
The client secret value - it will be ignored if 'secret.key' is set |
string |
|
The CredentialsProvider name which should only be set if more than one CredentialsProvider is registered |
string |
|
The CredentialsProvider client secret key |
string |
|
Authentication method. |
|
|
If provided, indicates that JWT is signed using a secret key |
string |
|
The CredentialsProvider name which should only be set if more than one CredentialsProvider is registered |
string |
|
The CredentialsProvider client secret key |
string |
|
If provided, indicates that JWT is signed using a private key in PEM or JWK format |
string |
|
If provided, indicates that JWT is signed using a private key from a key store |
string |
|
A parameter to specify the password of the key store file. If not given, the default ("password") is used. |
string |
|
The private key id/alias |
string |
|
The private key password |
string |
|
Key identifier of the signing key added as a JWT 'kid' header |
string |
|
JWT life-span in seconds. It will be added to the time it was issued at to calculate the expiration time. |
int |
|
The host (name or IP address) of the Proxy. Note: If OIDC adapter needs to use a Proxy to talk with OIDC server (Provider), then at least the "host" config item must be configured to enable the usage of a Proxy. |
string |
|
The port number of the Proxy. Default value is 80. |
int |
|
The username, if Proxy needs authentication. |
string |
|
The password, if Proxy needs authentication. |
string |
|
Certificate validation and hostname verification, which can be one of the following values from enum |
|
|
An optional trust store which holds the certificate information of the certificates to trust |
path |
|
A parameter to specify the password of the trust store file. |
string |
|
A parameter to specify the alias of the trust store certificate. |
string |
|
A unique tenant identifier. It must be set by |
string |
|
If this tenant configuration is enabled. |
boolean |
|
The application type, which can be one of the following values from enum |
|
|
Relative path of the OIDC authorization endpoint which authenticates the users. This property must be set for the 'web-app' applications if OIDC discovery is disabled. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC userinfo endpoint. This property must only be set for the 'web-app' applications if OIDC discovery is disabled and 'authentication.user-info-required' property is enabled. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC RFC7662 introspection endpoint which can introspect both opaque and JWT tokens. This property must be set if OIDC discovery is disabled and 1) the opaque bearer access tokens have to be verified or 2) JWT tokens have to be verified while the cached JWK verification set with no matching JWK is being refreshed. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC JWKS endpoint which returns a JSON Web Key Verification Set. This property should be set if OIDC discovery is disabled and the local JWT verification is required. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC end_session_endpoint. This property must be set if OIDC discovery is disabled and RP Initiated Logout support for the 'web-app' applications is required. This property will be ignored if the discovery is enabled. |
string |
|
Public key for the local JWT token verification. OIDC server connection will not be created when this property is set. |
string |
|
Path to the claim containing an array of groups. It starts from the top level JWT JSON object and can contain multiple segments where each segment represents a JSON object name only, example: "realm/groups". Use double quotes with the namespace qualified claim names. This property can be used if a token has no 'groups' claim but has the groups set in a different claim. |
string |
|
Separator for splitting a string which may contain multiple group values. It will only be used if the "role-claim-path" property points to a custom claim whose value is a string. A single space will be used by default because the standard 'scope' claim may contain a space separated sequence. |
string |
|
Source of the principal roles. |
|
|
Expected issuer 'iss' claim value. Note this property overrides the |
string |
|
Expected audience 'aud' claim value which may be a string or an array of strings. |
list of string |
|
Expected token type |
string |
|
Life span grace period in seconds. When checking token expiry, current time is allowed to be later than token expiration time by at most the configured number of seconds. When checking token issuance, current time is allowed to be sooner than token issue time by at most the configured number of seconds. |
int |
|
Name of the claim which contains a principal name. By default, the 'upn', 'preferred_username' and |
string |
|
Refresh expired ID tokens. If this property is enabled then a refresh token request will be performed if the ID token has expired and, if successful, the local session will be updated with the new set of tokens. Otherwise, the local session will be invalidated and the user redirected to the OpenID Provider to re-authenticate. In this case the user may not be challenged again if the OIDC provider session is still active. For this option be effective the |
boolean |
|
Refresh token time skew in seconds. If this property is enabled then the configured number of seconds is added to the current time when checking whether the access token should be refreshed. If the sum is greater than this access token’s expiration time then a refresh is going to happen. This property will be ignored if the 'refresh-expired' property is not enabled. |
||
Forced JWK set refresh interval in minutes. |
|
|
Custom HTTP header that contains a bearer token. This option is valid only when the application is of type |
string |
|
Allow the remote introspection of JWT tokens when no matching JWK key is available. Note this property is set to 'true' by default for backward-compatibility reasons and will be set to |
boolean |
|
Allow the remote introspection of the opaque tokens. Set this property to 'false' if only JWT tokens are expected. |
boolean |
|
The relative path of the logout endpoint at the application. If provided, the application is able to initiate the logout through this endpoint in conformance with the OpenID Connect RP-Initiated Logout specification. |
string |
|
Relative path of the application endpoint where the user should be redirected to after logging out from the OpenID Connect Provider. This endpoint URI must be properly registered at the OpenID Connect Provider as a valid redirect URI. |
string |
|
Relative path for calculating a "redirect_uri" query parameter. It has to start from a forward slash and will be appended to the request URI’s host and port. For example, if the current request URI is 'https://localhost:8080/service' then a 'redirect_uri' parameter will be set to 'https://localhost:8080/' if this property is set to '/' and be the same as the request URI if this property has not been configured. Note the original request URI will be restored after the user has authenticated if 'restorePathAfterRedirect' is set to 'true'. |
string |
|
If this property is set to 'true' then the original request URI which was used before the authentication will be restored after the user has been redirected back to the application. Note if |
boolean |
|
Remove the query parameters such as 'code' and 'state' set by the OIDC server on the redirect URI after the user has authenticated by redirecting a user to the same URI but without the query parameters. |
boolean |
|
Both ID and access tokens are fetched from the OIDC provider as part of the authorization code flow. ID token is always verified on every user request as the primary token which is used to represent the principal and extract the roles. Access token is not verified by default since it is meant to be propagated to the downstream services. The verification of the access token should be enabled if it is injected as a JWT token. Access tokens obtained as part of the code flow will always be verified if |
boolean |
|
Force 'https' as the 'redirect_uri' parameter scheme when running behind an SSL terminating reverse proxy. This property, if enabled, will also affect the logout |
boolean |
|
List of scopes |
list of string |
|
If enabled the state, session and post logout cookies will have their 'secure' parameter set to 'true' when HTTP is used. It may be necessary when running behind an SSL terminating reverse proxy. The cookies will always be secure if HTTPS is used even if this property is set to false. |
boolean |
|
Cookie path parameter value which, if set, will be used to set a path parameter for the session, state and post logout cookies. The |
string |
|
Cookie path header parameter value which, if set, identifies the incoming HTTP header whose value will be used to set a path parameter for the session, state and post logout cookies. If the header is missing then the |
string |
|
Cookie domain parameter value which, if set, will be used for the session, state and post logout cookies. |
string |
|
If this property is set to 'true' then an OIDC UserInfo endpoint will be called |
boolean |
|
Session age extension in minutes. The user session age property is set to the value of the ID token life-span by default and the user will be redirected to the OIDC provider to re-authenticate once the session has expired. If this property is set to a non-zero value then the expired ID token can be refreshed before the session has expired. This property will be ignored if the |
|
|
If this property is set to 'true' then a normal 302 redirect response will be returned if the request was initiated via JavaScript API such as XMLHttpRequest or Fetch and the current user needs to be (re)authenticated which may not be desirable for Single Page Applications since it automatically following the redirect may not work given that OIDC authorization endpoints typically do not support CORS. If this property is set to |
boolean |
|
Default TokenStateManager strategy. |
|
|
Default TokenStateManager keeps all tokens (ID, access and refresh) returned in the authorization code grant response in a single session cookie by default. Enable this property to minimize a session cookie size |
boolean |
|
Additional properties which will be added as the query parameters to the authentication redirect URI. |
|
|
Type |
Default |
|
The base URL of the OpenID Connect (OIDC) server, for example, |
string |
|
Enables OIDC discovery. If the discovery is disabled then the 'token-path' property must be configured. |
boolean |
|
Relative path of the OIDC token endpoint which issues access and refresh tokens using either 'client_credentials' or 'password' grants |
string |
|
The client-id of the application. Each application has a client-id that is used to identify the application |
string |
|
The maximum amount of time connecting to the currently unavailable OIDC server will be attempted for. The number of times the connection request will be repeated is calculated by dividing the value of this property by 2. For example, setting it to |
||
The number of times an attempt to re-establish an already available connection will be repeated for. Note this property is different to the |
int |
|
The amount of time after which the current OIDC connection request will time out. |
|
|
The maximum size of the connection pool used by the WebClient |
int |
|
Client secret which is used for a |
string |
|
The client secret value - it will be ignored if 'secret.key' is set |
string |
|
The CredentialsProvider name which should only be set if more than one CredentialsProvider is registered |
string |
|
The CredentialsProvider client secret key |
string |
|
Authentication method. |
|
|
If provided, indicates that JWT is signed using a secret key |
string |
|
The CredentialsProvider name which should only be set if more than one CredentialsProvider is registered |
string |
|
The CredentialsProvider client secret key |
string |
|
If provided, indicates that JWT is signed using a private key in PEM or JWK format |
string |
|
If provided, indicates that JWT is signed using a private key from a key store |
string |
|
A parameter to specify the password of the key store file. If not given, the default ("password") is used. |
string |
|
The private key id/alias |
string |
|
The private key password |
string |
|
Key identifier of the signing key added as a JWT 'kid' header |
string |
|
JWT life-span in seconds. It will be added to the time it was issued at to calculate the expiration time. |
int |
|
The host (name or IP address) of the Proxy. Note: If OIDC adapter needs to use a Proxy to talk with OIDC server (Provider), then at least the "host" config item must be configured to enable the usage of a Proxy. |
string |
|
The port number of the Proxy. Default value is 80. |
int |
|
The username, if Proxy needs authentication. |
string |
|
The password, if Proxy needs authentication. |
string |
|
Certificate validation and hostname verification, which can be one of the following values from enum |
|
|
An optional trust store which holds the certificate information of the certificates to trust |
path |
|
A parameter to specify the password of the trust store file. |
string |
|
A parameter to specify the alias of the trust store certificate. |
string |
|
A unique tenant identifier. It must be set by |
string |
|
If this tenant configuration is enabled. |
boolean |
|
The application type, which can be one of the following values from enum |
|
|
Relative path of the OIDC authorization endpoint which authenticates the users. This property must be set for the 'web-app' applications if OIDC discovery is disabled. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC userinfo endpoint. This property must only be set for the 'web-app' applications if OIDC discovery is disabled and 'authentication.user-info-required' property is enabled. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC RFC7662 introspection endpoint which can introspect both opaque and JWT tokens. This property must be set if OIDC discovery is disabled and 1) the opaque bearer access tokens have to be verified or 2) JWT tokens have to be verified while the cached JWK verification set with no matching JWK is being refreshed. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC JWKS endpoint which returns a JSON Web Key Verification Set. This property should be set if OIDC discovery is disabled and the local JWT verification is required. This property will be ignored if the discovery is enabled. |
string |
|
Relative path of the OIDC end_session_endpoint. This property must be set if OIDC discovery is disabled and RP Initiated Logout support for the 'web-app' applications is required. This property will be ignored if the discovery is enabled. |
string |
|
Public key for the local JWT token verification. OIDC server connection will not be created when this property is set. |
string |
|
Path to the claim containing an array of groups. It starts from the top level JWT JSON object and can contain multiple segments where each segment represents a JSON object name only, example: "realm/groups". Use double quotes with the namespace qualified claim names. This property can be used if a token has no 'groups' claim but has the groups set in a different claim. |
string |
|
Separator for splitting a string which may contain multiple group values. It will only be used if the "role-claim-path" property points to a custom claim whose value is a string. A single space will be used by default because the standard 'scope' claim may contain a space separated sequence. |
string |
|
Source of the principal roles. |
|
|
Expected issuer 'iss' claim value. Note this property overrides the |
string |
|
Expected audience 'aud' claim value which may be a string or an array of strings. |
list of string |
|
Expected token type |
string |
|
Life span grace period in seconds. When checking token expiry, current time is allowed to be later than token expiration time by at most the configured number of seconds. When checking token issuance, current time is allowed to be sooner than token issue time by at most the configured number of seconds. |
int |
|
Name of the claim which contains a principal name. By default, the 'upn', 'preferred_username' and |
string |
|
Refresh expired ID tokens. If this property is enabled then a refresh token request will be performed if the ID token has expired and, if successful, the local session will be updated with the new set of tokens. Otherwise, the local session will be invalidated and the user redirected to the OpenID Provider to re-authenticate. In this case the user may not be challenged again if the OIDC provider session is still active. For this option be effective the |
boolean |
|
Refresh token time skew in seconds. If this property is enabled then the configured number of seconds is added to the current time when checking whether the access token should be refreshed. If the sum is greater than this access token’s expiration time then a refresh is going to happen. This property will be ignored if the 'refresh-expired' property is not enabled. |
||
Forced JWK set refresh interval in minutes. |
|
|
Custom HTTP header that contains a bearer token. This option is valid only when the application is of type |
string |
|
Allow the remote introspection of JWT tokens when no matching JWK key is available. Note this property is set to 'true' by default for backward-compatibility reasons and will be set to |
boolean |
|
Allow the remote introspection of the opaque tokens. Set this property to 'false' if only JWT tokens are expected. |
boolean |
|
The relative path of the logout endpoint at the application. If provided, the application is able to initiate the logout through this endpoint in conformance with the OpenID Connect RP-Initiated Logout specification. |
string |
|
Relative path of the application endpoint where the user should be redirected to after logging out from the OpenID Connect Provider. This endpoint URI must be properly registered at the OpenID Connect Provider as a valid redirect URI. |
string |
|
Relative path for calculating a "redirect_uri" query parameter. It has to start from a forward slash and will be appended to the request URI’s host and port. For example, if the current request URI is 'https://localhost:8080/service' then a 'redirect_uri' parameter will be set to 'https://localhost:8080/' if this property is set to '/' and be the same as the request URI if this property has not been configured. Note the original request URI will be restored after the user has authenticated if 'restorePathAfterRedirect' is set to 'true'. |
string |
|
If this property is set to 'true' then the original request URI which was used before the authentication will be restored after the user has been redirected back to the application. Note if |
boolean |
|
Remove the query parameters such as 'code' and 'state' set by the OIDC server on the redirect URI after the user has authenticated by redirecting a user to the same URI but without the query parameters. |
boolean |
|
Both ID and access tokens are fetched from the OIDC provider as part of the authorization code flow. ID token is always verified on every user request as the primary token which is used to represent the principal and extract the roles. Access token is not verified by default since it is meant to be propagated to the downstream services. The verification of the access token should be enabled if it is injected as a JWT token. Access tokens obtained as part of the code flow will always be verified if |
boolean |
|
Force 'https' as the 'redirect_uri' parameter scheme when running behind an SSL terminating reverse proxy. This property, if enabled, will also affect the logout |
boolean |
|
List of scopes |
list of string |
|
Additional properties which will be added as the query parameters to the authentication redirect URI. |
|
|
If enabled the state, session and post logout cookies will have their 'secure' parameter set to 'true' when HTTP is used. It may be necessary when running behind an SSL terminating reverse proxy. The cookies will always be secure if HTTPS is used even if this property is set to false. |
boolean |
|
Cookie path parameter value which, if set, will be used to set a path parameter for the session, state and post logout cookies. The |
string |
|
Cookie path header parameter value which, if set, identifies the incoming HTTP header whose value will be used to set a path parameter for the session, state and post logout cookies. If the header is missing then the |
string |
|
Cookie domain parameter value which, if set, will be used for the session, state and post logout cookies. |
string |
|
If this property is set to 'true' then an OIDC UserInfo endpoint will be called |
boolean |
|
Session age extension in minutes. The user session age property is set to the value of the ID token life-span by default and the user will be redirected to the OIDC provider to re-authenticate once the session has expired. If this property is set to a non-zero value then the expired ID token can be refreshed before the session has expired. This property will be ignored if the |
|
|
If this property is set to 'true' then a normal 302 redirect response will be returned if the request was initiated via JavaScript API such as XMLHttpRequest or Fetch and the current user needs to be (re)authenticated which may not be desirable for Single Page Applications since it automatically following the redirect may not work given that OIDC authorization endpoints typically do not support CORS. If this property is set to |
boolean |
|
Default TokenStateManager strategy. |
|
|
Default TokenStateManager keeps all tokens (ID, access and refresh) returned in the authorization code grant response in a single session cookie by default. Enable this property to minimize a session cookie size |
boolean |
|
About the Duration format
The format for durations uses the standard You can also provide duration values starting with a number.
In this case, if the value consists only of a number, the converter treats the value as seconds.
Otherwise, |