Migrate Graylog from virtual machines to Kubernetes

Move Graylog from VMs or Docker hosts onto Kubernetes with the official Helm chart, with MongoDB, Data Node storage, inputs and log sources cut over in a controlled sequence.

On this page

Migrate Graylog from VMs to Kubernetes without losing log sources

Moving Graylog from virtual machines or Docker hosts onto Kubernetes is a re-platform of the runtime, not a change to how Graylog works. The hard parts are the MongoDB configuration store and the search backend, because both hold state that Kubernetes will not preserve for you, and the effort depends mostly on how those two backends are set up today and how many inputs must be re-pointed. Treat the runtime change as the easy part and plan the data and the log sources around it. The official Graylog Helm chart requires Kubernetes v1.32 or later and Helm v3.0 or later. Unless you supply your own MongoDB through graylog.config.mongodb.customUri, it also requires the MongoDB Controllers for Kubernetes Operator v1.6.1, so the operator becomes a platform dependency you must install, version and upgrade. Decide early whether MongoDB will run under that operator inside the cluster or stay on infrastructure you already run and be reached by URI, because that choice changes your backup, failover and network paths. Confirm the chart version you intend to deploy against its README before you write any values file. Graylog 7.2 is the current documented version, so target it unless your compatibility checks say otherwise, and confirm MongoDB and search backend versions against the compatibility matrix for that release. No fixed duration applies to this move. Ask any partner for a written scope that lists each Graylog node, each input, each backend and each log source you will cut over, and let that inventory set the schedule.

What maps cleanly from a VM Graylog to Kubernetes and what does not

This table compares each part of a VM-based Graylog with its Kubernetes counterpart under the official Helm chart. Read the right-hand column as the work you will need to plan, since items marked for rework depend on node-local state, host ports or addresses that change on the cluster. Confirm every chart value against the Helm chart README before you write a values file.

ComponentOn a VM or Docker hostOn Kubernetes with the Helm chartMigration note
Graylog server nodesPackaged services on each host, each with its own server.confPods managed by the chart, with settings supplied through chart valuesRecreate node settings as values; do not copy host config files across
MongoDBLocal or external MongoDB replica setManaged through the MongoDB Controllers operator or an external URI via customUriChoose one path before cutover and confirm the operator version in the README
Data Node or OpenSearchCluster on dedicated hosts with local data pathsVolumes from a StorageClass; on EKS the provider option creates a gp3 classIndex data must be restored or reindexed; it does not move as host files
Certificates and keysFiles on each host, often referenced by pathKubernetes Secrets or mounted volumes, with encryption at rest configured separatelyPath references in config need rework; check how the chart mounts them
Configuration filesPer-node files edited by handChart values, Helm overrides and Secrets for sensitive keysRebuild the values file rather than editing per pod; confirm keys against the README
Inputs (syslog, GELF, Beats)Listen on fixed host ports on each serverExposed through Services and ingress or load balancers the chart does or does not manageHost-based ports need new addresses; update every log source after cutover
Follower nodes (is_leader set to false)Set per host in configurationSet through chart values per deployment; confirm how replicas are configuredLeader role must follow the chart design; verify only one leader exists
Load balancer addressFixed hostname or virtual IP in front of nodesService or ingress endpoint that changes when the release is recreatedAny client or source pointing at the old address needs an update
Index sets, streams and pipelinesStored in MongoDB and configured through the web interface or APIStored in MongoDB, so they carry over if the database is preservedExport and verify them before cutover; confirm the database path with your plan

Choosing MongoDB and Data Node storage for the cluster

With the MongoDB Controllers for Kubernetes Operator, the chart creates and manages the MongoDB deployment inside the cluster. This keeps MongoDB lifecycle inside the same GitOps and Helm workflow as Graylog, which suits teams that already run the operator. The operator version is a prerequisite, and the official chart README names MongoDB Controllers for Kubernetes Operator v1.6.1 for this path.

  • Chart-managed MongoDB: the operator provisions the replica set that Graylog uses for configuration and metadata.
  • Operator version pinning: install v1.6.1 as documented in the chart README and record it in your change records.
  • Backups stay with your team: the operator does not replace a tested backup plan for MongoDB data, so define snapshot schedules and restore tests yourself.
  • Upgrades are shared: you schedule MongoDB and operator upgrades alongside Graylog upgrades and check the compatibility matrix for supported MongoDB versions.
  • Storage is cluster-bound: MongoDB volumes depend on the same StorageClass decisions as Data Node.

Confirm who on your team will restore MongoDB and how often that restore is rehearsed before you choose this path.

Documented tools and export paths for moving Graylog configuration and data

Moving Graylog onto Kubernetes splits into two jobs: rebuilding the runtime with the official Helm chart, and carrying over configuration and metadata. Log data follows a separate path, and each tool below covers only part of the move.

Official Graylog Helm chart

The chart deploys Graylog server nodes on Kubernetes and is driven by a values file, so most of the target design lives in configuration you can review and version. Check the chart README for the Kubernetes and Helm versions it requires, and for how it expects MongoDB to be supplied. Decide early whether the chart manages MongoDB through the operator or connects to an existing database through graylog.config.mongodb.customUri, because that choice changes your values file and your restore sequence.

MongoDB dump and restore

Graylog keeps configuration and metadata in MongoDB, including users, streams, pipelines and event definitions. A standard MongoDB dump and restore can carry that database into a new cluster, but it does not carry index data, and it should be tested against the exact MongoDB version your target Graylog release supports. Confirm the restore procedure with the Graylog docs and your MongoDB vendor before the cutover window, and verify that restored Graylog nodes start cleanly against the copied database.

Data Node migration from OpenSearch

Where the source runs self-managed OpenSearch, Graylog documents an in-place migration path to Data Node. This matters for the Kubernetes move because it changes the search backend, not only the host layout. Confirm the version prerequisites, backup steps and certificate requirements in the official docs, and decide whether the search backend moves before or after the application servers, since the two steps have different rollback points.

Graylog API content export

Graylog's own API exposes content objects such as streams, processing pipelines and event definitions. Exporting these through the API gives you a reviewable, version-controlled record that does not depend on a database snapshot, and it helps you spot objects that reference hosts, inputs or index sets that will change on Kubernetes. Check the current API reference for each object type you export, because endpoints and payload formats can change between major releases.

Log data stays on the source

Log data is not moved by default. Indices on the existing VMs or Docker hosts usually remain there until retention deletes them, so the source cluster must stay available for search during the retention window. Plan for that by keeping source nodes running in read mode, sizing the source storage for the remaining retention, and confirming with Graylog whether any archive or restore option applies to your edition before you retire hosts.

Confirm tool behavior before planning

Each tool above changes between Graylog and chart releases, and the behavior that matters for your migration is the one in the version you will run, not the one in older guides. Record the exact Graylog, MongoDB, Data Node and chart versions you plan to use, then check each tool's current documentation against that set. Put the confirmed steps and their owners into the migration runbook before scheduling the cutover.

Sequence for inventory, pilot, parallel run and cutover

This sequence moves Graylog from VMs or Docker hosts onto Kubernetes without losing log intake, by building and validating the new cluster beside the old one before any log source is switched. It ends with a documented cutover per source and a decommission decision that waits until the rollback window has closed.

  1. Inventory inputs, streams, pipelines and index sets

    The current Graylog administrator and the owner of each log source export the configuration that must survive the move: every input with its port and protocol, streams, processing pipelines, index sets with their rotation and retention settings, and the certificates used for TLS on inputs and the web interface. Each source is mapped to the input it sends to, and each input is marked as reachable from its senders today. The step is done when the team has one inventory that a second engineer can read without asking questions, and every source owner has confirmed the destination they expect.

  2. Build the Kubernetes cluster in a pilot namespace

    The platform team prepares a Kubernetes cluster that meets the chart's documented prerequisites, then installs the official Graylog Helm chart into a dedicated pilot namespace. MongoDB is either provided by the MongoDB Controllers for Kubernetes Operator or supplied as an external URI through graylog.config.mongodb.customUri, and Data Node storage is sized from the ingest and retention figures in the inventory. The step is done when pods are healthy, the Graylog web interface loads through the intended address, and a test message sent to a test input is searchable.

  3. Load MongoDB configuration into the new cluster

    The team exports the configuration from the existing deployment and imports the inputs, streams, pipelines, index sets, users and roles into the new MongoDB database, then reviews each object for references to hostnames, IP addresses or certificate paths that belong to the old VMs. Any such reference is rewritten to the Kubernetes service or ingress that will serve it. The step is done when a configuration comparison between old and new shows no unexplained differences and a sample of pipelines processes test messages the same way on both sides.

  4. Re-expose inputs and set follower nodes correctly

    Each input port is published through a Kubernetes service or load balancer with the address and protocol that log senders will use, and TLS settings are carried over from the inventory. Graylog nodes that are not the leader must have is_leader set to false in their configuration, so that only one node performs leader-only tasks. The step is done when a test sender reaches each published input from its own network segment, and the Graylog system page shows the expected node roles.

  5. Run both clusters in parallel with dual delivery

    Sources that can send to two destinations are configured to send to the existing VMs and the Kubernetes cluster at the same time, so the team can compare volumes, parsing results, index growth and alert behavior side by side. Each source owner checks that their events appear in the right streams and dashboards on the new cluster. The step is done when counts and parsed fields match within the tolerance the team agreed in advance, and the message journal and Data Node disk usage are stable under real traffic.

  6. Cut over inputs one source at a time

    Sources are switched to the Kubernetes inputs in small groups, starting with the least critical, and each group is recorded with the date, the owner, the change made and the rollback step. The old input stays available for the agreed rollback window so senders can be pointed back quickly if a problem appears. The step is done when every source in the inventory sends only to the new cluster, and no source owner reports missing or delayed events.

  7. Decommission the VMs after windows close

    Once the rollback window and the retention commitments for the old indices have been confirmed by the Graylog owner and the compliance lead, the VMs are shut down in stages, with snapshots or exports kept wherever retention requires. Backup jobs, monitoring checks and DNS records that pointed at the old hosts are removed at the same time. The step is done when the old endpoints no longer receive traffic, the retained data can be searched or restored as the retention policy requires, and the decommission record is signed off.

Exposing syslog, GELF and Beats inputs from Kubernetes

On a virtual machine, a syslog, GELF or Beats input listens on a host IP address that every sender already knows. On Kubernetes, those ports sit behind a Service, usually a load balancer or node-level exposure that you define in the chart values, so the address senders connect to changes. Every device, agent and application that writes to Graylog needs a new destination, and the port protocol must match what each input expects. Confirm the exact service type, external address and port mapping with your platform team before you touch any sender, and record the old and new endpoint for each input in the same inventory.

Protocol behavior is where cutover tests tend to fail. Syslog over UDP has no delivery acknowledgement, so a misrouted or dropped packet is silent, and a load balancer or NAT layer can change the source address Graylog records. TCP and Beats connections are stateful, so you must check how long-lived connections rebalance after a pod restarts and whether senders retry cleanly. Source IP visibility matters for stream rules and audit evidence, so send a test event from each sender type and confirm the recorded source, the input type and the message count in Graylog before you remove the old listener. Firewall rules on both sides need the same review, because the new source addresses may come from node or load balancer ranges rather than the original hosts.

Source-side changes usually take the longest part of cutover, because each change belongs to a different owner: network devices, Linux hosts running a log shipper, application teams, cloud services and security tools each need their own change window and rollback step. Build a list per device or application owner that names the sender, the input it targets, the change required, the test event to send and the person who signs off. Keep the old VM listener running until every item on that list is confirmed, and plan for some senders to be unreachable during the window.

What drives the cost and duration of a VM to Kubernetes move

This table lists the factors that most change the effort of moving Graylog from VMs or Docker hosts onto Kubernetes, and whether each one is paid once or keeps costing time. Use it to scope a quote, since each row names what to ask for and where the work usually grows. No prices or durations are given here because none were supplied for this move.

Effort driverWhy it changes the workType of cost and what to ask for
Number of log sources and inputsEach syslog, GELF or Beats input needs a Kubernetes service, port and load balancer path, and each source needs its own retestOne-time per input. Ask the partner to list every input, protocol and port in the written scope
Existing MongoDB topologyA single-node or self-managed MongoDB may need migration to the operator or an external URI, with data moved and verifiedOne-time migration effort. Ask whether the chart's operator path or a customUri is assumed, and who owns the database afterward
Search backend: Data Node or OpenSearchMoving to Data Node is a separate migration from the platform move, and staying on OpenSearch means version and certificate work carries overOne-time for the backend change. Confirm the OpenSearch version, since OpenSearch 1.x is deprecated for Graylog 7.x
Graylog edition in useEnterprise or Security features such as archive restore, data tiering or SSO need their own configuration and licensing checksOne-time configuration, plus license fees that recur annually. Confirm the edition before scoping
Kubernetes platform maturityA cluster with existing storage classes, ingress, secrets handling and upgrade routines shortens the work, while a new cluster adds build and hardening stepsOne-time build, then recurring upgrades. Ask which Kubernetes version the cluster runs and its upgrade plan
Identity integrationConnecting Graylog sign-in to your directory or SSO provider adds design, testing and role mapping workOne-time setup, then recurring access reviews. Ask which provider and which authentication methods are in scope
Retention and archive requirementsLonger retention increases storage sizing, persistent volume capacity and backup scope, which all grow with ingestRecurring storage cost driven by daily ingest and retention. Ask for the sizing basis used in the quote
Teams that must change sender configEach team that points hosts or devices at new endpoints needs coordination, testing and a cutover windowOne-time per team, with some recurring work for new sources. Ask who approves each cutover and who tests it

What usually goes wrong during a Graylog Kubernetes cutover

Most failed cutovers trace back to a handful of decisions made during the move: how inputs switch, what storage and journal capacity carries over, how the database is protected, and how secrets are handled. Each card below names one of these risks and the check that prevents it before log sources are pointed at the new cluster.

Dropped messages during input cutover

Inputs on the old VM or Docker host and the new Kubernetes service often run side by side only briefly, or not at all. If the sending side switches before the new inputs are listening and accepting traffic, syslog or GELF messages are lost with no error on the sender. Prevention: keep the old inputs running, bring up the new inputs on the Kubernetes service, send test messages from each source type, confirm they appear in the expected stream, and only then repoint senders one group at a time.

Journal sizing lost in the move

The message journal on the old hosts may have been tuned for a specific disk size and ingest rate. A new pod with a default volume can accept less buffered data than the source produced, so a backend slowdown during the first days becomes data loss. Prevention: size the journal volume from the daily ingest and the Graylog system architecture guidance of 3 to 5 times daily ingest on SSDs, set it explicitly in the Helm values, and verify the value on each node after the rollout.

MongoDB backups never restored

Teams often confirm that a MongoDB backup job runs but never test a restore. Graylog keeps its configuration, users, pipelines and input definitions in MongoDB, so an untested backup can leave the cutover with no working rollback. Prevention: restore the latest backup into a separate namespace, start a Graylog test node against it, and confirm that inputs, streams and dashboards load before the production cutover date is set.

Secrets stored unencrypted in etcd

Kubernetes stores Secrets unencrypted in etcd by default. The Graylog password secret, MongoDB credentials and any SMTP or PagerDuty tokens therefore sit in plain form in the cluster datastore and in its backups. Prevention: enable encryption at rest for Secrets on the API server, restrict list and watch access with least-privilege RBAC, and treat etcd snapshots as sensitive material with restricted access and a documented restore test.

Graylog and MongoDB versions out of step

The Graylog compatibility matrix limits which MongoDB versions each Graylog release supports. When the Helm chart pulls a MongoDB version from the operator, or an external MongoDB is older or newer than the matrix allows, Graylog may fail at startup or show subtle metadata problems. Prevention: check the Graylog release you are deploying against the matrix before setting the MongoDB version, pin both versions in your values, and record the pairing in the change ticket.

Sender IP changes break allow lists

Pods on Kubernetes receive addresses from the cluster network, and the load balancer or node IP that senders see can differ from the address they used on the VM. Firewalls, syslog relays and cloud security groups that allow only the old source addresses will silently drop traffic. Prevention: list every sending network and its allow rule before cutover, confirm with your platform team which address the service exposes, and update the allow lists before repointing any source.

Cluster prerequisites and security settings to confirm before cutover

Confirm the Kubernetes foundation before anyone installs the Graylog chart. The Graylog Helm chart requires Kubernetes v1.32 or later and Helm v3.0 or later, and it needs the MongoDB Controllers for Kubernetes Operator v1.6.1 unless you supply your own MongoDB through graylog.config.mongodb.customUri. Check the version your distribution ships against the Kubernetes releases page, because the project supports only the three most recent minor releases. Plan upgrades under the version skew policy: the API server moves first, one minor version at a time, and kubelets may lag by up to three minor versions. Since Graylog ingest runs on worker nodes, a cluster upgrade is also a log-ingest event, so schedule it against your inputs and journal capacity.

If you build the control plane yourself, treat high availability as a prerequisite, not a later improvement. The kubeadm guidance describes a stacked topology or an external etcd cluster, with at least three control plane nodes behind a TCP load balancer on port 6443. Confirm the etcd member count (odd, with five members recommended in production), that an etcd snapshot schedule exists, and that someone has rehearsed a restore. On the security side, confirm that encryption at rest is enabled for Secrets, because they are stored unencrypted in etcd by default. The Graylog chart places the MongoDB credentials and the Graylog password secret in that store, so this is not optional. Restrict list and watch access on Secrets with least-privilege RBAC, and consider an external store through the Secrets Store CSI Driver if your policy requires it. Review the CIS Kubernetes Benchmark with your platform team and map its general control areas, such as API server flags, RBAC and worker node configuration, to the cluster you will run Graylog on.

Apply Pod Security Standards to the namespace that holds Graylog, MongoDB and any collector components, and decide which level you can meet before the chart is installed. Also plan Graylog's own authentication during the move, because users will not simply carry over from virtual machines. Graylog Open supports Active Directory and LDAP as well as trusted header authentication, while Graylog Enterprise adds Okta, generic OpenID Connect and SAML single sign-on. Confirm which edition you hold, which identity provider is authoritative, and how administrator and break-glass accounts will be stored and tested before cutover. Kubernetes user authentication (client certificates, OpenID Connect or a proxy) is a separate decision for operators of the cluster, and it should be settled in the same review.

Questions teams ask before moving Graylog to Kubernetes

How much does it cost to move Graylog to Kubernetes?

The cost depends on the size of the environment, the number of log sources to cut over, and how much of the platform work your team can absorb. Expect one-time work for design, chart configuration, MongoDB and Data Node setup, input exposure, testing and cutover, plus recurring costs for infrastructure, storage and support. Your own cloud or data center capacity is a separate line item from labor. Ask any partner for a quote built from a written scope that lists the MongoDB approach, storage classes, number of inputs and sources, and test plan. Graylog's licensing is also a cost driver: the Graylog pricing page lists Enterprise and Security starting prices and minimum volumes, and it is licensed on processed data, not per user.

How long does a Graylog move to Kubernetes take?

Duration is set by the number of environments, the readiness of the target cluster, the MongoDB decision, the storage design for Data Node, and how many log senders must be re-pointed. Clusters that already meet the chart prerequisites and have approved change windows move faster than those that need platform work first. Plan separate phases for parallel running, sender cutover and rollback, because the slowest part is usually coordinating owners of hosts, network devices and applications. Confirm the timeline with the vendor or partner against your own environment rather than a generic estimate.

What does our team need to provide before the migration starts?

Most delays come from missing access and information, so prepare these items before scoping:

  • Cluster access: a Kubernetes cluster that meets the Graylog Helm chart requirements, with namespace, RBAC and storage class details.
  • Inventory: every input, host, device and application currently sending logs, with ports and protocols.
  • Sender owners: a named contact for each log source who can test and approve the new destination.
  • Change windows: approved dates for cutover, plus a rollback window for each source group.
  • Backend details: current MongoDB and search backend versions, retention settings and backup locations.

The chart requires Kubernetes v1.32 or later, Helm v3.0 or later, and the MongoDB Controllers for Kubernetes Operator v1.6.1 unless you supply your own MongoDB URI.

Can our internal team do the migration without a partner?

Yes, if your team already runs Kubernetes, Helm and Graylog in production and has time for design, testing and cutover. A partner adds value mainly when the team lacks recent Kubernetes or Graylog operations experience, or when the migration must fit a compliance or change-control schedule. Whichever route you choose, assign owners for chart configuration, MongoDB, Data Node storage, ingress or load balancing for inputs, and each log source. Write down who signs off on each cutover step. DeployOpen plans and implements these migrations under a written, fixed scope in infrastructure you control, so the decision is about capacity and skills, not vendor access.

Does Graylog Open or Enterprise change the migration approach?

The core approach is the same, since both editions run the same server architecture. The difference is what you are allowed to use. Graylog Open is licensed under SSPL-1.0, which is not an OSI-approved open source license, and some inputs and features need an Enterprise or Security license. Check which inputs, archive or restore features, and authentication methods you depend on before design starts, because a missing license can force a redesign of the cutover. Authentication also varies: Graylog Open supports Active Directory, LDAP and trusted header authentication, while Enterprise adds Okta, generic OpenID Connect and SAML. Confirm these details against the Graylog Open product page and your license terms.

What happens to our historical logs during the move?

Historical logs stay in the search backend, so the migration decision is about where that data lives, not whether it moves automatically. Options include keeping the existing backend running until retention expires, migrating indices into Data Node, or restoring from snapshots or archives in the new environment. Each option has different effort and downtime. Index retention behaves the same on the new platform only if index sets, rotation and retention settings are reproduced exactly, so review those before cutover. Take and test backups of MongoDB and the search backend before any change, and confirm with your compliance owner how long records must remain searchable.

What engineering risks should we check before cutting over log sources?

The main risks are lost or delayed messages during cutover, storage that fills faster than planned, and MongoDB or Data Node configuration that does not survive pod restarts. Check the message journal and buffer sizing, the storage class and volume sizing, and whether inputs are exposed with the right service type and load balancing. Sizing guidance from Graylog suggests planning log storage as daily ingest times retention days times 120 percent, and giving the journal 3 to 5 times daily ingest on SSDs. Run both platforms in parallel for each source group and compare message counts before redirecting senders.

How DeployOpen scopes and delivers a Graylog Kubernetes migration

DeployOpen starts every Graylog Kubernetes migration with a written, fixed scope agreed before any work begins. The scope names each Graylog input being moved, each log source being cut over, the target cluster and namespace, the MongoDB approach (the MongoDB Controllers for Kubernetes Operator or an external URI supplied through graylog.config.mongodb.customUri), the Data Node storage design, and the acceptance tests that close each item. The first phase is an inventory of what the current virtual machines or Docker hosts actually do: which inputs listen on which ports, which streams and processing pipelines route messages, which index sets hold data and for how long, which event definitions and notifications depend on them, and which sources send to fixed addresses. Most cutover delays trace back to a source nobody listed, so this inventory is the step we treat as the basis for the quote.

The build happens inside your cluster, in your cloud account or data center, under your change control. DeployOpen plans the chart values for the official Graylog Helm chart, confirms the prerequisites in the chart README (Kubernetes v1.32 or later, Helm v3.0 or later, and the MongoDB Controllers for Kubernetes Operator v1.6.1 unless you bring your own MongoDB), and then hardens the deployment: Pod Security Standards, least-privilege RBAC, encryption at rest for Secrets, and a restricted network path from Graylog to Data Node and MongoDB. We test each input separately, including syslog, GELF and Beats where they are used, by sending known test messages, checking parsing and stream routing, and confirming the message journal drains. Cutover then moves one source group at a time, with the old host kept available until its traffic has been verified on the new endpoint.

After go-live, support is optional. Teams that want help with upgrades, cluster maintenance, testing of new inputs or ongoing operations can move to a retainer, which is priced separately from the migration scope. Before you request a quote, confirm with your platform team which Kubernetes distribution and version you will run, whether your cluster already provides a storage class and an EBS CSI driver or equivalent, and who in your organization owns the sign-off for each cutover window. Those answers change effort more than almost any other input.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.