How Ceph SSO and identity integration fits your existing directory
Ceph Dashboard supports single sign-on through SAML 2.0, and through OAuth2 when cephadm runs the Management Gateway and OAuth2 Proxy services. The Ceph Object Gateway (RGW) supports LDAP, Keystone and AWS STS-based authentication. Those facts answer the question, but they describe two separate identity surfaces that teams often merge in conversation. The first governs who can administer the cluster through the Dashboard and its management APIs. The second governs who can reach buckets and objects through S3 or Swift clients. Each surface has its own prerequisites, mapping decisions and failure modes, so the work should be scoped and tested one surface at a time.
On the administration side, the first decision is which protocol fits your identity provider. SAML 2.0 requires the provider's metadata, a trusted signing certificate and agreed attribute names for user and group claims. OAuth2 depends on cephadm deploying the Management Gateway and OAuth2 Proxy services, so it is tied to how your cluster is orchestrated and to the release you run. Confirm in the Dashboard documentation for your target release whether each path is available and what it requires before you commit. Then decide which directory groups receive the Dashboard administrator role, which receive read-only access, and which should have no Dashboard access at all. Keep a small set of local fallback accounts in a documented, tightly held state so an identity outage cannot lock out the team that must repair the cluster.
On the object side, the directory decision is different. LDAP authentication in RGW requires a bind account, a search base and a filter that maps directory users to Ceph identities, along with network paths from RGW hosts to the directory servers. Keystone authentication ties RGW to an OpenStack identity service, which makes sense only if that service already exists and your team can operate it. STS-based authentication issues temporary credentials, so the prerequisite is a role model that application teams can assume without long-lived keys. Confirm which of these fits your estate before designing policy. Each brings its own service dependencies, certificate handling and test burden, and changing the choice later means re-validating every client that authenticates against RGW.
Four issues make this harder than it looks. First, group-to-role mapping: directory groups must map cleanly to Dashboard roles or RGW policies, and nested or duplicated groups can produce access that nobody approved. Second, tenant and bucket ownership: RGW tenants and bucket owners should be decided before application teams arrive, because moving ownership later is an operational task with its own change record. Third, token lifetimes: session and STS credential durations determine how often users re-authenticate and how long a revoked user keeps access, so set them deliberately and test revocation end to end. Fourth, identity changes do not alter cephx access. Keys used by daemons and internal cluster components remain governed by cephx, so removing a directory account does not revoke them. Plan a separate review of cephx key scope alongside the directory integration.
Which Ceph components handle identity
Ceph separates human sign-in from internal trust. The Dashboard and the Object Gateway each accept directory-based identity at their edge, while cephx continues to authenticate daemons and clients inside the cluster. Read the cards together to see which component each identity decision touches.
Dashboard single sign-on with SAML 2.0
The Ceph Dashboard supports single sign-on through SAML 2.0, so administrators can sign in with your existing identity provider. The provider's signing configuration, assertion attributes and metadata must match what the Dashboard expects, so check them against the documentation for your Ceph release before testing. Confirm which directory groups should map to which Dashboard roles, and keep a local administrator account for recovery if the identity provider is unavailable.
Dashboard OAuth2 through cephadm services
OAuth2 sign-in for the Dashboard depends on two services that cephadm deploys: the Management Gateway and OAuth2 Proxy. Without both running, this path is unavailable, so plan their placement, certificates and health checks as part of the cluster build. Confirm that your release supports this configuration and that your identity provider works with the proxy flow you need. Review the gateway as an additional exposed entry point, in the same way you review the Dashboard itself.
Object Gateway authentication with Keystone and LDAP
The Ceph Object Gateway can authenticate S3 and Swift requests against OpenStack Keystone or an LDAP directory. Keystone suits environments where OpenStack already issues tokens and projects, while LDAP suits organizations that want directory accounts to access buckets directly. Each option changes how users map to Ceph identities and tenants, so settle that mapping before loading user lists. Ask the team to test group changes and account disablement, because revoked access must stop working at the gateway.
Multi-factor authentication and Open Policy Agent
Multi-factor authentication and Open Policy Agent integration add controls on top of gateway authentication. Confirm which clients and API calls the multi-factor mechanism covers before relying on it for sensitive buckets. Open Policy Agent integration lets an external policy decision govern access, which moves policy logic into a system your security team can review. Check how the gateway behaves when the decision service is unreachable, since a failure can either block legitimate access or allow more than intended.
AWS STS, IAM and SNS compatible APIs
The Object Gateway also exposes AWS-compatible STS, IAM and SNS APIs. STS issues temporary credentials, which suits applications and federated users that should not hold long-lived keys. IAM-style policies and SNS notifications depend on the same user and role model, so define roles before publishing them to teams. Test each API with the client tools your teams actually use, because compatibility depends on the operations each client calls.
cephx for daemons and clients
cephx remains the authentication mechanism between Ceph daemons and clients inside the cluster. Directory integration at the Dashboard and the gateway does not replace it, so monitors, OSDs and client keys still need their own lifecycle. Plan key rotation and capability scope separately from user directory changes. Disabling a directory account does not remove cluster-internal access, so confirm which keys a departing administrator could still use.
Choosing the Ceph SSO and identity option for each surface
This table compares the five Ceph identity options covered on this page: Dashboard over SAML 2.0, Dashboard over OAuth2, RGW with LDAP, RGW with Keystone and RGW with STS. Read each row by first checking the fit condition, then the operational cost you would carry after go-live. Most teams pick one option per surface, so the main takeaway is that the Dashboard and the Object Gateway are configured separately and each choice adds its own services, certificates and directory dependencies.
| Option | When it fits | Operational cost | Choose it when |
|---|---|---|---|
| Dashboard over SAML 2.0 | Your identity provider speaks SAML 2.0 and you want single sign-on for the Ceph Dashboard without running the OAuth2 services | Maintain SAML metadata and signing certificates on both sides, and renew them before expiry; confirm the identity provider's attribute mapping to Dashboard roles | Your identity provider is SAML-only or cephadm is not available for the OAuth2 path |
| Dashboard over OAuth2 | cephadm runs the Management Gateway and OAuth2 Proxy services for your cluster | Run and patch the Management Gateway and OAuth2 Proxy, manage their TLS certificates, and confirm the OIDC client settings with your identity team | You want OAuth2 login for the Dashboard and your cluster is managed with cephadm |
| RGW with LDAP | Users and their group membership already live in a directory and S3 access should follow directory membership | Depends on the directory team for account lifecycle, service bind accounts and TLS to the directory; directory outages affect S3 authentication | Accounts are driven by a directory and you accept a dependency on that directory for every request |
| RGW with Keystone | An OpenStack identity service already exists and tenants and roles are managed there | Requires running and securing the Keystone integration, keeping OpenStack identity healthy, and aligning project and role mapping to buckets | Your organization already operates OpenStack and wants one identity source for compute and object storage |
| RGW with STS | Applications or federated users need short-lived credentials instead of long-lived access keys | Design role trust policies, session duration and the identity source that federates into STS; you must test token expiry in each application | Workloads or federated users must access buckets without storing permanent keys |
How Ceph maps a directory login to access
Ceph authenticates a directory user at the entry point for each surface, but it does not decide on its own which directory group becomes a Dashboard administrator, which account owns a bucket, or which role a temporary session receives. Those mappings are a separate design task. Teams should plan them with the identity owners before any integration work starts, because the authentication settings and the authorization outcomes live in different places and are changed by different people. For the Dashboard, single sign-on uses SAML 2.0. The browser is redirected to the identity provider, the user signs in there, and the identity provider returns a signed assertion to the Dashboard endpoint. The Dashboard validates the assertion against the configured identity provider metadata and then creates a session. Ceph's documented SAML settings cover the identity provider and service provider details, including which attribute carries the user name. Where OAuth2 is used instead, cephadm must run the Management Gateway and OAuth2 Proxy services, which sit in front of the Dashboard and handle the token exchange. Confirm in the Ceph Dashboard documentation for your release which SSO options are supported and how the gateway services are deployed. RGW works differently. A client presents an identity to the gateway, and RGW checks that identity against LDAP or Keystone before it authorizes an S3 or Swift request. The documentation covers both backends, but the exact LDAP search filters, group handling and Keystone token validation behavior are details to confirm for the release in use. Access to a given bucket is then decided by ownership, bucket policy and IAM-style policies, not by the directory login alone. For temporary credentials, the AWS STS-compatible API issues role sessions, and the session policy and role definition determine what the session may do. Confirm how role trust and session tags are configured for your release. The practical planning task is to write a mapping table before configuration. For each directory group, record whether it grants Dashboard administrator rights, which tenant or RGW user it corresponds to, which buckets it owns or may read, and which STS roles it may assume. Assign an owner for each row and review it when the directory changes. Ceph will not generate this table for you, and a login that succeeds does not prove that the mapping is correct. Finally, test the mapping as a separate step from the login test. Use a set of test accounts for each directory group, confirm that Dashboard roles, bucket access and STS sessions match the table, and check that removed or disabled users lose access at the identity provider and in Ceph. Record the results so auditors can compare them with the approved design.
Ceph SSO setup in the order that avoids lockouts
This sequence connects Ceph's Dashboard and Object Gateway to your identity systems in an order that keeps administrators able to get back in at every stage. Each step closes with a check, so a failed login or mapping is caught in a test cluster rather than in production.
Inventory identity sources and their owners
Before touching Ceph, list every identity source that will sign in to the Dashboard or access object storage, such as a corporate SAML identity provider, an LDAP directory, a Keystone service or a workload identity provider for STS. For each source, name the owner who can change group membership, certificates and service accounts, and record who approves changes. Agree the group names that will map to Dashboard roles and to tenants. The step is done when the owners have signed off on this list and each group has a documented purpose. Confirm with your identity team which protocol versions and certificate chains they will support, because those choices constrain the later steps.
Confirm the Ceph release and cephadm management
Record the exact Ceph release running in each cluster and confirm that cephadm manages the Dashboard, Manager and RGW daemons. This matters because the OAuth2 path depends on cephadm running the Management Gateway and OAuth2 Proxy services, and cephadm was introduced in v15.2.0 (Octopus) and does not support older releases. Check whether your cluster runs Squid (19.2.x) or Tentacle (20.2.x), and note the end-of-life estimate for that release, which affects whether you plan an upgrade before or after the SSO work. The step is closed when the release, the cephadm service list and the Dashboard URL are written down and verified with the ceph orchestrator status output.
Create a break-glass local administrator first
Before any SSO change, create a local Dashboard administrator account with a strong, unique credential stored in your secrets vault under a documented break-glass procedure. Limit its use to recovery, and make sure the account does not depend on the identity provider being reachable. Test that you can sign in with this account on the current, unchanged Dashboard. Also confirm that the cephx administrative keyring is available to the operators on call, because it gives a path to recovery through the command line if every web login fails. The step is closed when a successful local login is recorded and the credential custody owner has confirmed the storage location.
Configure Dashboard SSO in a test cluster
In a non-production cluster that matches production's Ceph release and cephadm layout, configure the Dashboard for SAML 2.0, or for OAuth2 if the Management Gateway and OAuth2 Proxy services are deployed. Register the Ceph Dashboard as a service provider or client with your identity provider, exchange metadata or client settings, and set the certificate trust. Then test a full login and logout with a named test user. The step closes with two checks: a successful test login that lands on the Dashboard with the expected user name, and a successful logout that ends the session. Record any redirect or certificate errors so they can be fixed before production.
Map groups to Dashboard roles and test denials
Define the mapping from identity provider groups to Ceph Dashboard roles, starting with the smallest role set that covers each job, and apply it in the test cluster. Test with at least three accounts: one in a mapped administrative group, one in a mapped read-only group, and one in no mapped group. The closing checks are a successful login with the expected role for each mapped account, and a denied login or no-permission result for the account in an unmapped group. Keep a written record of the mapping so the identity team can review it and so changes go through the same owners listed in the first step.
Configure RGW authentication and test with a non-production user
Choose the Object Gateway authentication path that matches your environment, whether LDAP, Keystone or STS, and configure it in the test cluster. For STS, confirm how short-lived credentials are issued and which role each caller assumes. Use a non-production user to make a successful S3 request with the issued credential, then make a request outside that user's permissions and confirm it is refused. The step closes when both the allowed request and the refused request are recorded. Also confirm that RGW endpoints are reached over the network path your security team approved, since msgr2 secure mode protects cluster traffic but does not replace the authentication configuration you set here.
Map tenants and buckets to owners
Connect each identity group to the tenant, user or bucket it owns, and record the owner for every bucket that will hold production data. Check that the mapping grants access only to the owner's buckets and that a shared bucket has a named accountable owner. In the test cluster, list the buckets visible to each test identity and confirm that an identity cannot see or write to a bucket it does not own. The step closes with a written owner register matched against the test results, which becomes the reference for access reviews after production.
Promote to production with a rollback plan
Apply the tested configuration to production in a planned change window agreed with the owners from the first step. Before the change, write a rollback plan that states how to disable SSO and return to the break-glass local administrator, and how to revert the RGW authentication settings, with the command or configuration steps named. Run the same login, denial and S3 checks used in testing against production with test accounts, then remove or disable those accounts. The sequence is complete when production checks pass, the rollback plan has been rehearsed in the test cluster, and the change record is signed off by the identity and storage owners.
Ceph SSO differences by deployment model
A single cephadm-managed cluster that needs only Dashboard SSO has the smallest identity surface. The main decision is the SSO protocol. SAML 2.0 is supported for the Dashboard, while OAuth2 requires cephadm to run the Management Gateway and OAuth2 Proxy services. The users are administrators, so the design centers on who can reach the Dashboard and which identity provider groups map to Ceph administrative roles.
- Protocol choice: SAML 2.0 directly, or OAuth2 through the Management Gateway and OAuth2 Proxy services that cephadm deploys.
- Reachability: the identity provider must reach the Dashboard callback endpoint, and administrator browsers must reach the identity provider. Confirm both paths in your network design.
- Role mapping: map identity provider groups to Dashboard roles and agree the least-privilege mapping with your security team.
- Added services: the Management Gateway and OAuth2 Proxy are extra components to patch, monitor and include in the upgrade plan.
- Cluster traffic: SSO does not change daemon-to-daemon traffic, so confirm separately whether msgr2 secure mode is in scope.
Before cutover, test the login path administrators will use and confirm that a documented break-glass local administrator path exists and is audited.
When one cluster serves the Ceph Object Gateway to several business units, identity moves from administrators to tenants and applications. The design question is how each unit's users authenticate and how their identities map to tenants, buckets and policies, so that one unit cannot read another unit's data. RGW supports Keystone and LDAP authentication and AWS STS, IAM and SNS compatible APIs, so the right choice depends on the identity source each unit already uses.
- Identity source per unit: decide whether each unit authenticates through LDAP, Keystone or STS-issued temporary credentials, and document the mapping.
- Tenant boundary: define which identities belong to which tenant, and confirm that bucket ownership and policies enforce the separation.
- Policy engine: consider Open Policy Agent integration if authorization decisions must be evaluated outside bucket policies, and confirm the fit with your policy team.
- Reachability: RGW endpoints must be reachable from each unit's network, and the LDAP or Keystone servers must be reachable from the gateways.
- Service accounts: applications, credential rotation and any multi-factor authentication requirement need a named owner in each unit.
Before onboarding a second unit, test cross-tenant access with a deliberately unauthorized identity from each unit and record the expected refusal.
In a multisite design, the same user must be authenticated and authorized consistently in every zone, so identity configuration becomes part of the zone design. A credential issued in one zone must work where requests are served, or a user who can write in one zone may be refused in another. Decisions about where the identity source lives and how a site behaves when that source is unavailable need to be made before the first zone is built.
- Source of truth: decide where identity lives and whether each zone queries the same LDAP or Keystone service.
- Credential consistency: confirm how access keys and STS credentials are created, propagated and revoked across zones.
- Reachability: every zone's gateways must reach the identity source, and the links between sites carry replication traffic that needs its own planning.
- Failure behavior: define what happens when the identity service is down at one site, including whether requests fail closed.
- Metadata scope: confirm which user and policy metadata replicates between zones, and test the cutover order for identity changes in a non-production realm.
Verify with a credential issued at one site and used at another, and document the expected result for each failure case before go-live.
In an air-gapped or restricted network, the identity provider, its certificate authority and every certificate chain are internal, and no external service can be used to validate identities. The identity design must work without internet access. SAML metadata, OAuth2 endpoints, keys and certificates have to be imported locally, and revocation checks must reach internal endpoints. Both the Ceph hosts and the identity provider depend on trust material that stays current, so renewal is part of the design.
- Internal identity provider: confirm that SAML metadata or OAuth2 endpoints are hosted internally and reachable from the Dashboard hosts.
- Certificate chains: install the internal root and intermediate certificates on Dashboard and RGW endpoints, and plan renewal before expiry.
- Revocation and time: confirm that internal revocation endpoints are reachable and that time synchronization is consistent, because token validation depends on it.
- Image sources: cephadm container images must come from an internal registry, and the identity-related components must be included in that mirror.
- Sign-off: certificate trust stores, offline update procedures and break-glass access need approval from the security team.
Test a full login and token validation with internet access blocked on the Ceph hosts, then record the renewal procedure alongside the test results.
What drives the effort of Ceph identity integration
This table lists the factors that change the size of a Ceph identity integration, from identity sources and group design to environments and access review evidence. Read each row as a question to answer in a written scope before asking for a quote, with the right-hand column showing how to keep that factor under control.
| Driver | How it changes cost or duration | How to keep it down |
|---|---|---|
| Number of identity sources | Each directory, SAML identity provider, OAuth2 provider, LDAP server or Keystone instance needs its own trust setup, attribute testing and failure path. Dashboard and RGW may use different sources. | Confirm which source is authoritative for each user population and limit the first release to one source per interface. |
| Groups and roles | Every group that must map to a Dashboard role or an RGW policy adds design review, naming decisions and test cases. Nested or overlapping groups multiply the cases to check. | Reuse existing directory groups where they already match duties, and cap the first role set to a short list of administrative roles. |
| Tenants and buckets needing owner mapping | Each tenant, user namespace or bucket with a distinct owner needs an agreed mapping, quota owner and access test. Ownership disputes usually surface late and slow the build. | Map owners for the first tenants only, and record the rest as a follow-on item with a named business owner. |
| Number of environments (lab, staging, production) | Each environment needs its own identity configuration, test accounts, certificates and cutover checks. Drift between environments adds rework. | Build the configuration once as code or templates, then promote it through environments with the same steps. |
| Certificate and metadata exchange changes | SAML metadata, signing certificates, redirect URIs and TLS chains must be exchanged and rotated with the identity team. Each change can need a coordinated window. | Agree the certificate authority, rotation owner and metadata exchange method in the scope before build starts. |
| RGW versus Dashboard scope | RGW authentication (LDAP, Keystone, STS) and Dashboard SSO (SAML 2.0 or OAuth2) are separate integrations with different roles, tests and operators. Covering both roughly doubles the design work. | Split the work into phases so each interface has its own acceptance criteria and sign-off. |
| Evidence required for access reviews | Auditors and internal reviewers may ask for role assignments, change records, login logs and periodic review outputs. Designing these outputs adds work for logging, reporting and procedure documentation. | Ask the reviewer to list the evidence fields once, then build the export and retention settings to match that list. |
How to test Ceph SSO so it fails safely
Testing Ceph SSO is not finished when a mapped user can log in. The failure paths decide whether the integration is safe in production, so give them the same weight as the success path. Before go-live, the test plan should cover two surfaces: the Ceph Dashboard, where SSO is configured over SAML 2.0 or, when cephadm runs the Management Gateway and OAuth2 Proxy services, OAuth2, and the Object Gateway (RGW), where LDAP, Keystone or AWS STS-based access applies. Each surface needs its own cases, and each case needs an expected result written down before the test runs.
On the success side, test a user who belongs to a mapped group and confirm the role or tenant they receive is the one you designed, not a broader one. Then test denial: a user with no mapping, a disabled account in the directory, and a user whose group membership is missing the attribute Ceph expects. Denied logins should fail closed, with no partial session and no default role. Confirm the exact message and log entry the reader will see, because operations staff will rely on it during an incident.
Next, test what happens when the identity provider or directory is unreachable. Stop the IdP or block the LDAP port from a monitor or gateway host, then observe whether existing sessions keep working, whether new logins are refused, and whether RGW STS requests fail with a clear error. Also test logout and session expiry on the Dashboard, and remove a user from the group that grants access, then check whether an existing session or an unexpired STS credential still works. Those results decide your revocation window. Test STS credential expiry separately by requesting short-lived credentials and confirming that requests fail once the lifetime passes.
The break-glass path must be tested before go-live, not after the first outage. Confirm that a local Dashboard administrator account or a documented cephadm and CLI procedure works when SSO is down, that the credentials are stored under your controls, and that using them is logged and alerted. Rehearse the steps with the people who would perform them at night.
Record every case in the acceptance checklist with the test identity, the action, the expected result, the observed result and the evidence location. Ask your partner or internal team to agree the checklist before testing begins, so that a failed case is a defect to fix rather than a result to explain away. Retest any case that changes after an upgrade, a directory schema change or a certificate rotation.
Securing the identity path for Ceph administrators and applications
Single sign-on and directory integration decide who can administer a Ceph cluster and which applications can obtain temporary storage credentials. The cards below cover the controls on that path, from transport and certificates to group scoping, multi-factor authentication, secrets handling and break-glass access. Confirm each control against the identity path you choose before the design is signed off.
Protected channels for SAML and LDAP
SAML assertions and LDAP bind traffic carry the credentials and group data that decide access to the Dashboard and the Object Gateway. Confirm that every connection uses TLS with certificates validated against your internal certificate authority, and that hostname checks are enabled rather than skipped. Test certificate rotation before go-live, because an expired identity provider certificate can lock every administrator out at once.
Dashboard rights limited to named groups
Map identity provider groups to Dashboard roles deliberately, and avoid granting administrator rights to broad directory groups such as all staff in a department. Review the role assignments with the cluster owner and record which group owns each role. Confirm how the Dashboard handles users who belong to several groups, since the effective role may not be the one you expect.
Multi-factor authentication where supported
Require a second factor for administrative sign-in when the chosen path supports it, and confirm which step enforces it: the identity provider, the Dashboard login, or the RGW authentication flow. Write down the fallback for users who lose their device and who approves a reset. Do not assume that a Dashboard login without a second factor is covered by the identity provider policy until you test it.
Minimal permissions on STS roles
Object Gateway STS roles let applications receive temporary credentials, so each role should grant only the bucket actions and resources that one workload needs. Write the trust policy to name the specific identity or group allowed to assume the role, and set session lifetimes you can justify. Review role policies after each application change, because roles that were broad for testing often stay broad in production.
Client secrets kept out of configuration files
OAuth2 client secrets, SAML signing material and LDAP bind passwords should live in the secrets store your organization has approved, not in cephadm specifications, configuration files or shell history. Confirm how the Dashboard and RGW read these values after a restart, and who can read them from the store. Plan rotation as a documented procedure with a named owner, so secret changes do not depend on one engineer.
Offline and audited break-glass account
Keep a local break-glass administrator account for use when the identity provider or directory is unavailable, and store its credentials offline under dual control. Each use should be recorded and reviewed, and the account should be disabled again once the incident closes. Test the procedure in a non-production cluster so the team knows it works before an outage requires it.
What to monitor, document and renew after Ceph SSO goes live
Go-live is the start of identity operations, not the end of the project. Once Dashboard SSO or RGW authentication is working, four recurring tasks keep it working: reviewing group-to-role mappings on a schedule, tracking certificate and metadata expiry for each identity provider, watching failed login and denied access events, and rotating client secrets. Assign each task a named owner and a fixed review interval before the cutover, so that nobody has to rediscover them when something breaks.
Group-to-role mappings drift. Dashboard roles, such as administrator, read-only or pool manager, are granted by group membership in the identity provider, and RGW user and tenant access depends on the groups or claims your LDAP, Keystone or STS setup passes through. Review each mapping against the current directory at a set interval, and remove mappings for groups that no longer have a clear business owner. Record who approved each change, because a silent group rename in the directory can either lock administrators out or grant broader access than intended.
Certificates and SAML metadata expire on their own schedule, and an expired signing certificate or metadata file causes SSO to fail for every user at once. For each identity provider, record the expiry date of the signing and TLS certificates, the metadata URL or file, and who is notified before renewal. Confirm the renewal procedure in your own environment, including whether the identity provider publishes new metadata automatically or needs a manual upload to the Dashboard. The same applies to OAuth2 client secrets used through the Management Gateway and OAuth2 Proxy services: rotate them on a schedule, and plan the cutover so both old and new values are not needed at once in a way that breaks logins.
Failed login and denied access events are the early warning for both misconfiguration and misuse. Forward Dashboard authentication logs and RGW access logs to your central log platform, and alert on spikes in failures, logins from unexpected identity providers, and repeated denials for the same user. Decide who triages these alerts and how often someone reviews the quieter signals. Confirm with your security team which events they need retained, and for how long, because that is a policy decision rather than a Ceph default you can assume.
Every Ceph upgrade can change how authentication behaves, so identity settings must be retested after each one, not assumed to survive. This applies to the current Squid line, whose estimated end of life is October 31, 2026, and to the Tentacle release (20.2.x, estimated end of life June 1, 2027), which is the planned upgrade target described in the upgrades topic. Keep the test cases from go-live and run them on a staging cluster before every production upgrade. Handover should contain the mapping matrix, the test cases with their latest results, the owner of each identity source, and the break-glass procedure for local administrator access when the identity provider is unavailable. Store these in your change system, and update them whenever a mapping, certificate or owner changes.
What Ceph SSO integration costs and what it needs from your team
What drives the cost of Ceph SSO and identity integration?
The cost follows the number of identity sources, how complex the role and tenant mapping is, and how many environments and evidence requirements sit on top. Main drivers:
- Dashboard SSO over SAML 2.0 or OAuth2, which affects how much cephadm-managed service work is needed
- RGW authentication through LDAP, Keystone or STS, each with its own configuration and test cases
- Mapping directory groups to Ceph roles, buckets and tenants, which grows with the number of teams
- Separate test, staging and production environments, plus any audit evidence your assessors expect
A written quote should name each identity source, each mapping rule and each environment in scope. No price figure is given here. Ask for it to be itemized by those items.
Can our own team implement Ceph SSO without outside help?
Yes, if your team already has directory administration, certificate management and Ceph administration skills. The skills that matter:
- Directory administration for LDAP or the identity provider, including group design and service accounts
- Certificate work for SAML metadata, TLS on the Dashboard and RGW endpoints, and trust chains
- Ceph administration with cephadm, including service placement, config changes and rolling restarts
If one of these areas is thin, outside help is most useful for the mapping design and the test plan, where mistakes are easiest to miss. Ask your team to confirm each skill before deciding.
How long does Ceph SSO integration take to complete?
Duration depends on the decisions and tests involved, not on a fixed number of days. What sets the timeline:
- Agreeing the role matrix and which directory groups map to which Ceph permissions
- Confirming whether Dashboard SSO uses SAML 2.0 or OAuth2, since OAuth2 depends on the Management Gateway and OAuth2 Proxy services being deployed through cephadm
- Running login, logout and permission tests for each identity source and each environment
- Waiting on directory owners and certificate authority contacts to respond
Ask the provider to show the decision points and test cases in the proposed plan, and to list which of them depend on your teams.
What does the work need from our team?
Four roles must be named before work starts, and each one controls a decision or a dependency. Your team provides:
- Directory owners who can confirm groups, attributes and service accounts for LDAP, Keystone or your identity provider
- Certificate authority contacts who issue and renew the certificates used for SAML metadata and TLS
- A named Ceph administrator who applies changes on the cluster and owns the result after handover
- An approver for the role matrix who signs off which groups receive which Ceph and bucket permissions
If any of these roles is unnamed, the schedule usually slips at the first test.
Does a fixed-scope agreement suit Ceph SSO integration?
Often yes, when the scope is clear before work starts. DeployOpen typically agrees scope, deliverables and timelines in writing before work begins, and most engagements are fixed-scope. A fixed scope works best when you can state:
- The identity sources and protocols in scope, such as SAML 2.0 for the Dashboard and LDAP for RGW
- The number of environments and the role groups to map
- The evidence you need, such as configuration records and test results
If the role matrix is still being decided, a short discovery phase before the fixed-scope quote usually gives a more accurate scope. Ongoing support after go-live can be set up as a separate retainer.
Which Ceph SSO decisions carry the most risk to get wrong?
The highest-risk decisions are the role mapping and the certificate trust, because errors there either lock out administrators or grant too much access. Check these before go-live:
- Whether group membership maps to the intended Ceph roles, with no default administrator access
- Whether SAML metadata, signing certificates and TLS chains are renewed on a schedule your team owns
- Whether RGW users and tenants map to the right buckets, especially where shared groups exist
- Whether a documented break-glass path exists for the Dashboard if the identity provider is unavailable
Test each of these in a non-production environment first, and record the results for your assessors.
What should we ask for in a quote for Ceph SSO integration?
Ask for a written scope that separates one-time work from anything recurring. Include these items in the request:
- A list of identity sources and protocols, with the Ceph component each one connects to
- The role matrix and the approver who signs it off
- The environments covered, and how test results and configuration records will be delivered
- The assumptions about your team's availability, including the named roles in the previous section
- Which items are fixed, which depend on your decisions, and what triggers a change order
- Whether ongoing support or testing is priced separately as a retainer
A quote built this way lets you compare providers on the same scope.
How DeployOpen works on this
DeployOpen plans and implements Ceph identity integration inside your own infrastructure, starting from a written scope that names each identity source, each Dashboard or RGW entry point and each tenant mapping. The work is delivered as a fixed-scope engagement, with testing, documentation and handover agreed before the build starts.
How we scope
- Inventory the identity systems in use (SAML 2.0 provider, OAuth2 provider, LDAP directory or Keystone) and confirm which ones must authenticate to Ceph.
- Confirm the Ceph release and whether cephadm manages the cluster, since Dashboard OAuth2 depends on the Management Gateway and OAuth2 Proxy services.
- Agree in writing which access paths are in scope: Dashboard single sign-on, RGW authentication, STS roles or user-to-tenant mapping.
- Record the group-to-role and group-to-bucket mapping rules the client approves before any configuration begins.
- Define acceptance tests and documentation deliverables in the written scope, so the quote follows from defined work.
How we build
- Configure Dashboard single sign-on against the agreed identity provider, using SAML 2.0 or OAuth2 as the scope specifies.
- Configure RGW authentication (LDAP, Keystone or STS) in a non-production environment first, then promote the change under change control.
- Map directory groups to Dashboard roles and RGW users, tenants and bucket policies according to the approved matrix.
- Test login, token expiry, denied access and cross-tenant isolation, and keep the results as evidence for your reviewers.
- Confirm that management traffic and RGW endpoints are exposed only on the networks and ports the design allows.
How we hand over
- Deliver a runbook covering each identity integration, its configuration files, its owners and its dependencies on the identity provider.
- Document the group-to-role and group-to-tenant mapping as it was built, with a change process for adding users or groups.
- Walk your operations and security staff through login flows, failure symptoms and the rollback steps for each integration.
- Hand over test scripts and acceptance results so your team can repeat the checks after upgrades or directory changes.
- Record any open items, such as identity provider features you still need to confirm, with an owner and a next step.
How we support
- Offer ongoing support, upgrades and continuous testing as a retainer, with coverage agreed in writing.
- Re-test identity paths after each Ceph upgrade, since release changes can affect Dashboard and RGW authentication settings.
- Review access mappings on a schedule you set, so departed users and changed groups do not keep stale access.
- Keep documentation current when the identity provider, certificates or Ceph release changes, and record each change.
- Confirm with your identity team and the Ceph release notes which features your chosen release supports before scheduling changes.

