Ceph with cephadm vs Rook: which deployment model fits your team
If you need Ceph and must choose how to deploy it, the decision comes down to who will operate the storage. Choose cephadm when your team runs Linux hosts and wants Ceph managed as Ceph, with the cluster lifecycle handled through the orchestration interface. Choose Rook when your storage should be provisioned and operated through Kubernetes APIs, or when you want Kubernetes to consume an existing Ceph cluster through Rook's external mode. The Ceph installation docs list both as recommended methods, and both run the same Ceph project, so the question is about ownership, not storage features.
cephadm manages Ceph as containers on hosts that run systemd, Python 3 and Podman or Docker. It bootstraps a single-node cluster with one Monitor and one Manager, then adds hosts and daemons through the orchestration interface, which you can drive from the CLI or the dashboard. It does not depend on Ansible, Rook or Salt. This suits a storage or infrastructure team that thinks in hosts, OSDs and daemons. Rook, by contrast, runs a Kubernetes operator that deploys, configures, provisions, scales, upgrades and monitors Ceph, so the people who own the cluster also need Kubernetes skills. Confirm with your platform team which group will be paged when an OSD fails.
Rook's external mode is the option to check first if you already run Ceph and only want Kubernetes workloads to use it. In that model the Ceph cluster keeps its own lifecycle, and Kubernetes connects to it. If your Kubernetes clusters are new and your storage team is new to Ceph, a single-model deployment may be simpler to reason about. Before you decide, list your Ceph version and support window, your upgrade owner and whether your operators already run Kubernetes control planes. The Rook introduction is the natural next read on what the operator manages.
How cephadm and Rook compare on lifecycle, licensing and operating model
This table compares the two Ceph deployment methods the Ceph project recommends across the factors that change day-to-day work: host platform, lifecycle scope, interface, external cluster support, release support and licensing. Read each row against the platform your team already runs, because the right method usually follows from where Ceph's daemons and the people operating them will live.
| Factor | cephadm on Linux hosts | Rook in Kubernetes |
|---|---|---|
| Host platform | Linux hosts with systemd, Python 3 and Podman or Docker, with Ceph daemons run as containers | A running Kubernetes cluster, with Ceph daemons scheduled as Kubernetes workloads by the Rook operator |
| Lifecycle scope | Bootstrap of a single-node cluster with one Monitor and one Manager, then adding hosts and daemons, and updating Ceph containers | Operator deploys, configures, provisions, scales, upgrades and monitors Ceph inside Kubernetes |
| Primary interface | Ceph CLI and the Ceph Dashboard for orchestration tasks | Kubernetes APIs and custom resources for storage resources and provisioning |
| External cluster support | Not the focus of this method. Connecting other clients is handled through standard Ceph access, so confirm the exact setup with the Ceph docs | Can connect a Kubernetes cluster to an existing external Ceph cluster, so Ceph can run outside Kubernetes |
| Release support | Supports Octopus and newer releases. Tentacle (v20) and Squid (v19) are the active Ceph releases | Follows the Rook and Ceph versions it supports, so confirm the Rook-to-Ceph compatibility matrix before upgrades |
| External tooling | Does not rely on Ansible, Rook or Salt | Depends on Kubernetes and the Rook operator as the management layer |
| Licensing | Ceph is licensed under LGPL-2.1 or LGPL-3.0, with no paid edition from the project | Rook is open source and a CNCF graduated project, and Kubernetes is licensed under Apache 2.0 |
| Assumed team skills | Linux host administration, container runtime operation and Ceph administration | Kubernetes operations, including the control plane, RBAC, storage classes and upgrades, plus Ceph knowledge |
| Who it fits | Teams running storage on dedicated Linux hosts without a Kubernetes platform to share | Teams already operating Kubernetes that want storage managed through the same APIs and GitOps workflows |
What cephadm manages on Linux hosts
cephadm bootstraps a single-node cluster with one Monitor and one Manager, then grows it by adding hosts and daemons through its orchestration interface. You can drive that work from the command line or the Ceph Dashboard, and cephadm also updates the Ceph containers over time. Because the orchestrator owns daemon placement, the operational question for your team is who will run day-two changes such as adding a host, replacing a failed OSD host or scheduling an upgrade, and whether those people are comfortable doing it through ceph orch commands rather than configuration management scripts they already maintain.
The host prerequisites are narrower than many teams expect. Each Linux host needs systemd, Python 3 and either Podman or Docker, and cephadm does not depend on external configuration tools such as Ansible, Rook or Salt. Confirm that your host image, kernel and container runtime policy allow those components before you commit to this route, and check the Cephadm documentation for the release you plan to run, since cephadm only supports Octopus and newer releases.
Not every host can run cephadm. The Ceph installation docs list ceph-salt, Juju, Puppet and manual installation as other routes, and manual installation is the one the docs cite for hosts such as FreeBSD. If a subset of your estate falls into that category, plan for a second deployment and operations procedure alongside the cephadm one, and confirm with the Ceph project which routes are still documented for your target release before you standardize on them.
How the two topologies are built
Both methods deploy the same Ceph daemons, but they place them differently. cephadm runs those daemons as containers on hosts you manage directly, while Rook turns them into Kubernetes workloads driven by the operator, and external mode lets Kubernetes consume a cluster that already exists. The cards below cover the building blocks and the hardware choices that shape either layout.
cephadm host layout
cephadm bootstraps a cluster with one Monitor and one Manager, then adds hosts and daemons through its orchestration interface. Each daemon runs as a container under systemd on Linux hosts with Python 3 and Podman or Docker. Monitors, Managers, OSDs, the Object Gateway (RGW) and the Dashboard are placed on hosts you choose. Check that your hosts can run the container runtime and that you can patch them without taking the whole cluster down.
Rook operator and CRDs
In Kubernetes, the Rook operator deploys, configures, provisions, scales, upgrades and monitors Ceph. Cluster and storage resources are declared as Kubernetes objects, so Monitors, Managers and OSDs run as workloads scheduled by the cluster. This means your storage lifecycle follows your Kubernetes upgrade and RBAC practices. Confirm which Kubernetes versions your Rook release supports and who owns the operator's permissions in your cluster.
Rook external mode
External mode lets a Kubernetes cluster consume an existing Ceph cluster instead of hosting its own daemons. Storage stays managed on the Ceph side, often by a team that runs cephadm, while Kubernetes workloads request block, file or object storage. Ask how the Ceph credentials and network paths between the two clusters will be scoped and rotated, because the Kubernetes side depends on them.
Dedicated drive per OSD
The Ceph hardware recommendations advise one dedicated drive per OSD, so each OSD has its own failure domain and I/O path. Sharing a drive between OSDs or with the operating system undermines that isolation. This applies to either topology, so plan drive counts per host before choosing where the Monitors and OSDs will run. Ask your hardware vendor for a benchmark on your workload, because the guidance is to benchmark before buying.
WAL and DB on shared SSDs
For HDD-based OSDs, the recommendations move the write-ahead log (WAL) and the database (DB) onto shared SSDs. This shapes the host bill of materials, since each host needs enough SSD capacity and the SSDs become a shared dependency for several OSDs. Enterprise-class SSDs are advised for metadata. Check how a failed SSD affects every OSD it serves, and plan replacement procedures before go-live.
Bonded links across two switches
The recommendations advise bonding network links across two switches, so a single switch failure does not isolate a host from the cluster. This is a physical design decision that applies whether cephadm or Rook manages the daemons, but Kubernetes networking adds its own layer on top of it. Confirm that your switch design, bonding mode and Kubernetes CNI were tested together, and size memory for peak use rather than calm periods.
What Rook takes over inside Kubernetes
Rook is a CNCF graduated storage orchestrator, and its operator takes over the Ceph lifecycle inside Kubernetes: it deploys, configures, provisions, scales, upgrades and monitors Ceph. Storage is requested through Kubernetes APIs rather than through the cephadm CLI or dashboard, so a platform team works with objects such as storage classes and persistent volume claims instead of Ceph daemons on hosts. That is the trade. Ceph still runs its own monitors, managers and OSDs, but they are scheduled and reconciled by the operator. Before adopting it, confirm which Rook and Ceph versions your Kubernetes distribution and your storage vendor support, and who owns upgrades of the operator itself, since that step now sits in the Kubernetes change process.
Rook also offers an external mode, where Kubernetes consumes an existing Ceph cluster instead of hosting one. In that model the Ceph cluster lifecycle can stay with a separate storage team that deploys it with cephadm or another method, while the platform team manages only the connection and the resulting storage classes. This split is useful when storage must serve workloads outside Kubernetes too. Decide in advance who holds the keys and credentials for the external cluster, how capacity requests reach the storage team, and which party is paged when an OSD fails. Those answers matter more than the install method.
The storage layer inherits Kubernetes constraints. Kubernetes maintains only its three most recent minor releases, and kube-apiserver must be upgraded one minor version at a time before the other control plane components and kubelets, so a Rook upgrade often waits on a Kubernetes upgrade. The control plane also depends on etcd, which stores cluster state and should run with an odd number of members, with a backup plan and tested restores. If etcd fails or is restored badly, the operator's view of the Ceph cluster is affected too. Ask your platform team to confirm the Kubernetes version support window and etcd backup procedure before committing to Rook for production storage.
Which team should choose each model
Choose cephadm when your team runs Linux hosts, manages storage directly, and has no Kubernetes footprint that storage needs to plug into. cephadm deploys Ceph as containers on the hosts themselves, bootstrapping a single-node cluster with one Monitor and one Manager and then adding hosts and services through the orchestration interface, managed from the CLI or dashboard. Its lifecycle work covers adding daemons and updating Ceph containers without a second configuration layer.
- Fewer moving parts: cephadm does not rely on Ansible, Rook or Salt, so the cluster is operated with Ceph's own tooling.
- Host-level control: Teams used to managing disks, network bonds and OSD placement on bare metal keep that model.
- Requirements to meet: Hosts need systemd, Python 3 and Podman or Docker, and cephadm supports only Octopus and newer releases.
- When the other model fits better: if storage requests will arrive as PVCs from application teams, cephadm leaves that integration for you to build.
Before committing, confirm the host OS and container runtime support against the current Ceph installation documentation and your own hardware plan.
Choose Rook in-cluster when your platform team already runs Kubernetes and wants storage requested and provisioned through Kubernetes APIs. The Rook operator deploys, configures, provisions, scales, upgrades and monitors Ceph inside the cluster, so application teams consume storage with PersistentVolumeClaims instead of tickets to a storage group. Ownership of the storage layer then sits with the same people who operate the cluster.
- PVC-driven provisioning: Storage requests follow the same workflow as other Kubernetes resources.
- Operator-managed lifecycle: Upgrades and scaling run through the operator rather than a separate host tool.
- Shared failure domain: Storage pods compete for the same nodes, so node sizing and placement rules matter more than in a host-based build.
- Skills required: Your team needs to be comfortable with Kubernetes upgrades, node labels and storage-specific debugging.
- When cephadm fits better: if the Kubernetes cluster is a small add-on and storage must survive independently of it, host-based deployment separates the two.
Confirm your Kubernetes version against the Rook introduction and the Kubernetes support window you plan to run.
Choose Rook in external mode when a Ceph cluster already exists and serves other consumers, and Kubernetes workloads now need access to it. Rook connects the Kubernetes cluster to the external Ceph cluster instead of deploying a new one, so the storage team keeps its established operations and the platform team gains PVC-based access. This option suits organizations that do not want to migrate existing data or change how the storage cluster is run.
- No second cluster: Existing monitors, OSDs and pools remain where they are.
- Separation of duties: The storage group keeps operating Ceph while Kubernetes consumers request capacity.
- Network reachability: Kubernetes nodes must reach the Ceph monitors and services, which needs to be designed and tested.
- Limits of the integration: You still own the Ceph cluster's upgrades, capacity and recovery, so confirm which team carries each task.
- When full in-cluster Rook fits better: if no Ceph cluster exists yet, deploying one under Rook avoids building a separate cluster first.
Ask your Ceph and Rook versions to be checked together, using the Ceph installation documentation, before you plan the connection.
Upgrades, backups, monitoring and skills for each model
This table compares how each deployment model handles upgrades, backups and disaster recovery, monitoring, and the skills your team needs to run it. Read each row against your own platform staffing, since the right model often depends on who already operates Linux hosts and who already operates Kubernetes. The main takeaway is that cephadm concentrates effort on Ceph itself, while Rook adds Kubernetes lifecycle and etcd responsibilities to every storage decision.
| Area | Ceph with cephadm on Linux hosts | Ceph with Rook in Kubernetes |
|---|---|---|
| Upgrades | cephadm updates the Ceph containers on hosts through its orchestration interface. Confirm the target release is one the project still maintains, such as Tentacle or Squid, before planning the path. | The Rook operator upgrades Ceph, but your Kubernetes version, its skew policy and the Rook release must also line up. Plan Kubernetes upgrades and Ceph upgrades as one change calendar. |
| Kubernetes version support | Not applicable. Hosts run systemd, Python 3 and a container runtime such as Podman or Docker, managed on your own OS schedule. | Kubernetes maintains only the three most recent minor releases, so plan an upgrade path before the current minor leaves support. |
| Backups and disaster recovery | Back up Ceph configuration and the cluster state you rely on, and test restore of the pools that hold your data. Confirm the exact procedure for your release with the Ceph documentation. | Back up etcd on the Kubernetes control plane using etcdctl snapshot save, and keep restore tested with etcdutl. Rook custom resources also need backing up alongside cluster data. |
| Monitoring | The Ceph Dashboard and cluster status tooling report health, daemons and capacity. Confirm which alerts your existing monitoring stack must scrape. | Monitoring builds on Kubernetes tooling and the Ceph status interfaces. Confirm how the operator's metrics and alerts integrate with your current cluster monitoring. |
| Authentication for admin access | The Ceph Dashboard supports SAML 2.0 single sign-on, and OAuth2 when cephadm runs the Management Gateway and OAuth2 Proxy services. | Kubernetes access is governed by its authentication methods and RBAC, while Ceph Dashboard access is configured separately. Plan both identity paths. |
| Core skills | Linux administration, systemd, container runtimes, networking for bonded links across switches, and Ceph operations. | Kubernetes administration, custom resource definitions, RBAC, storage classes, etcd operations, and Ceph operations. |
| Failure domain of the control layer | The Ceph management layer runs on the storage hosts, so host maintenance and cluster management share one operational boundary. | The control plane is separate from the storage nodes, but etcd health becomes a dependency for storage provisioning and lifecycle actions. |
How to decide in four steps
This sequence settles who owns the platform, whether the cluster is new or existing, which Ceph release you can support, and who answers pages at night, so the cephadm or Rook choice follows from facts your team has confirmed.
Confirm who owns the Kubernetes platform
Start by establishing whether Kubernetes already exists in your environment and who runs it day to day. If a platform team already operates clusters, storage is usually a question of whether Rook fits that team's workflow. If Kubernetes is not yet in place, or storage is being built for hosts outside any cluster, cephadm on Linux hosts is the route the Ceph installation docs recommend for that case. Done means you have a named owner for the Kubernetes control plane, or a written statement that none exists, and you know whether that owner wants storage managed through Kubernetes APIs.
Decide whether Ceph is new or already running
Determine whether you are building a new Ceph cluster or connecting to one that already exists. Rook can connect a Kubernetes cluster to an existing external Ceph cluster, which changes the decision: the Ceph cluster may keep its current deployment method while Kubernetes consumes its storage. For a new build, you choose between cephadm and Rook as the deployment method. Done means you have written down which case applies and, for existing clusters, the method already in use and who administers it.
Check the Ceph release against support dates
Compare the release you plan to deploy with the lifecycle dates on the Ceph releases page. Squid's estimated end of life is October 31, 2026, so it is a poor choice for a new deployment that must stay supported for long. Tentacle, released November 18, 2025, has an estimated end of life of June 1, 2027. Confirm the current status of any dates with the Ceph project before committing, since they are estimates. Done means the chosen release has a support window that covers your planned go-live and upgrade schedule, and you have recorded the dates you checked.
Map the on-call and upgrade ownership
List who will receive alerts, perform upgrades and respond to incidents for the Ceph cluster, and whether that team already runs Kubernetes operators or Linux host orchestration. cephadm manages the cluster lifecycle through the orchestration interface, while Rook's operator deploys, configures, upgrades and monitors Ceph inside Kubernetes, so the skills required differ. Name a primary and a backup for each layer, including Kubernetes if Rook is chosen. Done means each on-call role has a name, a documented escalation path, and the skills gap, if any, has been identified for training or a support retainer.
Confirm network and hardware through benchmarks
Before buying hardware, confirm the storage network design and sizing with benchmarks on your own workload. The Ceph hardware recommendations advise a dedicated drive per OSD, moving WAL and DB to shared SSDs for HDD-based OSDs, using enterprise-class SSDs for metadata, and bonding network links across two switches. They also advise sizing memory for peak use and benchmarking before buying, because no two clusters are alike. Done means a test plan exists with a workload profile, a benchmark result or pilot measurement, and a signed-off network and drive layout that the deployment method can support.
Common questions about cephadm and Rook
Do I need Rook to run Ceph on Kubernetes?
No. Rook is one recommended route for running Ceph in Kubernetes, and the Ceph installation docs also list cephadm as the recommended method for managing a cluster on Linux hosts. The cephadm documentation points to Rook as the alternative way to deploy Ceph on Kubernetes, so the choice depends on where you want the storage lifecycle managed. Rook uses Kubernetes APIs to provision storage and manage Ceph daemons, which suits teams already operating Kubernetes as their main platform. If you run Ceph on hosts outside Kubernetes, cephadm is the route the Ceph project documents for that layout. Confirm the supported combination for your Ceph release with the Ceph installation docs before you commit.
How much effort does each method take to run?
Effort depends less on the installer than on the operating model your team already has. cephadm manages the cluster as containers on Linux hosts, starting with a bootstrap that creates one Monitor and one Manager, then adding hosts and daemons through the orchestration interface from the CLI or dashboard. Rook asks your team to operate Kubernetes well first, because the operator runs Ceph as Kubernetes resources and depends on the cluster's storage, networking and upgrade discipline. Drivers of effort include the number of hosts, the drive layout (the Ceph hardware recommendations advise a dedicated drive per OSD and separate WAL and DB devices on HDD-based OSDs), network bonding across two switches, and how often you upgrade. Ask any implementer to split the estimate into initial build, upgrades and day-two support.
Can my team run cephadm without outside help?
Yes, a team with Linux administration skills can run cephadm on its own, provided it has the systemd, Python 3 and Podman or Docker prerequisites in place and is willing to learn the Ceph operational model. cephadm does not depend on external configuration tools such as Ansible, Rook or Salt, which keeps the toolchain smaller. The harder parts are sizing memory for peak use rather than calm periods, benchmarking hardware before purchase, planning failure domains and running upgrades in the supported order. Teams without storage operations experience usually find the first year the most demanding. DeployOpen can plan, implement, document and support a self-hosted Ceph cluster inside your own infrastructure under a written, fixed scope, so you can decide which parts your staff owns.
What does Rook external mode require from my Kubernetes cluster?
Rook external mode connects a Kubernetes cluster to a Ceph cluster that already exists elsewhere, so the Ceph cluster is run and maintained outside Kubernetes. The Ceph installation docs list this as one of the two reasons to choose Rook. Your team needs a working Kubernetes cluster with the Rook operator installed, network reachability from the Kubernetes nodes to the external Ceph monitors and services, and credentials and configuration that Rook can use to provision storage. You also need clear ownership of the external Ceph lifecycle, because Rook does not replace the operational work of the external cluster. Check the exact prerequisites, supported Rook and Ceph versions, and credential model with the Rook introduction and in a written scope before you design the network.
How long does a Ceph deployment take?
No deployment duration is stated on this page, because the time depends on your hardware, network design, number of hosts or nodes, integration with identity and monitoring, and how much data migration is involved. Timelines should come from a written scope that lists deliverables, environment checks and acceptance tests, not from a general estimate. Ask for the phases in writing, including hardware validation, bootstrap or operator installation, storage pool and client configuration, testing and handover. Also ask which items depend on your own teams, such as network changes, procurement, and access approvals, because those often set the pace more than the software does. DeployOpen engagements are fixed-scope, so timelines are agreed in writing before work starts.
What skills does my team need to keep Ceph running?
Plan for three skill areas: Linux and network operations, storage fundamentals, and the platform that hosts the cluster. With cephadm, the core skills are Linux host administration, container runtime management, and Ceph concepts such as Monitors, Managers, OSDs and pools. With Rook, the team also needs strong Kubernetes operations, including RBAC, storage classes, upgrades and the Kubernetes version skew rules. Both routes benefit from someone who can read Ceph health output and act on it during an incident. Security skills also matter: the Ceph Dashboard supports SAML 2.0 and, with cephadm's Management Gateway and OAuth2 Proxy services, OAuth2 single sign-on, and messenger v2 can run in a secure mode. Confirm which of these your team already covers before choosing the method.
Can we switch from cephadm to Rook later?
Switching is possible in principle, but it is a migration project, not a configuration change. The two methods manage the cluster lifecycle differently, so moving from cephadm-managed daemons to Rook-managed resources, or the reverse, changes who upgrades, scales and monitors the cluster. Plan for data movement, client reconfiguration, a change window and rollback steps, and confirm with the Ceph and Rook documentation whether a supported path exists for your versions. Keeping the Ceph release, network layout and pool design documented from day one lowers the cost of any later move. Ask any implementer for a written migration plan with a test environment and acceptance checks before you agree to switch in production.
How DeployOpen scopes and runs Ceph deployments
DeployOpen is a Chainscore Labs company that plans, implements, hardens, documents and supports self-hosted open-source platforms inside the client's own infrastructure. For Ceph, the work starts with the deployment method you choose, whether cephadm on Linux hosts or Rook inside Kubernetes, and then covers the storage services, networks and operating processes that surround it.
How we scope
- Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.
- The written scope states whether the cluster runs on cephadm hosts, under Rook in Kubernetes, or as Rook connected to an existing external Ceph cluster.
- Scope lists which interfaces are in use, such as RBD block, CephFS file or RGW object storage, and which identity sources feed them.
- Ask for the scope to name the Ceph release line, the host or Kubernetes versions and the hardware plan agreed with your team.
How we build
- Deployment is carried out inside your own cloud accounts, data centers or air-gapped networks, not on DeployOpen systems.
- Build work covers OSD layout, WAL and DB placement, network bonding and monitor placement, checked against the Ceph hardware recommendations.
- Security testing of the cluster interfaces, dashboard single sign-on and gateway authentication can be included in the written scope.
- Configuration choices such as msgr2 secure mode and RGW authentication are documented as decisions, not left as defaults.
How we hand over
- Handover includes documentation of the topology, upgrade path, backup approach and the owner for each Ceph component.
- Runbooks cover adding hosts or nodes, replacing failed OSDs and performing staged upgrades within your support window.
- Your team receives the operational knowledge needed to run the chosen method, whether cephadm orchestration or Kubernetes-managed Rook resources.
- Compliance evidence, where in scope, is prepared for your assessor, and DeployOpen does not issue audit reports or certifications.
How we support
- Ongoing support, upgrades and continuous testing are available as retainers after handover.
- Retainers can cover tracking of Ceph release end-of-life dates and planning of upgrades before a release line stops receiving fixes.
- Ask any provider, including DeployOpen, to confirm response expectations in writing before you sign, since those terms belong in the contract.
- DeployOpen does not publish a price list, so a retainer quote follows from the written scope and your environment.

