Free audit

View Audit Scope
ECK Operator & HelmMaster/Hot/Warm nodeSets · <=31GiB JVM · EKS, GKE & AKS

Elasticsearch on Kubernetes (ECK) Consulting & Operations

JusDB architects and operates production Elasticsearch clusters on Kubernetes using Elastic Cloud on Kubernetes (ECK) and Helm across AWS EKS, GCP GKE, and Azure AKS. Our database reliability engineers isolate Master, Data-Hot, Data-Warm, and Ingest nodeSets, enforce the 31 GiB compressed-oops JVM heap boundary, configure kernel vm.max_map_count init containers, and wire allocation-aware PodDisruptionBudgets.

The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance.

  • NDA before access
  • Read-only by default
  • Written scope before work starts

ECK Kubernetes architecture & guardrails

Select a subsystem to inspect

Dedicated Master / Hot / Warm / Ingest Roles

Role-isolated pods

Separate ECK nodeSets isolate 3 quorum Master pods from heavy indexing and aggregation pressure on Data-Hot, Data-Warm, and Ingest tiers.

Running all roles in a single default nodeSet exposes cluster state elections to GC pauses triggered by uncalibrated aggregations.

Inspect ECK topology states

Operator and JVM boundaries verified against Elastic Cloud on Kubernetes (ECK) documentation.

K8s platforms supported
AWS EKS, Google GKE, Azure AKS, OpenShift, and bare-metal Kubernetes with ECK or Helm
JVM & kernel baseline
50% RAM heap (<= 31 GiB compressed oops), Dedicated QoS, and vm.max_map_count=262144
Initial-response targets
15 minutes for a critical (P1) incident under a 24x7 support agreement; 2 to 4 hours in business hours. See details
Coverage hours
Business hours (03:30–12:30 UTC) by default; 24x7 on-call available under your service agreement

Selected clients

  • Innoviti
  • Blitz
  • Freecharge
  • Nango
  • Recochain
  • Screen Facts
  • Nexora
  • WeCredit

Production failure modes

Why Elasticsearch clusters fail on Kubernetes and how we fix them

Container schedulers treat pods as disposable, while Elasticsearch relies on pinned JVM heaps, off-heap Lucene mmap caches, and coordinated shard recovery.

Elasticsearch on Kubernetes production symptoms, root causes, and first diagnostic actions
Kubernetes / ES signalWhat is usually happeningWhere we start
OOMKilled (Exit 137)Data pods killed by Kubernetes cgroup memory limits during mergesJVM -Xmx was set above 50% of container memory limits or crossed the 32 GiB compressed-oops threshold, leaving insufficient off-heap memory for Lucene mmap files and Netty buffers.Cap JVM -Xms/-Xmx at 50% of the pod memory request (never exceeding 30-31 GiB), size the container memory limit to at least 2x heap, and inspect _nodes/stats/jvm.
max_map_count [65530]Elasticsearch pods crash-loop on startup after worker node scale-outNew EKS, GKE, or AKS worker nodes boot with the default Linux vm.max_map_count=65530, failing Elasticsearch production bootstrap checks for Lucene mmapfs.Configure node-pool launch templates or a privileged ECK initContainer setting sysctl -w vm.max_map_count=262144 and verify swap is disabled across all nodes.
Cluster Status REDKubernetes node upgrades evict multiple data pods at the same timeMissing PodDisruptionBudgets or missing topologySpreadConstraints allowed two pods holding the primary and replica of the same shard to land on drained nodes concurrently.Enforce maxUnavailable: 1 PDBs, add cluster.routing.allocation.awareness.attributes: k8s_node_name, and wire preStop hooks to drain shards before pod termination.
Master Election TimeoutCluster state updates stall and nodes drop out under heavy search loadMaster-eligible roles are co-located on data pods, so long JVM garbage collection pauses or EBS/PersistentDisk I/O saturation starve Zen2/Raft cluster coordination.Split out a dedicated 3-pod master nodeSet with anti-affinity across three Availability Zones, dedicated GP3/PD-SSD PVCs, and isolated CPU/memory requests.
DiskWatermark [90%]Hot PVCs hit flood-stage watermark and indices lock into read-onlyIndex Lifecycle Management (ILM) rollover thresholds do not match PersistentVolumeClaim sizes, or oversharding created thousands of tiny shards on hot storage.Align ILM max_primary_shard_size (30-50 GiB) with PVC capacity, enable StorageClass allowVolumeExpansion, and automate rollover from Data-Hot NVMe to Data-Warm tiers.
EsRejectedExecutionBulk indexing queues reject writes during shard relocation stormsPod restarts trigger immediate unassigned shard recovery across the network, saturating disk IOPS and starving bulk write thread pools on hot nodes.Tune index.unassigned.node_left.delayed_timeout (e.g., 5m for transient pod restarts) and throttle cluster.routing.allocation.node_concurrent_recoveries.

Technical scope

What our Elasticsearch on Kubernetes engineering covers

We design, harden, and operate ECK Operator and Helm deployments with GitOps-ready manifests, deterministic JVM memory boundaries, and tested drain runbooks.

  • ECK Operator multi-tier nodeSet design

    We replace monolithic StatefulSets with dedicated Elastic Cloud on Kubernetes (ECK) nodeSets for Master, Data-Hot, Data-Warm, Data-Cold, Ingest, and Coordinating roles.

    • 3-node quorum Master nodeSet isolated from query and bulk indexing heaps
    • Zone-aware topologySpreadConstraints and podAntiAffinity across 3 AZs

    ECK Operator · elasticsearch.k8s.elastic.co/v1 · topologySpreadConstraints

    Elasticsearch consulting
  • JVM <= 31 GiB heap & cgroup calibration

    Containerized Elasticsearch requires strict alignment between Kubernetes pod memory limits, JVM heap flags, and off-heap Lucene filesystem cache.

    • Enforce 50% RAM allocation to JVM heap capped at 30-31 GiB for compressed oops
    • Dedicated QoS class (requests == limits) to prevent Kubernetes CPU throttling

    -Xms30g -Xmx30g · G1GC · Kubernetes Dedicated QoS · _nodes/stats/jvm

  • Local NVMe & CSI storage class engineering

    Lucene segment merges and translog fsyncs are bound by disk latency. We benchmark and configure CSI storage classes for every ILM data tier.

    • Local NVMe RAID-0 or high-IOPS gp3/io2/pd-ssd StorageClasses for Data-Hot
    • Online PVC volume expansion and sysctl vm.max_map_count=262144 automation

    AWS EBS CSI · GCP PD-SSD · Local Path Provisioner · vm.max_map_count

  • ILM shard rollover & hot-warm-cold tiering

    Keep fast NVMe storage reserved for active indexing while automatically migrating immutable time-series indices to dense warm nodes and searchable snapshots.

    • Target 30-50 GiB shard sizing with automated ILM rollover and force-merge
    • S3, GCS, and Azure Blob repository integration for snapshots and cold tiers

    _ilm/policy · max_primary_shard_size · repository-s3 · force_merge

  • Safe Kubernetes node drains & rolling upgrades

    Prevent Karpenter, Cluster Autoscaler, or EKS/GKE control-plane upgrades from dropping cluster health to RED during node replacements.

    • PodDisruptionBudgets paired with ECK shard allocation exclusion hooks
    • Delayed unassigned shard allocation timeouts for transient pod restarts

    PodDisruptionBudget · allocation.exclude._name · delayed_timeout

  • Prometheus observability & TLS automation

    Full visibility into JVM GC pause times, thread-pool rejections, and shard skew, backed by automated cert-manager TLS rotation across transport and HTTP layers.

    • prometheus-elasticsearch-exporter ServiceMonitors and Grafana alert rules
    • Automated mTLS transport certificates and RBAC role mappings via ECK

    elasticsearch_exporter · Prometheus · Grafana · cert-manager

    Elasticsearch support

Shared responsibility & response targets

Where default Kubernetes charts stop and what JusDB engineers

Installing the ECK Operator or Helm chart gives you a running CRD, but pod memory governance, shard placement awareness, and safe node drain orchestration require deliberate engineering.

Comparison between default Kubernetes Elasticsearch setups and JusDB production engineering
ECK / K8s subsystemDefault chart / uncalibrated setupWhat JusDB engineers & operates
Node role topologyDefault Helm charts or basic manifests launch a single StatefulSet where every pod runs master, data, and ingest roles together.Separates ECK nodeSets into dedicated Master, Data-Hot, Data-Warm, and Ingest pools with per-tier nodeSelectors, taints, and PVCs.
Memory & JVM compressed oopsLeaves default small heaps or allows engineers to set 40+ GiB heaps that break 32-bit pointer compression and trigger cgroup OOM kills.Locks JVM heap at <= 31 GiB (50% of pod memory), sets Dedicated QoS requests==limits, and reserves the remaining 50% for Lucene mmap page cache.
Kubernetes node drains & autoscalingKubernetes evicts pods on node termination without checking whether primary and replica shards are still relocating.Configures PodDisruptionBudgets, zone awareness attributes, delayed allocation timeouts, and ECK pre-stop shard drain orchestration.
Index Lifecycle Management (ILM)Indices grow unchecked or create thousands of tiny daily shards until hot PVCs hit the 90% flood-stage disk watermark.Designs rollover policies targeting 30-50 GiB shards, force-merges read-only segments on Data-Warm, and offloads retention to S3/GCS.
Kernel & storage tuningRelies on generic cloud worker defaults (vm.max_map_count=65530, default gp2/standard disks, uncalibrated read-ahead).Enforces vm.max_map_count=262144 via node bootstrap or initContainers, disables swap, and matches gp3/io2/NVMe IOPS to merge throughput.
Snapshot & disaster recoveryManual S3/GCS repository setup with unverified snapshot schedules and no tested restore runbook.Wires IRSA / Workload Identity object storage credentials, automates SLM policies, and runs scheduled snapshot restore drills.

Published initial-response targets by severity

Standard business hours: 03:30–12:30 UTC

Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

SeverityInitial responseDefinitionChannel & coverage
P1 · Critical15 minutesProduction database down, primary unreachable, data corruption risk, or active failover event.24x7 on-call (under your service agreement) · Direct PagerDuty, Opsgenie, or phone page plus incident bridge
P2 · High30 minutesSevere latency spike, replication lag climbing rapidly, connection exhaustion, or degraded HA node.24x7 on-call (under your service agreement) · On-call alert plus shared Slack or Teams channel
P3 · Medium60 minutesNon-critical slow query regression, staging issue, backup warning, or replication check alert.24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket
P4 · Low90 minutesConfiguration question, index advisory, planned schema review, or general operational request.24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket

Our engineering team is in India; business-hours coverage is Mon–Fri 09:00–18:00 IST (UTC+5:30), and 24x7 on-call is available under your service agreement.

Initial-response targets, not resolution guarantees. The target for your engagement is set in your service agreement.

Interactive ECK topology simulator

How ECK nodeSets behave during node drains and rolling upgrades

Compare a role-isolated Master/Hot/Warm ECK cluster against an unguarded Kubernetes node drain and an allocation-aware rolling upgrade.

Elasticsearch on Kubernetes (ECK) cluster simulator

Select an operational state to inspect pod roles, shard allocation, and JVM heap behavior.

Ingest / Coordinating Service & Shard Allocation

Stateless Ingest/Coordinating pods terminate TLS and route bulk writes to Data-Hot NVMe pods while ILM moves aged indices to Data-Warm.

Cluster GREEN · 3-AZ shard awareness · <=31GiB heaps
  • es-master-0..2 (3 Pods · 3 AZs)

    Dedicated Master nodeSet · 4Gi RAM / 2Gi Heap

    QUORUM OK · Cluster state elected

  • es-data-hot-0..5 (6 Pods · NVMe)

    Data-Hot & Content · 62Gi RAM / 30Gi Heap

    INDEXING · 50% RAM in Lucene cache

  • es-data-warm-0..3 (4 Pods · EBS gp3)

    Data-Warm tier · Force-merged read replicas

    ONLINE · ILM rollover target

Isolating Master pods from Data-Hot and Data-Warm pods prevents heavy aggregation or segment-merge GC pauses from disrupting cluster coordination. Each Data-Hot pod caps JVM heap at 30 GiB so compressed oops remain active and 32 GiB stays free for OS page cache.

Representative production deliverable

How an ECK topology and JVM memory remediation is delivered

Every engagement produces GitOps-ready ECK Custom Resource Definitions, StorageClass specs, and verification commands tested against your cluster.

Sample deliverable · ECK Master/Data-Hot isolation & 30 GiB compressed-oops capECK v2.14 · Elasticsearch 8.15 on AWS EKS

Finding

40 GiB JVM heap broke compressed oops and caused cgroup OOM kills on EKS node rotations

Data pods were deployed in a single 48 GiB container with -Xmx40g and co-located master roles. Crossing the 32 GiB compressed-oops boundary reduced effective addressable heap capacity while leaving only 8 GiB for Lucene mmap segments, triggering OOMKilled (ExitCode 137) during heavy merges.

p99 Search latency1,420ms → 84ms
Data-Hot JVM / Pod RAM30 GiB / 62 GiB

1. ECK CRD: Dedicated Master and Data-Hot nodeSets with 30 GiB heap and AZ spread

elasticsearch-prod.yaml · ECK v1 CRD

apiVersion: elasticsearch.k8s.elastic.co/v1
kind: Elasticsearch
metadata:
  name: prod-search
  namespace: elastic-system
spec:
  version: 8.15.3
  podDisruptionBudget:
    spec:
      maxUnavailable: 1
  nodeSets:
    - name: master
      count: 3
      config:
        node.roles: ["master"]
      podTemplate:
        spec:
          containers:
            - name: elasticsearch
              env:
                - name: ES_JAVA_OPTS
                  value: "-Xms4g -Xmx4g"
              resources:
                requests: { memory: 8Gi, cpu: "2" }
                limits:   { memory: 8Gi, cpu: "2" }
    - name: data-hot
      count: 6
      config:
        node.roles: ["data_hot", "data_content", "ingest"]
        cluster.routing.allocation.awareness.attributes: k8s_node_name,zone
        node.attr.k8s_node_name: ${HOSTNAME}
      podTemplate:
        spec:
          initContainers:
            - name: sysctl
              securityContext: { privileged: true }
              command: ["sh", "-c", "sysctl -w vm.max_map_count=262144"]
          containers:
            - name: elasticsearch
              env:
                - name: ES_JAVA_OPTS
                  value: "-Xms30g -Xmx30g -XX:+UseG1GC"
              resources:
                requests: { memory: 62Gi, cpu: "8" }
                limits:   { memory: 62Gi, cpu: "8" }

2. Verify compressed oops and delayed unassigned shard timeout

elasticsearch api · verification & drain safety

# Confirm compressed object pointers are enabled ("using_compressed_ordinary_object_pointers": "true")
GET _nodes/jvm?filter_path=nodes.*.jvm.mem.heap_max_in_bytes,nodes.*.jvm.using_compressed_ordinary_object_pointers

# Prevent shard relocation storms during brief Kubernetes pod restarts
PUT /_all/_settings
{
  "settings": {
    "index.unassigned.node_left.delayed_timeout": "5m"
  }
}

Ways to work together

How to engage JusDB for Elasticsearch on Kubernetes

Start with a read-only audit of your ECK manifests and shard layout, scope a Kubernetes migration or topology redesign, or put your search cluster under ongoing SRE coverage.

Scoped ECK consulting projectThis page

Architect, tune, or migrate onto ECK.

A fixed-scope engagement delivering GitOps manifests, StorageClass benchmarks, ILM rollover policies, and rehearsed Kubernetes drain runbooks.

Common ECK scopes agreed in writing first

  • Master/Hot/Warm nodeSets
  • <=31 GiB JVM & G1GC tuning
  • ILM rollover & S3/GCS SLM
  • Safe Karpenter / node drains
  • VM or Cloud to ECK cutover
Free ECK & shard audit

One Elasticsearch cluster, audited read-only.

We review your ECK CRDs or Helm values, JVM heap and cgroup ratios, shard sizing, and PVC storage performance, then return a written remediation plan.

What we check on your Kubernetes cluster

  • JVM compressed oops & container cgroup memory headroom
  • Master/Hot/Warm nodeSet isolation & AZ anti-affinity
  • ILM shard sizes, PDBs & node-drain eviction safety
Ongoing ECK operations & support

Named engineers covering your search estate.

Continuous Prometheus monitoring, ECK operator upgrades, shard rebalancing, and incident response under a 24x7 support agreement or in covered business hours.

  1. Page on-callavailable where your service agreement includes it
  2. 15 minP1 initial-response target
  3. Written RCAafter every P1 incident
Evaluation Vector
JusDB DBRE
In-House DBALegacy AgencyDeveloper Generalist
Elastic Cloud on Kubernetes (ECK) Operator ArchitectureDeploys the official ECK operator with multi-NodeSet CustomResourceDefinitions, separating dedicated master, data (hot/warm/cold), and ingest roles with declarative GitOps reconcilers.Uses unmaintained community Helm charts or monolithic manifests without operator reconciliation, requiring manual kubectl interventions during rolling mutations.Deploys naked Kubernetes StatefulSets without operator intelligence, breaking elasticsearch.yml configuration discovery and internal TLS rotation.Deploys Elasticsearch as a standalone single-replica Deployment without StatefulSet semantics, leading to pod restart data loss.
Dedicated Master Quorum Isolation & Split-Brain PreventionProvisions dedicated 3-pod master-eligible NodeSets with strict pod anti-affinity, cluster.initial_master_nodes bootstrapping, and no data roles to prevent quorum split-brain.Co-locates master and data roles on the same worker pods; heavy search queries exhaust CPU and memory, dropping master heartbeats and triggering false leader elections.Configures 2-pod or even-numbered master nodes without odd-quorum voting configuration, inducing split-brain partitions during network blips.Deploys a single master node pod without quorum redundancy; any worker node rescheduling halts cluster state management cluster-wide.
Persistent Volume Claim (PVC) & Local NVMe Storage ClassesEngineers low-latency NVMe storage classes via DirectPV/local-volume CSI with dynamic volume expansion, volumeClaimTemplates, and S3 searchable snapshot tiering.Relies on default network-attached block storage (e.g., standard gp3/pd-standard) with unoptimized IOPS, causing disk queue latency spikes during bulk indexing.Mounts shared NFS or cluster-wide network filesystems across Elasticsearch pods, causing Lucene index lock contentions and segment corruption.Uses ephemeral hostPath or emptyDir storage without persistent volume durability; worker node restarts permanently wipe all indexed documents.
Pod Anti-Affinity & Multi-Zone Shard Allocation AwarenessEnforces topologySpreadConstraints and hard podAntiAffinity across availability zones, synchronizing Kubernetes topology labels with cluster.routing.allocation.awareness.attributes: zone.Deploys pods without zone awareness; primary and replica shards land on worker nodes in the same cloud availability zone, creating single-point-of-failure exposure.Relies on basic Kubernetes default scheduling; multiple master and data pods schedule onto the same physical hypervisor node.Ignores affinity and multi-zone placement entirely; entire clusters go offline when Kubernetes reschedules pods to a single drained node.
Rolling Stateful Upgrades & PDBsImplements strict PodDisruptionBudgets (maxUnavailable=1 for masters and data tiers), automated shard reallocation disabling (cluster.routing.allocation.enable: "primaries"), and preStop sync hooks.Executes blind kubectl rollout restart, restarting multiple data pods simultaneously, triggering massive cluster-wide shard recovery storms and degraded query latency.Schedules multi-hour maintenance downtime to stop and recreate StatefulSets sequentially during off-peak hours.Updates container image tags directly in production manifests without PDBs; Kubernetes terminates multiple pods concurrently, causing red cluster state.
Native Cloud Observability & Metricbeat ExportersIntegrates Elastic Agent/Metricbeat DaemonSets, Prometheus Elasticsearch Exporter, and curated Grafana dashboards monitoring JVM GC pauses, Lucene segment merges, and indexing queue depths.Relies only on basic Kubernetes pod CPU and memory utilization metrics, remaining blind to Lucene segment counts, circuit breaker trips, and unassigned shards.Injects generic APM agents into Elasticsearch containers, consuming critical JVM heap without tracking cluster state publication latencies.No monitoring configured; discovers cluster degradation only after customer support tickets report search timeouts and 503 errors.

Kubernetes platforms and ecosystem integrations we support

For procurement and platform security teams

Mutual NDA first, least-privilege RBAC, and written scope

We operate inside your Kubernetes security boundary via scoped ClusterRoles, bastion/VPN tunnels, and GitOps pull requests. Your platform team approves production manifest changes and keeps every runbook.Raguraman, Engineering Manager · Allen D, Lead Database SRE
  • Mutual NDA
  • Written statement of work
  • Named engineers
  • Least-privilege K8s RBAC
  • NDA before access

    Signed before any manifest or cluster review. The 30-minute scoping call requires no Kubernetes or Elasticsearch credentials.

  • Written statement of work

    Covered clusters, deliverables, maintenance windows, and fees agreed in writing before onboarding.

  • Read-only by default

    Scoped read-only Kubernetes RBAC and Elasticsearch cluster_monitor roles with full audit logging.

  • GitOps manifests you keep

    Every ECK CRD, Helm chart value, and drain runbook stays in your repository. Meet the JusDB team.

JusDB's security practices are aligned with ISO 27001 and SOC 2 Type II, and JusDB is pursuing both certifications (see Terms, section 12). Read the stated status.

Technical FAQ

Elasticsearch on Kubernetes (ECK) common questions

Answers on ECK vs Helm, <=31 GiB JVM heap sizing, vm.max_map_count, PodDisruptionBudgets, ILM shard rollover, and storage classes.

Still have a question?

Ask it on a scoping call. No production access needed.

Book a 30-min scoping call (opens Google Calendar in a new tab)

Should we run Elasticsearch on Kubernetes using the ECK Operator or Helm charts?

For production clusters, we recommend Elastic Cloud on Kubernetes (ECK). While Helm charts only template static StatefulSets, the ECK Operator actively reconciles Elasticsearch cluster health: it orchestrates safe rolling upgrades one pod at a time, manages transport and HTTP TLS certificates, excludes pods from shard allocation before termination, and allows independent scaling of Master, Data-Hot, Data-Warm, and Ingest nodeSets.

How should JVM heap and Kubernetes pod memory limits be sized for Elasticsearch?

Assign 50% of the pod's memory request and limit to the Elasticsearch JVM heap (-Xms and -Xmx set identically) and leave the remaining 50% for the Linux kernel page cache, which Lucene uses to memory-map index segments via mmapfs. Never configure a JVM heap above 31 GiB (we typically cap at 30 GiB in a 60-64 GiB pod) so the JVM preserves 32-bit compressed object pointers (compressed oops).

Why do Elasticsearch pods fail with max virtual memory areas vm.max_map_count [65530] is too low?

Elasticsearch uses Lucene's hybrid mmapfs/niofs directory implementation, which maps index files directly into the process address space. Standard Linux worker nodes default to vm.max_map_count=65530, whereas Elasticsearch requires at least 262144. We enforce sysctl vm.max_map_count=262144 either in your EKS/GKE/AKS node launch templates or via an ECK privileged initContainer so autoscaled nodes never fail bootstrap checks.

How do you prevent Kubernetes node upgrades or Karpenter from causing RED cluster health?

We configure three layers of protection: (1) cluster.routing.allocation.awareness.attributes tied to topology.kubernetes.io/zone and kubernetes.io/hostname so primary and replica shards never share a physical node or AZ, (2) PodDisruptionBudgets with maxUnavailable: 1, and (3) ECK preStop lifecycle hooks plus index.unassigned.node_left.delayed_timeout=5m so transient restarts do not trigger shard relocation storms.

What storage classes work best for Elasticsearch Data-Hot and Data-Warm pods?

Data-Hot pods require low-latency IOPS for translog fsyncs and Lucene segment merges; we use local NVMe SSDs (on AWS i3en/i4i or GCP Local SSD) when replica counts and zone anti-affinity protect durability, or provisioned-IOPS EBS gp3/io2 and GCP pd-ssd with allowVolumeExpansion enabled. Data-Warm pods serve read-only force-merged indices and run cost-effectively on higher-capacity EBS gp3 or standard SSD persistent volumes.

How do you size shards and Index Lifecycle Management (ILM) policies on Kubernetes?

Oversharding is the leading cause of heap exhaustion in Kubernetes Elasticsearch clusters. We design ILM rollover policies targeting 30 GiB to 50 GiB per shard (or 200M documents), keep shard counts below 20 shards per GiB of JVM heap, force-merge indices to 1-2 segments upon moving to Data-Warm, and archive cold retention tiers to S3, GCS, or Azure Blob Storage via Snapshot Lifecycle Management (SLM).

Can you migrate our existing VM-based or Elastic Cloud cluster onto Kubernetes?

Yes. Depending on your version and network topology, we migrate clusters onto ECK using S3/GCS Snapshot and Restore, Cross-Cluster Replication (CCR), or staged remote reindexing with dual-write ingestion pipelines, verifying document counts and mapping parity before cutting search traffic over.

What are your initial-response targets for Elasticsearch on Kubernetes incidents?

Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

Next step

Talk to an engineer about your Elasticsearch on Kubernetes cluster

Tell us which Kubernetes platform, ECK or Helm version, and shard volumes you run. The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance, subject to availability: mutual NDA before read-only access, a prioritized report within one week after access is ready, and no obligation.

NDA before access · read-only by default · written scope first