Kubernetes support

Kubernetes Support for EKS, AKS, GKE, OpenShift and On-Premises Clusters

Last reviewed by Tyler Eastridge

AceMQ supports production Kubernetes 24/7 across Americas, EMEA and APAC: EKS, AKS, GKE, OpenShift, Rancher and on-premises or air-gapped clusters. Most calls start with one of three problems: pods OOMKilled with a healthy heap, StatefulSet pods stuck in Terminating after a node drain, or a cluster upgrade that stalls with stateful workloads half-moved. We are deepest on brokers, databases and caches.

AceMQ supports production Kubernetes on EKS, AKS, GKE, OpenShift, and on-premises clusters, with particular depth in the stateful workloads that are hardest to run there: message brokers, databases, and caches. StatefulSet pods wedged in Terminating, quorum lost after a node drain, JVMs OOMKilled by cgroup limits, failed cluster upgrades, and storage classes that can't sustain fsync. Every ticket reaches a named senior engineer.

Support quotes answered within 1 hour, by a senior engineer.

Planning a build, upgrade or migration instead? See AceMQ Kubernetes consulting and services.

160+
Customers supported
10+
Years in production support
40+
Sev 1 incidents handled a year
24/7
Americas, EMEA and APAC
1hour
Quote reply

Customers

  • Microsoft
  • Henry Schein
  • Enbridge
  • Gojek

Partners

  • Broadcom
  • Redis
  • VMware Tanzu
  • OSSeva

Incident Triage

Problems we fix every week on Kubernetes

Nine Kubernetes failures that hit stateful workloads hardest, from OOMKilled brokers to hung upgrades, each with the kubectl output or metric we start from.

Common Kubernetes production problems and how AceMQ resolves them
Symptom you're seeingWhat we check first
Exit code 137 with a healthy heapkubectl describe pod shows OOMKilled and Last State: Terminated, Exit Code: 137. The kernel killed the container for crossing its cgroup memory limit, which counts more than the heap: metaspace, thread stacks, direct buffers, page cache attributed to the cgroup, native libraries. We graph container_memory_working_set_bytes against the limit and the JVM's own heap and non-heap numbers, then use Native Memory Tracking on a test replica. Raising the limit hides the problem and raises the bill.
CPU throttling shows up as latency, not as CPU useCheck container_cpu_cfs_throttled_periods_total against container_cpu_cfs_periods_total. A pod at 40 percent of its node can still be throttled for a fifth of its periods because the CFS quota is per 100 ms window. Brokers and JVMs with many GC and compiler threads are hit hard when the limit is below their thread count. We set requests, limits and runtime thread counts together.
A StatefulSet pod is stuck in TerminatingLook at metadata.finalizers, the volume's VolumeAttachment, and the node's state. A pod on a NotReady node holds its PVC until the attach is released, and a cluster that needs that member for quorum will not reform. We resolve it without forcing a delete that risks two writers on one volume.
A routine node drain breaks quorumkubectl drain honours PodDisruptionBudgets, but a budget of maxUnavailable: 1 on a three-member quorum workload is only safe if the other two are healthy at that moment. We design budgets per workload, add readiness probes that mean "caught up", and rehearse a drain before the maintenance window.
Liveness probes kill healthy brokersA broker under a log recovery or a long GC pause fails a short liveness probe and is restarted into the same problem. We separate startup, readiness and liveness, set failureThreshold and periodSeconds from measured recovery time, and use startupProbe for slow starts.
Writes stall on a storage class that cannot sustain fsyncBrokers and databases care about fsync latency more than throughput. We benchmark the PVC with fio using --fsync=1 and a realistic block size, compare it with what the workload needs, and check the storage class's provisioned IOPS, burst credits and volume binding mode. WaitForFirstConsumer matters for zonal volumes: a pod rescheduled to another zone cannot attach its volume.
DNS timeouts and conntrack at scaleIntermittent five-second delays usually mean a CoreDNS issue, ndots:5 search-path amplification, or a conntrack table race. We check CoreDNS metrics, kube_pod_container_status_restarts_total, and node nf_conntrack counts, and set dnsConfig or node-local caching where it helps.
A cluster upgrade hangs partwayDeprecated API versions still in use (apiserver_requested_deprecated_apis), an admission webhook with failurePolicy: Fail whose backend is down, a CNI or CSI driver version outside the supported range for the new minor, or a PDB blocking node replacement. We run the pre-flight checks before the window and keep a rollback per step.
The control plane is slowFor self-managed clusters, etcd_disk_wal_fsync_duration_seconds and apiserver_request_duration_seconds tell you quickly whether etcd is on slow disk. On managed control planes you cannot see etcd, so we read API server latency and request flow control metrics and the cloud provider's control plane logs.

Each P1 report records the manifest, probe, quota or storage setting that failed and the amended spec we left in place.

Brokers crash-looping after a node drain? Request a quote and expect a reply inside one hour.

Contact Us

Deployment coverage

Which Kubernetes platforms does AceMQ support, and who covers what?

PlatformWhat AceMQ coversWhat the platform vendor coversExcluded
Amazon EKSWorkloads, storage, scheduling, upgrades planning, node group and Karpenter behaviour as it affects your pods, brokers and databases on the clusterAWS runs the EKS control plane and supports it under AWS Support; node groups you create stay in your account and are not auto-upgraded with the control plane (AWS EKS documentation)AWS control-plane faults
Azure AKSThe same workload scope, plus node pool and upgrade planningMicrosoft supports the AKS service and its supported Kubernetes versionsAzure platform faults
Google GKE and AutopilotThe same workload scopeGoogle supports the GKE serviceGoogle platform faults
Red Hat OpenShiftOperators, SCC and storage behaviour as it affects stateful workloads, upgrade planning with the cluster's operator versionsRed Hat supports OpenShift under its subscription (Standard and Premium)OpenShift platform defects stay with Red Hat; we work the escalation with you
Rancher, RKE2, kubeadmWorkload layer, etcd and control-plane health on self-managed clusters, upgradesThe distribution vendor, where you hold a subscriptionFaults inside commercial distributions you do not subscribe to
VMware Tanzu Kubernetes GridWorkload layer and cluster behaviourBroadcom for the Tanzu productBroadcom entitlement matters: see our Tanzu pages
Air-gapped and disconnected clustersImage mirroring, promotion paths, certificate rotation, upgrade rehearsal inside your boundaryYour platform vendorAnything that needs outbound access we do not have
Brokers, databases and caches on any of the aboveRabbitMQ and Kafka operators, StatefulSets, Redis, PostgreSQL and others on the clusterThe operator maintainers and technology vendors for their productsProduct defects in a vendor's operator we cannot patch

Support options

Who provides enterprise support for Kubernetes? Platform vendors and independent support compared

Kubernetes itself is a community project with no vendor behind it. Support comes from whoever supplies your cluster: AWS, Microsoft, Google, Red Hat, SUSE (Rancher) or Broadcom. Those contracts cover the platform. They do not cover how your brokers, databases and services behave on it. Independent support from AceMQ covers that workload layer on any distribution.

Platform vendor support (EKS, AKS, GKE, OpenShift)
AceMQ independent support
What it coversTheir Kubernetes distribution or service: control plane, supported versions, platform defects
What it coversYour workloads on any distribution: storage, scheduling, memory, probes, upgrades, stateful brokers and databases
Example termsRed Hat Standard: Severity 1 first response 1 business hour. Red Hat Premium: 24x7 for Severity 1 and 2, Severity 1 first response 1 hour
Example terms24/7 across Americas, EMEA and APAC; response targets from 15 minutes, by plan
Version policyAWS: each EKS minor version is under standard support for 14 months after its EKS release; node groups are not upgraded automatically. Kubernetes project: the three most recent minor versions are maintained
Version policyWe support clusters on the minors you run (see table below) and plan the move between them
Product defectsThe vendor fixes its own code
Product defectsWe diagnose, gather evidence and work the escalation with the vendor
Root cause analysisPlatform-level
Root cause analysisWritten root cause analysis on every P1
PriceSubscription or support plan set by the vendor
Price$24,000 to $72,000 a year (USD), set by SLA, scope and deployment. Quote reply within 1 hour
Multi-cloudOne vendor per platform
Multi-cloudOne contract across EKS, AKS, GKE, OpenShift and on-premises

Dated sources: Red Hat production support SLA page, access.redhat.com/support/offerings/production/sla, read 17 November 2026; Amazon EKS documentation, "Understand the Kubernetes version lifecycle on EKS", read 17 November 2026; kubernetes.io/releases, read 17 November 2026.

What's Included

Everything in your Kubernetes support contract

Requests and limits, probes, PodDisruptionBudgets, storage classes, operators and upgrades are covered on EKS, AKS, GKE, OpenShift and clusters you run yourself.

  • 01

    Emergency Incident Response

    Broker pods crash-looping, quorum lost, or a cluster that won't reform after a node event. With response targets from 15 minutes, by plan, a senior engineer joins a live bridge with kubectl access to diagnose — not a ticket acknowledgement.

  • 02

    Root Cause Analysis

    Every P1 closes with a written RCA: what failed, why, the fix applied, and the manifest, probe, or policy change that prevents recurrence. Delivered as standard, not on request.

  • 03

    Storage & StatefulSet Design

    Storage class selection, IOPS and throughput sizing against broker fsync patterns, volume expansion procedures, and PVC retention policy — reviewed before you discover the limits during an incident.

  • 04

    Resilience & Disruption Budgets

    PodDisruptionBudgets that actually protect quorum, anti-affinity across zones and nodes, topology spread constraints, and drain runbooks your platform team can execute without paging us.

  • 05

    Operator & Helm Support

    RabbitMQ Cluster Operator, Strimzi, and vendor Helm charts — reconcile failures, CRD upgrades, values drift, and the version-skew problems that surface when the operator and broker upgrade on different schedules.

  • 06

    Migration to and from Kubernetes

    Moving brokers onto Kubernetes from VMs or bare metal, and moving them back off when the operational cost isn't justified. Both directions, with parallel-run validation and zero message loss.

Why AceMQ

Why platform teams add a stateful-workload specialist

  • Named Engineers, Zero Cold Start

    The same senior engineers stay on your account. They know your cluster layout, your storage class, and your broker topology — so a P1 call starts with diagnosis, not twenty minutes of you explaining which cloud and which operator.

  • No Tier-1 Triage Layer

    You reach a senior engineer directly by phone, email, or Slack. No help desk collecting information to pass along, and no escalation approval process standing between you and someone who can actually fix it.

  • Broker and Platform, Not One or the Other

    Your Kubernetes vendor doesn't know RabbitMQ internals. Your broker vendor doesn't debug CNI or CSI. Broker-on-Kubernetes incidents live exactly in that gap, and both parties will tell you the problem is on the other side.

  • Genuine Follow-the-Sun Coverage

    Round-the-clock coverage for customers in 26+ countries. Your 3am node-drain incident is someone's mid-afternoon — no overnight skeleton crew, no waiting for a region to wake up.

  • Proactive, Not Just Reactive

    Quarterly reviews of your manifests, probes, disruption budgets, and storage headroom. When a chart or operator version introduces a regression on one customer's cluster, every affected customer hears about it before their next upgrade window.

  • Regulated and Air-Gapped Clusters

    We work in environments with no outbound network access, private registries only, and change control that measures deployments in weeks. Support that assumes you can just pull a new image is not support for these clusters.

Kubernetes platforms we work on

Managed control planes at the three big clouds, OpenShift, Tanzu Kubernetes Grid, Rancher and RKE2, plain kubeadm, and air-gapped clusters.

  • Amazon EKS
  • Azure AKS
  • Google GKE & Autopilot
  • Red Hat OpenShift
  • VMware Tanzu Kubernetes Grid
  • Rancher / RKE2
  • Self-managed kubeadm clusters
  • Air-gapped / disconnected clusters
  • RabbitMQ Cluster Operator
  • Strimzi & Kafka on Kubernetes
  • ActiveMQ Artemis on Kubernetes
  • Istio, Linkerd & service mesh deployments

Version coverage

Versions we support

We support the Kubernetes minor versions your clusters run and plan the upgrade between them.

Versions we support
Kubernetes minorSupported by AceMQ
1.37Yes
1.36Yes
1.35Yes
1.34Yes
1.33Yes
1.32Yes
1.31Yes
1.30Yes
1.29Yes
1.28 and olderAsk us at scoping; we plan the move to a newer minor

Source: kubernetes.io/releases, read 17 November 2026, which maintains release branches for the three most recent minors (1.37, 1.36 and 1.35 at that date). The list above follows the existing version checker on the page. Distributions: EKS, AKS, GKE and Autopilot, OpenShift, Rancher and RKE2, Tanzu Kubernetes Grid, kubeadm clusters, air-gapped clusters.

In practice

Running stateful workloads on Kubernetes without losing them

Most Kubernetes estates are healthy for stateless services. Trouble starts when the workload has memory of its own: a message broker with a quorum, a database with a write-ahead log, a cache with a persistence file. Kubernetes treats every pod as replaceable. A broker is not. The four decisions below are where those two views collide, and where most of our calls begin.

Storage decides whether the cluster is stable. A quorum queue or a Kafka log makes a durable write, then waits for the disk to confirm it. If the volume's fsync latency is high or erratic, the broker slows, the quorum leader is lost to a slow follower, and the cluster looks sick when the disk is the cause. Cloud volumes differ in baseline IOPS, burst credits and per-volume ceilings. We benchmark the real PVC with fio before a broker is placed on it, and write the result into the sizing record so the next change to the storage class is a decision with numbers. Binding mode matters too. With WaitForFirstConsumer, a volume is created in the zone where the pod first lands, and a pod rescheduled to a different zone cannot attach it. Anti-affinity and zone spread need to match the volume topology, or a node failure turns into a stuck pod.

Memory limits must account for everything the process uses. A JVM broker has a heap, metaspace, thread stacks, direct memory and native allocations. A limit set from the heap alone gets OOMKilled with no OutOfMemoryError, no dump, and healthy heap graphs. We set heap as a percentage of the limit, cap thread pools and direct buffers, and alert on container working set against the limit.

Disruption budgets are part of the broker design. An upgrade or autoscaler event drains nodes. A PodDisruptionBudget that allows one pod unavailable only protects a three-member quorum if the other two are in sync at that moment. A readiness probe that returns ready as soon as the port opens will let the drain move to the next pod while the last one is still catching up. We write readiness checks that mean "caught up", set budgets per workload, and rehearse a drain in staging with the operations team watching, because the first real drain should not be the first drain.

Upgrades need an order. Platform, operators, CSI and CNI drivers, then workloads. Each has a supported range for the next Kubernetes minor, and stateful workloads go last, one pod at a time, with a rollback at every step. We produce the pre-flight checklist (deprecated APIs in use, webhooks that can block, driver versions), rehearse on a non-production cluster and run the window with your team.

What we do not do on this page: run the cluster for you (see /containers/managed-services/) or host your workloads. Support means that when something breaks at 3am, a senior engineer who knows your storage class, your PDBs and your broker settings joins the bridge.

Consulting

Kubernetes consulting and professional services

AceMQ consulting on Kubernetes is scoped work with named deliverables, usually two to six weeks, delivered with your platform team. It centres on stateful and messaging workloads, where our depth is. Deliverables, by engagement: Stateful workload readiness assessment. A written review of storage classes (fsync benchmark with fio), binding modes, anti-affinity and zone spread, resource requests and limits, probe settings and PodDisruptionBudgets for every broker, database and cache on the cluster, with a ranked fix list. Memory and CPU standard for JVM workloads. Heap percentages, thread and buffer caps, base-image settings and container-level alerts, tested on a replica with Native Memory Tracking. Upgrade plan and rehearsal. An inventory of components, versions, deprecated API use, admission webhooks and driver compatibility; per-cluster upgrade order with a rollback at each step; a staged rehearsal. Disruption and drain runbook. Budgets, readiness checks, the drain procedure per workload and a timed rehearsal with your operations team. Backup and restore design. Velero or equivalent configured against your object storage, with a measured full-restore time recorded in the runbook. Operator and Helm review. RabbitMQ Cluster Operator, Strimzi and other operator settings checked against the operator's supported matrix. Air-gapped supply chain design. Registry mirror, image promotion path and certificate rotation that work without outbound access. For clusters you want AceMQ to run, see /containers/managed-services/. For a quick read on where a cluster stands first, ask for the health check. Quote reply within 1 hour.

Escalation Path

Your first hour of a Kubernetes outage

Quorum lost after a node event outranks a probe tuning question. Each severity has its own response clock, set by plan.

  1. From 15 min (by plan)first responseEmergencyProduction down: quorum lost after a node event, stateful pods crash-looping, or a cluster that will not reform
  2. 1 hourfirst responseCriticalSevere degradation: containers OOMKilled at exit code 137, CPU throttling inflating latency, writes stalling on slow persistent volumes
  3. 4 hoursfirst responseHighStatefulSet pods stuck in Terminating, drains violating quorum, a cluster upgrade hanging on deprecated APIs or webhooks
  4. Next Dayfirst responseStandardQuestions on PodDisruptionBudgets, probe settings, storage class choice, DNS tuning and moving workloads onto or off Kubernetes

Response clocks differ by plan and severity: a cluster that will not reform is not queued behind an upgrade question.

Need a Kubernetes engineer who knows your stateful workloads? Get a quote or send us a message.

Contact Us

Pricing

What does AceMQ Kubernetes support cost?

Kubernetes support usually costs $24,000–72,000 a year. Cluster and distribution count, the stateful workloads you run on them, and the response plan decide where in that range your quote falls.

All prices are in US dollars (USD). Response targets start at 15 minutes by plan, 24/7, and quote requests are answered within 1 hour. A contract spanning your brokers, databases and clusters earns a multi-technology discount.

Support In Practice

Kubernetes incidents we have resolved

Kubernetes support and stabilization work from AceMQ. Each card links to the full write-up: the cluster, what AceMQ diagnosed or changed, and the result.

All use cases

Support options

Four tiers of Kubernetes support.

AceMQ offers Kubernetes support in four tiers, each handing more of the day-to-day work to AceMQ: 24/7 support and incident management for clusters your team runs, proactive monitoring that finds sizing, probe and upgrade problems first, managed Kubernetes on your own infrastructure, and fully managed Kubernetes on AceMQ infrastructure. EKS, AKS, GKE, OpenShift and self-managed clusters are covered in all four, on the current Kubernetes release and the five end-of-life release lines before it.

  • Tier 1

    Kubernetes 24/7 Support & Incident Management

    Your platform team owns clusters, we join incidents

    Best for: Platform groups who handle Kubernetes themselves but want a senior engineer for broker, database or quorum failures.

  • Tier 2

    Kubernetes 24/7 Support with Proactive Monitoring

    Quarterly health reviews of limits, probes and storage

    Best for: Teams that want budgets, anti-affinity and fsync performance checked before a drain or a node loss does it for them.

  • Tier 3

    Managed Kubernetes on Your Infrastructure

    We operate clusters and workloads in your accounts

    Best for: Organizations that keep Kubernetes on their own cloud accounts or hardware and need specialists running day-two work.

  • Tier 4

    Fully Managed Kubernetes on AceMQ Infrastructure

    We run the platform and workloads for you

    Best for: Product teams that want applications running on Kubernetes without staffing a platform team.

FAQ

Kubernetes support questions

Still have questions about Kubernetes? Email an Expert

Who provides enterprise support for Kubernetes?

Kubernetes is a community project, so enterprise support comes from your platform vendor (AWS for EKS, Microsoft for AKS, Google for GKE, Red Hat for OpenShift, SUSE for Rancher, Broadcom for Tanzu) for the platform itself. Independent providers such as AceMQ support what runs on it: workloads, storage, memory, upgrades and stateful brokers and databases, 24/7 with response targets from 15 minutes, by plan, on any distribution.

What does 24/7 Kubernetes support from AceMQ cover?

Round-the-clock response from 15 minutes on top plans, a written root cause after each P1, plus limits, probes, budgets and upgrade planning. Example Sev 1: a RabbitMQ cluster that will not reform after a node drain, where an engineer reads pod events and PDB state on a bridge. P2 is 1 hour.

Do you support RabbitMQ on Kubernetes?

Yes. We support the RabbitMQ Cluster Operator and Messaging Topology Operator, quorum queue behaviour on Kubernetes storage, node drain and upgrade procedures, and the monitoring that catches a quorum losing a member. See the use case above for an airport systems example.

Can you support Kafka on Kubernetes?

Yes, including Strimzi and OpenShift deployments: broker pod behaviour, storage, rack awareness against node topology, rolling restart order and the Kafka-side effects of a node drain.

Why do our pods get OOMKilled when the heap looks fine?

Because the cgroup limit counts memory outside the heap: metaspace, thread stacks, direct buffers and native libraries. Exit code 137 gives no JVM error. We compare container working-set memory with JVM memory, run Native Memory Tracking on a replica and size heap as a share of the limit.

Why does a StatefulSet pod stick in Terminating, and is it safe to force delete it?

Often because a finalizer, a volume attachment or a NotReady node is holding it. A force delete can leave two writers on one volume. We check the attachment and node state, release it safely and then fix the cause.

How do we upgrade Kubernetes without breaking stateful workloads?

Check deprecated API use, webhooks and driver compatibility first. Upgrade platform, then operators and drivers, then workloads, one pod at a time, with a rollback per step, and rehearse on non-production. Kubernetes project guidance maintains the three most recent minor versions, so plan to move by one minor at a time.

Our platform team already supports Kubernetes. Where do you fit?

We work with them. Platform teams own clusters; the incidents that need an engineer at 3am are often in the workload on top: a broker that lost quorum, a database that stalled on fsync. We bring that depth, 24/7, and hand back a root cause analysis.

What happens when the cause is in EKS, AKS, GKE or OpenShift itself?

We gather the evidence, which usually shortens the vendor's work, and work the escalation with you under your own vendor contract. We cannot patch a vendor's code.

Do you support air-gapped Kubernetes clusters?

Yes. We work inside your access and change controls: image mirroring, promotion paths, certificate rotation and upgrade rehearsal with no outbound access.

Is Kubernetes support only available on a yearly basis?

No. An upgrade rehearsal, a PodDisruptionBudget and probe review or a migration of brokers onto Kubernetes can be quoted as a single engagement. Teams whose stateful workloads are business critical then switch to the annual agreement for 24/7 cover and named engineers.

What drives the price of Kubernetes support?

Annual contracts typically fall between $24,000 and $72,000 (USD). The quote reflects how many clusters you run, which distributions (EKS, AKS, GKE, OpenShift or self-managed), which stateful workloads sit on them, and the response plan. Send those facts and a quote reply arrives within 1 hour.

Let's talk

Stateful Workloads Deserve More Than Best-Effort

Tell us your distributions and the brokers and databases on them. We reply to quote requests within 1 hour.

A senior Kubernetes engineer, not a sales queueQuote requests answered within 1 hourAd hoc engagements or an annual partnership

Production incident right now?Email a Kubernetes Architect