nano SIEM
Integrations

Vector Aggregator

Supported in:Self-hosted

Run a Vector aggregator on your network to receive syslog, OTLP, files and Fluent logs, tag each with its source, and forward to nano

Run a Vector aggregator on your network to collect logs from sources that can't send to nano directly: syslog from firewalls and switches, OpenTelemetry from applications, log files on servers, and Fluent protocol from Kubernetes.

The aggregator receives logs locally, tags each event with its nano source, and forwards them to nano.

Steps 1 to 3 install Vector, add sources and tag each event with its log type. Step 4 forwards each log type to nano through its own HEC sink, authenticated with the ingest token bound to that type's source.

How an aggregator selects the source

nano picks a parser for each event by its source, and on push ingest the token decides the source. Syslog, OTLP, and Fluent do not identify a nano source, and one syslog port can receive logs from many device types.

The aggregator:

  1. Receives logs over any protocol Vector supports.
  2. Tags each event with its log type in .source_type, using VRL.
  3. Forwards each log type through its own sink, with the token bound to that type's nano source, where the source's parser maps it to OCSF.

Prerequisites

  • log_sources:deploy in nano, to issue ingest tokens
  • A Linux server, VM or container on your network that your devices can reach
  • Outbound access to nano: HTTPS to your ingest host (Self-run), or your nano host's HEC port :8088 (open core)
  • Root or CAP_NET_BIND_SERVICE if you listen on port 514

Step 1: Install Vector

# Official install script
curl --proto '=https' --tlsv1.2 -sSfL https://sh.vector.dev | bash

# Or a package (Debian/Ubuntu: apt-get install vector; RHEL: yum install vector)
vector --version

Step 2: Configure sources

Create /etc/vector/vector.toml and add the sources you need.

Syslog

[sources.syslog_udp]
type = "syslog"
address = "0.0.0.0:514"
mode = "udp"

[sources.syslog_tcp]
type = "syslog"
address = "0.0.0.0:514"
mode = "tcp"

OpenTelemetry (OTLP)

[sources.otlp]
type = "opentelemetry"
grpc.address = "0.0.0.0:4317"
http.address = "0.0.0.0:4318"

Vector's OpenTelemetry source has separate outputs; use otlp.logs as the input for log transforms. To send OTLP straight to nano instead, see OTLP.

Log files

[sources.nginx_logs]
type = "file"
include = ["/var/log/nginx/access.log"]

[sources.app_logs]
type = "file"
include = ["/var/log/myapp/*.log"]

Fluent protocol (Fluentd / Fluent Bit)

[sources.fluent]
type = "fluent"
address = "0.0.0.0:24224"

Step 3: Tag each event with its source

Every event needs a .source_type before it leaves the aggregator, so Step 4 can send it through the right sink. Use the value of the nano log source it belongs to: the bundled OCSF parsers and their source values are listed in Supported sources. For a format nano doesn't parse yet, pick your own value and build a parser for it.

Syslog

Route by hostname, app name or message content:

[transforms.tag_syslog]
type = "remap"
inputs = ["syslog_udp", "syslog_tcp"]
source = '''
hostname = to_string(.hostname) ?? ""
appname = to_string(.appname) ?? ""

if starts_with(hostname, "fw-") || starts_with(hostname, "pa-") {
    .source_type = "palo_alto"
} else if starts_with(hostname, "fgt-") || starts_with(hostname, "forti-") {
    .source_type = "fortinet"
} else if starts_with(hostname, "asa-") {
    .source_type = "cisco_asa"
} else if appname == "nginx" {
    .source_type = "nginx"
} else {
    .source_type = "syslog"
}
'''

OTLP

OTLP log records go to the OpenTelemetry logs parser when it is deployed; it claims otlp_log:

[transforms.tag_otlp]
type = "remap"
inputs = ["otlp.logs"]
source = '.source_type = "otlp_log"'

Files

For a file source you know the type up front:

[transforms.tag_nginx]
type = "remap"
inputs = ["nginx_logs"]
source = '.source_type = "nginx"'

[transforms.tag_app]
type = "remap"
inputs = ["app_logs"]
source = '.source_type = "my_app"'

Fluent

Route on the Fluent tag:

[transforms.tag_fluent]
type = "remap"
inputs = ["fluent"]
source = '''
tag = to_string(.tag) ?? ""
if starts_with(tag, "nginx.") {
    .source_type = "nginx"
} else {
    .source_type = "json_generic"
}
'''

Step 4: Forward to nano

Issue one ingest token per nano source under Ingestion → Log Sources → Credentials, and export each as an environment variable for Vector, for example NANO_TOKEN_PALO_ALTO. Then split the tagged events with a route transform and send each log type through its own HEC sink. The token decides the source; the .source_type tag only picks the sink.

[transforms.by_source]
type = "route"
inputs = ["tag_syslog", "tag_otlp", "tag_nginx", "tag_app", "tag_fluent"]
route.palo_alto = '.source_type == "palo_alto"'
route.nginx = '.source_type == "nginx"'

# palo_alto: events land in this source because of the token alone.
[sinks.nano_palo_alto]
type = "splunk_hec_logs"
inputs = ["by_source.palo_alto"]
endpoint = "https://<ingest-host>"
default_token = "${NANO_TOKEN_PALO_ALTO}"
endpoint_target = "event"
compression = "gzip"
encoding.codec = "json"

[sinks.nano_nginx]
type = "splunk_hec_logs"
inputs = ["by_source.nginx"]
endpoint = "https://<ingest-host>"
default_token = "${NANO_TOKEN_NGINX}"
endpoint_target = "event"
compression = "gzip"
encoding.codec = "json"

endpoint is the base URL; Vector adds /services/collector/event. On open core, use http://NANO_HOST:8088. Events that match no route go to by_source._unmatched; leave it unconnected (dropped) or send it to a debug sink rather than guessing a source.

Give each sink a disk buffer so events survive an outage:

[sinks.nano_palo_alto.buffer]
type = "disk"
max_size = 1073741824  # 1 GB
when_full = "block"

Retry on 429 and 503 (Vector does by default).

Vector native (mutual TLS)

From v2.0.30, nano also accepts Vector's native protocol (v2) on port 6000, on open core and Self-run. The protocol has no token, so a client certificate is the credential: every connection must present one issued for your install, or the TLS handshake is refused before any event is read. There is no plaintext mode and no switch to turn it off, even for a sender on the same server. If a TLS file is missing or unreadable, the port refuses every sender.

On v2.0.29 and earlier, :6000 was plaintext with no credential check, bound to 127.0.0.1 by default.

Events arrive as the vector_native source, whichever sender sent them; an upstream .source_type is kept as claimed_source_type. Set NANO_VECTOR_NATIVE_TRUST_SOURCE_TYPE=true on nano only if every sender with a certificate is an aggregator you control; nano then routes on .source_type. To pick the source per sender, use the HEC sinks above.

This section is for a single server. For several servers, see Vector native on a multi-server cluster; for Kubernetes, Vector-native client certificates.

How trust is set up. The installer creates it on install and upgrade. A listener CA in ~/nano/.nano-pki/vector-native (mode 0700, never in .env, never mounted into a container) signs nano's listener certificate; senders verify nano with its certificate, ca.crt. Each sender gets its own trust anchor, and the listener trusts the bundle of active anchors, so revoking one sender doesn't affect the others.

Issue a certificate for each sender, on the nano server:

cd ~/nano
scripts/nano vector-client-cert edge-dc1                        # [--out DIR] [--days N] [--address HOST[:PORT]]
scripts/nano vector-client-cert edge-dc2 --csr edge-dc2.csr     # the key stays on the sender

Without --csr, it writes edge-dc1.key (mode 0600, never printed), edge-dc1.crt and ca.crt to ./nano-vector-edge-dc1/. Certificates last 825 days unless you pass --days (up to 3650). Vector on nano restarts for a few seconds to trust the new sender. Copy the files to the sender and add the printed sink:

[sinks.nanosiem]
type = "vector"
inputs = ["tag_syslog", "tag_otlp", "tag_nginx", "tag_app", "tag_fluent"]
address = "nano.example.com:6000"
version = "2"
acknowledgements.enabled = true
tls.enabled = true
tls.crt_file = "/etc/vector/nano/edge-dc1.crt"
tls.key_file = "/etc/vector/nano/edge-dc1.key"
tls.ca_file = "/etc/vector/nano/ca.crt"
  • Address. The printed address is NANO_VECTOR_NATIVE_PUBLIC_HOST from .env, or else the BASE_URL host. With a localhost BASE_URL, set NANO_VECTOR_NATIVE_PUBLIC_HOST or pass --address. The listener certificate covers localhost, the server's host name and addresses and the BASE_URL host. For a name or address the server can't see (a NAT or cloud public address, a TCP load balancer), add it to NANO_VECTOR_NATIVE_SANS=203.0.113.7,ingest.example.com in .env and rerun install.sh.
  • List and renew. scripts/nano vector-client-cert --list shows each sender as active, expiring (under 30 days), expired or revoked; install.sh and scripts/nano upgrade warn about expiring ones. --renew edge-dc1 [--days N] [--csr FILE] re-signs the sender under the same anchor, with no restart on nano: copy the new edge-dc1.crt to the sender.
  • Revoke. scripts/nano vector-client-cert --revoke edge-dc1 removes that sender's anchor and restarts Vector on nano, so the sender is refused from then on. No other sender needs new files. If Vector can't be restarted, the command says the revocation isn't effective yet and exits 1.
  • Listener certificate. It lasts 825 days. nano re-issues it when its names change or when it has under 30 days left, but only when install.sh or scripts/nano upgrade runs, so run one of them in that last month.
  • Back up. scripts/nano backup includes .nano-pki, and scripts/nano restore puts it back. If the listener CA is missing where certificates were issued, install.sh stops with a restore hint instead of making a new CA. NANO_VECTOR_NATIVE_NEW_CA=1 starts over on purpose; every sender then needs a new certificate.
  • Port. 6000 is published on every interface, like 8080 and 8088. NANO_VECTOR_NATIVE_BIND_ADDRESS narrows it to one address. Docker publishes it, so UFW doesn't filter it: allow it only from your senders in your cloud firewall or Docker's DOCKER-USER chain (see Firewall).

Step 5: Start the aggregator

vector validate /etc/vector/vector.toml
sudo systemctl enable --now vector
sudo journalctl -u vector -f

Or as a container:

docker run -d \
  --name vector-aggregator \
  -v /etc/vector/vector.toml:/etc/vector/vector.toml:ro \
  -p 514:514/udp -p 514:514/tcp \
  -p 4317:4317 -p 4318:4318 \
  -p 24224:24224 \
  timberio/vector:latest-alpine

Step 6: Point sources at the aggregator

Network devices (syslog)

# Cisco IOS / IOS-XE
logging host 10.0.1.50
logging trap informational

# Palo Alto
set deviceconfig system syslog-server Vector server 10.0.1.50 transport UDP port 514 facility LOG_LOCAL0

# Fortinet FortiGate
config log syslogd setting
    set status enable
    set server "10.0.1.50"
    set port 514
end

Applications (OTLP)

export OTEL_EXPORTER_OTLP_ENDPOINT="http://10.0.1.50:4317"

Step 7: Deploy parsers and check the data

In Ingestion → Log Sources, make sure a parser is deployed for each source you tag. Then search by source:

metadata.log_source="palo_alto" | stats count by class_name
metadata.log_source="syslog" | stats count by device.hostname

Multiple aggregators

For several sites, run one aggregator per site or network segment. All forward to the same nano deployment, and the same sources merge into one searchable stream. Give each site its own tokens so you can revoke one site without touching the others.

Troubleshoot

Need help with these checks? Contact support with the deployment, request ID and time with timezone.

No events in nano

  1. Check the aggregator receives logs: journalctl -u vector -f.
  2. Inspect what it sends with a temporary console sink:
    [sinks.debug]
    type = "console"
    inputs = ["tag_syslog"]
    encoding.codec = "json"
  3. Look for 401 (wrong, revoked or unbound token) in Vector's logs, and check that the sink reaches the endpoint: nc -zv <ingest-host> 443 (Self-run) or nc -zv NANO_HOST 8088 (open core).

Events arrive but aren't parsed

  • The sink's token must be bound to the source whose parser reads that log type. Check under Ingestion → Log Sources → Credentials.
  • Check the source's parser is published. See Supported sources.
  • A parser that can't read an event emits it as Base Event (class_uid 0):
metadata.log_source="palo_alto" class_uid=0 | head 20

Syslog not reaching the aggregator

  • Check the device's target IP and port, and the host firewall for UDP/TCP 514.
  • Watch the wire: tcpdump -i any port 514.

Buffer filling up

When nano is unreachable, Vector buffers to disk up to max_size. With when_full = "block", Vector applies backpressure; with "drop_newest", it drops new events. Alert on buffer size.

What's next

On this page