Running on Kubernetes?

Kubernetes cluster too big or too broken? We sort it out.

Most clusters that land in our lap were sized for traffic that never arrived, run twice the nodes they need, and have nobody left who remembers why. We cut it back to what the workload actually requires, without a rewrite of your applications.

  • Since 2015Fixing technology
  • FreeEstimates
  • US teamReal engineers

kubectl-events.log

still failing

What it is

Kubernetes at a glance

Kubernetes, often shortened to K8s, is an open-source container orchestrator: software that schedules containers across a group of machines and keeps them running the way you declared. Google open-sourced it in June 2014 based on their internal Borg system, and it now sits under the Cloud Native Computing Foundation.

It automates the deployment, scaling and day-to-day operation of containerised applications across a cluster. The core objects you work with are Pods, Services, Deployments, ReplicaSets, DaemonSets, StatefulSets, Jobs, CronJobs, Ingress and PersistentVolumes. Every big cloud offers it as a managed product: EKS on AWS, AKS on Azure, GKE on Google Cloud, DOKS on DigitalOcean. Releases come out roughly every three months, with one year of support per minor version.

Type
Container orchestrator
First released
2014 public release
License
Apache 2.0, free and permissive
Maintained by
The CNCF and a wide group of contributors
Typically used for
Containerised microservices, batch workloads, platform engineering, hosting many applications on shared infrastructure

The honest version

Kubernetes pros and cons

No technology is all upside. This is where Kubernetes earns its place and where it tends to cause trouble.

Where Kubernetes is strong

  • The industry standard for orchestrationEvery major cloud, vendor and tooling ecosystem assumes Kubernetes exists. Hiring people who have used it is far easier than finding people for bespoke setups.
  • You describe the end state, not the stepsDeclarative manifests tell the cluster what should be running. The control loop keeps bringing reality back toward that description without manual intervention.
  • It heals small failures on its ownCrashed pods are replaced, failing nodes are drained, and unhealthy containers are restarted without a human noticing most of the time.
  • Scaling is a first-class featureHorizontal pod autoscaling, cluster autoscaling and rolling updates are built in. You rarely need a bespoke deploy script to add capacity.
  • Strong, reusable primitivesDeployments, Services, ConfigMaps, Secrets, Ingress, Jobs and CronJobs cover most of what a backend needs without inventing new concepts per team.
  • Managed offerings everywhereEKS, AKS, GKE and DOKS take the control plane off your plate, which removes most of the worst upgrade work.
  • GitOps fits naturallyTools like Argo CD and Flux make the cluster a reflection of a Git repository, so changes are reviewed, auditable and easy to roll back.

Where Kubernetes bites

  • The operational overhead is realEven a managed cluster still means nodes, networking, storage classes, add-ons and version upgrades. None of that goes away because you chose a cloud button.
  • Most teams simply do not need itThree to five services usually run quite happily on a plain PaaS or a couple of virtual machines. Reaching for Kubernetes before the problem demands it buys complexity you then have to pay for every month.
  • Costs spiral once the add-ons arriveLoad balancers, redundant nodes, ingress controllers, cert-manager, logging stacks and monitoring quietly multiply the bill until a small workload is running on a large invoice.
  • The security surface is wideRBAC, pod security admission, network policies, secrets handling and image provenance all need attention. Defaults are not a safe production posture on their own.
  • Control-plane and etcd upgrades need careRunning versions out of support leaves security holes; rushing the upgrade breaks workloads. Either way there is work that has to be planned rather than clicked.
  • Abandoned clusters collect debrisStale deployments, orphaned namespaces and forgotten CronJobs accumulate when teams change, and nobody is quite sure what will break if it is deleted.

Sound familiar?

Common Kubernetes problems we fix

The Kubernetes problems that bring people to us, and what you have once each one is fixed.

EKS node group: $8,200 (was $1,200)

The cloud bill jumped and nobody knows why

Autoscaling with generous requests, idle nodes left running, and new workloads that quietly doubled the footprint. Right-sizing requests and limits usually recovers most of it.

Cluster cut back to real demand

3 services on a 9-node cluster

The cluster is wildly over-built for the workload

A platform sized for a roadmap that never arrived, with more node capacity than the apps will ever use. In some cases the right answer is a smaller cluster, in some cases it is no cluster at all.

Right-sized or moved off entirely

CrashLoopBackOff on 4 pods

Pods keep restarting and we cannot work out why

Missing config, wrong image tag, a readiness probe that never passes, or an app that runs out of memory within seconds of starting. We trace it from the event stream rather than guessing.

Pods healthy, probes honest

no runbook, no owner

We inherited a cluster from the last team

A kubeconfig that still works, manifests that may or may not match what is deployed, and nobody who knows how it was built. We map it, document it, and bring it back under control.

Cluster mapped and in your hands

version 1.24 · unsupported

The Kubernetes version is years out of date

An old minor version with no upstream support and add-ons that will not run on a newer one. Upgrades need rehearsing; skipping versions needs planning.

Upgraded on a tested path

ImagePullBackOff · registry 401

Deploys fail because images will not pull

An expired registry credential, a private repository that was never wired into the service account, or a tag that no longer exists in the registry.

Pulls working, credentials rotated

etcd: database space exceeded

The control plane is struggling

An etcd that has grown past its quota, usually because of churn from controllers or very large resources being written and rewritten.

etcd healthy, growth watched

What we do

Kubernetes help, from rescue to right-sizing

Call us for one broken deploy, or hand us the whole cluster.

Rescue
A cluster that will not deploy, will not scale, or is burning money. We stabilise it first and explain what happened second.
Right-sizing
Requests, limits, node sizes and autoscaling settings reviewed against real usage, with the bill before and after.
Upgrades
Minor-version upgrades rehearsed on a copy of the cluster, with add-ons tested against the target version before the live run.
Inherited clusters
Mapping what is actually deployed, finding who owns what, and bringing the configuration back into a repository you control.
Move off Kubernetes
When the workload no longer justifies the overhead, we move it onto simpler hosting without losing uptime.
Managed Tech
Upgrades, monitoring, cost reviews and a team to call, on an ongoing basis.

How it works

From first message to fixed

  1. Look Free estimate

    Tell us what's going wrong. We look at it, then tell you plainly what's wrong and what it will cost.

  2. Fix

    We fix the cause, not the symptom. If something is down, getting it back up comes first.

  3. Harden

    Backups, monitoring, updates and access, so the same problem can't quietly come back.

  4. Hand back or stay on

    You get a plain-language write-up. Or we stay on for hosting, upkeep and new work.

Often found together

Running Kubernetes alongside something else?

We work on the whole stack, so the problem can be wherever it actually is.

Questions

Kubernetes questions

Something else? Call+1 737 727 7327

Do we actually need Kubernetes for this?

Often the honest answer is no. If you have a handful of services and modest traffic, a managed PaaS or a couple of virtual machines will cost less and break less. Kubernetes starts to earn its keep when you have many services, many teams, or scaling patterns that a simpler platform cannot handle.

Can you take over a Kubernetes cluster from a previous team?

Yes, and this is a common request. We start by inventorying what is deployed against what is in version control, writing down what each workload does, and bringing the configuration back into a repository you control before changing anything.

Why did our EKS, GKE or AKS bill jump?

Usually a node group scaled up and never scaled back, or a new workload landed with very generous memory requests, or a load balancer was created per service without anyone noticing. We trace the increase to the specific resources and show you what to turn down.

How do we upgrade our Kubernetes cluster safely?

Not by clicking the upgrade button on a Friday. We rehearse the minor-version upgrade on a copy, confirm every add-on works on the target version, deprecate removed APIs in your manifests, and only then schedule the real one with a rollback plan ready.

Should we move off Kubernetes to simpler hosting?

Sometimes, yes. If the cluster exists because it was fashionable rather than because the workload demanded it, moving to a PaaS or plain virtual machines often saves money and operational time. We will tell you plainly when that is the better call.

How much does Kubernetes help cost?

Estimates are free. Describe the cluster and what is going wrong, and you get a price before any work starts.

Free estimate

Kubernetes giving you trouble?

Tell us what you're running and what's going wrong. A person reads it and comes back with an estimate.

  • No charge to find out what it will take
  • If it's urgent, say so

Replies come from a person. By sending, you authorize us to email you back. No marketing.