Moving a Kubernetes Estate to the Cloud: Prove the Base, Name Every Byte, Then Cut Over
Software
A platform migration fails on the layer nobody looked at. How our team moves a Kubernetes estate: a proven minimal base, a data audit per workload, and a gate at every phase.
Published November 2026, dated to the month the work was done.
A platform migration rarely fails on the containers. It fails on the layer nobody looked at: the app that loses data on restart, the default path that works only by accident, the credential stored in the wrong place. Copy the workloads first and those faults move with you.
So when our team began moving a production Kubernetes estate from an on-premises cluster to a managed cloud service, we worked in a fixed order. Prove the smallest cloud base. Audit every workload's data against its source code. Then move in waves behind gates, with the existing cluster kept as the authoritative production path until cutover is proven. This post covers that foundation.
Layer one: the smallest base that works
The first step was a deliberately minimal cluster on the target cloud: a managed control plane, a minimal worker pool sized only for validation, simple networking, and a container registry the cluster can pull from without stored passwords. We kept to one x86 architecture so every image build stayed the same.
We treated the new platform as untrusted until each boundary passed a written check:
- The node and all system pods were ready.
- An image pushed to the registry was pulled by the cluster with no stored secret.
- A disk volume bound, and a file written to it survived deleting and recreating the pod. That is the persistence contract file-backed services require.
- A service answered inside the cluster, and a test workload answered from outside the cluster through a shared ingress controller.
A known-good workload stayed up as the reference path for later deployments. A cost check flagged an oversized node disk. We replaced the node pool with a right-sized one and confirmed that the data volume reattached and the endpoint still answered.
The deployment guide from this stage has a few hard rules:
- Build images for one architecture.
- Apps with a single-file database run one replica with a recreate strategy. Never two writers on one file.
- All apps share one public entry point through the ingress, never one load balancer each.
- Secrets come through an approved secret-management path with access control and rotation, never baked into images.
Layer two: know where every byte lives
With the base proven, we audited every workload against its source code: what it reads, what it writes while running, and where that data must live in the cloud. Most workloads turned out to be stateful. One workload was redundant and is out of scope.
The audit found a set of quiet defects, several of them already present in production:
- One writer. Only one app writes to the shared production data. Every other app should mount it read-only, and the writer must never run as two copies.
- Data lost on restart. Some apps had no persistent volume, so their state did not survive a pod restart. Another wrote to a folder it had no mount for.
- Silent defaults. One app stored its database in a temporary folder unless an environment variable said otherwise. It was safe only because the old manifest happened to set that variable.
- Host-specific paths. Hardcoded file paths that would break on Linux nodes.
- Credential handling. Credentials kept outside the secret store, which needed remediation whether or not the migration went ahead.
The last class was treated as stop-the-line, independent of the move.
Layer three: a plan with gates
The plan has six phases, and each one ends with a gate that must pass before the next starts. The existing cluster stays authoritative until cutover criteria, recovery procedures and rollback are proven.
- Phase 0, fix code in place. Credentials out of repositories, paths driven by configuration, persistence defects fixed. The gate: everything still runs on the existing cluster, and a repository search finds no secret.
- Phase 1, cloud infrastructure. Node pool, namespace, volumes, secrets provisioned through the approved secret-management path, certificates and a test domain.
- Phase 2, data seed. Copy from the live cluster volumes, then verify file count, total size and sample checksums.
- Phase 3, read-only apps first. They cannot damage data, so they go first, each validated against the existing cluster through functional and data checks.
- Phase 4, sign-in and stateful apps. Sign-in first, then the stateful apps, and the single data writer last.
- Phases 5 and 6, dual-run and cutover. Both clusters run in parallel with daily parity checks, then a DNS switch, with the source cluster frozen as a fallback for a defined window.
One gate earned its place early. An early seed plan used an offline copy of the data. Measured against the live volume, it was out of date and held far fewer files. It failed the freshness contract. The plan now states it plainly: seed only from the live volumes, and the numbers must match.
What the design guarantees
Two sizing choices follow the rule of matching what already works. One node pool instead of two, because the existing estate already runs on a single worker pool, and resource limits plus a quota give enough separation. And no long-term price commitment until monitoring confirms the size.
The larger point is order. This is Governance-Driven Contract Design applied to a migration. Name the outcome: every workload keeps its data and its behavior. Write the guarantees: one writer, persistent state, no secret outside the store. Check them at every gate. Moving containers is the easy part. Knowing which app writes which data, and fixing the quiet defects before they follow you to the new platform, is what decides whether the move holds.
Platforms will change again. The contract has to survive every move. Every line holds.