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 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
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.
- A client application (or a login helper such as
kubeloginforkubectl) redirects the user to Dex with an OAuth 2.0 authorization request. - Dex shows the configured logins, and the connector sends the user to the upstream identity source, or checks the password against LDAP.
- 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_accesswas requested). - The client presents the ID token as a bearer token, for example to the Kubernetes API server.
- 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_accessonly for clients that need to run unattended, such askubectl. - 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
kubectland 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
kubectlsessions. - 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

