Happy Dussehra! May good always win. Merry Christmas! Warm wishes from Vizag. Happy New Year! Here’s to a great year ahead.

DevOps · CNCF daily

Dex: A Federated OpenID Connect Provider for Kubernetes and Your Apps

CNCF Sandbox. A small Go service that gives applications one standard OpenID Connect login while it handles LDAP, GitHub, Microsoft, SAML, OIDC and other identity sources behind the scenes, with a Kubernetes-ready token format and a token exchange for CI.

23 min read

CNCF Sandbox

  • Dex
  • OpenID Connect
  • OAuth 2.0
  • LDAP
  • Kubernetes
  • Helm
  • AWS EKS
CNCF project page

Dex is an identity broker: a service that speaks OpenID Connect (OIDC) to your applications and speaks whatever the real identity system speaks (LDAP, a GitHub organisation, Microsoft Entra, SAML, another OIDC provider) on the other side. Your applications integrate with Dex once. When the company changes its directory or a partner brings their own login, you change Dex’s configuration and the applications never notice.

For a DevOps engineer, the most common use is giving kubectl, Argo CD, Grafana and internal tools a single sign-in that is backed by the directory the organisation already has. The second most common is giving CI jobs a short-lived, verifiable identity by exchanging a token they already hold.

CNCF daily · Sprint 5, post 8 of 14 · Security & Compliance

At a glance

Category Provisioning, subcategory Security & Compliance (CNCF Landscape)
CNCF status Sandbox. Accepted in June 2020 (CNCF presentations page)
Written in Go, shipped as one static binary and a container image
License Apache-2.0
Current release v2.46.1, a small follow-up to v2.46.0. v2.46.0 was already in downstream update pull requests on 8 October 2026; v2.45.1 was the previous line
What it issues OIDC ID tokens (signed JWTs), access tokens and refresh tokens, with the groups claim Kubernetes can use
Upstream sources (connectors) LDAP and Active Directory, GitHub and GitHub Enterprise, GitLab, Google, Microsoft, OpenID Connect, OAuth 2.0, SAML 2.0, Bitbucket Cloud, LinkedIn, OpenShift, OpenStack Keystone, Atlassian Crowd, AuthProxy, a built-in local user store and a mock connector for tests
Storage Kubernetes CRDs, PostgreSQL, MySQL, SQLite3, etcd v3, or memory (tests only)
Install routes Container image, Helm chart (charts.dexidp.io), Kubernetes manifests, a plain binary
User store of its own? No. Dex has no user database beyond the optional built-in local connector; authentication is delegated upstream

The problem Dex solves

Every application wants to log users in, and each identity system is different. An internal tool that needs LDAP, GitHub and Microsoft logins ends up with three integrations, three sets of group mappings and three places to fix when something changes.

Kubernetes has no user database. The API server only validates credentials. The standard way to get human users into a cluster is its OIDC authenticator, which needs an OIDC provider that issues tokens with a username and groups claim. Many corporate directories are not OIDC providers at all.

Machines need identity too. A CI pipeline can usually obtain a token from its own platform, but the services it calls expect a token from your issuer.

Dex addresses all three with the same shape: it sits in front of the upstream sources, authenticates the user there, and returns a standard OIDC token. In the project’s own words, applications only ever speak OIDC while Dex handles the mess upstream.

Key concepts

Term Meaning
Issuer The public URL of Dex (for example https://dex.example.com). It appears in every token as iss, and clients verify tokens against it.
Connector A strategy for authenticating a user against an upstream system, such as LDAP, GitHub or OIDC. A connector decides whether refresh tokens and group claims are possible.
Client An application registered with Dex. A client has an ID, optionally a secret, and redirect URIs. It can be public (no secret kept) or confidential.
ID token A signed JWT that states who the user is. It carries iss, sub, aud, exp, and optionally email, groups, name and preferred_username.
Scopes openid (required), email, profile, groups, offline_access (refresh token), federated:id and audience:server:client_id:<id> for cross-client use.
Groups claim A list of group names taken from the upstream source, usable by Kubernetes RBAC.
Refresh token Lets a client obtain a new ID token without another login. Not every connector supports it.
Token exchange The RFC 8693 grant that swaps a token from a trusted upstream OIDC issuer for a Dex token. Only the OIDC connector supports it.
Static client and static password Clients and local users written straight into the configuration file.
Storage Where Dex keeps its small state: auth requests, codes, refresh tokens, signing keys and, when enabled, local users.

Architecture

Dex architecture: a client application sends an authentication request to Dex, which uses a connector to reach upstream identity sources such as LDAP, GitHub or another OIDC provider. Dex signs tokens with rotating keys published as JWKS and keeps state in Kubernetes CRDs, a SQL database or etcd. The Kubernetes API server verifies ID tokens with those keys, and a gRPC API manages clients and users.

Dex is one service in the middle: applications on one side, identity sources on the other, a small store underneath. Blue is a client or caller, dark grey is the upstream identity, purple is a Dex component and green is the store. Open the zoomable diagram, or download it as SVG or PNG.

Component Responsibility
OIDC endpoints Discovery (/.well-known/openid-configuration), authorization, token and keys (/keys, a JSON Web Key Set). Standards-compliant clients run the authorization code flow against them directly.
Login UI A built-in page that lists the configured connectors and, for LDAP and the local connector, asks for a username and password. Templates and CSS can be themed.
Connectors One per upstream source. Each translates the upstream response into a standard identity (ID, email, name, groups).
Signing keys RSA keys that Dex rotates and publishes as a JWKS. Relying parties such as the Kubernetes API server fetch them to verify tokens.
Storage Holds auth requests, authorization codes, refresh tokens, keys, offline sessions and local passwords.
gRPC API Optional management API for clients, users and refresh tokens. It has no authorization beyond TLS client authentication.

Design principle. Own as little as possible. Dex keeps no user directory of its own and does not try to replace the identity system. It translates, issues and verifies tokens, and leaves the question “who are my users” to the system that already answers it.

One login and one API call

Dex login flow: the client application redirects the user to Dex, Dex sends the user to the upstream identity source to sign in, then Dex issues a signed ID token carrying email and groups. The client presents the token as a bearer token to the Kubernetes API server, which verifies the signature with Dex signing keys.

Steps 1 to 3 log the user in; steps 4 and 5 use the token against the API. Open the zoomable diagram, or download it as SVG or PNG.

  1. A client application (or a login helper such as kubelogin for kubectl) redirects the user to Dex with an OAuth 2.0 authorization request.
  2. Dex shows the configured logins, and the connector sends the user to the upstream identity source, or checks the password against LDAP.
  3. Dex receives the result, maps it to claims, and returns an authorization code. The client exchanges the code for a signed ID token (and a refresh token if offline_access was requested).
  4. The client presents the ID token as a bearer token, for example to the Kubernetes API server.
  5. The API server fetches Dex’s public keys, checks the signature, the expiry and the issuer and audience claims, and takes the username and groups from the token.

Dex documentation · Kubernetes authentication through Dex

Install Dex

The commands below follow the project’s and its chart’s documentation. I did not run them here; check chart and image versions against the release you choose.

Container, for a first look

docker run -d --name dex -p 5556:5556 \
  -v "$PWD/config.yaml:/etc/dex/config.yaml:ro" \
  ghcr.io/dexidp/dex:latest dex serve /etc/dex/config.yaml

Pin a version tag instead of latest for anything shared. The image and binary take a serve command that reads one YAML file.

Kubernetes with Helm

helm repo add dex https://charts.dexidp.io
helm install dex dex/dex --namespace dex --create-namespace -f values.yaml

The chart takes the Dex configuration under a config: key in values.yaml. Use the Kubernetes storage type when Dex runs inside the cluster: Dex stores state in custom resources, so no external database is needed, and it works out its namespace from its service account. Give the Dex service account a ClusterRole that allows dex.coreos.com resources and the creation of CustomResourceDefinitions; the chart can create this for you.

Plain binary

Dex is a single static Go binary. Build or download it, point it at a configuration file and run dex serve config.yaml. Anything beyond a lab should run behind TLS.

Using Dex

All snippets are adapted from the official guides and are untested here.

A minimal configuration

issuer: https://dex.example.com

storage:
  type: kubernetes
  config:
    inCluster: true

web:
  https: 0.0.0.0:5554
  tlsCert: /etc/dex/tls/tls.crt
  tlsKey: /etc/dex/tls/tls.key

oauth2:
  skipApprovalScreen: true

staticClients:
  - id: kubernetes
    name: Kubernetes
    secretEnv: KUBERNETES_CLIENT_SECRET
    redirectURIs:
      - http://localhost:8000

connectors:
  - type: ldap
    id: corp-ldap
    name: Corporate directory
    config:
      host: ldap.example.com:636
      rootCA: /etc/dex/ldap-ca.pem
      bindDN: cn=dex-reader,ou=service,dc=example,dc=com
      bindPW: $LDAP_BIND_PASSWORD
      userSearch:
        baseDN: ou=people,dc=example,dc=com
        filter: "(objectClass=person)"
        username: uid
        idAttr: uid
        emailAttr: mail
        nameAttr: cn
      groupSearch:
        baseDN: ou=groups,dc=example,dc=com
        filter: "(objectClass=groupOfNames)"
        userMatchers:
          - userAttr: DN
            groupAttr: member
        nameAttr: cn

secretEnv reads a client secret from an injected environment variable instead of writing it into the file, and values starting with $ in a connector read from the environment too. The LDAP connector binds with a service account to find the user, then tries to bind as that user to check the password; a search that returns more than one entry is treated as ambiguous and fails.

Sign in with GitHub and require an organisation

connectors:
  - type: github
    id: github
    name: GitHub
    config:
      clientID: $GITHUB_CLIENT_ID
      clientSecret: $GITHUB_CLIENT_SECRET
      redirectURI: https://dex.example.com/callback
      orgs:
        - name: my-organization
          teams:
            - platform
      teamNameField: slug

When orgs is set a user must belong to at least one of them to sign in, and group claims come back as org:team, for example my-organization:platform.

Federate another OIDC provider and map its claims

connectors:
  - type: oidc
    id: partner
    name: Partner login
    config:
      issuer: https://login.partner.example
      clientID: $PARTNER_CLIENT_ID
      clientSecret: $PARTNER_CLIENT_SECRET
      redirectURI: https://dex.example.com/callback
      scopes: [openid, profile, email]
      claimMapping:
        groups: "cognito:groups"
      insecureEnableGroups: true
      claimModifications:
        modifyGroupNames:
          prefix: "partner-"

By default the OIDC connector does not pass groups on because group claims only refresh when the ID token is refreshed, so a regular refresh would leave them stale. insecureEnableGroups: true accepts that risk per connector. modifyGroupNames adds a prefix (or suffix) to every group, which keeps partner groups from colliding with internal ones.

Point the Kubernetes API server at Dex

With a recent Kubernetes (the guide says 1.30 and later) use a structured authentication file:

apiVersion: apiserver.config.k8s.io/v1beta1
kind: AuthenticationConfiguration
jwt:
  - issuer:
      url: https://dex.example.com
      audiences:
        - kubernetes
    claimMappings:
      username:
        claim: email
      groups:
        claim: groups
    userValidationRules:
      - expression: "!user.username.startsWith('system:')"
        message: username cannot use the reserved system: prefix

Start the API server with --authentication-config=/path/to/file. On any Kubernetes version the older flags work too: --oidc-issuer-url, --oidc-client-id, --oidc-ca-file, --oidc-username-claim=email and --oidc-groups-claim=groups. Dex has to be served over HTTPS, reachable from both the user’s browser and the API server, and the API server must trust its CA. The API server does not need Dex running when it starts. Flag-based configuration trusts tokens issued to a single client; Dex’s cross-client trust lets one client mint tokens for another.

Then bind RBAC to the claims:

apiVersion: rbac.authorization.k8s.io/v1
kind: ClusterRoleBinding
metadata:
  name: platform-admins
subjects:
  - kind: Group
    name: my-organization:platform
    apiGroup: rbac.authorization.k8s.io
roleRef:
  kind: ClusterRole
  name: cluster-admin
  apiGroup: rbac.authorization.k8s.io

If a claim other than email is used as the username with the flag-based setup, Kubernetes prefixes it with the issuer URL to stop user-controlled claims being used for privilege escalation.

Log in from kubectl

A helper such as kubelogin opens a browser, completes the Dex login and caches the token. The documented kubeconfig entry uses an exec plugin:

kubectl config set-credentials oidc \
  --exec-api-version=client.authentication.k8s.io/v1beta1 \
  --exec-command=kubectl \
  --exec-arg=oidc-login \
  --exec-arg=get-token \
  --exec-arg=--oidc-issuer-url=https://dex.example.com \
  --exec-arg=--oidc-client-id=kubernetes \
  --exec-arg=--oidc-extra-scope=email \
  --exec-arg=--oidc-extra-scope=groups

Let a CI job exchange its own token (RFC 8693)

Machine callers cannot complete an interactive login. With the OIDC connector, a pipeline can swap a token from its platform for a Dex token:

oauth2:
  grantTypes:
    - authorization_code
    - refresh_token
    - urn:ietf:params:oauth:grant-type:token-exchange

connectors:
  - type: oidc
    id: github-actions
    name: github-actions
    config:
      issuer: https://token.actions.githubusercontent.com
      scopes: [openid, groups]
      userNameKey: sub

staticClients:
  - id: ci
    name: CI
    secret: change-me
    public: true
curl https://dex.example.com/token \
  --user ci:change-me \
  --data-urlencode connector_id=github-actions \
  --data-urlencode grant_type=urn:ietf:params:oauth:grant-type:token-exchange \
  --data-urlencode "scope=openid groups federated:id" \
  --data-urlencode requested_token_type=urn:ietf:params:oauth:token-type:access_token \
  --data-urlencode subject_token="$UPSTREAM_TOKEN" \
  --data-urlencode subject_token_type=urn:ietf:params:oauth:token-type:access_token

The client ID and secret travel as Basic authentication, which is why the guide marks the client public: the secret is not really secret in a pipeline. The docs compare this to workload identity federation on the big clouds. Access tokens from the upstream are validated by calling its user-info endpoint, so getUserInfo: true is required when exchanging access tokens.

Validate a token in your own application

An application that consumes Dex tokens builds an OIDC verifier for the Dex issuer, checks the signature, expiry and audience, and reads email, email_verified and groups. The official guide’s Go example uses go-oidc and oauth2, and notes that the verifier should only trust the application’s own client ID.

Features

Area What you get
OIDC provider Authorization code flow, refresh tokens, device authorization, token exchange, discovery and a JWKS endpoint. Implicit flow is available only when configured.
Grant types Default set: authorization_code, refresh_token and token exchange. Password grant needs passwordConnector. Client credentials needs a feature flag (DEX_CLIENT_CREDENTIAL_GRANT_ENABLED_BY_DEFAULT=true).
Connectors Stable: LDAP, GitHub, SAML 2.0. Beta: OpenID Connect, GitLab and Microsoft. Alpha: Google, OAuth 2.0. See the status column of the connector page.
Group handling Group claims from LDAP (including nested groups through recursionGroupAttr), GitHub teams, Microsoft and Google groups, allowedGroups filters and group renaming.
Claim modification claimMapping for odd claim names, plus newGroupFromClaims, filterGroupClaims and modifyGroupNames on the OIDC connector.
Public clients For tools that cannot keep a secret. Without redirect URIs they accept only http://localhost redirects or the out-of-browser URL.
Cross-client trust trustedPeers plus the audience:server:client_id: scope let one client obtain tokens on behalf of another.
Local users Built-in connector with bcrypt-hashed static passwords or users managed through the gRPC API.
Theming Custom web templates and CSS for the login page.
gRPC API Create, update and delete clients, passwords and refresh tokens; list clients.
Added in v2.46.0 Auth sessions with SSO sharing policy, TOTP and WebAuthn second factors, RP-initiated logout and id_token_hint, CEL expression support, SAML refresh tokens, ES256 signing, cookie encryption, back-channel logout with a sid claim, a home page showing the signed-in session and Kerberos support. Some of these arrive as new capabilities, so read the release notes before depending on them.

Configuration reference

The official configuration pages list far more; these are the keys you meet first.

Key Purpose
issuer Public base URL; must match what clients and the Kubernetes API server use
storage.type and storage.config kubernetes (with inCluster: true), postgres, mysql, sqlite3, etcd or memory
web.http / web.https, tlsCert, tlsKey Listener addresses and certificates
grpc.addr, tlsCert, tlsKey, tlsClientCA, reflection gRPC API listener and client-certificate authentication; plaintext if no TLS credentials are given
telemetry.http Address for metrics and health
expiry.idTokens Lifetime of ID tokens; the docs prefer short ones, for example 10 minutes
expiry.authRequests, expiry.deviceRequests Time windows for exchanging a code or authorising a device
oauth2.grantTypes, responseTypes Which flows are allowed
oauth2.skipApprovalScreen, alwaysShowLoginScreen Reduce or force login prompts
oauth2.passwordConnector Connector used for the password grant, for example local
staticClients[] id, secret or secretEnv, public, redirectURIs, trustedPeers
connectors[] type, id, name and a config block specific to each type
enablePasswordDB, staticPasswords[] Local users; each needs email, bcrypt hash, username and userID
Connector scopes, insecureEnableGroups, getUserInfo, allowedGroups Control which claims flow through an OIDC connector
Connector insecureSkipEmailVerified For providers that omit email_verified; use deliberately

Production reference design

  • Run Dex over HTTPS with a stable issuer URL. Changing the issuer invalidates every token and every relying party’s trust.
  • Choose storage by where Dex runs. Inside a cluster, the Kubernetes CRD storage needs no database and the documentation calls it very effective for many Kubernetes use cases, though it may not suit a very large number of users. Outside Kubernetes or at larger scale use PostgreSQL or MySQL, or etcd v3.
  • Run more than one replica against shared storage so a restart does not interrupt logins; with SQL or CRD storage the replicas share state.
  • Give each application its own client with exact redirect URIs. Keep secrets in secrets, referenced with secretEnv.
  • Use a read-only service account for LDAP and require TLS to the directory. Do not enable the insecure skip options outside a lab.
  • Keep ID tokens short-lived and request offline_access only for clients that need to run unattended, such as kubectl.
  • Put group-to-role mapping in RBAC, not in each application, so access changes are made in one place.
  • Front it with an ingress and restrict network paths; keep the gRPC API on a private address.

Security

Area What the documentation and release notes say
Transport Kubernetes requires Dex on HTTPS. The LDAP connector warns that insecureNoSSL leaks passwords on the network and may be removed.
gRPC API No authentication or authorisation beyond TLS client authentication; if you expose it, run it on a private address with tlsClientCA. Without TLS credentials it runs in plaintext.
SAML connector The documentation warns that it is unmaintained, likely vulnerable to authentication bypass vulnerabilities and under consideration for deprecation, and recommends OIDC, OAuth 2.0 or LDAP where the provider supports them. v2.46.0 nevertheless added SAML refresh tokens, so check current status before relying on it.
Group freshness Groups from the OIDC connector refresh only when the ID token refreshes, so removed memberships can linger until the next login.
Client trust Clients are bound to redirect URIs. Public clients and trustedPeers widen who can obtain tokens; use them deliberately.
Recent fixes v2.46.0 includes fixes for client-to-connector restrictions on token grants (referenced as a GitHub security advisory), device-flow secret handling, MFA enforcement and WebAuthn clone detection, plus several auth-surface hardening changes. Staying on a current release matters for an authentication service.
Image trust v2.46.1 rebuilt the image to distrust some compromised intermediate CA certificates.
Reporting The project asks for suspected vulnerabilities to be emailed to the maintainers, not filed publicly.

Monitoring and day-2 operations

Task How
Health and metrics Enable the telemetry listener; check the discovery document at /.well-known/openid-configuration as a smoke test
Rotate secrets Rotate client and connector secrets; v2.46.0 can read an OpenShift client secret from a file without a restart
Upgrade Read each release’s notes; v2.46.0 changed sessions and added a lot of surface, and v2.45.1 fixed a MySQL 8.0+ migration problem
Back up Back up the SQL database or etcd; with CRD storage, back up the dex.coreos.com resources
Reduce PII in logs v2.46.0 added excludeFields for log redaction
Add a login source Add a connector entry and redeploy; applications do not change
Symptom First checks
Kubernetes rejects the token Issuer URL spelling, audience matches the client ID, API server trusts Dex’s CA, username claim exists
No groups in the token Request the groups scope; check the connector supports groups; for OIDC upstreams insecureEnableGroups
No refresh token offline_access scope requested; the connector must support refresh (SAML does not)
Login loop or redirect error redirectURI on the connector equals Dex’s issuer plus /callback, and the client’s redirectURIs list the exact URL
LDAP user not found or ambiguous userSearch base DN, filter and username attribute; multiple matches fail
Token exchange rejected connector_id, client Basic auth, getUserInfo: true for access tokens, grant type enabled

Usage cases

  • Kubernetes login. Give kubectl and cluster dashboards one sign-in backed by LDAP, GitHub or a corporate OIDC provider, with RBAC on groups.
  • One login for internal tools. Argo CD, Grafana, Harbor and similar tools all use the same OIDC integration.
  • Federation. Let partners or other organisations sign in with their own provider while your applications see one issuer.
  • Machine identity. Exchange CI platform tokens for tokens your services accept.
  • Test environments. Use the mock connector or static users for repeatable logins in pipelines.
  • Cold-chain sprint project. The Sprint 5 final project uses Dex for OIDC sign-in federated to partner identity providers.

Operational considerations

  • It is a broker, not a full identity platform. There is no user self-service, password reset, user registration or admin console of the kind Keycloak provides.
  • Connector quality varies. Check the stable, beta and alpha markings for the one you need, and what it supports (refresh tokens, groups, preferred username).
  • Group and refresh limits. Some connectors cannot refresh groups or cannot issue refresh tokens at all, which affects long-lived kubectl sessions.
  • Single issuer for Kubernetes by flags. The flag-based setup trusts tokens issued to a single client; plan cross-client trust or use the structured configuration.
  • Sandbox maturity. The project is a sandbox project with an active release cadence but a small maintainer group; the 2023 annual review noted it had not yet been certified for OIDC conformance, and later releases added conformance test scripts. I did not check the current certification state.
  • Documentation age. Many pages show ages of years, and some features (such as the 2.46 sessions) are not fully described in the docs yet. Trust the release notes and the example configuration for your version.
  • Version drift. The Kubernetes guide shows old CRD manifest examples; use the Helm chart or the current manifests.

Adoption

The project’s ADOPTERS.md lists production users. The entries I saw include Argo CD (single sign-on for its web UI and CLI), Kubeflow (external OIDC), sigstore (for its public Fulcio certificate authority), Chef Automate, Elastisys (single sign-on across Grafana, OpenSearch and Harbor in its platform), Flant, Kasten, Kyma, Pydio Cells, Terrakube, LitmusChaos and LLMariner. The 2023 annual review calls Argo CD and sigstore the prominent CNCF and open-source projects using Dex and says the list is only a small part of its users. It also reports over 400 contributors from over 300 companies, and the 2021 review splits users into projects that embed Dex and teams that run it as an OIDC proxy in front of their identity sources.

Alternatives

Solution Model Best suited to
Keycloak (CNCF Incubating) Full identity and access management server with its own user store, admin console, self-service and identity brokering When you need users, registration, MFA policies, a UI for administrators and SSO in one product, and can run a heavier Java service with a database
Ory Hydra Headless OAuth 2.0 and OIDC server; you build the login and consent app Teams that want a certified OAuth server and will write their own login flow
Authelia Authentication and access-control service for apps behind a reverse proxy, with MFA Protecting web apps behind a proxy, rather than issuing tokens to many kinds of clients
Pinniped (CNCF Sandbox) Kubernetes-focused authentication that works across many clusters Organisations with many clusters who want one login experience
Cloud identity services (for example AWS Cognito, Microsoft Entra) Managed identity When a managed service is acceptable; Dex can sit in front of them as an upstream
Authentik, ZITADEL Full open-source identity platforms Teams that want a complete platform with UI, flows and user management

Strengths and limitations

Strengths Limitations
Small, single Go binary, no JVM and no database required Not a user directory or self-service portal
Standard OIDC front end; applications are decoupled from identity sources Connector support and maturity are uneven
Strong Kubernetes fit: groups claim, CRD storage, kubelogin pattern Groups and refresh tokens are limited by what each upstream offers
Token exchange gives CI and workloads federated identity SAML connector is flagged as unmaintained in the docs
Apache-2.0, CNCF governance, widely embedded in other projects Sandbox maturity and a small maintainer group
New session, MFA and logout features in v2.46 Newer features have little long-form documentation yet

Project status and roadmap

Dex is a CNCF Sandbox project (accepted June 2020), originally created at CoreOS. The latest release I found is v2.46.1; v2.46.0 was a large release with sessions, TOTP and WebAuthn second factors, SSO sharing, RP-initiated logout, Kerberos, CEL integration and a refactor of the server into smaller packages, preceded by v2.45.1 (a MySQL 8 migration fix) and v2.45.0 (PKCE for the OIDC connector, a Vault-based JWT signer and an unprivileged user in the image). The 2023 review listed improved end-to-end tests, OIDC certification and connector middleware among its goals. I did not find a published long-term roadmap beyond these.

Recommendation

Adopt Dex when you need a small, standards-based OIDC front door, especially to give Kubernetes and internal tools one sign-in backed by LDAP, GitHub or a corporate OIDC provider, or to federate partner logins without changing applications. Trial the token exchange for CI and the new session and MFA features before relying on them. Assess Keycloak instead if you need user management, self-service or a full administrative console, and look at Pinniped if multi-cluster login is the main problem. Before production: serve Dex over HTTPS with a stable issuer, keep ID tokens short, prefer OIDC or LDAP over SAML, restrict the gRPC API and stay on a current release.

References: Dex documentation · Connectors · Tokens · Scopes and claims · OAuth2 settings · Storage · Kubernetes authentication through Dex · Machine authentication (token exchange) · The Dex API · LDAP connector · OpenID Connect connector · GitHub connector · SAML connector · v2.46.0 release · v2.45.0 release · CNCF project page

Spotted something wrong or out of date?Suggest a correction. I review every suggestion before changing the page.