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.
| Component | On a VM or Docker host | On Kubernetes with the Helm chart | Migration note |
|---|---|---|---|
| Graylog server nodes | Packaged services on each host, each with its own server.conf | Pods managed by the chart, with settings supplied through chart values | Recreate node settings as values; do not copy host config files across |
| MongoDB | Local or external MongoDB replica set | Managed through the MongoDB Controllers operator or an external URI via customUri | Choose one path before cutover and confirm the operator version in the README |
| Data Node or OpenSearch | Cluster on dedicated hosts with local data paths | Volumes from a StorageClass; on EKS the provider option creates a gp3 class | Index data must be restored or reindexed; it does not move as host files |
| Certificates and keys | Files on each host, often referenced by path | Kubernetes Secrets or mounted volumes, with encryption at rest configured separately | Path references in config need rework; check how the chart mounts them |
| Configuration files | Per-node files edited by hand | Chart values, Helm overrides and Secrets for sensitive keys | Rebuild the values file rather than editing per pod; confirm keys against the README |
| Inputs (syslog, GELF, Beats) | Listen on fixed host ports on each server | Exposed through Services and ingress or load balancers the chart does or does not manage | Host-based ports need new addresses; update every log source after cutover |
| Follower nodes (is_leader set to false) | Set per host in configuration | Set through chart values per deployment; confirm how replicas are configured | Leader role must follow the chart design; verify only one leader exists |
| Load balancer address | Fixed hostname or virtual IP in front of nodes | Service or ingress endpoint that changes when the release is recreated | Any client or source pointing at the old address needs an update |
| Index sets, streams and pipelines | Stored in MongoDB and configured through the web interface or API | Stored in MongoDB, so they carry over if the database is preserved | Export 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.
An external MongoDB keeps the database under a team that already operates it, such as a managed database service or a replica set run outside Kubernetes. You point the chart at it with graylog.config.mongodb.customUri, and the chart does not install the operator in that case. Graylog still needs a replica set that matches the compatibility matrix for your release.
- Connection string ownership: the URI, credentials and TLS settings live in your secret management, so set them outside the values file where possible.
- Replica set setup: Graylog's multi-node guidance expects MongoDB as a replica set, so confirm the external topology before cutover.
- Backups belong to the database team: agree on backup scope, retention and restore testing in writing before go-live.
- Upgrades follow the database platform: check the Graylog compatibility matrix against the MongoDB version the external service offers.
- Network path: verify that Graylog pods can reach every replica set member on the required ports from the cluster network.
Ask the database owner for their restore procedure and the MongoDB version they will keep running during the Graylog upgrade window.
Graylog recommends Data Node as the search backend, and the installation documentation treats it as the default path for new deployments. Data Node runs as its own cluster, and in a Kubernetes migration it becomes the store for indexed log data that Graylog servers query. Storage class choice and volume size determine how long data stays searchable and how quickly the cluster recovers.
- Dedicated cluster: the multi-node guidance places three Data Nodes on their own cluster, separate from Graylog servers.
- Sizing formula: the system architecture page advises daily ingest times retention days times 120 percent, so use it as the starting volume estimate.
- Journal headroom: the same page advises 3 to 5 times daily ingest for the message journal on SSDs, which needs its own volume planning.
- Chart storage: on Amazon EKS,
provider=awscreates a gp3 StorageClass for all chart-managed volumes and requires the Amazon EBS CSI Driver add-on. - Backups: snapshot and restore planning for indices belongs to your team, not the chart.
Confirm the storage class, volume size and journal volume against the sizing guidance before you set provider in values.
If the current Graylog runs on self-managed OpenSearch, you can carry that backend into Kubernetes instead of moving to Data Node during the same change. This reduces the number of variables at cutover, but it means the team owns OpenSearch lifecycle, security configuration and storage. Graylog 7.0 deprecates OpenSearch 1.x, and Graylog 8.0 removes it, so the OpenSearch version must be confirmed before the move.
- Version check: the compatibility matrix supports OpenSearch from 1.1.x up to 3.7.x for Graylog 7.0 to 7.2, and Graylog Security needs OpenSearch 2.0 or later.
- Storage ownership: persistent volumes, snapshot repositories and node sizing for OpenSearch stay with your team.
- Upgrade path: plan a separate move to Data Node, since keeping OpenSearch on Kubernetes adds a second stateful system to operate.
- Two stateful systems: the cluster now hosts both MongoDB and OpenSearch state, so backup and restore runbooks must cover both.
- Rollback: keep the original VM-based cluster reachable until the new search path is verified.
Check the current OpenSearch version against the compatibility matrix before choosing this option, because the version determines whether the move is a migration or an upgrade first.
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.
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.
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.
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.
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.
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.
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.
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 driver | Why it changes the work | Type of cost and what to ask for |
|---|---|---|
| Number of log sources and inputs | Each syslog, GELF or Beats input needs a Kubernetes service, port and load balancer path, and each source needs its own retest | One-time per input. Ask the partner to list every input, protocol and port in the written scope |
| Existing MongoDB topology | A single-node or self-managed MongoDB may need migration to the operator or an external URI, with data moved and verified | One-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 OpenSearch | Moving to Data Node is a separate migration from the platform move, and staying on OpenSearch means version and certificate work carries over | One-time for the backend change. Confirm the OpenSearch version, since OpenSearch 1.x is deprecated for Graylog 7.x |
| Graylog edition in use | Enterprise or Security features such as archive restore, data tiering or SSO need their own configuration and licensing checks | One-time configuration, plus license fees that recur annually. Confirm the edition before scoping |
| Kubernetes platform maturity | A cluster with existing storage classes, ingress, secrets handling and upgrade routines shortens the work, while a new cluster adds build and hardening steps | One-time build, then recurring upgrades. Ask which Kubernetes version the cluster runs and its upgrade plan |
| Identity integration | Connecting Graylog sign-in to your directory or SSO provider adds design, testing and role mapping work | One-time setup, then recurring access reviews. Ask which provider and which authentication methods are in scope |
| Retention and archive requirements | Longer retention increases storage sizing, persistent volume capacity and backup scope, which all grow with ingest | Recurring storage cost driven by daily ingest and retention. Ask for the sizing basis used in the quote |
| Teams that must change sender config | Each team that points hosts or devices at new endpoints needs coordination, testing and a cutover window | One-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.

