Forwarders are one of the most essential components in any Splunk deployment. They are responsible for collecting data from source systems and sending it to the Splunk indexers.
This section will help you understand the types of forwarders, and how to deploy and manage them effectively, especially in larger environments.
Splunk provides two types of forwarders. Both are used to transport data, but they have different capabilities and use cases.
A lightweight agent used only to forward data.
It does not include a GUI (Graphical User Interface).
It has a minimal resource footprint, which makes it ideal for installation on production systems.
It cannot parse or index data on its own — that work is done by indexers.
Use Case:
Use Universal Forwarders to collect logs from servers, network devices, or applications, and send them to indexers. They are best for performance, scalability, and low maintenance.
Example:
Installing a UF on a Linux server to monitor /var/log/messages and forward the logs to Splunk.
A full Splunk Enterprise instance that includes indexing and parsing capabilities.
Can filter, route, and transform data before forwarding it.
Uses more CPU and memory than the Universal Forwarder.
Use Case:
Use Heavy Forwarders when you need to manipulate or filter data before sending it to indexers. Also needed for some Splunk apps or add-ons that require data parsing at the source.
Example:
Using a HF to route logs from multiple locations to different indexers based on log type.
Proper deployment of forwarders is essential for system performance, manageability, and scalability.
In most environments, Universal Forwarders are preferred because they are easy to install and manage.
They consume fewer system resources, which is important on production servers.
Indexing data on HFs consumes license volume and may result in duplicate indexing if not managed carefully.
Use HFs only when parsing or routing is required and you understand the impact.
Enable SSL/TLS encryption between forwarders and indexers to protect sensitive log data in transit.
This is especially important in public networks or security-sensitive environments.
Configuration Tip:
Use outputs.conf to enable secure communication on forwarders.
A Deployment Server (DS) allows you to push configurations to many forwarders from a central point.
You can manage:
inputs.conf for data inputs.
outputs.conf for indexer destinations.
Apps and add-ons required on the forwarders.
This is essential when you have hundreds or thousands of forwarders.
A server class is a group of forwarders that share the same configuration or receive the same set of apps from the Deployment Server.
Helps you organize your forwarders based on:
Operating system
Department
Log type
Location
Example:
Group all Windows UFs in one server class, and all Linux UFs in another.
In outputs.conf, you can list multiple indexers as data destinations.
The forwarder will balance the data load across them.
This avoids overloading a single indexer and improves overall indexing performance.
Example configuration:
[tcpout]
defaultGroup = indexer_group
[tcpout:indexer_group]
server = indexer1.example.com:9997, indexer2.example.com:9997
While Heavy Forwarders (HFs) are generally not recommended for indexing due to licensing and architectural concerns, they can perform data parsing before forwarding.
HFs can apply parsing logic defined in props.conf and transforms.conf.
Typical parsing actions include:
Line breaking
Timestamp extraction
Field extractions
Event routing or filtering
After processing, the data can be forwarded to downstream indexers.
You may deploy an HF in front of a firewall that emits noisy logs. The HF can filter out unnecessary messages and forward only relevant data, reducing index volume and license usage.
HFs can consume license if indexing is not explicitly disabled. Always ensure index = false in inputs or configure the HF strictly as a parsing-only forwarder.
The Deployment Server is designed for managing Universal Forwarders (UFs) at scale via server classes and deployment apps. It is not suitable for managing:
Heavy Forwarders
Search Heads
Indexer Clusters
HF and SH configurations are more complex, often involving clustering, role-specific apps, or dynamic replication policies.
Deployment Server lacks awareness of clustering state, which can lead to inconsistent or conflicting configurations.
“The Deployment Server should not be used to manage clustered search heads or indexers.”
This is both a best practice and a possible exam-tested point.
Splunk provides a Forwarder Management App, which is a GUI-based interface to manage:
Deployment clients (e.g., Universal Forwarders)
Server classes and app assignment
Status of check-ins and app deployments
View all UFs connected to the Deployment Server.
Group UFs into server classes based on IP, hostname, or metadata.
Assign deployment apps to each class and track status centrally.
While GUI tools are rarely covered in depth on the SPLK-2002 exam, understanding their purpose and capabilities is valuable for real-world operations and may help in scenario-based questions.
What is the main difference between a Universal Forwarder and a Heavy Forwarder in Splunk?
A Universal Forwarder performs lightweight data forwarding, while a Heavy Forwarder can parse and transform data before forwarding.
The Universal Forwarder (UF) is a lightweight agent designed primarily for forwarding raw data to indexers. It consumes minimal system resources and performs limited processing.
The Heavy Forwarder (HF) runs a full Splunk Enterprise instance (without indexing). Because it includes the full Splunk processing pipeline, it can perform advanced tasks such as:
Parsing and filtering data
Applying index-time transformations
Routing data to different indexers
Integrating with external systems
Architecturally, UFs are deployed on most source systems for efficient data collection, while HFs are used when centralized processing or routing logic is required.
Demand Score: 94
Exam Relevance Score: 94
What is the role of the Deployment Server in a Splunk architecture?
The Deployment Server centrally manages configuration for Splunk forwarders.
A Deployment Server is used to distribute configuration files and apps to multiple Splunk forwarders from a central location.
Instead of manually configuring each forwarder, administrators place configurations inside deployment apps. These apps are then pushed to forwarders through the deployment server.
Key benefits include:
Centralized configuration management
Automated updates for thousands of forwarders
Consistent configuration across environments
Simplified operational management
Forwarders periodically contact the deployment server to check for updates and retrieve new configurations.
Demand Score: 86
Exam Relevance Score: 93
Why are Universal Forwarders preferred for most data ingestion scenarios?
Because they consume fewer system resources and are optimized for high-volume data forwarding.
Universal Forwarders are designed to be lightweight agents. They perform minimal data processing and focus primarily on forwarding events to indexers.
Advantages include:
Low CPU and memory usage
Small installation footprint
Minimal impact on production systems
Efficient forwarding of large volumes of data
Because of these characteristics, UFs are commonly installed on application servers, databases, and infrastructure components where resource efficiency is important.
Heavy Forwarders are only used when additional processing or routing capabilities are required.
Demand Score: 81
Exam Relevance Score: 90
How does the Deployment Server scale to manage thousands of forwarders?
By grouping forwarders into server classes that receive specific configuration bundles.
The deployment server uses server classes to organize forwarders into logical groups. Each server class represents a collection of forwarders that should receive a specific configuration or app.
For example:
Linux servers → receive Linux monitoring app
Web servers → receive Apache log configuration
Database servers → receive DB monitoring configuration
When forwarders connect to the deployment server, they are matched to the appropriate server class and receive the corresponding apps.
This architecture allows administrators to manage large numbers of forwarders efficiently without individually configuring each instance.
Demand Score: 77
Exam Relevance Score: 91
Why might a Heavy Forwarder be deployed between data sources and indexers?
To perform centralized data processing, filtering, or routing before indexing.
In complex environments, organizations often place a Heavy Forwarder between data sources and indexers. This architecture allows the HF to perform additional processing tasks before events reach the indexers.
Common use cases include:
Filtering unnecessary logs
Applying index-time transformations
Routing data to different indexers
Integrating external data ingestion pipelines
This approach reduces the load on indexers and ensures that only relevant data is indexed.
However, because Heavy Forwarders consume more resources than Universal Forwarders, they are typically deployed selectively in centralized processing layers.
Demand Score: 79
Exam Relevance Score: 92