nano SIEM
Concepts

Deployment models

Supported in:Self-hosted

The two ways to run nano, Open and Self-run, and where to run it: Docker Compose on one server or several, Kubernetes with Helm, or air-gapped.

Every nano deployment runs the same architecture: Vector receives and parses logs, ClickHouse stores events, and PostgreSQL holds rules, alerts, cases, users, settings and audit metadata. Events are normalized to OCSF and queried with nPL, so searches, detections and dashboards work the same way wherever nano runs.

One deployment serves one organization. Its data, credentials, detections, risk, prevalence and enrichment results are never shared with another deployment.

Two ways to run nano

PriceWho runs itInstall guide
OpenFree (AGPL-3.0)You, on your own serversInstall with Docker Compose
Self-runPaidYou, on your own serversStart at Self-run, then Docker Compose, High availability or Kubernetes (Helm)

Both run on servers you control. Pages in these docs marked Self-hosted apply to both; where a feature needs the paid license, the page says so.

What each includes

OpenSelf-run
LicenseAGPL-3.0Commercial license
Imagesghcr.io/nano-rs/nano-* (public)nano's licensed registry; credentials tied to your license
Ingest, parsing, search, detections, alerting, dashboards✓✓
Cases, notebooks, pivt AI, risk analytics, SSO (OIDC), playbooks, custom enrichmentsNo✓
High availabilityNo✓
Air-gapped operationNo✓
Runs onDocker Compose, one serverDocker Compose (one server or several), Kubernetes (Helm)

Every Self-run deployment runs one build: the same set of images; only the deployment around it differs. Contact hello@nano.rs about commercial licensing.

Deployment options

Docker ComposeKubernetes (Helm)
EditionOpen or Self-runSelf-run
Where it runsOne server, or three or more for Self-run high availabilityYour Kubernetes cluster
ScaleUp to about 100 GB/dayFrom one node to multi-shard ClickHouse (10 TB/day+)
High availabilitySelf-run across three or more servers: ClickHouse replicas, Keeper quorum, several ingest servers, and from v2.0.7 several app servers and PostgreSQL failover. See High availabilityOptional ClickHouse replicas, multiple app replicas, external PostgreSQL
IngestOne server: Vector ports or /ingest through nginx. Several servers (Self-run): a dedicated ingest frontendA dedicated ingest frontend with its own hostname
GuideInstall with Docker ComposeInstall on Kubernetes (Helm)

Docker Compose

The installer sets up the whole stack on one server: nginx, the API, search, jobs and web services, ClickHouse, PostgreSQL, Vector and Valkey. Open installs from the public nano-rs/nano repository; Self-run installs from the Self-run installer bundle with your license values. Both verify every image against a committed digest lock before starting.

curl -fsSL https://get.nano.rs | bash

See Install with Docker Compose for requirements, sizing and production setup. For Self-run across three or more servers, see High availability.

Kubernetes with Helm (sovereign)

The nano Helm chart runs Self-run on your own cluster. ClickHouse and Keeper run through the official ClickHouse operator, PostgreSQL is bundled or external, and the chart ships sizing presets from about 10 GB/day to about 10 TB/day. Ingest gets its own hostname, Ingress or load balancer, edge pods and node pool, so a flood of events can't take the app down. See Install on Kubernetes (Helm).

Air-gapped

Self-run also runs in disconnected networks, with a signed image tarball, signed offline content bundles, an offline license and on-premises AI. See Air-gapped deployment.

Storage and query

  • Events live in the ClickHouse table nanosiem.ocsf_logs, partitioned by day. Hot OCSF paths (endpoints, users, hosts, processes, files and more) are stored as typed, indexed columns; the full event is kept as JSON, and fields the parser didn't map stay under unmapped. See OCSF schema.
  • One table holds every OCSF version: each row keeps its own metadata.version, so a new OCSF release needs no migration of stored data.
  • nPL compiles to ClickHouse SQL. Searches always carry a time range, so ClickHouse reads only the partitions in it.
  • Detection findings, platform audit, prevalence and identity data are also stored in ClickHouse and searchable with nPL.
  • OTLP traces and metrics go to their own tables and power the services, service, trace and metric search commands.

Ingest

Vector receives and parses events on every deployment.

ProtocolDocker Compose, one serverKubernetes, or Compose with several serversAuth
HTTP (JSON / NDJSON)http(s)://<host>/ingest, or :8080https://<ingest-host>/ingestAuthorization: Bearer <token>
HEC:8088/services/collector/eventhttps://<ingest-host>/services/collectorAuthorization: Splunk <token>
OTLP/HTTPhttp(s)://<host>/otlp/v1/{logs,traces,metrics}https://<ingest-host>/otlp/v1/{logs,traces,metrics}Source-bound ingest token
Raw OTLP, Fluent Forward127.0.0.1 by default; opt in to other interfacesCluster-internal unless you expose themNone
Vector native (:6000)Every interface (from v2.0.30)On each ingest server (multi-server); in-cluster on Kubernetes when enabledMutual TLS: a client certificate per sender
Pull sourcesKafka, AWS S3/SQS, GCP Pub/Sub, SaaS pull feedsSamePer-source credentials

Ingest tokens are bound to one log source each and issued from Ingestion → Log Sources → Credentials. Unauthenticated listeners (raw OTLP, Fluent Forward) are for trusted networks only. Vector native requires a client certificate from v2.0.30; see Vector native. Syslog ships disabled; enable it in Vector, or send syslog to a collector that forwards over HTTP or HEC. See Integrations.

Retention

ClickHouse keeps events for 365 days by default and deletes them by daily partition when they age out. You can change the window, move older data to S3-compatible object storage, and let disk pressure protect the local disk. See Storage & Retention.

Choose a deployment

  • Docker Compose to try nano, run Open, or run Self-run on one server up to about 100 GB/day, or on three or more for high availability.
  • Kubernetes (Self-run) if you already run clusters, or ingest more than one server can handle.
  • Air-gapped (Self-run) if the deployment can't reach the internet.

What's next

On this page