Wazuh central components upgrade

A planned Wazuh central components upgrade moves the indexer, server and dashboard in a fixed order, with verified backups, rolling indexer steps and alert validation. This page sets out the path, the checkpoints and what drives the effort.

On this page

Wazuh central components upgrade: when to move and which path to follow

This section covers when a Wazuh 4.x team should move the Wazuh indexer, server and dashboard to a newer release, and which upgrade path to follow. The path itself is set by the Wazuh documentation for the target version, so any sequence in an internal plan should be treated as a draft until it matches that documentation. The current Wazuh release line is 4.14. Wazuh 4.14.9 was released on 14 October 2026 and 4.14.8 on 23 September 2026. Timing decisions start with two questions: which 4.x version is running now, and which target version the team can support through its next planning cycle. The answers determine how much of the documented path applies to your environment.

Wazuh shipped 4.14 patch releases on 17 March, 23 April, 1 July, 29 July, 23 September and 14 October 2026, roughly one every one to two months. That cadence means the target is a moving point. A plan written early in the year may name a patch that is no longer the latest when the change window opens. Record the exact target version, its release notes and the matching upgrade guide at the start of planning, and check them again before the window. Note which fixes in the release notes touch the components being upgraded, because those fixes are a reason to move and they also shape the test scope.

Before planning, confirm the current version of each central component: the indexer, the server and the dashboard. Plan to move them together and confirm which version combinations the documentation allows. Confirm whether the Wazuh server runs as a cluster, and read the documented cluster procedure for the target version. Identify the installation method that built the environment, whether all-in-one, step-by-step, OVA, container, Kubernetes, Ansible or Puppet, and check that the upgrade guide matches it. If the network is offline, confirm that the offline installation guide and an offline vulnerability repository are ready before the window. Finally, inventory custom rules, decoders and dashboard content so the validation plan has a clear baseline.

Decide early whether the change runs in one window or several. The documented component order, and the rolling steps for the indexer with shard allocation set to primaries, determine how much service interruption to plan for. Confirm those steps in the documentation for the target version and check any older internal guides against it. Before any change, take snapshots of the indexer and back up server and dashboard configuration, then test a restore on a copy, because rollback depends on that data. When you ask a partner for a quote, request a written scope that names the target version, the component order, backup and restore verification and alert validation afterward, since these items usually shape effort more than the version number alone.

What changes in the 4.14 patch releases and what to check

This table lists the kinds of change a 4.14 patch release can carry and what each one means for a central components upgrade. Wazuh publishes the actual changes, deprecations and breaking items in the release notes for each version, so each row tells you what to confirm there for your target version. The main takeaway: check the notes for the exact version you plan to install, because 4.14 patch releases have arrived roughly every one to two months.

ChangeImpactAction needed
Current release line4.14 is the current Wazuh line, and 4.14.9 (14 October 2026) is the most recent patch in this seriesConfirm the target version in the release notes before you set the upgrade date
Patch cadence4.14 patches shipped on 17 March, 23 April, 1 July, 29 July, 23 September and 14 October 2026Set a recurring review of the release notes and recheck them on each planned change date
Component changesEach release lists changes to the indexer, server and dashboard, which may affect upgrade orderIdentify which component changes apply to your deployment and whether all three must move together
DeprecationsDeprecated settings, options or APIs can break custom configuration, integrations and automation scriptsCheck the deprecation items against your server configuration, integrations and API scripts
Breaking itemsBreaking changes can alter cluster behavior, dashboard compatibility or required upgrade stepsConfirm each breaking item for the target version and add a verification step for it
Indexer stepsThe indexer upgrade depends on cluster health and shard allocation, and the notes may adjust those stepsCompare the target notes with your runbook and keep shard allocation set to primaries during the rolling upgrade
Server clusterCluster nodes may need a specific upgrade order or matching versions to keep agents connectedConfirm node order and version alignment in the notes, then rehearse it in a non-production environment
Backups and snapshotsSnapshot repository settings and backup procedures must still work after the changeConfirm snapshot and backup steps for the target version and test a restore before upgrading
Alert validationChanges to rules, decoders or indexing can alter alert output after the upgradeCompare sample alerts and alert volumes before and after the upgrade for the rules you rely on

Why the indexer, server and dashboard upgrade in a fixed order

The indexer, server and dashboard must be upgraded in a fixed order because each component depends on the one beneath it to store, process and display security data. Wazuh has four components. The Wazuh indexer is a full-text search and analytics engine that stores alerts. The Wazuh server analyzes data from agents using decoders and rules, and it can run as a cluster to scale horizontally. The Wazuh dashboard is the web interface where analysts search and review alerts. Wazuh agents sit on endpoints and send their data to the server.

The dependencies explain the sequence. The server writes its output into the indexer, so the indexer has to accept the data the server will produce after its upgrade. The dashboard reads from the indexer and queries the server, so it goes last. If the dashboard moves first, it can point at a server still running the older release, and the views may fail or show incomplete results. Before the window opens, read the compatibility guidance for your target release and confirm which indexer, server and dashboard combinations Wazuh supports. Record the current versions of all three so you can reconstruct the starting state if a step fails.

The server also manages agent configuration and handles agent upgrades remotely. This makes it the control point for what endpoints receive. A server upgrade can change the configuration that agents pull and the versions they are permitted to move to, so the central plan has to account for the agent fleet even though agents are not upgraded in this step. Confirm which agent versions the target server supports, check how many endpoints are still on older releases, and decide whether agent work will wait until the central stack is stable. Agent upgrades are covered on the separate Wazuh agent upgrades page in this group.

In practice, the order gives each step a clear test. After the indexer is upgraded and its cluster reports healthy, confirm that it accepts new data and that existing indices are readable. After the server is upgraded, confirm that agents still check in, that decoders and rules load without errors, and that new alerts reach the indexer. After the dashboard is upgraded, confirm that saved searches, dashboards and alert views return data from the indexer. Assign one owner to each gate and agree in advance who can stop the work if a gate fails.

What to back up and inventory before touching the indexer

Four preparation areas and one deployment condition determine how safely the indexer can be changed. Each card names something to back up, record or rehearse before the first node is touched. Together they give you a restore path, a known configuration and a tested sequence to fall back on.

Verified snapshots and a tested restore

Take a snapshot of indexer data before any change, and confirm it is registered in a snapshot repository your team controls. Until a snapshot has been restored at least once, it only shows that a backup job ran, not that the data can be recovered. Restore a copy into an isolated environment, check that indices and alert data open and return expected counts, and record how long the restore took on your hardware. Document the repository location and access rights so someone other than the upgrade engineer can run the restore.

Configuration backups for server and dashboard

Copy the server configuration file, the custom rule and decoder directories, and the cluster settings if the server runs as a cluster. For the dashboard, back up its configuration file and any local customizations, and record the exact package versions installed on each node. Store these copies outside the nodes being upgraded, and confirm that each file can be read back before the upgrade starts.

Inventory of custom content and integrations

List every custom rule, decoder, dashboard saved object, index template, integration and SSO setting in use. For each item, note where it lives, who owns it and whether it changed since the last release. Include the SAML configuration, certificates and API users, because these are often set in the dashboard and seldom appear in change records. This list becomes the checklist for validating alerts after the upgrade.

Test environment matching production

Build a staging environment with the same component versions, cluster sizes, node roles, shard and replica layout, certificates and authentication path as production. Use a copy of production data where your data handling rules allow it, or a representative data volume where they do not. Rehearse the full sequence, including rollback steps, and record each deviation from the production procedure. A test environment with a different topology can hide the shard allocation and restart problems the rehearsal is meant to expose.

Offline deployment checks

If the environment has no internet access, confirm that the offline installation guide for the target version matches the packages you plan to install. Check that the offline vulnerability repository has been refreshed for that version, because vulnerability detection can depend on it in place of the Wazuh Cyber Threat Intelligence platform. Mirror packages and their dependencies into the isolated network before the maintenance window and verify their checksums. Do not assume that a guide written for an earlier release still applies.

How a rolling indexer upgrade with shard allocation set to primaries works

Restarting indexer nodes one at a time keeps the cluster searchable and protects alert data, but only if each step waits for the cluster to recover before the next node is touched. The Wazuh indexer is a full-text search and analytics engine that stores alerts, so a node restart is not a cosmetic event. Every primary shard on that node has to move or wait, and every replica that was on it has to be rebuilt somewhere else. The team's job is to control that movement so the cluster never has to guess which copy of a shard is authoritative.

During a node-by-node restart, teams commonly limit shard allocation to primaries. The reasoning is that when a node leaves, the cluster should not start copying replicas onto other nodes while the node is briefly absent and may return with its data intact. Restricting allocation keeps the cluster from creating large amounts of replica traffic on every restart and from reshuffling shards that would have recovered on their own. Confirm the exact allocation setting name, its accepted values and the command that sets and resets it in the Wazuh documentation for your target version. Do not copy it from an older runbook, and record the value you started with so you can restore it after the final node. Between nodes, health is checked against the cluster state rather than against the time elapsed. After a node rejoins, the team looks at cluster health, the count of unassigned shards and whether any recovery is still running. The indexer's own health reporting is the authority here. Agree in advance which status you will accept before the next restart, whether unassigned shards must be zero, and how long the team will wait before escalating. Those thresholds belong in the change record, not in someone's memory during the window. The rule that matters most is that the cluster must return to a healthy state before the next node is touched. Restarting a second node while shards are still recovering can leave a primary with no available copy, and that is the failure that turns a routine window into a restore from snapshot. If health does not recover within the agreed window, stop, keep the remaining nodes running, investigate the blocking shards and decide with the change owner whether to roll back the node already upgraded. Plan that rollback path before the first node restarts, and confirm snapshot availability first.

Central components upgrade sequence with checkpoints and rollback

This sequence moves the Wazuh indexer, server and dashboard to the target release in an order where each stage has a check that must pass before the next one begins. Each step names its rollback point, from a snapshot restore to the previous package version on a single host. The team confirms every step against the documentation for the release being installed.

  1. Freeze changes and confirm the change window

    The change owner freezes configuration, rule and decoder changes on all central components and confirms a change window with the operations and security leads. The team identifies the target release and reads the upgrade documentation for that exact release before any host is touched. The step is complete when a change record is approved, the freeze is announced to everyone with access to the cluster, and no other deployment is scheduled during the window. Nothing has changed at this point, so the rollback is to stop and reschedule.

  2. Take and verify snapshots and configuration backups

    The team takes a snapshot of the indexer indices into a registered snapshot repository and backs up configuration from the indexer, server and dashboard hosts. That includes custom rules, decoders, certificates and the dashboard configuration file. Verify the snapshot by confirming it reports a successful state and lists the expected indices, and restore a sample index into a test location if your environment allows it. The step is done when each backup has a recorded location, the restore path for the indexer is written down, and the installed package version on every host is recorded. That record is the rollback point for every later step.

  3. Record baseline cluster health

    Before the first node changes, capture the indexer cluster health status, the list of nodes, the shard counts and any unassigned shards. Also record the server cluster node status, the number of agents reporting as connected, and the rate at which new alerts are arriving in the indexer. Keep these values in the change record, because the later checks compare against them. The step passes when the team can explain any warning already present, so it is not mistaken for an upgrade fault later. If the baseline is not healthy, stop here and resolve it before continuing.

  4. Upgrade indexer nodes one at a time

    Set shard allocation to primaries as the release documentation describes, then stop one indexer node, upgrade its package and start it again. Wait for the node to rejoin the cluster and for cluster health to return to the recorded baseline before moving to the next node. Only one indexer node should be out of service at a time. After the last node is upgraded, restore the shard allocation setting to the value the documentation specifies. The rollback for a node that will not rejoin is to reinstall its previous package version, then start it and confirm it rejoins before retrying.

  5. Upgrade server nodes in documented order

    Upgrade the Wazuh server nodes in the order the release documentation gives for their cluster roles, one node at a time. After each node is upgraded, confirm that its services are running, that it reports as connected to the server cluster, and that it is accepting agent connections. The step is complete when every server node runs the target version and the cluster reports all nodes as connected. Because the indexer has already been upgraded, the team checks that alerts continue to flow into it. Rollback for a server node is its previous package version, restored from the recorded package version and configuration backup.

  6. Upgrade the dashboard after the backend

    Upgrade the Wazuh dashboard only after the indexer and server nodes have passed their checks. Confirm that the dashboard loads, that a local or single sign-on login succeeds, and that the prebuilt views show recent alerts from the indexer. Check that the dashboard can reach the server API. The step is done when a named operator has signed in and confirmed these views against the baseline. The rollback is the previous dashboard package together with the dashboard configuration backup taken earlier, which the team restores if the views or logins fail.

  7. Confirm agent reconnection and alert validation

    Watch the number of connected agents until it returns to the baseline recorded before the upgrade, and investigate any agent that remains disconnected. Generate a controlled test event on a sample endpoint and confirm that the resulting alert appears in the dashboard and the indexer. The step passes when agent counts match the baseline, the test alert is searchable, and no new errors appear in the server logs. If agents fail to reconnect after a server node change, check the compatibility guidance in the release documentation before rolling that server node back to its previous package version. Agent upgrades are handled as a separate piece of work.

How to confirm alerts still flow after the upgrade

Write the acceptance criteria before the maintenance window opens, not during it. Each check should name the evidence that proves it passed. First, confirm that every agent in the inventory shows as active on the upgraded Wazuh server, and that agents disconnected before the window reconnect without manual re-registration. Second, generate a known test event on a monitored endpoint and confirm the resulting alert appears in the Wazuh indexer with a current timestamp. Third, replay a set of known test events through your custom decoders and rules, and confirm that each expected rule fires with its expected level and fields. Keep the test events and their expected outputs in version control so the same set runs after every upgrade.

Next, cover the user-facing and intelligence paths. Load the main dashboard views and each compliance dashboard your organization relies on, such as the PCI DSS, GDPR, HIPAA or NIST 800-53 views, and confirm that panels return data for the expected time range. If single sign-on is configured through SAML, test a login for each identity provider group and check that role mappings still apply. A broken federation can lock administrators out while the rest of the platform looks healthy, so test it deliberately. For vulnerability detection, confirm that the vulnerability data is updating from the Cyber Threat Intelligence platform or from your offline repository, whichever your environment uses, and that a test agent's software inventory is being correlated against it.

Decide in advance whether a failed check leads to rollback or fix-forward. The change owner should make that call, with the security operations lead providing the view of alert flow and a named approver for any service impact. Put the criteria in the change plan. A server that rejects agents or an indexer that stops receiving alerts usually justifies rollback, while a single broken dashboard panel or a non-blocking decoder warning usually justifies fixing forward within a time limit the plan sets. A rollback is an option only if snapshots were taken before the window and the restore path was tested. If neither exists, the team is committed to fix-forward, and the plan should state that openly so nobody discovers it mid-window.

Close the section by recording evidence. Save the test event identifiers, rule outputs, agent status export, dashboard check results and login results, each with a timestamp, in the change record. Set a monitoring period in the plan during which the security operations team compares alert volume against the baseline taken before the window, and agree who signs off the window when that period ends. Confirm with your own team and the Wazuh documentation which checks apply to your deployment type, including any offline installation, because the steps for vulnerability data differ there.

What makes a central components upgrade take longer

This table lists the factors that lengthen a Wazuh central components upgrade and explains why each one adds time. Use the third column to find what your team or partner must confirm before setting a window. The main takeaway is that data volume, customization and environment access usually matter more to the schedule than the upgrade commands themselves.

DriverWhy it mattersWhat to confirm
Indexer node count and data volumeSnapshot and restore time grows with stored alerts, and a rolling indexer upgrade runs node by node.Node count, index sizes, snapshot repository location and a tested restore procedure
Server cluster sizeEach server node in a cluster needs its own upgrade step and a check that agents reconnect correctly.Number of server nodes, load balancer behavior during node restarts and the upgrade order
Custom rules, decoders and dashboardsLocal changes may conflict with new defaults and need review, testing and sometimes rework after the upgrade.Count of custom files, their owners, version control status and dashboard objects to export
SSO and external integrationsSAML settings, certificates and downstream connectors can break and must be tested after each component changes.Identity provider configuration, certificate expiry dates and every system that receives Wazuh alerts
Air-gapped or offline vulnerability repositoryAn offline repository must be refreshed and staged before the upgrade so vulnerability detection keeps working.Repository source, update process, transfer path into the network and who owns the refresh
Number of agents to checkAgent connectivity and version status must be verified after the central upgrade, and large fleets take longer to review.Agent count, versions in use, groups and how connection status will be checked
Change window and approval requirementsApproval cycles and freeze periods limit when the upgrade can run and how long rollback time must be reserved.Approved window length, approvers, rollback criteria and communication to security operations staff
Test environment fidelityA test environment that differs from production hides data volume, integration and configuration problems until the live run.Versions, data size, integrations and configuration that the test environment matches, and what it does not match

How much does a Wazuh central components upgrade cost and what does it need from our team?

Does the self-hosted Wazuh software carry a license fee?

No. The self-hosted Wazuh software is open source and carries no license fee. It is distributed under the GNU General Public License version 2, with an exception that permits linking with the OpenSSL library. What you pay for is the work and the infrastructure around the upgrade: the people who plan and execute it, the test environment, snapshot storage, maintenance windows and post-upgrade validation of alerts. Wazuh Cloud is a different offering. It is the vendor's managed, cloud-delivered XDR and SIEM service, sold under its own plans and terms. Confirm the license terms in the LICENSE file in the Wazuh GitHub repository before your legal review relies on them.

What drives the cost of a Wazuh central components upgrade?

Scope and the current state of your deployment drive most of the cost. Scope covers how many indexer, server and dashboard nodes you run, whether the server is a cluster, and how much custom content such as decoders, rules, dashboards and integrations must be checked after the change. Current state covers the version gap, whether the environment is offline, and whether usable backups and snapshots already exist and have been tested. Effort also rises with the number of approval gates and change windows. The upgrade itself is one-time work. Patch releases in the 4.14 line have arrived roughly every one to two months, so ongoing patching is recurring effort to plan for. Ask any quote to itemize assessment, planning, execution, validation and handover separately.

How long does a central components upgrade take?

The duration depends on the same drivers as the cost, so ask for a timeline built from your written scope. The number of nodes and components, the volume of custom content to validate, the completeness of your backups and the number of change windows and approvals all affect elapsed time. Illustratively, a multi-node cluster with a long list of custom rules usually needs more test passes than a single-node lab. Timing also depends on how quickly your team provides environments, access and test data. Plan for at least one non-production rehearsal before the production window, since the rehearsal often sets the schedule. Ask the proposal to show phases, the dependencies between them and which items sit on your side.

What does our team need to provide before an upgrade starts?

Plan to provide access, named owners and decisions before anyone changes a node. Typical needs include:

  • Access: administrative access to the indexer, server and dashboard hosts, cluster and API credentials, and access to backup storage.
  • Owners: one technical owner per component, plus someone who can accept the risk to the alert pipeline.
  • Change windows and approvals: dates agreed with operations, security and any change board, with rollback criteria signed off in advance.
  • Test data: representative alerts, a non-production copy of the environment and known-good alert samples for comparison after the upgrade.
  • Documentation: current configuration, custom rules and decoders, and any integrations that depend on the dashboard or API.

Confirm each item before the scope is written, because missing access tends to delay the start.

Can our internal team run a Wazuh upgrade without outside help?

Often yes, if the team has Linux administration experience, has run Wazuh before and can dedicate time to planning and validation. The vendor documentation sets out the component order, the rolling indexer procedure and the snapshot steps, so the sequence is documented. What is harder to staff is validation and judgment: checking custom rules and decoders against the new release, confirming that alerts still flow and dashboards still render, and deciding when to stop. Teams working alone should schedule a non-production rehearsal and name one person to own the go or no-go decision. If your team lacks capacity during the change window, a fixed-scope engagement can cover the parts you hand over. Compare your internal skills against the documentation before you decide.

How is Wazuh Cloud different from upgrading a self-hosted deployment?

Wazuh Cloud is a separate managed service, so upgrading your own central components does not apply to it. It is the vendor's cloud-delivered XDR and SIEM offering, and it is sold in Small, Medium, Large and Custom tiers. Every paid plan includes at least Standard support. A 14-day free trial is available and needs no credit card, which lets you evaluate the service before deciding. Because Wazuh Cloud is a subscription service, it carries different costs, responsibilities and terms from a self-hosted deployment in your infrastructure. Pricing for each tier is set by the vendor, so ask Wazuh directly. Keep the decision separate: this scope covers self-hosted components in environments you control.

Can we roll back a failed Wazuh central components upgrade?

Rollback is possible only when you have prepared for it. Before the change, take snapshots of the indexer indices and back up the server and dashboard configuration, then confirm that a restore works in a non-production environment. Without a verified snapshot, a failed indexer upgrade can leave you with no clean path back. Clusters need extra care: document the shard allocation handling, and record which nodes were upgraded and in what order. Agree rollback criteria, such as alerts not arriving or dashboards failing, before the change window opens. DeployOpen does not guarantee a rollback outcome, because the result depends on your storage, your backups and the nature of the failure. Check the restore procedure for each component in the Wazuh documentation and in your own environment before the change.

How do you turn a written scope into a fixed-scope quote?

A quote starts with a written scope. DeployOpen does not publish a price list, so the scope determines the figure. The scope names the components and environments involved, such as indexer nodes, the server cluster and the dashboard, along with the environments to upgrade and the validation expected afterward. It lists deliverables, such as plans, backup verification, runbooks and handover documents, and any dates or constraints that apply. Once the scope is agreed in writing, the quote follows from it, and the work is fixed to that scope and its timelines. To speed things up, send your current version, node counts, custom content inventory, backup status and change-window constraints. Anything outside the written scope, such as a new integration, needs its own scope and quote.

How DeployOpen works on this

DeployOpen plans and performs Wazuh central components upgrades inside your own infrastructure, sequencing the indexer, server and dashboard in the order the Wazuh documentation calls for. Each engagement starts with a written scope so you know what is changed, tested and handed back before work begins.

How we scope

  • Inventory current indexer, server and dashboard versions, cluster topology and any custom rules or decoders.
  • Confirm backup and snapshot repository locations and recovery steps before any component changes.
  • Agree in writing which alert validation checks and documentation deliverables are included in the fixed scope.

How we build

  • Run the rolling indexer upgrade with shard allocation set to primaries, checking cluster health between nodes.
  • Upgrade the server and dashboard in sequence, reviewing configuration files and integrations at each step.
  • Test a rehearsal in a non-production copy where your environment allows, then record each step taken.

How we hand over

  • Provide a runbook covering the executed order, rollback points, snapshot references and health check results.
  • Document alert validation results so your team can confirm detections still fire after the upgrade.
  • Walk your engineers through the cluster checks they will repeat during future patch releases.

How we support

  • Ongoing support, upgrades and continuous testing are available as a retainer after the handover.
  • Agree in advance how patch releases in the 4.14 line will be reviewed and scheduled.
  • Ask for the support boundaries, response expectations and escalation path in the written quote.

Sources and further reading

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.