Ceph vs Longhorn

Longhorn fits teams that need replicated block volumes for a Kubernetes cluster with modest storage scope. Ceph through Rook fits teams that need block, file and object storage from one cluster and can staff its operations.

On this page

Ceph vs Longhorn: when each one is the right Kubernetes storage choice

Longhorn is per-volume replicated block storage that runs on Kubernetes, and Ceph is a unified block, file and object system that you deploy on Kubernetes through Rook. That single difference shapes most of the decision. Longhorn gives each volume its own storage controller and replicates it synchronously across nodes, so the scope stays narrow: persistent block volumes for your workloads. Ceph stores everything on one RADOS cluster and serves RBD block devices, CephFS file systems and the RGW object gateway from it, which makes it a larger system to size, tune and operate. The choice turns on three questions: how many storage interfaces your platform must serve, what hardware and staffing you can commit, and whether backups will go to S3-compatible storage or NFS.

Start with the interface count. If every requirement is ReadWriteOnce block volumes for databases and stateful services, Longhorn covers the need with fewer moving parts. If you also need shared file access for many pods, or S3 endpoints for applications and backup targets inside the cluster, Ceph's single-system design removes the need to run separate products. Next, check the hardware. Ceph's hardware recommendations call for a dedicated drive per OSD, WAL and DB on shared SSDs for HDD-based OSDs, enterprise-class SSDs for metadata, bonded network links across two switches, and memory sized for peak use. Confirm with your hardware vendor and a benchmark on your own nodes before buying, because the project notes that no two clusters are alike. Longhorn places fewer demands on the storage layout, but you still need to plan replica placement and node capacity for your volume sizes.

Then decide where backups go. Longhorn's README lists backups to NFSv4 or S3-compatible storage with change block detection and recurring snapshot and backup schedules, so a team with an existing NFS appliance or an object store can often use it directly. Ceph's RGW exposes S3 and Swift APIs, which suits organizations that want one storage platform for both workloads and backups. Before you commit, test a full restore from your chosen target, not only a successful backup job. Finally, match the choice to your team. Running Ceph well means someone must understand monitors, OSDs, placement groups and upgrade paths, and the Ceph releases page lists Squid's estimated end of life as October 31, 2026, so plan the next upgrade early. Confirm your Kubernetes version support window on the Kubernetes releases page when you pick a storage release train.

Which storage fits each Kubernetes scenario

This table maps common Kubernetes storage scenarios to the platform that usually fits better, with the reason and the condition that makes the advantage matter. Read each row against your own node count, workload mix and team skills, because the better fit changes as those inputs change.

ScenarioBetter fitWhy
A single block volume class for stateful appsLonghornLonghorn gives each volume its own storage controller and replicates it synchronously across nodes, so one block class with few moving parts covers the need. This matters when block is the only storage interface you require.
S3-compatible object storage in the same clusterCephCeph Object Gateway (RGW) provides S3 and Swift APIs on the same RADOS cluster that serves RBD and CephFS. Longhorn stores backups in S3 but does not serve S3 as a general object store for applications.
Shared file storage for multiple podsCephCephFS on the same RADOS cluster serves file access to many pods. Choose Ceph when several workloads need shared file access and you can operate the cluster, since Longhorn's README centers on block volumes.
A small cluster with few nodesLonghornLonghorn runs on the Kubernetes nodes you already have and avoids the separate storage layer Ceph needs. The advantage holds while node count and data volume stay modest, and you should confirm replica placement for your node count.
A large cluster with dedicated storage hardwareCephCeph's hardware guidance favors a dedicated drive per OSD, shared SSDs for WAL and DB on HDD-based OSDs, and bonded links across two switches. This pays off when you can dedicate hardware and benchmark before buying.
A team with no Ceph experienceLonghornCeph's cluster design, sizing and network layout require storage expertise. Longhorn has a smaller operating surface and a GUI dashboard, which helps when storage skills are new to the team. Plan training either way.
Backups to S3 or NFS with scheduled snapshotsLonghornThe Longhorn README lists backups to NFSv4 or S3-compatible storage with change block detection and recurring schedules. Confirm the backup target and restore procedure in your environment before relying on it.

How Ceph through Rook and Longhorn are built and what that means for operations

Ceph through Rook and Longhorn both give Kubernetes persistent volumes, but they get there by different routes. One spreads a storage system across many daemons and pools, the other attaches a controller to each volume. The cards below set out those designs and the operating work each one creates after go-live.

Per-volume controllers in Longhorn

Longhorn gives each volume its own storage controller and replicates that volume synchronously across nodes. The failure domain stays small, so one volume's trouble does not spread through a shared cluster map. Check how replica count, node placement and disk pressure are monitored per volume, because the number of volumes grows with the workload and each one needs watching. Ask how replica rebuilds behave when a node is drained during an upgrade.

One RADOS cluster, three interfaces

Ceph stores data in a single RADOS cluster and exposes it as RBD block devices, CephFS file systems and RGW object storage. Consolidating three interfaces on one cluster reduces the number of storage platforms to run, but every interface depends on the same monitors, OSDs and placement rules. Plan capacity and failure testing for the whole cluster, not for each service separately, and confirm which interfaces your workloads will actually use.

Rook as the Kubernetes route

Rook is the operator path for running Ceph inside Kubernetes, and the CNCF lists it as Graduated since October 7, 2020. Rook moves Ceph lifecycle work into Kubernetes custom resources, so upgrades and daemon placement follow cluster GitOps workflows. Teams should confirm which Ceph version a given Rook release supports, and who on the platform team can debug Ceph itself when the operator layer hides a failing daemon.

Drives, WAL and DB placement

Ceph's hardware guidance calls for a dedicated drive per OSD, moving WAL and DB onto shared SSDs for HDD-based OSDs, and enterprise-class SSDs for metadata. Bonded network links across two switches are also advised. These choices set the performance and failure behavior of the cluster, and they are hard to change after data is written. Ask your hardware vendor and your Ceph partner to confirm the layout against your workload before purchase, and benchmark it.

Memory sized for peak use

Ceph's hardware recommendations say to size memory for peak use rather than calm periods, because recovery and rebalancing after a failure drive memory use well above steady state. Longhorn's footprint is spread across the nodes that host its volumes, so memory pressure shows up differently. Budget for rebuild events in your capacity plan, and ask both vendors to document expected memory during recovery at your cluster size.

Tentacle and Squid release lines

Ceph Tentacle (v20) was released on November 18, 2025 with estimated end of life June 1, 2027. Ceph Squid (v19) reaches estimated end of life October 31, 2026. Squid's window closes first, so a cluster built on it will need an upgrade plan before that date. Treat the end-of-life dates as estimates and confirm them on the release page before scheduling work, because upgrades on a storage cluster need testing and a rollback path.

Side-by-side capabilities: Ceph and Longhorn

This table sets Ceph (deployed through Rook) against Longhorn on license, storage interfaces, backups, upgrades, identity and transport security. Where the supplied facts do not cover a Longhorn row, the cell tells you what to confirm in the Longhorn documentation before deciding. Read it as a checklist of requirements: a gap in one column is a question to put to the vendor, not a verdict.

CapabilityCeph (through Rook)Longhorn
LicenseLGPL-2.1 or LGPL-3.0 for most of the source, with some bundled components under other licenses; no paid edition from the projectApache-2.0
CNCF statusRook is a CNCF Graduated project (since October 7, 2020); Ceph itself is not listed as a CNCF project in these factsCNCF Incubating
Storage interfaces (block, file, object)Block (RBD), file (CephFS) and object (RGW S3 and Swift APIs) on one RADOS clusterBlock storage per volume on Kubernetes; confirm any file or object interface in the Longhorn documentation
Snapshots and backupsSnapshot and backup behavior depends on the interface in use; confirm the exact workflow for your Rook versionIncremental snapshots and backups with change block detection
Backup targetsRGW S3 API for object storage use; confirm how your Kubernetes volumes are backed up in your Rook setupS3-compatible storage or NFSv4
Recurring schedulesConfirm scheduling options for your Rook and Ceph versions before relying on themRecurring snapshot and backup schedules
Upgrade behaviorUpgrades run through the Ceph release lifecycle; plan around the Squid and Tentacle end-of-life datesNon-disruptive upgrades per the Longhorn README; confirm the steps for your cluster size
GUI or dashboardCeph Dashboard, with SSO options listed in the identity rowGUI dashboard included
Identity integrationCeph Dashboard: SAML 2.0, and OAuth2 when cephadm runs the Management Gateway and OAuth2 Proxy. RGW: Keystone, LDAP, multi-factor authentication and Open Policy Agent integrationConfirm SSO and RBAC options for the Longhorn UI and API in the Longhorn documentation
Messenger encryptionmsgr2 secure mode on port 3300 encrypts all post-authentication traffic with AES-GCM and adds integrity checksConfirm how traffic between Longhorn components is encrypted in your environment
Latest releaseTentacle 20.2.4 (end of life June 1, 2027) and Squid 19.2.7 (end of life October 31, 2026), per the Ceph releases page1.13.0, per the Longhorn README

How identity, access and extensibility differ between the two

Identity matters most for Ceph once object storage is shared with applications or teams outside the cluster. The Ceph Object Gateway (RGW) supports Keystone and LDAP authentication, multi-factor authentication, Open Policy Agent integration, and AWS STS, IAM and SNS APIs, so access can follow the directory and policy tools you already run. The Ceph Dashboard supports single sign-on through SAML 2.0, and OAuth2 only when cephadm runs the Management Gateway and OAuth2 Proxy services. Before you choose Ceph for this reason, list which of these paths your administrators and applications need and confirm each one in your Ceph release. The supplied facts do not cover Longhorn's identity features, so confirm with the Longhorn project how its UI and API authentication and any single sign-on work in the version you plan to run.

Storage access also depends on the Kubernetes layer, which handles most of the identity work either way. Kubernetes does not store normal users as API objects. It authenticates them with X.509 client certificates, bearer tokens including OpenID Connect and JWT, webhook token authentication, or an authenticating proxy. Secrets are stored unencrypted in etcd by default, and Ceph credentials such as RGW access keys and Rook configuration typically reach pods as Kubernetes Secrets. The storage choice does not replace encryption at rest or least-privilege RBAC. Ask your platform team to enable encryption at rest, restrict list and watch access to Secrets, and decide whether an external store fits better. Apply the same controls to Longhorn, because the risk sits in the cluster, not the storage engine.

Extensibility is where Ceph offers the most room to grow. RGW provides S3 and Swift compatible APIs, compression, and documented multisite configuration, which lets object data replicate between Ceph clusters in separate sites. Multisite is worth its added complexity when you need replicated object storage across sites, a second site for failover or a regional data placement requirement. If your need is only protection against node or disk loss within one site, it adds effort without a clear benefit. Longhorn's documented extensibility centers on snapshots, backups to NFSv4 or S3-compatible storage and recurring schedules. Confirm with the Longhorn project whether it offers any cross-site replication beyond backups before you assume a gap or a match. The Ceph Object Gateway documentation lists the multisite and authentication options to check against your requirements.

What the licenses and editions of Ceph and Longhorn cost you

Ceph's source code is licensed under LGPL-2.1 or LGPL-3, written in SPDX form as LGPL-2.1-only OR LGPL-3.0-only, according to the Ceph COPYING file. The project does not sell a paid edition, so the software itself carries no license fee. Some bundled components are under other licenses, and your legal team should review the full set of components you deploy rather than relying on the headline license alone.

  • Source license: LGPL-2.1 or LGPL-3 (SPDX LGPL-2.1-only OR LGPL-3.0-only), as stated in the COPYING file.
  • Bundled components: some parts of the codebase ship under other licenses, so review them when you build your bill of materials.
  • No project paid edition: the Ceph project offers no commercial tier of its own, so any paid support comes from a third party.
  • Active release lines: the Ceph releases page lists Tentacle (20.2.x, first released November 18, 2025, estimated end of life June 1, 2027) and Squid (19.2.x, first released September 26, 2024, estimated end of life October 31, 2026).
  • Upgrade horizon: the Squid end-of-life date falls within a short window, so plan an upgrade path to Tentacle or a later release before it passes.

Confirm the current end-of-life dates on the releases page before you commit, since they are estimates and the project may update them. Ask your support provider which Ceph release lines it covers.

What drives the running cost of Ceph and Longhorn

The running cost of Ceph and Longhorn is set less by the software license, since both are open source with no paid edition from the project itself, and more by the hardware, the people who operate the cluster and the backup capacity behind it. Split the cost into one-time items (architecture and design, hardware purchase, deployment, and any migration from existing storage) and recurring items (day-two operations, upgrades, support contracts, and backup capacity that grows with retention). For Ceph, the hardware bill is driven by the dedicated drive per OSD rule, by moving WAL and DB onto shared SSDs for HDD-based OSDs, by enterprise-class SSDs for metadata, and by bonded network links across two switches. For Longhorn, the cost sits in extra local disk on each node, because every volume keeps its own replicas, so replica count multiplies capacity use.

Memory and network are the costs teams most often underestimate. The Ceph hardware recommendations say to size memory for peak use rather than calm periods, so the cost of a cluster is set by its worst recovery event, not its average load. Recovery and rebalancing also consume network bandwidth, which is why bonded links matter. Staff time is the largest recurring cost in most environments. Ceph usually needs a team that can read cluster health, manage placement and recovery, and handle cephadm or Rook upgrades, while Longhorn asks for Kubernetes skills and careful management of replica counts and backup schedules. Each Ceph and Longhorn release cycle brings an upgrade effort, and Ceph's Squid and Tentacle lines carry different estimated end of life dates, so plan upgrades as a recurring budget line, not a one-time event.

Backups add a recurring cost on both sides. Longhorn can send backups to NFSv4 or S3-compatible storage with change block detection, and Ceph's Object Gateway can host backup targets, so the cost is the capacity and retention policy you choose. Before buying anything, benchmark on representative workloads, because the Ceph hardware guidance states that no two clusters are alike. When you ask for a quote, request: hardware sizing scoped to your workload and failure domains, a backup design that names the target (S3 or NFS), retention and restore testing, a written upgrade plan covering the release cycle, the support tier and its response terms, and a clear statement of who runs operations after handover. No price or duration is supplied for either option in this comparison, so treat any figure you hear as something to confirm in writing with the vendor or integrator.

How to move persistent volumes from Longhorn to Ceph or back

This sequence moves Kubernetes persistent volumes between Longhorn and Ceph through Rook in a controlled order, so each workload reaches its new storage only after its backups have been restored and checked. The result is a verified cutover with the old storage retired last.

  1. Confirm storage interfaces for each workload

    Before any move, list every workload that uses persistent storage and record which interface it needs: block (RBD-style volumes), shared file (CephFS-style access) or S3-compatible object storage. Longhorn provides block volumes, so workloads that expect ReadWriteMany file access or object buckets need a different target design, and the platform team should agree that list with application owners. The step is done when each workload has a documented interface, access mode and owner, and the team has confirmed which of those Rook and Ceph will provide in the target cluster.

  2. Deploy and benchmark the target cluster

    Deploy the target storage in a separate or staged set of nodes using Rook, following the Ceph hardware recommendations for dedicated drives per OSD, shared SSDs for WAL and DB on HDD-based OSDs, and bonded network links across two switches. Run a benchmark with workload-like I/O before any data moves, since the Ceph project advises benchmarking before buying because no two clusters are alike. The step is complete when the benchmark results are recorded against the latency and throughput each workload needs, and the team accepts the result or changes the design.

  3. Validate backups and restore a test volume

    On the source side, confirm that recurring Longhorn backups reach the chosen NFSv4 or S3-compatible target and that the backup sets are complete for each volume. Restore one representative volume into a test namespace on the target cluster, then start the workload against it and check data integrity with the application owner. Confirm the restore path with the Longhorn and Rook documentation first, since no migration tool is named in the supplied facts. The step is done when a restored volume passes an agreed data check and the restore steps are written down.

  4. Rebuild platform services on the target

    Recreate what does not move with the data: StorageClasses and their parameters, backup targets and schedules, monitoring dashboards and alerts for the new storage, and access policies covering who can create, restore and delete volumes. Manifests and Helm values for workloads transfer through Git, but StorageClass names and volume parameters usually need editing to point at the target. The step is complete when a test claim provisions, mounts and snapshots on the target, and alerts fire in a controlled test.

  5. Move non-critical workloads first

    Migrate the lowest-risk workloads first, such as development or internal tools, using the restore procedure validated earlier. For each workload, scale it down, take a fresh backup, restore into the target StorageClass, update the manifest or Helm values to reference the new claim, and scale it back up. Record the time each cutover takes and any errors, which become the runbook for the stateful steps that follow. The step is done when those workloads have run on the target for an agreed observation period and no data issues appear.

  6. Migrate stateful volumes in a tested backup window

    For critical stateful workloads, schedule a window agreed with the application owners, stop writes, take a final backup of each volume, verify the backup set, restore it to the target and run the application's own consistency checks before routing traffic. Keep the source volumes intact and read-only until the cutover is accepted, so rollback is possible. The step is complete when each workload passes its checks on the target and the rollback path has been tested or explicitly accepted as untested.

  7. Retire old storage after verified cutover

    After every workload has run on the target through an agreed observation period, remove the old Longhorn volumes, backup schedules and related monitoring, and keep one final backup set according to the organization's retention policy. Update documentation, access reviews and inventory so no workload still points to the old StorageClass. The step is done when a final inventory shows zero claims on the old storage and the decommission has been signed off by the platform and application owners.

Where Ceph and Longhorn implementation projects usually run long

Ceph projects on Kubernetes usually slip in sizing and network design, not in installation. The Ceph hardware recommendations advise a dedicated drive per OSD, moving WAL and DB onto shared SSDs for HDD-based OSDs, enterprise-class SSDs for metadata, and bonded network links across two switches. Each of these choices changes the bill of materials, so the hardware order is often placed before anyone has benchmarked the workload. The same guidance says to size memory for peak use rather than calm periods and to benchmark before buying, because no two clusters are alike. Ask for a written sizing exercise and a benchmark plan before procurement, and confirm the switch topology needed to bond links across two switches in your own racks.

The second common slip for Ceph through Rook is the release line. Ceph Squid (v19) reaches estimated end of life on October 31, 2026, and Ceph Tentacle (v20) on June 1, 2027, according to the Ceph releases page. A deployment that starts on a line close to end of life may need an upgrade within months of go-live, which adds a change window and a validation cycle. Staff learning curves add time too, because cephadm and Rook each manage the cluster lifecycle in their own way, and the Rook operator sits inside Kubernetes alongside the team's existing workloads. Plan training and a rehearsal of failed OSD and failed host replacement before production data arrives.

Longhorn projects slip for different reasons. Replica placement and backup schedules look simple in the Longhorn settings but need checks: confirm that replicas land on distinct nodes, that recurring snapshot and backup schedules run to an NFSv4 or S3-compatible target, and that a restore has been tested into a separate namespace. Longhorn's Kubernetes dependency also needs attention, since the Kubernetes project maintains 1.37, 1.36 and 1.35 as of September 2026, according to kubernetes.io/releases. Align the Longhorn release with the cluster version before the upgrade plan is written. Node failure tests should be scheduled as a named deliverable, covering drain, power loss and network partition scenarios. DeployOpen plans and implements these in the client's own infrastructure, and scope, deliverables and timelines are agreed in writing before work starts.

Questions teams ask before choosing Ceph or Longhorn

How much more effort does running Ceph take compared with Longhorn?

Ceph takes more effort, because it is a full distributed storage system with monitors, managers, OSDs and separate block, file and object services, while Longhorn is a storage layer that installs into Kubernetes and manages a controller per volume. The Ceph hardware recommendations call for a dedicated drive per OSD, shared SSDs for WAL and DB on HDD-based OSDs, enterprise-class SSDs for metadata and bonded network links across two switches. Longhorn's effort concentrates on node disks, replica count, backup targets and upgrades. Your effort depends on how many nodes you run, how many workloads depend on the storage and how often your team changes the cluster. Ask any vendor, including DeployOpen, to walk through the day-two tasks for both options in your environment before you compare quotes.

Can our team run Longhorn without outside help?

A team with solid Kubernetes operations skills can often run Longhorn in-house, provided it can handle node disk planning, backup target configuration, recurring snapshot and backup schedules, and upgrades. Longhorn's README lists incremental snapshots, backups to NFSv4 or S3-compatible storage with change block detection, and non-disruptive upgrades, but those features still need an owner who knows how volumes behave during node failure and rebuild. Check whether your staff have run stateful workloads on Kubernetes before, who will be on call for storage incidents, and whether you have tested restores. DeployOpen can plan, implement, document and support Longhorn inside your infrastructure under a written scope, and the handover can be designed around whichever tasks your team keeps.

Does Ceph have to run through Rook inside Kubernetes?

No. Ceph can run in a separate cluster, and the cephadm documentation describes deploying it as containers on Linux hosts, bootstrapping a single-node cluster with one Monitor and one Manager and then adding hosts and services. Rook is the route the Ceph documentation points to for Kubernetes, and Rook's option to connect Kubernetes to an existing external Ceph cluster lets you separate the storage lifecycle from application clusters. The choice affects who upgrades Ceph, how failures are isolated and which skills the team needs. Before deciding, confirm which deployment method fits your network, your change control and your Kubernetes platform. A dedicated comparison of cephadm and Rook covers this decision in more depth.

How long does a migration from Longhorn to Ceph take?

No migration duration is supplied for this comparison, so treat any figure you hear with caution. The time depends on the volume of data, how many persistent volumes and applications are involved, how much downtime each application tolerates, whether you run a parallel cluster during cutover, how much new hardware must be installed and configured, and how many restore tests your change process requires. Application-level dependencies, such as databases that need consistent snapshots, often take longer than the data copy itself. Ask for a written plan that lists each workload, its cutover method, its rollback path and the verification steps. DeployOpen delivers fixed-scope work agreed in writing before it starts, so the timeline follows from that scope.

What should a quote for Ceph or Longhorn work include?

A useful quote lists the scope, the deliverables and the timeline in writing, because DeployOpen works from an agreed scope and does not publish a price list. Ask for the hardware and network assumptions, the Ceph or Longhorn versions and their support windows, the backup target design, the identity and access integration, the test plan for restores and failure scenarios, the documentation and knowledge transfer, and any handover to ongoing support. Separate one-time work, such as design, installation, migration and testing, from recurring work, such as upgrades, monitoring and retainer support. Also ask which items are excluded, such as hardware purchases or third-party licenses, so you can compare bids on the same basis.

Can one Ceph cluster serve both block storage and S3 needs?

Yes, Ceph provides object (RGW), block (RBD) and file (CephFS) storage on a single RADOS cluster, and the Object Gateway offers S3-compatible and Swift-compatible APIs. Sharing one cluster reduces the number of storage platforms to run, but it also means block, file and object workloads compete for the same hardware and must be sized together. The hardware recommendations advise benchmarking before buying because no two clusters are alike, and memory should be sized for peak use. Longhorn is a block storage system for Kubernetes volumes, and its backups can go to S3-compatible storage, but it does not serve S3 as a general object store. Confirm your workload mix, sizing targets and failure domains before you decide to consolidate.

How does the Kubernetes version policy affect Ceph and Longhorn?

Both depend on the Kubernetes version you run, so the upgrade plan must cover the platform and the storage together. Kubernetes releases about three times per year on a cycle of roughly 14 weeks, and the project maintains only the three most recent minor releases, with 1.37 supported until October 28, 2027. The version skew policy requires kube-apiserver to be upgraded one minor version at a time before the other control plane components and kubelets, and kubelets may be up to three minor versions older. Ceph Tentacle's estimated end of life is June 1, 2027 and Squid's is October 31, 2026, so check the Ceph and Longhorn compatibility matrices against your planned Kubernetes version before scheduling upgrades.

Can DeployOpen run storage operations after handover through a retainer?

Yes, ongoing support, upgrades and continuous testing are available as retainers, so DeployOpen can take on recurring operations after the initial implementation. The retainer scope should state which tasks are included, such as Ceph or Longhorn upgrades, backup restore testing, capacity reviews, incident response and documentation updates, and which remain with your team. Ask how response is organized, what access DeployOpen needs in your infrastructure and how changes are approved. Because DeployOpen works inside your own cloud accounts, data centers or air-gapped networks, confirm where operational data and credentials are held before you sign.

How DeployOpen helps teams choose and implement Ceph or Longhorn

DeployOpen is a Chainscore Labs company that plans, implements, customizes, integrates, hardens, backs up, upgrades, documents and supports self-hosted open-source platforms inside the client's own infrastructure. For Ceph vs Longhorn, the work starts with the storage requirements and the team's skills, then moves to a written scope before any build begins.

How we scope

  • Record the workloads, volume counts, access types (block, file or object) and performance targets before choosing a storage system.
  • Confirm hardware, network layout, Kubernetes distribution and existing backup targets such as S3-compatible storage or NFS.
  • Agree deliverables, timelines and responsibilities in writing, since most engagements are fixed-scope.

How we build

  • Deploy the chosen option, either Ceph through Rook or Longhorn, inside the client's cloud accounts, data centers or air-gapped networks.
  • Test replication, failure handling, snapshot and backup schedules, and restores against the agreed requirements.
  • Harden the storage layer and integrate it with the existing identity, monitoring and backup tooling where the client requires it.

How we hand over

  • Document the architecture, configuration, backup and restore procedures, and the upgrade path for the selected release.
  • Run a knowledge transfer so the client's operations team can perform routine tasks and recognize failure states.
  • Prepare the controls and evidence the client's compliance assessor may request, without issuing audit reports or certifications.

How we support

  • Offer ongoing support, upgrades and continuous testing as a retainer after handover.
  • Plan storage upgrades around the vendor's published release and end-of-life dates, confirmed at the time of work.
  • Repeat restore tests and security testing on a schedule the client agrees, so evidence stays current.

Sources and further reading

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.