OpenID Connect with Okta
This guide covers an example OpenID Connect plugin configuration to authenticate browser clients using an Okta identity provider.
For information about configuring OIDC using Okta as an Identity provider
in conjunction with the Application Registration plugin, see
Set Up External Portal Application Authentication with Okta and OIDC.
Authorization code flow with the OpenID Connect plugin and Okta
- If the client does not have a session cookie, it initiates sign in with Kong.
- Kong responds to the client with an authorization cookie and a location to redirect (with Okta as the header).
- the client redirects to Okta so the user can sign in.
- Okta responds with an authorization code and a location to redirect (with Kong as the header).
At this point, the client has successfully signed in and has an authorization code (from Okta) and an authorization cookie (from Kong).
- The client redirects to Kong and automatically sends the authorization code (from Okta) and an authorization cookie (from Kong).
- Kong verifies the authorization code with Okta.
- Okta sends and access token and ID token to Kong.
- Kong proxies the client request with the access token from Okta.
- Kong receives a service response.
- Kong sends the service response to the client, along with a session cookie for future access.
At this point, the client now has a session with Kong that allows mediated access to the service.
- The client sends requests with a session cookie.
- Kong matches the session cookie to the associate access token and proxies the request.
- Kong gets a response from the service.
- Kong sends the response to the client.
Kong’s session with the client ensures that the client does not need to make constant requests to Okta. The duration of the session can be configured.
Example of configuring the OIDC plugin with Okta
The steps in the guide offer an example of configuring OIDC with Okta on a specific route. To follow this guide, you need the following:
- A developer account with Okta.
- A running version of Kong Gateway.
- Access to the OpenID Connect plugin.
- A service
and route in
Kong Gateway whose access you want to protect with Okta. For this
guide, assume the route is in the default workspace.
- If using Kong Gateway locally, you need Internet access.
Any network access control to your Kong node must allow traffic to and from Okta, the upstream service, and the client.
For security reasons, make sure all requests are sent over HTTPS, and make the Kong proxy available
with a fully-qualified domain name and properly configured certificate.
Authorization tokens should also be stored securely.
- Register the application you are using Kong to proxy.
- From the left menu, select Applications, then Create App Integration.
Select the application type:
- Under Sign-in method, select OIDC - OpenID Connect.
- Under Application Type, select Web Application.
- Select Next. Configure the application:
- Create a unique name for your application.
- Under Grant Type, select Authorization Code.
In both the Sign-in redirect URIs and
Sign-out redirect URIs fields, enter a location handled by your Route
in Kong Gateway.
For this example, you can enter
- In the Assignments section, for Controlled access, choose your
preferred access level for this application. This preferred access level sets the permissions for
Save your settings to generate connection details.
Leave this page open. You’ll need the details here to configure the Kong OIDC plugin.
Add an Authorization Server. From the left sidebar, go to
Security > API > Authorization Server and create a server named
Kong API Management with an audience and description. Click Save.
On the page that appears, note the Issuer address. You need this address
to configure the Kong OIDC Plugin.
Configure the OIDC plugin in Kong Gateway
Minimum configuration requirements
Configure the following parameters:
issuer: The issuer
url from which OpenID Connect configuration can be discovered. Using Okta, specify the domain and server in the path:
auth_method: A list of authentication methods to use with the plugin, such as passwords, introspection tokens, etc. The majority of cases use
authorization_code, and Kong Gateway will accept all methods if no methods are specified.
client_id of the OpenID Connect client registered in OpenID Connect Provider. Okta provides one to identify itself.
client_secret of the OpenID Connect client registered in OpenID Connect Provider. These credentials should never be publicly exposed.
redirect_uri of the client defined with
client_id (also used as a redirection URI for the authorization code flow).
scopes: The scope of what OpenID Connect checks.
openid by default; set to
profile for this example.
Visiting a URL matched by that route in a browser will now redirect to Okta’s authentication
site and return you to the redirect URI after authenticating.
Test Your Configuration
Test the following conditions to ensure a successful integration of the OIDC plugin with Okta:
- Unauthorized access to a route is blocked
- Authorized access is allowed after login/providing first set of credentials
- Ensure the identity is registered with the IdP
- Steps for debugging
- Authorized access is allowed on immediate subsequent attempts
- Perhaps highlight where the cookie is stored
- Previously authorized access is no longer allowed after cookie terminates
- Set a very short TTL on the session to ensure the tester doesn’t need to wait long to get locked out
The example configuration allows users to authenticate and access the Route even though
no Consumer was created for them. Any user with a valid account in the directory
will have access to the Route. The OIDC plugin allows this as the simplest authentication option,
but you may wish to restrict access further. There are several options for this:
- Consumer Mapping
- Pseudo-Consumer Mapping
If you need to interact with other Kong plugins using consumer information, you
can add configuration that maps account data received from the identity provider to a Kong consumer.
For this example, the user’s Okta’s AD account GUID is mapped to a Consumer by setting it
custom_id on their consumer:
curl -i -X POST http://admin.kong.example/consumers/ \
--data username="Yoda" \
curl -i -X PATCH http://admin.kong.example/plugins/OIDC_PLUGIN_ID \
--data config.consumer_by="custom_id" \
Now, if a user logs into an Okta account with the GUID
e5634b31-d67f-4661-a6fb-b6cb77849bcf, Kong will apply configuration associated with the Consumer
Yoda to their requests.
This also requires that clients login using an account mapped to some Consumer, which might
not be desirable (e.g., you apply OpenID Connect to a service, but only use plugins
requiring a Consumer on some Routes). To deal with this, you can set the
in your OIDC plugin configuration to the ID of a generic Consumer, which will
then be used for all authenticated users that cannot be mapped to some other Consumer.
You can alternately set
true to allow similar logins
without mapping an anonymous Consumer.
For plugins that typically require consumers, the OIDC plugin can provide a consumer ID based on the value of a claim without mapping to an actual Consumer. Setting
credential_claim to a claim in your plugin configuration will extract the value of that claim and use it where Kong would normally use a consumer ID. Note that this may not work with all consumer-related functionality.
authenticated_groups_claim will extract that claim’s value and use it as a group for the ACL plugin.