Air-Gapped Deployment
Run nano inside a disconnected network with zero egress, a signed image tarball, offline content and AI, and an offline license.
Deploy nano inside a disconnected network to keep ingestion, storage, detection, search, and AI-assisted investigation on infrastructure you control. You use the same product as a connected deployment, with external capabilities pointed at on-premises equivalents.
What "air-gapped" means here
The connected product reaches external services for AI inference, enrichment feeds, license check-in, and image pulls. In an air-gapped install, each uses an offline path. Configure nano to avoid outbound connections across the gap.
When you run nano with AIRGAP_MODE=true, the platform:
- Disables every egress background job. Repository sync for parsers, rules, playbooks and the marketplace, IP-geo and IOC feed refresh, and the model-catalog sync no longer start. Internal jobs (detection, search, alerting, enrichment, cleanups) keep running normally.
- Never phones home for licensing. The periodic license check-in is not started; validity is established locally from a signed offline license file. No usage is reported automatically: nano keeps the daily ingested-volume record (GB per UTC day) locally, and you provide it on renewal.
- Routes AI through your on-prem endpoint only. There is no hosted AI gateway.
Features that need internet access use an offline equivalent or are disabled.
Reference architecture
Keep these components inside your trust boundary. Transfer offline bundles across the gap on your own schedule.
| Component | Role | Air-gap note |
|---|---|---|
| Vector | Log collection and VRL parsing to OCSF 1.9 | Fully local; parsers arrive in the offline content bundle |
| ClickHouse | Event storage, enrichment dictionaries, prevalence | Local; enrichment data arrives in offline bundles |
| PostgreSQL | Metadata: rules, alerts, users, dashboards, audit | Local |
| nano-api | Detection engine, alerting, ingest control, settings | Local |
| nano-search | nPL query execution and field stats | Local |
| nano web | Analyst UI: hunting, triage, detection authoring, dashboards | Served internally |
| On-prem inference (optional) | LLM and embeddings for AI assist | Bring your own endpoint; see AI on your terms |
Install options
Air-gapped installs use the commercial (Self-run) build with either orchestration:
- Docker Compose on one host: extract the Self-run compose bundle (
nano-compose-enterprise-2.0.4.tar.gz), load the signed image bundle (nano-2.0.4-enterprise.tar) into the host's Docker or your internal registry, and follow Install with Docker Compose. Skip the license step and import an offline license instead. - Kubernetes: install from the chart package (
.tgz), load the signed image bundle into your internal registry, and setglobal.imageRegistry. See Kubernetes → Air-gapped clusters.
See Deployment models for how the pieces fit together.
AI on your terms
pivt, nano's AI layer, powers detection generation, rule tuning, query assist, alert triage, and the autonomous shadow investigation that runs on new cases. AI is off by default and never routes through nano: connected installs call the model endpoint you configure directly (any OpenAI-compatible endpoint, or the Anthropic Messages API). In an air-gapped install, configure an OpenAI-compatible model endpoint inside your boundary (for example a self-hosted vLLM, Ollama, or LocalAI server running an open-weights model, plus a local embedding model for RAG).
Stand up an inference server inside the enclave that exposes an
OpenAI-compatible /chat/completions API. Note its internal URL (e.g.
http://vllm.internal:8000/v1).
In nano, go to Settings → pivt → Providers. Use the Direct inference endpoint card.
Enter the endpoint URL (including the API version segment), the provider row and API format, the model id your server serves, and an API key if your server requires one (many on-prem servers run open behind the network boundary, so the key is optional). Click Test connection, then Save.
nano talks to this endpoint over the internal network only. AI requests never leave the boundary, and the connectivity health check uses the same on-prem endpoint, so it reports the local model's status.
Offline content and enrichment
Connected, nano refreshes its detection content and enrichment data from upstream repositories and feeds. Air-gapped, those arrive as signed offline bundles you carry across the gap.
| Bundle | Contents | Lands in |
|---|---|---|
| Parsers | VRL log parsers for supported sources | Log-source / parser library |
| Rules | Detection rule packs | Detection rules library |
| Playbooks | Response playbooks | Playbook library |
| IP enrichment | IP geolocation and ASN database (IPinfo Lite) | IP enrichment |
| IOC | Threat-intel indicators (ThreatFox, Tor exit nodes, reputation) | IOC enrichment |
| License | Signed offline license (see Licensing) | License store |
Every bundle is signed; nano verifies the signature and per-file digests before importing and refuses anything that doesn't validate.
Importing a content bundle behaves like an offline repository sync: it populates the repositories page with the available items, and you choose what to import and activate, rather than auto-deploying everything. Detection still runs in real time against whatever intel is loaded; freshness becomes a function of how often you choose to bring a bundle in.
Licensing
Air-gapped licensing uses a signed offline license file, issued for your
term and validated entirely on-prem with no network call. Import it
(POST /api/airgap/license/import) when you first stand up the instance; renewal is a new file brought
across the gap. Licensing does not call home.
Product updates
Each release ships as a signed image tarball: a pinned,
digest-verified set of container images. Schema migrations run from the images
themselves, before the app services start. Each release publishes a
Self-run image lock (images.enterprise.lock) of verified digests, and the
installer refuses to start the stack on any digest mismatch. Mirror the
tarball into your internal registry and update on your change-control
schedule. Verify image integrity by digest before starting the stack.
Deployment lifecycle
Follow these four steps without opening egress:
Bring in: transfer the offline bundle (container images + initial
enrichment/content bundles) across the gap to an internal staging host. The
offline license comes later: install with NANO_LICENSE_MODE=offline, copy the
installation and organization IDs, generate the license for them in
app.nano.rs, then carry it in and import it.
Install: load the images into your internal registry, deploy the stack,
and set AIRGAP_MODE=true. nano boots against its local ClickHouse and
PostgreSQL. For TLS, add your certificate as in
Add your certificate.
Operate: ingest, detect, hunt, and investigate. Fully autonomous inside the boundary. Configure your on-prem AI endpoint and import content bundles as needed.
Update: on your cadence, bring in a new signed product bundle and refreshed feed bundles. Roll forward; nano verifies every image by digest before starting.
Pilot
Validate the deployment with a time-boxed offline pilot. Install in a representative enclave, ingest a sample of real log sources, and validate detection, search, and (optionally) on-prem AI assist end-to-end with no egress. The deliverable is a documented, reproducible air-gapped install your own team can stand up.
To run the pilot, bring the Self-run installer bundle and signed image tarball
across the gap, install with NANO_LICENSE_MODE=offline, then generate the
offline license in app.nano.rs for
the installation and organization IDs it shows and import it. The
Deployment lifecycle steps cover the rest. Need help? Contact support.
Troubleshoot
Need help with these checks? Contact support with the affected deployment, request ID and time with timezone.
Self-run features are unavailable
Check that the offline license is present, unexpired, and passes signature validation. Self-run features require a valid license.
AI is unavailable
Check the internal inference URL and model under Settings → pivt → Providers, then use Test connection. AI is optional; you can leave it unconfigured.
An offline bundle is refused
Check its signature and per-file digests. nano refuses bundles that fail validation; obtain a valid bundle before retrying.
What's next
Deploy with your AI agent
Let Claude Code, Codex or another coding agent size, install, verify and operate nano Self-run on your hosts with the nano-deploy agent skill.
nano-connect CLI
Generate local collectors with the Bash nano-connect client, issue a per-source ingest token for each, and verify that events land under the right source