Cloud computing is in a constant state of flux. Prices shift. Capacity comes and goes by region, and instances of almost any type can be hard to find in a particular place on a particular day. The architecture that was right for your cluster in January may not be right by June.
So we're giving you a choice. Cloud Native Qumulo can now be deployed on Azure Cobalt, Microsoft's own Arm-based processor family, as well as on x86. Run on one, and convert to the other whenever your needs, your pricing, or your availability change.
Flexibility is the point
Cobalt is Microsoft's own Arm-based processor, engineered in-house for Azure, and it offers a higher price-to-performance ratio than x86 in any event. That means choosing it is rarely a sacrifice. You can deploy on Cobalt from day one. You can deploy on x86 and convert later. You can move back again if the math, or the capacity in your region, changes. Cobalt isn't offered in every Azure region, so where it isn't, x86 is still there. That is the point of having the choice.
One of CNQ's core strengths is dynamic scalability: add compute when a workload needs more performance, scale back when it doesn't, and never move the data. That elasticity is only as good as the instances available to scale into. With both architectures on the table, you scale into whichever instances are available, and affordable, at the moment your workload demands them.
Better price-performance results too
Running CNQ on Cobalt-based nodes delivers more performance per dollar than equivalent x86 instances. How much depends on your region, instance family and purchase model, so model it for your own configuration.
Since you pay Azure directly for CNQ compute resources, those savings go straight to your Azure bill. Your Cloud Native Qumulo subscription works just as well on either platform.
Nothing else changes
This is the same CNQ, and that's deliberate:
The same software and features. Single namespace, multi-protocol access over SMB, NFS, and object, along with snapshots, quotas, replication, and Cloud Data Fabric – all of them work the same on Cobalt as on x86.
Nothing for applications to change. The processor only affects the cluster nodes. Clients keep connecting over the same NFS, SMB, and object access protocols as before, so there is nothing to refactor.
No licensing or marketplace changes. You choose a Cobalt instance type when you deploy, and nothing else about how you buy or license CNQ is different.
For sustained operations, CNQ does best when all nodes are the same processor type and configuration. CNQ nodes share a global cache and networking behavior, so running Arm and x86 nodes side by side over the long term can cause inconsistent performance for clients.
Switch whenever you need to
Converting a cluster is easy, and you can do it in either direction. A full cluster replace lets you switch to all-new Cobalt instances (or back to x86) while the CNQ system is running, without rebuilding it or even shutting it down. Because CNQ keeps its data in cloud object storage, only the compute changes, and the data doesn't move.
Under the hood, you can perform a rolling replacement. The two architectures can run side-by-side for the brief window it takes to replace all the nodes from one family with new nodes from the other. When the last node has been replaced, the cluster is back on a single architecture, just as it should be.
Deeper into Azure
CNQ on Cobalt is one more layer in the level of integration we've built with Azure. Running on Microsoft's own silicon means the data layer and the cloud it runs in are designed to fit each other, with full feature parity at a higher price-to-performance ratio.