How openDesk SSO and identity federation connects to your directory
If your users already sign in through Active Directory, LDAP or Entra ID, openDesk can accept those accounts without asking people to set a second password. The connection has two parts. First, openDesk runs a Keycloak-based identity provider, with Nubus providing the portal and identity and access management (IAM) layer. Second, single sign-on is federated over OIDC between that openDesk identity provider and your existing identity provider. User records reach openDesk separately, through the one-way Nubus Directory Importer for LDAP or Active Directory, which the openDesk federation documentation recommends for provisioning. Federation looks simple on a diagram, but three decisions make it harder. Identity choices shape every bundled component. Element, Nextcloud, OX App Suite, XWiki, OpenProject and CryptPad all rely on the same accounts, so a naming or attribute mistake shows up in all of them at once. Changing it later means re-matching accounts across the whole suite, which is costly after users have started working.
Second, user matching must be settled early. openDesk can match a federated login to an existing account by username or by another attribute, such as mailPrimaryAddress. Pick the attribute before the pilot. Check that it is unique and stable in your directory, that every user has it populated, and that it is the same value your existing identity provider emits in its OIDC claims. Mismatches produce duplicate accounts or logins that fail with no obvious cause. Ask the team that owns the directory to export a sample of users and check these values.
Third, Microsoft Entra ID is a different case. The documentation states that Entra ID does not expose LDAP, so the Nubus Directory Importer cannot read it directly. The documented route is Azure AD Domain Services, which provides an LDAP interface over the tenant. That adds a service to your Azure subscription with its own cost, network design and administration. Confirm with your Microsoft administrators whether Domain Services is already available, whether your tenant's licensing covers it, and how password hashes and group membership will be synchronized before you commit to this path.
Before you start, make three checks. List every directory source and the attribute you will match on. Confirm whether your existing identity provider can issue OIDC clients for openDesk and which redirect addresses it accepts. Ask openDesk and your implementation partner to document the import scope, including which groups and organizational units are imported and how often. Those answers define the identity design, and they should be written into the scope before any environment is built.
Which identity pattern to choose before you configure anything
This table compares the identity patterns openDesk can run alongside an existing identity provider or directory, including the matching attribute, Entra ID and a local recovery account. Read each row for when the option fits, what it asks your team to operate, and what to confirm with your identity owners first. The main takeaway is that you should settle which system owns accounts, passwords, MFA and offboarding before you configure anything, because that decision shapes every other setting.
| Option | When it fits | Operational cost | What to confirm |
|---|---|---|---|
| OIDC federation only | Identity owners want one sign-in point and accept the existing IdP as the login authority | Password policy and MFA stay with the external IdP; sign-in stops if it is unavailable | Whether the IdP can register an OIDC client for openDesk and who owns offboarding there |
| Directory sync only | Accounts must come from AD or LDAP and openDesk login can be governed separately | Account lifecycle follows the directory via the one-way importer; login policy needs its own owner | Whether disabled or removed directory users are deactivated in openDesk and how often sync runs |
| Both together | Directory supplies accounts and an external IdP handles sign-in in the same environment | Two sources to keep aligned; offboarding must cover both the directory and the IdP path | Which system is the source of truth for each attribute and who resolves mismatches |
| Matching attribute: username | Usernames are identical, stable and unique across the IdP and openDesk | Username changes or renames can break matching and need a controlled process | Whether usernames are unique and whether renames happen in the IdP or the directory |
| Matching attribute: mailPrimaryAddress | Mail addresses are unique, populated for every user and changed through a controlled process | Address changes, aliases and shared mailboxes can cause mismatches or duplicate matches | Whether the attribute is populated for all users and who approves any change to it |
| Microsoft Entra ID | Your identity tenant is Entra ID and you need directory-based provisioning | Entra ID does not expose LDAP, so Azure AD Domain Services is needed as an extra service to operate | Whether Azure AD Domain Services is available to you, its licensing and who operates it |
| Local administrative account for recovery | Decision: keep a local admin inside openDesk so administrators can sign in if federation fails | A standing privileged credential that must be stored, monitored and tested periodically | Who holds the credential, how its use is logged and whether your security policy allows it |
openDesk SSO and identity federation: build sequence
This sequence takes an organization from a verified Kubernetes target to a federated login path in which users sign in to openDesk with their existing identity provider and directory accounts. Each step closes with a check that the team can confirm before moving on, and the handover leaves a runbook the operations team can maintain.
Confirm cluster and ingress requirements
The platform team checks the target cluster against the openDesk requirements before any identity work starts. The cluster must be a CNCF-certified Kubernetes distribution at v1.33 or later, with an ingress controller (haproxy-ingress, or the deprecated Ingress nginx), cert-manager, an RWO volume provisioner, Helm 3.17.3 or later below v4, and Helmfile 1.0.0 or later. Tested platforms are kubespray clusters, not OpenShift. Closing check: recorded version output for each component and a written confirmation that the ingress hostname and TLS setup match the planned login endpoint.
Inventory the existing identity provider and directory
The identity team records what the current IdP and directory hold: user populations, group structure, attributes used by applications, and where multi-factor authentication is enforced. They also record which attributes are stable and unique, such as the username or mailPrimaryAddress, and which accounts are service or shared accounts that should not receive openDesk access. Closing check: a signed inventory that the identity owner and the application owner have both reviewed.
Agree the matching attribute and mapping
Both teams agree which attribute matches a person across the external IdP, the directory and the openDesk IdP. The openDesk federation documentation describes matching by username or by another attribute such as mailPrimaryAddress, so the choice must be unique and identical in every source. The team writes a mapping table covering each attribute and group, with an owner for each row. Closing check: the mapping is tested with a small set of sample accounts and the identity owner approves the table in writing.
Register openDesk as an OIDC client
The external IdP administrator creates an OIDC client for openDesk and records the client identifier, the redirect URIs, the allowed scopes and the client secret. Redirect URI formats and required client settings must be confirmed against the current openDesk federation documentation, because they change between releases. The secret goes into the organization's approved secret store, not into a ticket or shared document. Closing check: the client appears in the external IdP with the recorded settings, and the OIDC discovery document for the IdP is reachable from the openDesk network.
Configure federation in the Keycloak-based IdP
The openDesk administrator adds the external IdP to the Keycloak-based openDesk IdP as an OIDC identity provider, using the client settings from the previous step. Attribute mappers are created from the approved mapping table, and the first-login behavior is set as the documentation describes. Vendor-specific field names and options must be confirmed against the current federation documentation for the installed release. Closing check: a test account signs in through the external IdP and reaches openDesk with the expected username and attributes populated.
Set up the Nubus Directory Importer
For LDAP or Active Directory, the directory administrator creates a read-only bind account, and the openDesk team configures the Nubus Directory Importer to run one-way, from the directory into openDesk, with the search bases and filters agreed in the inventory. Microsoft Entra ID does not expose LDAP, so Entra ID environments need Azure AD Domain Services before this step applies. Closing check: a dry sync lists the expected users and groups, and an attempted write using the bind account is refused by the directory.
Run a pilot group through the full flow
A small pilot group, drawn from the agreed groups, tests the whole path: sign-in through the external IdP, multi-factor prompts, group membership mapped into openDesk roles, access to the first bundled applications, and logout. The pilot team checks that a sign-out from openDesk also ends the session the organization expects, and that a disabled directory account loses access after the next sync. Closing check: each test case in the pilot script has a recorded result, and failures have been fixed and retested.
Document and hand over the federation
The team writes a runbook covering endpoints, client identifiers without secrets, the mapping table, the sync schedule and failure handling, secret rotation owners, and the change approval path. The runbook also notes that openDesk plans minor releases monthly and that federation settings and the mapping must be retested after each upgrade. Closing check: the operations team walks through the runbook, performs one supervised sync and one secret rotation, and the handover is signed by both the identity and platform owners.
How the Nubus Directory Importer keeps openDesk users in step with AD or LDAP
The Nubus Directory Importer is the route the openDesk documentation recommends for provisioning users from LDAP or Active Directory, and it runs one way only, from the directory into openDesk. Changes made in openDesk accounts do not flow back to AD or LDAP, so the directory remains the system of record for identities. Before you configure anything, decide which OUs and groups are in scope. A search base that is too broad pulls in service accounts, shared mailboxes and retired staff, while one that is too narrow leaves out people who need access. Write the scope down as a list of base DNs and group filters, and have your directory team sign off on it before the first run.
Attribute mapping is the second decision. Each directory attribute must map to a field on the openDesk account, and the matching attribute determines whether a directory user lines up with an existing openDesk account. The federation documentation gives mailPrimaryAddress as one example of a matching attribute, so check which attribute your organization keeps accurate and unique. Agree the mapping with the team that owns the directory and the team that owns openDesk, and record which source attribute is authoritative for name, email address and group membership. Ask ZenDiS or your implementation partner for the supported attribute list for your release, because the list can change between versions.
Lifecycle handling is the third decision, and it is the one that most often surprises operations teams. You need a documented answer for users who are disabled in AD or LDAP, users removed from an in-scope group, and users who leave the organization entirely. Confirm in the current documentation for your release whether disabled accounts are deactivated or deleted, how often the import runs, and what happens to content owned by a removed user. These behaviors decide whether a departure appears in openDesk on the same day or later, and they set the data retention procedure you need to write. Do not rely on assumptions about defaults. Test each case in a lab and record the result.
The importer authenticates to the directory with a bind account, so the bind account needs a named owner. Ask the directory team to create a dedicated account with read-only rights limited to the in-scope OUs, and to assign ownership of its password to one role in the directory team. Set a rotation schedule and a documented procedure for updating the secret in the openDesk deployment configuration. A missed rotation or an expired password can cause sync failures that are easy to overlook, so alert on failed imports. Microsoft Entra ID does not expose LDAP, so tenants on Entra ID need Azure AD Domain Services before this route applies.
Run the importer first in a non-production environment that uses a copy of the in-scope directory structure, and do not point a first test at production users. Compare user counts for each in-scope group against the directory, then sample accounts across roles, including one disabled user and one user moved out of scope. Check that attributes such as name, email address and group membership match the agreed mapping. Repeat the run until counts and sampled attributes agree, and keep the reconciliation output as evidence for the rollout and for later audits.
What drives the effort of openDesk SSO and identity federation
This table lists the factors that change how much work openDesk identity federation takes and shows how to keep each one contained. Read each row as a question to answer before the quote: the more directories, dirty attributes and environments in scope, the longer the design and testing phases run. The main takeaway is that data quality and scope decisions made before implementation usually matter more than the federation mechanics themselves.
| Driver | Why it changes effort | How to keep it down |
|---|---|---|
| Number of directories and forests | Each AD or LDAP source needs its own import scope, bind account, search base and testing. Multiple forests add trust and naming questions. | Confirm which directories hold openDesk users. Import from one authoritative forest or domain where possible and document the others as out of scope. |
| Quality of existing attributes | The importer and federation match users on username or an attribute such as mailPrimaryAddress. Duplicate, empty or inconsistent mail values cause mismatches and manual fixes. | Clean and deduplicate mail addresses and usernames in the source directory before the first import. Agree the matching attribute with the owners of the directory. |
| Group model and role mapping | Groups decide access to openDesk services and must map to roles. Nested groups, legacy groups and unclear ownership multiply test cases. | Limit sync to named groups created for openDesk. Write the mapping table once, get sign-off from application owners, and retire unused groups before import. |
| Entra ID path through Azure AD Domain Services | Entra ID does not expose LDAP, so an LDAP-capable path must be built and maintained. This adds a cloud service, network and identity configuration to the scope. | Confirm early whether Azure AD Domain Services is already in use. If not, include its setup and ongoing cost in the quote as a separate line item. |
| Number of environments | Evaluation, test and production each need their own identity configuration, client registrations, secrets and test users. Differences between them cause rework. | Build one pilot design and reuse the same configuration pattern across environments, changing only endpoints, secrets and scope values. |
| MFA and conditional access at the external IdP | Stronger sign-in policies at the external identity provider affect OIDC flows, token lifetimes and user support. Policies applied to service accounts can block the import. | Document the existing MFA and conditional access rules before design. Exclude or separately test service and bind accounts, and agree which rules apply to openDesk clients. |
| Custom attributes | Extra attributes beyond the standard set need mapping, validation and sometimes changes in the openDesk IdP. Each one adds test effort and possible support questions. | Keep the attribute list short and justify each one. Add custom attributes only when a named service needs them. |
| Evidence for compliance assessment | Assessors usually expect records of configuration, access reviews, import scope and changes. Producing this evidence after the fact takes longer than collecting it during the build. | Agree the evidence list at the start, such as configuration exports, test records and change logs. DeployOpen prepares evidence but does not issue audit results; confirm the requirements with your assessor. |
What to monitor, back up and document after federation goes live
The first weeks after federation goes live show whether the identity layer behaves as designed, so monitoring should start on day one and cover both sides of the trust. Watch login failures in the Keycloak-based openDesk IdP, paying attention to clusters of errors tied to one external identity provider, which often point to an expired certificate, a changed redirect URI or client configuration drift. Track federation errors on the external provider's side as well, because some failures never reach openDesk logs. Agree who receives these alerts, which log sources feed them and who acts first when federated sign-in fails for many users at once. Confirm with your platform team which log collection stack already runs in the cluster and how long it retains identity events for your incident process.
The Nubus Directory Importer is one-way, so every change it applies originates in your directory, which makes its runs worth reviewing. After each scheduled run, check for failed records and for unexpected changes, such as large numbers of accounts disabled, renamed or added to groups they should not hold. Compare account counts with the directory before and after a run during the pilot so you know what normal looks like. Treat the bind account that reads the directory as a privileged credential: it should have read access only to the search base the importer needs, and its password should follow a rotation schedule your directory team owns. Rotate the client secret used by the federation on the same governance cycle. Confirm the exact rotation steps and any expected downtime against the documentation for your release before you schedule them.
Back up the Keycloak realm configuration, including identity provider definitions, client settings, attribute mappers and group configuration, and store it with the Helm values and secrets that deployed it. A realm export without the matching chart values is hard to use for a clean rebuild, and values without the export leave the federation settings to be recreated by hand. Keep both under the same change control, store copies outside the cluster and test a restore in a non-production namespace before you rely on it. Ask your implementation partner or the deployment documentation which realm artifacts are covered by the backup, how secrets are handled and whether the backup includes the database holding local accounts and sessions. Set the backup frequency from your operations policy, and record it in the runbook.
openDesk plans minor releases monthly and supports only the latest minor version, so federation is not a one-time configuration. A minor upgrade can change the Keycloak-based IdP, the chart or the Nubus components that carry your federation settings. Plan a re-test of federation after every minor upgrade and before the change reaches production users. The checklist should cover signing in through the external identity provider, confirming that the matching attribute, such as username or mailPrimaryAddress, still links to the right account, checking group membership on a pilot account and running one Directory Importer cycle against a test directory. If your environment falls several minor versions behind, the release documentation may require intermediate steps, so confirm that upgrade path before you start.
The final item is documentation that another engineer can act on during an incident. Keep the attribute mapping that links directory fields to openDesk user attributes, the matching rule that decides whether a federated login maps to an existing account and the group mapping that grants roles and workspace access. Add the offboarding procedure, which should state how a leaver's directory account is disabled, how the importer reflects that change, how active sessions and external sign-ins are ended and who confirms that access to files and chat has been removed. Version these documents alongside the Helm values and the re-test checklist, review them after each minor upgrade and ask your partner to list them as handover deliverables in the written scope.
Securing openDesk SSO and identity federation
Identity federation links openDesk's Keycloak-based IdP to your existing identity provider and directory, so these controls protect the trust path and the credentials that keep it running. openDesk also documents GPG verification of most Helm charts and digest pinning of container images, which support these controls but do not replace checks in your own environment.
Read-only directory bind account
Connect the Nubus Directory Importer to Active Directory or LDAP with a dedicated bind account that has read rights only, scoped to the users, groups and attributes openDesk needs. Do not reuse an administrator account for this purpose. Check it by attempting a write with the bind credentials from a test client and confirming the directory refuses it, then reviewing the account's group memberships in each access review.
Secrets in the cluster secret store
Keep OIDC client secrets and directory bind credentials in the Kubernetes secret store your cluster uses, and reference them from deployment values. Keep them out of Helmfile environment files and the Git history of the deployment repository. Limit read access to the namespaces and service accounts that need them. Check by searching the repository and rendered manifests for secret values and by listing which service accounts can read those secret objects.
TLS on every federation endpoint
Serve the discovery, authorization, token, userinfo and key endpoints of the external IdP over HTTPS, and connect to the directory over LDAPS or StartTLS. Confirm that openDesk validates the certificate chain against your internal certificate authority and that cert-manager issues the certificates on the openDesk side. Check with a TLS scan of each endpoint and by confirming that a plaintext connection attempt fails.
MFA enforced at the external IdP
openDesk relies on the authentication outcome of your existing identity provider, so the second factor must be enforced there for every user who reaches openDesk through federation. Ask your IdP team which policies apply to the openDesk client and whether the IdP can convey authentication context to openDesk. Check with a sign-in test using an account exempted from MFA, which the IdP policy should block.
Restrict changes to federation
Limit the Keycloak administrator role and write access to the Helmfile repository to a short, named list of platform engineers. Require review for changes to identity provider settings, claim-to-role mappings and user matching attributes, since a single mapping change can grant administrative rights to every user who signs in. Check with a periodic access review of both groups and an audit of recent changes to the mapping configuration.
Network policies for identity traffic
Apply Kubernetes network policies that allow outbound traffic from the Keycloak and directory importer workloads only to the IdP endpoints and directory ports that federation uses, and deny other egress by default. Confirm the policies appear in the rendered manifests and that your cluster's network plugin enforces them. Check by running a test pod in a neighboring namespace and attempting a connection to an unlisted host, which should fail.
How to test openDesk SSO and identity federation and fail safely
Test the federation before any pilot user depends on it, and design each test so that a failure leaves the organization able to log in and recover. The core plan has two parts: confirm that the external identity provider (IdP) and the Keycloak-based openDesk IdP agree on who each user is and what they may do, and confirm that a broken federation does not lock out the people who must repair it. Run these checks in a non-production environment first, then repeat the critical ones in the pilot environment with real pilot accounts. Record the expected result for every test in writing before you run it, so the outcome is not argued after the fact.
Start with login and identity matching. Choose pilot users from each directory group that will receive a different role, and have each one sign in through the external IdP over OIDC. For every test user, confirm that the attribute chosen for matching (the username or another attribute such as mailPrimaryAddress) resolves to exactly one openDesk account. Duplicate or zero matches are the most common federation fault, and they are easy to miss when only one administrator account is tested. Next, check that group membership in the directory produces the expected roles inside openDesk, and that a user outside the pilot groups receives no more access than intended. Ask your IdP administrator to confirm which claims and attributes are sent, because the test is only as good as the attribute mapping it exercises.
Then test the lifecycle. Disable a pilot account in the directory and confirm that the user can no longer sign in through the federated path. If users are provisioned from Active Directory or LDAP with the Nubus Directory Importer, check that the import reflects the disablement and that the openDesk account is handled as your policy requires. Test logout from openDesk and from the external IdP, and observe what happens to a session that is still open after a logout or after a change in the directory. Measure session expiry against the values your security owner has approved, not against defaults you assume. Do not treat any timeout as a fact until you have read it from your own configuration. If you cannot confirm a value, put that question to the vendor and to your own team as an open item.
The fail-safe checks decide whether the rollout is acceptable. Deliberately take the external IdP offline in the test environment and record which users and which administrators can still reach openDesk. Confirm that at least one named administrator can sign in through a recovery path that does not depend on the external IdP, and rehearse that path before pilot launch, not during an incident. Also record what happens to sessions that exist at the moment of the outage: whether they continue, end, or require re-authentication. For the import, induce a failed or partial directory import and confirm that your monitoring or log review detects it, that the operator can identify the affected accounts, and that the rollback procedure restores the previous state. A rollback you have not rehearsed is not a rollback.
Document the results as evidence for the rollout decision and for any compliance assessment. Each test should have an owner, the expected result, the observed result, and a sign-off by the business and security owners. Failures should block pilot access for the affected group until they are fixed and retested. If you engage a partner, ask for the test plan, the test accounts used, the recovery procedure and the rollback steps as written deliverables, and confirm in the scope which environment the tests run in and who holds the administrator credentials at the end of the engagement.
Questions buyers and engineers ask about openDesk SSO and identity federation
How much effort does openDesk SSO federation usually take?
Effort depends mainly on the number of identity sources, the quality of the directory data and how many applications need login testing. No public effort figure applies to this work, so ask each bidder to break the estimate into discovery, identity provider configuration, directory import, testing and handover. Federating openDesk's Keycloak-based identity provider with an existing OIDC provider is often a bounded task once the claims and user matching rules are agreed. Directory synchronization usually takes more time than expected because of nested groups, disabled accounts, duplicate mail addresses and service accounts. If you use Microsoft Entra ID, plan for the Azure AD Domain Services dependency. Ask the quote to state which items are in scope, who supplies directory administrator time and what pilot testing is included.
How long does openDesk identity federation take to deploy?
No duration applies to this work in general, so any timeline should come from a written scope. The main timeline drivers are change approvals for the identity provider, directory access, DNS and certificate issuance, and the time needed to agree which attributes identify each user. Federation can only be tested once an openDesk deployment runs on a supported Kubernetes cluster with its external services, so cluster readiness and services such as PostgreSQL and the SMTP relay can set the critical path. Ask for milestones with named dependencies: identity owner sign-off, a configured test identity provider, a validated pilot group and a production cutover. DeployOpen agrees scope, deliverables and timelines in writing before work starts, so ask how the plan handles a failed pilot and whether a documented fallback exists for login.
What does our team need to provide for openDesk SSO?
Plan for four inputs before work starts: identity owners, directory access, DNS and certificates, and an approved pilot group. Identity owners decide the matching attribute, such as username or mailPrimaryAddress, and approve which users and groups federate. Directory access means a service account with read rights to the LDAP or Active Directory source, or a configured Azure AD Domain Services instance for Entra ID. DNS records and TLS certificates must exist for the openDesk login endpoints and for the redirect addresses that the external identity provider needs. An approved pilot group of live users, small enough to support closely, tests login, logout and group mapping before wider rollout. Ask the quote to list each input, its owner and the date it is needed.
Can our internal team set up openDesk SSO without a partner?
A capable internal team can do this work alone if it has three skills in place: Kubernetes operations for the openDesk deployment, administration of your existing identity provider, and enough directory knowledge to design the import. The OIDC federation steps are documented in the openDesk federation guide, and the Nubus Directory Importer is the recommended route for LDAP or Active Directory users. Teams most often need help agreeing attribute mapping across identity owners, testing edge cases such as disabled or duplicate accounts, and documenting the result for operations. Check whether your staff have already run openDesk release upgrades, because federation settings must survive later changes. An outside partner can add an independent review of the design and test plan, or take on a fixed-scope handover.
Does openDesk SSO federation keep working during a minor upgrade?
openDesk ships minor releases monthly and supports only the latest minor version, so plan to retest federation after each minor upgrade. The supplied release model does not confirm that federation settings carry over unchanged in every minor release, so check the release notes for the target version before scheduling. Rehearse the upgrade in a staging environment that uses the same federation settings as production. Then test a login with a pilot account, a group-based access check and a logout. Review the Helmfile values and any federation-related configuration in your change record. If you skip several minor versions, the release documentation says intermediate steps may be needed, so move through the required versions in order.
How does Microsoft Entra ID user sync work with openDesk?
Microsoft Entra ID does not expose LDAP, so the recommended LDAP-based import route needs Azure AD Domain Services in front of the tenant. Login for Entra ID users can be handled through OIDC federation, but directory provisioning depends on how Domain Services is set up. Before quoting, confirm whether Domain Services is already in use, because enabling it adds a managed directory that must be secured, monitored and kept in step with Entra ID. Also confirm which groups and users fall inside the sync scope, who owns the Domain Services instance and how credentials for the import account are rotated. Ask the implementer to show how a user removed in Entra ID is deprovisioned in openDesk during the pilot.
What does the Nubus Directory Importer do with Active Directory users?
The Nubus Directory Importer is the recommended one-way route for provisioning openDesk users from LDAP or Active Directory. One-way means changes flow from the directory into openDesk, so the directory remains the source of truth and edits made in openDesk do not write back. Ask the implementer to confirm which object types, attributes and groups the import reads, how disabled accounts are handled and how a removed user is deprovisioned. Test the import against a copy of production-like directory data before the pilot group is added. Confirm the import schedule, who can start a manual run and where import errors are logged for the operations team.
How DeployOpen scopes, builds and hands over openDesk identity work
DeployOpen plans, implements, integrates, documents and supports openDesk identity federation inside the client's own infrastructure. The work follows a fixed written scope, covering how the Keycloak-based openDesk IdP connects to the organization's existing identity provider over OIDC and how users reach openDesk from their directory.
How we scope
- We confirm which identity provider the organization runs and whether openDesk will federate with it over OIDC.
- We record how users will be matched, by username or an attribute such as mailPrimaryAddress, in the written scope.
- We confirm whether users come from Active Directory or LDAP through the Nubus Directory Importer, or from Microsoft Entra ID.
How we build
- We configure the OIDC federation between the existing identity provider and the openDesk IdP in a non-production environment first.
- We set up one-way user provisioning with the Nubus Directory Importer, or document the Azure AD Domain Services route for Entra ID.
- We test login, attribute mapping, logout and account changes across the bundled openDesk applications before anything moves to production.
How we hand over
- We deliver configuration as Helmfile and Helm values, with each federation setting documented against its source system.
- We provide a runbook covering user matching rules, sync schedules, failure checks and the steps to rotate client credentials.
- We walk the organization's identity and operations staff through the configuration and record the test results they can rerun.
How we support
- Ongoing support, upgrades and continuous testing are available as a retainer, scoped separately from the initial engagement.
- Identity changes are re-tested after each openDesk minor release, since only the latest minor version is supported.
- Support scope, response expectations and any Enterprise Edition support terms are confirmed in writing before work starts.

