Kubernetes migration goes smoother when you fix settings, data, access and rollback first. Get the checklist to run before you move.

Kubernetes Migration: What to Fix Before You Move Workloads, Not After

Kubernetes migration goes wrong when you move problems you haven’t fixed: hard-coded settings, data stored on the server, no health checks, wide-open access and no rollback plan. Fix those before you move, and the migration itself is far less painful.

This is for IT managers and owners planning to move applications onto Kubernetes who want a pre-flight checklist. Pansoft’s Kubernetes page covers the service itself.

What should you fix before a Kubernetes migration?

Six things, in roughly this order. They’re cheaper to fix while the application still runs where it does today, and some of them decide whether you can undo the move.

Fix first Why it matters on Kubernetes What to check
Hard-coded settings The same build should run anywhere, with settings held outside the code Can one build run in test and production by changing only its environment?
Data on the server Pods are replaced, so anything stored locally can disappear Where does the app write files and sessions?
Health checks Kubernetes can run liveness, readiness and startup probes Does the app expose something a check can call?
Resource needs Production guidance expects limits set through container resources Do you know how much memory and CPU it needs?
Access and secrets The Kubernetes security checklist covers RBAC, network policies and secrets Who can do what in the cluster?
Rollback Some release patterns make going back straightforward How would you reverse the move?

Fix settings, data and rollback before anything else, because they decide whether the move is reversible. Health checks, sizing and access matter just as much, but you can tune them in the new cluster. Don’t leave them until after go-live.

Why do settings and data cause the most trouble?

Because Kubernetes replaces and reschedules containers constantly, and an application that depends on one machine’s disk or one machine’s config file doesn’t survive that. Kubernetes is container orchestration, so it expects containers you can stop, copy and replace.

The Twelve-Factor App, a well-known set of habits for software that runs as a service, says to keep settings out of the code and to avoid storing user sessions on the server itself. Its site was last updated in 2017, so treat it as a foundation, not the last word.

For applications that really do need persistent storage or a stable network identity, Kubernetes offers StatefulSets. The documentation lists some limits worth knowing. Storage has to be provisioned by a provisioner or an admin. Scaling down or deleting a StatefulSet doesn’t delete its volumes, deliberately, to protect data. And you have to create the headless Service that gives pods their network identity. None of that is hard, but nobody should discover it during cutover.

What does the cluster itself need?

An answer to availability, scale and access, before workloads arrive. Kubernetes’ production guidance describes a single-machine cluster as a single point of failure, and describes a highly available one as having the control plane separated from worker nodes, replicated across machines and load-balanced, with enough worker nodes to cope as demand changes.

That’s kubernetes architecture in a sentence. The same page says shared clusters with important workloads need more than full admin access for everyone, and recommends role-based access control and policies, plus limits on container resources.

Should you run it yourself or use a managed service?

Usually use a managed one, unless you’ve a reason not to. Kubernetes’ own guidance lists a spectrum, from serverless, to a managed control plane, to managed worker nodes, with each step handing more upkeep to the provider.

Managed Kubernetes services shift the patching and upgrades, not the accountability. Amazon’s EKS documentation, for example, says AWS runs the control plane across three Availability Zones and manages the API servers and etcd. With self-managed nodes, you patch and upgrade them yourself, and AWS recommends infrastructure as code tools to make upgrades easier. Microsoft’s cloud-native guidance adds that self-managing Kubernetes can be complex, and that you always keep your own data, configuration and identities.

How do you keep the move reversible?

Deploy to every environment the same way, and keep a way back. continuousdelivery.com recommends one deployment process everywhere, smoke tests after each deployment, and blue-green deployment as a pattern that enables rollback.

A migration is a good time to tighten the pipeline. Scan images and handle secrets as part of the build, which is where DevSecOps practices earn their keep. Kubernetes’ security documentation also covers images and verifying signed artifacts.

What does it look like in practice?

Picture a 35-person property inspection software company with one large application that stores uploaded photos on the server’s own disk. This is a hypothetical, not a client story. Move it to Kubernetes as it stands and the photos live and die with whichever container wrote them.

The fix comes first. Move uploads to shared storage, give the app a way to report that it’s healthy, and move its settings into the environment. Then the move is just a deployment.

What should you ask a provider?

Ask what they’ll fix before they move anything. Searching for a Kubernetes service Australia wide, or for CI/CD pipeline consulting Australia wide, returns plenty of names. For the wider picture, see Pansoft’s DevOps page, and if you’d like a second opinion before committing, DevOps consulting is a sensible first step.

  • What will you change in the application, and what won’t you touch?
  • Where will data live after the move?
  • Who owns upgrades and patching afterwards?
  • How will we reverse it? Walk through it.
  • Can you migrate one low-risk service first?

Quick questions

Can we migrate a stateful database to Kubernetes?
Yes, but it’s the hardest case. Kubernetes offers StatefulSets for applications that need persistent storage or a stable identity. Keeping the database outside the cluster at first is a legitimate choice. Decide deliberately, and rehearse recovery before you rely on either option.

How do we avoid downtime during a migration?
Run the old and new environments side by side, move traffic gradually, and keep the ability to switch back. Rehearse the cutover before the real one, because the plan nobody has tested is the one that surprises you. Agree who makes the call to roll back.

How long does a Kubernetes migration take?
It depends on how many applications you have and how much needs fixing first, so be wary of fixed answers from anyone who hasn’t seen them yet. Migrating one low-risk service first gives you real evidence for planning the rest.

Want to talk it through?

If you’re planning a move to Kubernetes, there’s no pressure. Pansoft can look at what you run today and what needs fixing before it moves. You can get in touch whenever suits you.

Leave A Comment