Skip to content

Configuration

Configuration is how intent is expressed in JANUS. It is authored as declarative objects, versioned in Git, and compiled by the Controller into the desired state that each Gateway applies. Nothing is configured imperatively: an object is the whole statement of intent for the thing it describes.

This page is the complete reference for every configuration object kind. It assumes you have never read the JANUS source code; every field, type, required flag and validation rule below is the behavior of the shipping configuration loader and validator.

The configuration model

Every object, whatever its kind, has the same envelope:

apiVersion: janusaccess.net/v1alpha1
kind: <Kind>
metadata:
  name: <lowercase-kebab-identifier>
  uuid: <optional durable identity>
  displayName: <optional presentation label>
spec:
  ...
Field Type Required Meaning
apiVersion string yes Declarative schema version. Canonical value janusaccess.net/v1alpha1.
kind string yes The object kind. Matched case-insensitively.
metadata.name string yes Human-readable, scoped identifier and the reference key.
metadata.uuid string no Durable, immutable machine identity.
metadata.displayName string no Presentation-only label.
metadata.deployment string — Never written in YAML. Derived from the object's file path.
spec object yes Kind-specific body.

apiVersion

The canonical declarative version is:

apiVersion: janusaccess.net/v1alpha1

It is the product namespace, and every newly authored object — through the Management API, the WebUI or client enrolment — uses it.

The value used by older repositories is accepted as a supported, deprecated alias:

apiVersion: access.korves.net/v1alpha1

What the deprecation means for you as an operator:

  • objects that use the alias still load, validate, compile and reconcile exactly like canonical objects;
  • they are normalized in memory to the canonical value; the file on disk is never rewritten by the loader;
  • a deprecation warning is collected for each such object, identifying the object, the version in use, the canonical version and the migration action. A warning never fails a load.

Any other value — an unknown namespace, a future version, or a missing apiVersion — is a hard error. JANUS never guesses a schema, so an object that declares a version it does not recognise fails closed rather than being interpreted as the current one.

kind

Object decoding switches on the kind field. Matching is case-insensitive, so kind: user and kind: User are the same object; unknown kinds fail closed. The directory name a file lives in is not a reliable signal and is never used to determine the kind.

metadata

metadata.name, metadata.uuid and metadata.displayName are described in Identity and naming.

metadata.deployment is a derived field that never appears in YAML. It is the first path segment of the object's path below the repository root, so northwind-prod/users/alice.yaml is scoped to the deployment northwind-prod. A file with fewer than three path segments (<name>.yaml, or <plural>/<name>.yaml) belongs to the platform scope, written as the empty string "".

File layout and encoding

Deployment-scoped kinds live under a deployment directory:

<repository-root>/
  tenants/<name>.yaml              # platform scope
  deployments/<name>.yaml          # platform scope
  gatewaynodes/<name>.yaml         # platform scope
  <deployment>/
    gateways/<name>.yaml
    sites/<name>.yaml
    siteedges/<name>.yaml
    prefixes/<name>.yaml
    resources/<name>.yaml
    users/<name>.yaml
    groups/<name>.yaml
    devices/<name>.yaml
    accesspolicies/<name>.yaml
    routepolicies/<name>.yaml
    natpolicies/<name>.yaml

All YAML files must use:

  • UTF-8 encoding
  • LF line endings
  • two-space indentation
  • one object per file

Files and directories whose name begins with . or _ are ignored, as are non-YAML files.

Platform-scoped versus deployment-scoped kinds

Scope Kinds File location
Platform Tenant, Deployment, GatewayNode <plural>/<name>.yaml at the repository root
Deployment Gateway, Site, SiteEdge, Prefix, Resource, User, Group, Device, AccessPolicy, RoutePolicy, NATPolicy <deployment>/<plural>/<name>.yaml

Platform-scoped kinds describe the multi-tenant control plane — ownership, entitlements, capability and placement. They must not live inside a deployment directory; the validator rejects that. Deployment-scoped kinds carry the deployment's own addressing, identities and policy. See Architecture overview.

Identity and naming

Every object carries three identity fields in metadata.

Field Purpose Scope Mutable Unique
metadata.name human-readable reference key (deployment, kind); platform kinds: platform-wide renameable (preserves UUID) within scope
metadata.uuid durable machine identity global no (immutable) globally
metadata.displayName presentation none yes no

name versus uuid versus displayName

  • name is lowercase kebab-case, matching ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$, with a maximum of 128 characters. It is the key that every declarative reference uses (spec.owner, spec.gateway.primary, spec.destination.resource, spec.site, spec.subject.user, …).
  • uuid is a UUID (canonical 8-4-4-4-12 hexadecimal form). It is optional in a hand-authored Git object; the Management API assigns a time-ordered UUIDv7 on first write and never changes it afterwards. It is immutable — a rename preserves it, and delete-and-recreate produces a new one — and it is globally unique: two objects sharing a UUID fail validation. It is not a human-facing label and should not be typed by hand.
  • displayName is free text of at most 256 characters, used only for presentation. It is not a reference key, not unique, and never an authorization identity. When empty it falls back to metadata.name.

Identity-bearing references. A few security-relevant relationships do not resolve by name. The owning-tenant relationships — Deployment.spec.tenant, GatewayNode.spec.tenants (dedicated nodes) and MSP.spec.tenants — are identity-bearing: the target's immutable metadata.uuid is authoritative and the name is advisory display metadata:

tenant:
  uuid: 0191f0aa-7c3e-7b21-9f4a-1a2b3c4d5e6f   # authoritative
  name: northwind                                # advisory, may be stale

A name-only reference (the legacy scalar form tenant: northwind) is accepted only so a pre-existing repository keeps parsing, but it fails validation until it is pinned to the target's durable identity — this is what the local janus-controller config migrate-references does. The reason is security: if a name were the durable link, re-using a name for a different tenant would silently re-bind the relationship. When a uuid is present the name is never consulted, so a rename (or a stale name) can never change which object a reference designates. All other references (spec.owner, spec.gateway.primary, spec.site, …) remain in-deployment name-based.

Name uniqueness scope

Human-readable identity is (deployment, kind, name):

  • a deployment-scoped name must be unique among objects of the same kind in the same deployment — two deployments may each declare a User named alice without collision;
  • a platform-scoped name (Tenant, Deployment, GatewayNode) must be unique platform-wide.

References resolve within the referencing object's own deployment only. There is no cross-deployment reference syntax; a reference that does not resolve in-deployment fails closed. See Relationships and ordering.

Identifier rules

Field Rule
metadata.name ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$, max 128; unique per (deployment, kind), platform kinds platform-wide
metadata.uuid UUIDv7, immutable, globally unique; 8-4-4-4-12 hex
metadata.displayName free text, max 256, not a reference key, falls back to name
Capability / entitlement key ^[a-z][a-z0-9-]*(:[a-z0-9][a-z0-9-]*)?$, max 128, e.g. remote-access, connector:hpe-aruba
WireGuard public key base64 of exactly 32 bytes
Ed25519 identity key base64 of exactly 32 bytes
Gateway.spec.wireguard.endpoint host:port: DNS name, IPv4 literal or bracketed IPv6, port 1-65535

How configuration is authored

Git is the source of truth

The declarative repository is authoritative. Every object, however it is created, ends up as a versioned file:

  • direct Git — commit the YAML file yourself under the paths above;
  • Management API — write through the supported REST endpoints;
  • WebUI — edit through the browser, which writes the same objects.

All three paths converge on the same validated objects. A direct Git change is validated with the same fail-closed rules as an API write, against the whole declarative repository, before compile and reconcile. A change that fails validation is never partially applied.

One object per file

Each file contains exactly one object and one object only. The desired-state layout is <deployment>/<plural>/<name>.yaml for deployment-scoped kinds and <plural>/<name>.yaml for platform-scoped kinds. The plural directory for each kind is the one shown in the file-layout listing above and is the same directory the Management API and WebUI use.

Validation is fail-closed

Validation is deliberately fail-closed. The presence of a contradiction — an unresolvable reference, an empty required list, a duplicate name, an invalid key — is always an error, never a warning or a silent default. Where a list must carry a meaning, an explicitly empty list is rejected rather than interpreted as "unset". A referencing object created before its referent fails validation; there is no partial resolution.

The Management API, the WebUI and the CLI surface these errors; see Reference: API and Reference: CLI.

Object reference

The subsections below are ordered Tenant, Deployment, GatewayNode, Gateway, Site, SiteEdge, Prefix, Resource, Device, User, Group, AccessPolicy, RoutePolicy, NATPolicy. Addresses in the examples use documentation and private-use ranges only.

Tenant

A Tenant is the administrative, security, ownership and commercial boundary. It owns one or more deployments and is deliberately not itself a deployment. It is a platform-scoped object.

apiVersion: janusaccess.net/v1alpha1
kind: Tenant
metadata:
  name: northwind
  uuid: 0191f0aa-7c3e-7b21-9f4a-1a2b3c4d5e6f
  displayName: Acme Corp
spec:
  enabled: true
  entitlements:
    - connector:hpe-aruba
    - remote-access
Field Type Required Meaning
metadata.name string yes Locator. Unique across the platform.
spec.enabled bool yes Tenant lifecycle. A disabled tenant owns its deployments for audit, but holds no entitlement in effect.
spec.entitlements []string no Capability keys the tenant is licensed to use.

Entitlements. An entitlement is a licence to use a capability. It is not a grant of access and it is never a throughput ceiling. A capability is in effect only when the tenant is entitled to it and a placed, enabled node is capable of it and the deployment requires it. A capability key is a lowercase token, either feature or namespace:name; the vocabulary is open and extensible.

The reserved default tenant. The name default is reserved. It owns any deployment scope that has no explicit Deployment object, so existing installations keep working. The implicit default tenant holds no entitlement. Declaring a Tenant named default materialises the same identity so entitlements can be granted to it; ownership of its deployments does not change.

Validation

  • name must be lowercase kebab-case, within the length limit, and unique across the platform;
  • a duplicate entitlement is rejected;
  • a malformed capability key is rejected;
  • the object must be platform-scoped — placing it in a deployment directory is rejected;
  • a duplicate metadata.uuid anywhere is rejected.

Deployment

A Deployment declares the control-plane facts about one deployment scope: the owning tenant, the required capabilities and where it may execute. It is a platform-scoped object, and metadata.name must equal the deployment name used as the first path segment of that deployment's objects.

apiVersion: janusaccess.net/v1alpha1
kind: Deployment
metadata:
  name: northwind-prod
spec:
  tenant:
    uuid: 0191f0aa-7c3e-7b21-9f4a-1a2b3c4d5e6f
    name: northwind
  capabilities:
    - connector:hpe-aruba
  placement:
    gateways:
      - her-01
  network:
    internalPrefixes:
      - 10.100.0.0/16
      - 2001:db8:1234::/48
Field Type Required Meaning
metadata.name string yes The deployment scope name. Must equal the deployment directory. Unique across the platform.
spec.tenant object {uuid, name} yes The owning tenant, as an identity-bearing reference: the immutable uuid is authoritative and name is advisory display metadata. An empty, name-only or unknown-uuid value fails closed.
spec.capabilities []string no Capability keys this deployment requires.
spec.placement.gateways []string no GatewayNode names this deployment may execute on.
spec.selfService object no Centrally defined self-service policy.
spec.network.internalPrefixes []string no Extra prefixes classified as INTERNAL.

Capability, entitlement and placement. A required capability is in effect only when all of these hold: the owning tenant is enabled and entitled to it; at least one GatewayNode the deployment is placed on is enabled and capable of it; and, for a dedicated node, the node admits the owning tenant. Capability alone never grants use, and entitlement alone never grants use.

spec.selfService. Declares the bounds of the self-service device management portal. When it is absent, or present with enabled: false, self-service is unavailable and the portal fails closed. A user manages only their own devices, inside the bounds declared here — self-service never becomes an authorization-policy editor.

Field Type Required Meaning
enabled bool no Turns self-service device management on.
gateway string yes when enabled The declared Gateway self-service devices attach to.
clientIPv4Pool / clientIPv6Pool string at least one when enabled The client address pool(s). Valid CIDR, a network address with no host bits, and at least one usable host.
maxDevicesPerUser int no Control-plane scale bound. Default 10; 0 means the built-in default; negative is rejected.

spec.network.internalPrefixes. Additional deployment-scoped prefixes classified as INTERNAL for Internet egress. These are classification overrides only — never routes and never authorizations. A default route is rejected here, because it would classify the whole address space as internal. See Internet egress.

Validation

  • empty spec.tenant is rejected;
  • a name-only spec.tenant is rejected — the owning tenant must be referenced by its immutable uuid (author the {uuid, name} mapping, or pin an existing name-only reference with the local reference migration). A name is advisory and must never be the durable link, so a re-used name can never silently re-bind the relationship;
  • a spec.tenant.uuid that does not resolve to a declared, durably-identified tenant is rejected (the reserved default resolves implicitly);
  • a second Deployment object for one deployment name is rejected — ownership would be ambiguous;
  • the object must be platform-scoped;
  • a required capability that the tenant is not entitled to (or whose tenant is disabled) is rejected;
  • a required capability for which no enabled, capable, placed node exists is rejected;
  • an unknown, disabled or dedicated-ineligible node in spec.placement.gateways is rejected;
  • a duplicate node or capability entry is rejected;
  • an internal prefix that is a default route is rejected; a duplicate or malformed internal prefix is rejected;
  • on an enabled self-service policy: a missing or unknown gateway, no client pool, a pool with host bits set or no usable host, or a negative maxDevicesPerUser is rejected.

GatewayNode

A GatewayNode is the infrastructure / execution node abstraction: what a node can technically execute and how it may be shared. It is never owned by a tenant and is distinct from the deployment-scoped Gateway. It is a platform-scoped object.

apiVersion: janusaccess.net/v1alpha1
kind: GatewayNode
metadata:
  name: her-01
spec:
  enabled: true
  country: DE
  region: NRW
  city: Herne
  sharing: shared
  capabilities:
    - connector:hpe-aruba
    - remote-access
Field Type Required Meaning
metadata.name string yes Node name. Unique across the platform; the name deployments place against.
spec.enabled bool yes Node lifecycle. A disabled node satisfies no capability and cannot host a deployment.
spec.country / spec.region / spec.city string no Operator-facing location metadata.
spec.sharing string no shared (default) or dedicated.
spec.tenants []object {uuid, name} for dedicated only The tenants a dedicated node is reserved to, as identity-bearing references (immutable uuid authoritative; name advisory).
spec.capabilities []string no Capability keys the node can technically execute.

Sharing. shared may host multiple eligible tenants and deployments and must not carry a tenant list. dedicated restricts placement to the named tenants and must name at least one; a deployment of any other tenant placed on it fails closed. Shared versus dedicated is a placement/policy distinction on the node only — both use the same data plane.

Validation

  • an unknown spec.sharing value is rejected;
  • shared with a tenant list is rejected; dedicated with no tenant is rejected;
  • a spec.tenants entry that is unknown or name-only is rejected (each entry must carry the tenant's immutable uuid); a duplicate entry is rejected;
  • a malformed or duplicate capability key is rejected;
  • a duplicate node name is rejected;
  • the object must be platform-scoped.

Gateway

A Gateway declares one Access Concentrator gateway host / WireGuard endpoint for one (deployment, node). It is a deployment-scoped kind, living at <deployment>/gateways/<name>.yaml. spec.gatewayNode names the platform GatewayNode this object runs on — the authoritative link between the deployment-scoped Gateway and the infrastructure node.

apiVersion: janusaccess.net/v1alpha1
kind: Gateway
metadata:
  name: fra-01-gw1
spec:
  enabled: true
  gatewayNode: her-01
  location:
    country: DE
    region: NW
    city: Herne
  wireguard:
    listenPort: 51820
    endpoint: gw.example.net:51820
  capabilities:
    remoteAccess: true
    siteToSite: true
    bgp: false
    publicPrefixes: true
    nat: true
  network:
    allowedPublicIPv4:
      - 203.0.113.0/24
  fabric: {}
Field Type Required Meaning
metadata.name string yes Gateway identifier, deployment-scoped.
spec.enabled bool yes Whether the gateway is active.
spec.gatewayNode string no The platform GatewayNode this gateway runs on. When set it must name a real node; it links this object to the node's enrolled runtime identity.
spec.location.country / region / city string no Location metadata.
spec.wireguard.listenPort int no WireGuard UDP listen port (default 51820).
spec.wireguard.endpoint string no Public host:port a client dials. A locator, not an identity.
spec.capabilities.* bool no Feature flags; all default to false.
spec.network.allowedPublicIPv4 / allowedPublicIPv6 []string no Public address space this gateway may use.
spec.fabric object no Declares this (deployment, node) a fabric participant. The block carries no key.

Capabilities. remoteAccess, siteToSite, bgp, publicPrefixes and nat are boolean feature flags for this gateway; each defaults to false.

WireGuard keys are automatic. The gateway's WireGuard public key and its per-participant fabric public key are not authored here. The gateway generates the matching private keys locally (they never leave the host) and reports the public keys through its authenticated enrollment; the controller is the single source of truth for those public identities. There is deliberately no spec.wireguard.publicKey or spec.fabric.publicKey field: an operator never types, pastes or copies a JANUS Gateway/Fabric key. (External keys — a Device's own client key, a Site, a Site Edge's transport key — are still authored, because JANUS does not own those private keys.)

Fabric participation. Declaring the spec.fabric block makes this (deployment, node) a fabric participant; the participant's transport key is reported automatically. A Gateway with no spec.fabric block is not a fabric participant — it joins no fabric and no other participant installs a peer for it. In a fabric with more than one participant, every participant must declare spec.wireguard.endpoint. Fabric participation is required before a Gateway can be a SiteEdge attachment target.

Validation

  • spec.gatewayNode, when set, must name a declared GatewayNode;
  • spec.wireguard.endpoint, when set, must be host:port (DNS name, IPv4 literal or bracketed IPv6), with a port in 1-65535;
  • in a multi-participant fabric, a participant with no declared transport endpoint host is rejected;
  • a name colliding with another Gateway of the same deployment is rejected.

Site

A Site is a remote Site-to-Site VPN peer. It is a deployment-scoped kind at <deployment>/sites/<name>.yaml.

apiVersion: janusaccess.net/v1alpha1
kind: Site
metadata:
  name: leipzig-warehouse
spec:
  enabled: true
  gateway:
    primary: fra-01-gw1
  wireguard:
    publicKey: AwoRGB8mLTQ7QklQV15lbHN6gYiPlp2kq7K5wMfO1dw=
  tunnel:
    ipv4:
      local: 10.255.10.1/31
      remote: 10.255.10.0/31
  routing:
    mode: static
    advertisedPrefixes:
      - 192.0.2.0/24
Field Type Required Meaning
metadata.name string yes Site identifier, deployment-scoped.
spec.enabled bool yes Whether the site connection is active.
spec.gateway.primary string yes Gateway this site connects to, in the same deployment.
spec.wireguard.publicKey string yes The site's WireGuard public key.
spec.tunnel.ipv4.local / .remote string no Tunnel IPv4 addresses (CIDR).
spec.tunnel.ipv6.local / .remote string no Tunnel IPv6 addresses (CIDR).
spec.routing.mode string no static or bgp (default static).
spec.routing.advertisedPrefixes []string no Prefixes the site advertises (CIDR).

Routing modes. static compiles routes from advertisedPrefixes; bgp exchanges routes via BGP and requires FRR on the gateway.

Validation

  • spec.gateway.primary must resolve to a Gateway of the same deployment;
  • spec.wireguard.publicKey must be a valid WireGuard public key;
  • each tunnel address must be valid CIDR, and a tunnel IP must not be reused by another site in the same deployment;
  • spec.routing.mode must be static or bgp;
  • each advertised prefix must be valid CIDR;
  • two enabled sites in a deployment must not advertise the same prefix, and must not advertise overlapping prefixes.

SiteEdge

A SiteEdge is one JANUS Site Edge: the customer-side software that terminates JANUS connectivity on behalf of a Site. It is a deployment-scoped kind at <deployment>/siteedges/<name>.yaml, and it references an existing Site in the same deployment. One site may own several Site Edges.

A Site Edge routes; the provider authorizes. See Site Edge.

apiVersion: janusaccess.net/v1alpha1
kind: SiteEdge
metadata:
  name: leipzig-edge1
spec:
  enabled: true
  site: leipzig-warehouse
  roles: [ingress, egress]
  attachment:
    primary: fra-01-gw1
  identity:
    publicKey: CRYjMD1KV2RxfouYpbK/zNnm8wANGic0QU5baHWCj5w=
  wireguard:
    publicKey: AwoRGB8mLTQ7QklQV15lbHN6gYiPlp2kq7K5wMfO1dw=
  lan:
    prefixes:
      - 192.0.2.0/24
      - 2001:db8:50::/48
  ha:
    precedence: 10
Field Type Required Meaning
metadata.name string yes Name, scoped to (deployment, kind, name).
spec.enabled bool yes Access state, never an activity state.
spec.site string yes An existing Site in the same deployment.
spec.roles []string yes Non-empty subset of {ingress, egress}.
spec.attachment.primary string yes when enabled The single provider Gateway this edge attaches to.
spec.identity.publicKey string yes Pre-registered Ed25519 control-plane public key.
spec.wireguard.publicKey string no Edge WireGuard transport public key (public material).
spec.lan.prefixes []string no Customer-local prefixes the edge declares.
spec.ha.precedence int no Declarative redundancy preference.

Roles. spec.roles is a set over the closed enum {ingress, egress}. bidirectional is not a value: it is expressed as the two roles together. Direction is enforced, not descriptive — a customer source reaching the Internet is a customer-to-JANUS NEW connection and therefore needs ingress; an egress-only edge denies that flow even when the subject holds a valid Internet policy.

Attachment. spec.attachment.primary names exactly one provider Gateway of the same deployment, and it is desired state rather than an observation. The named gateway must exist in the edge's own deployment, be enabled, and be a fabric participant (declare a spec.fabric block). A disabled edge may omit the attachment, but a stated one must still resolve.

Identity. The pre-registered Ed25519 public key is the edge's durable control-plane identity. One identity key may back exactly one Site Edge everywhere; a second registration of the same key is rejected.

Declared versus accepted prefixes. Declaring a prefix in spec.lan.prefixes does not make it reachable. A customer prefix becomes provider reachability only when it is declared by both the edge's spec.lan.prefixes and an enabled Resource bound to the edge via spec.siteEdge:

acceptedStaticPrefixes(edge) =
    edge.spec.lan.prefixes  INTERSECT  prefixes of enabled Resources bound to the edge

A declared prefix with no bound Resource is visible and reportable but never becomes provider reachability. A default route (0.0.0.0/0, ::/0) is representable but is never accepted for provider transit. Any prefix length is representable, including /0, /32 and /128.

Validation

  • spec.site is required and must resolve in the same deployment;
  • spec.roles must be non-empty, contain no duplicates, and contain only ingress and egress (not bidirectional);
  • on an enabled edge, spec.attachment.primary is required and must name an enabled, fabric-participant Gateway of the same deployment;
  • spec.identity.publicKey is required and must be a valid Ed25519 key; a key already pre-registered to another Site Edge is rejected;
  • spec.wireguard.publicKey, when present, must be a valid WireGuard public key;
  • each LAN prefix must be valid CIDR, with no duplicate; two enabled Site Edges in one deployment must not accept the same prefix;
  • spec.ha.precedence must not be negative;
  • a declared prefix with no bound enabled Resource, or a declared default route, produces a warning (not accepted) rather than becoming reachability.

Prefix

A Prefix is an IP prefix assignable to a site or device, and usable as an AccessPolicy source network. It is a deployment-scoped kind at <deployment>/prefixes/<name>.yaml.

apiVersion: janusaccess.net/v1alpha1
kind: Prefix
metadata:
  name: leipzig-public-v4
spec:
  prefix: 203.0.113.0/24
  family: IPv4
  public: true
  assignedTo: alice
  site: leipzig-warehouse
Field Type Required Meaning
metadata.name string yes Prefix identifier, deployment-scoped.
spec.prefix string yes CIDR notation.
spec.family string no IPv4 or IPv6; auto-detected from the prefix when empty.
spec.public bool yes Whether this is a public (Internet-routable) prefix.
spec.assignedTo string no Free-text assignment label.
spec.site string no Site this prefix is assigned to.

Validation

  • spec.prefix must be valid CIDR;
  • when spec.family is set it must match the prefix's address family (case-insensitive), otherwise the object is rejected;
  • when spec.public is true, the prefix must fall within the allowed public aggregates configured on the Controller, otherwise it is rejected. Those aggregates are installation configuration, not desired state: the Controller configuration is the upper safety boundary, and no object in Git can widen it. The same aggregates bound a Gateway's spec.network.allowedPublicIPv4 / allowedPublicIPv6 and therefore which snat addresses a deployment may use;
  • spec.assignedTo is a free-text label only.

Resource

A Resource is an internal resource — a VM, service or network — that clients or sites can access. It is a deployment-scoped kind at <deployment>/resources/<name>.yaml.

apiVersion: janusaccess.net/v1alpha1
kind: Resource
metadata:
  name: frankfurt-fileserver
spec:
  type: host
  addresses:
    - 10.20.0.10/32
  services:
    - name: ssh
      protocol: tcp
      port: 22
  gateway:
    primary: fra-01-gw1
Field Type Required Meaning
metadata.name string yes Resource identifier, deployment-scoped.
spec.type string yes Resource type. host, network or service.
spec.prefixes []string no Network prefixes (CIDR).
spec.addresses []string no Individual addresses (CIDR).
spec.services []object no Service definitions (see below).
spec.gateway.primary string no Gateway that provides reachability to, and originates, this resource.
spec.siteEdge string no A SiteEdge through which this resource is originated and reached.

Reachability ownership. spec.gateway.primary names the provider Gateway that provides reachability to the resource inside the deployment fabric; the resource's addresses are then originated by that participant. spec.siteEdge instead names a SiteEdge: the resource sits behind a customer edge, is reached through it, and the edge's spec.attachment.primary determines the provider Gateway path. The two are mutually exclusive — a resource behind a Site Edge is reached through that edge, so spec.gateway.primary must be empty when spec.siteEdge is set. A resource with neither field is neither advertised into the fabric nor bound to an edge.

A resource bound to a SiteEdge contributes to that edge's accepted prefixes: a customer prefix is accepted for provider transit only when it is declared by both the edge's spec.lan.prefixes and a bound, enabled Resource.

Service definition (shared with AccessPolicy):

Field Type Required Meaning
name string no Human-readable service name.
protocol string yes tcp, udp or sctp.
port int yes Port number, 1-65535.

Validation

  • spec.type is required; when it is host (case-insensitive), every address must be a /32 (IPv4) or /128 (IPv6) prefix;
  • every spec.prefixes and spec.addresses entry must be valid CIDR;
  • every service protocol must be tcp, udp or sctp, and every port must be 1-65535;
  • spec.gateway.primary, when set, must resolve to a Gateway of the same deployment;
  • spec.siteEdge must resolve to a deployment-scoped SiteEdge, and is mutually exclusive with spec.gateway.primary;
  • binding to a disabled Site Edge is a warning: the resource's prefixes are not accepted for provider transit.

Device

A Device is a VPN client device — a laptop or phone. It is a deployment-scoped kind at <deployment>/devices/<name>.yaml.

apiVersion: janusaccess.net/v1alpha1
kind: Device
metadata:
  name: alice-laptop
spec:
  owner: alice
  enabled: true
  wireguard:
    publicKey: AwoRGB8mLTQ7QklQV15lbHN6gYiPlp2kq7K5wMfO1dw=
    ipv4: 10.255.0.10/32
    ipv6: 2001:db8:10::10/128
  gateway:
    primary: fra-01-gw1
    eligible:
      - fra-01-gw1
      - fra-01-gw2
Field Type Required Meaning
metadata.name string yes Device identifier, deployment-scoped.
spec.owner string yes Owning User, in the same deployment.
spec.enabled bool yes Whether the device is active.
spec.wireguard.publicKey string yes The client's own WireGuard public key.
spec.wireguard.ipv4 / ipv6 string no Assigned overlay addresses (CIDR).
spec.gateway.primary string yes* Preferred gateway, in the same deployment.
spec.gateway.eligible []string no Closed set of gateways this device may attach to.

* primary may be omitted only when eligible is also omitted; the historical "any enabled gateway of the deployment" behavior is then preserved.

Client-owned keys. spec.wireguard.publicKey is the client's own public key. JANUS never generates, receives or stores a client private key. A device is normally created by the client-enrollment flow — which authors this object — but may equally be created by an administrator directly through the API or by committing the YAML. Both paths produce the same declarative object.

Eligibility semantics. eligible is the closed set of gateways this device is permitted to attach to. It is desired state: an administrator declares it.

primary   = the PREFERRED gateway (where the device attaches when reachable)
eligible  = the SET the device may attach to; runtime failover selects from it
  • eligible absent → effective eligibility is exactly [primary] (single-gateway behavior). If primary is also absent, the device may attach at any enabled gateway of the deployment — the historical behavior.
  • eligible present, non-empty → that set is the eligibility, and primary (which must be one of them) is the preferred member.
  • eligible present, empty → validation error. An explicitly empty list is never silently treated as [primary] and never silently widened.

Which gateway a device is currently using is runtime state and never produces a Git commit; only an administrator changes primary or eligible. A runtime observation may select only among gateways that are already eligible.

Validation

  • spec.owner must resolve to a User of the same deployment;
  • spec.wireguard.publicKey must be a valid WireGuard public key;
  • spec.wireguard.ipv4 and spec.wireguard.ipv6, when set, must be valid CIDR, and an overlay IP must not be reused by another device in the same deployment;
  • spec.gateway.primary, when set, must resolve to a Gateway of the same deployment;
  • spec.gateway.eligible, when present, must be non-empty, contain no empty or duplicate member, name only declared Gateways of the same deployment, and contain gateway.primary;
  • when eligible is set, primary is required; when primary is set and eligible is set, primary must be in eligible.

User

A User is a human user identity. It is a deployment-scoped kind at <deployment>/users/<name>.yaml.

apiVersion: janusaccess.net/v1alpha1
kind: User
metadata:
  name: alice
spec:
  displayName: Thomas Example
  email: alice@example.com
  enabled: true
Field Type Required Meaning
metadata.name string yes User identifier, deployment-scoped.
spec.displayName string no Human-readable display name.
spec.email string no Email address.
spec.enabled bool yes Whether the user account is active.

Note. spec.displayName is a pre-existing user-profile field. It is distinct from metadata.displayName — the two are separate fields on User, not aliases.

Validation

  • the name must satisfy the identifier rules and be unique within its (deployment, kind);
  • an AccessPolicy referencing a non-existent user is a validation error.

Group

A Group is a set of users, used as an AccessPolicy subject. It is a deployment-scoped kind at <deployment>/groups/<name>.yaml.

apiVersion: janusaccess.net/v1alpha1
kind: Group
metadata:
  name: engineering
spec:
  members:
    - alice
    - alice
Field Type Required Meaning
metadata.name string yes Group identifier, deployment-scoped.
spec.members []string no Names of the users in this group.

Validation

  • the name must satisfy the identifier rules and be unique within its (deployment, kind);
  • a group referenced by an AccessPolicy must exist in the same deployment.

AccessPolicy

An AccessPolicy grants a user, group, device or prefix access to a resource or to the Internet. It is a deployment-scoped kind at <deployment>/accesspolicies/<name>.yaml.

The default is deny: only explicitly enabled policies grant access.

apiVersion: janusaccess.net/v1alpha1
kind: AccessPolicy
metadata:
  name: alice-fileserver-ssh
spec:
  subject:
    user: alice
  destination:
    resource: frankfurt-fileserver
  services:
    - protocol: tcp
      port: 22
  enabled: true
  expires: 2026-09-11T18:00:00+02:00
Field Type Required Meaning
metadata.name string yes Policy identifier, deployment-scoped.
spec.subject object yes The one subject this policy applies to.
spec.destination object yes The one destination: a resource or the Internet.
spec.services []object no Protocol/port constraints; the ServiceDef shape above.
spec.enabled bool yes Whether the policy is active.
spec.expires string no Expiry timestamp.

Subjects. spec.subject sets exactly one of:

Subject Field Meaning
User spec.subject.user the user's devices
Group spec.subject.group the member users' devices
Device spec.subject.device exactly that Device — it does not grant the owner's other devices
Prefix spec.subject.prefix an existing deployment-scoped Prefix used as an authoritative source network

Setting none, or more than one, is a validation error. A raw CIDR is never a subject — a Prefix subject must name an existing Prefix of the same deployment. A Prefix subject must not be a default route or a SPECIAL range, and must have a valid ownership/routing relationship: either it declares a site that exists and actually covers the prefix (advertised or tunnel prefixes), or the prefix must be JANUS-known space (declared by an enabled Resource, a Site advertised prefix, or a Site Edge). A Device subject resolves to the device's canonical tunnel addresses from trusted desired state; a client-supplied address is never accepted as the meaning of a policy.

Destination. spec.destination is a discriminated pair — exactly one of resource or internet:

  • destination.resource names a Resource in the same deployment;
  • destination.internet: true means the deployment's INTERNET destination class — never 0.0.0.0/0 or ::/0. INTERNAL and SPECIAL destinations are excluded, so an Internet grant can never authorize an internal JANUS or customer destination. See Internet egress.

Setting both, or neither, is a validation error.

Services. The service model applies unchanged. A policy with no services grants nothing, and a policy is not automatically all protocols and ports: DNS is reachable only if the services allow it.

Temporary access. spec.expires states when the grant should be withdrawn; the Controller reconciles and removes the access without a new Git commit.

Validation

  • exactly one of subject.user, subject.group, subject.device, subject.prefix must be set, and must reference an existing object of the same deployment;
  • exactly one of destination.resource or destination.internet must be set;
  • a subject.prefix must be an existing deployment-scoped Prefix, must not be a default route or a SPECIAL range, and must be either site-covered or JANUS-known space;
  • each service protocol must be tcp, udp or sctp, and each port must be 1-65535.

RoutePolicy

A RoutePolicy controls which prefixes a site may import and export. It is a deployment-scoped kind at <deployment>/routepolicies/<name>.yaml.

apiVersion: janusaccess.net/v1alpha1
kind: RoutePolicy
metadata:
  name: leipzig-routes
spec:
  site: leipzig-warehouse
  import:
    - 192.0.2.0/24
  export:
    - prefix: 203.0.113.0/24
    - prefix: 2001:db8:5::/48
Field Type Required Meaning
metadata.name string yes Policy identifier, deployment-scoped.
spec.site string yes The Site this policy applies to.
spec.import []string no Prefixes the site may import (CIDR).
spec.export []object no Prefixes the site may export.
spec.export[].prefix string yes (per entry) A prefix CIDR the site may export.

Validation

  • spec.site must resolve to an existing Site of the same deployment;
  • each spec.import entry must be a valid CIDR;
  • each spec.export[].prefix value must be a valid CIDR. A Prefix object name is not accepted here: the validator parses the value as a prefix.

Effect in this release

RoutePolicy is part of the schema and is validated, but it does not change the compiled data plane in this release: the compiler deliberately produces no routing peers from it, and an empty import/export set means deny. Routing is static and is derived from the Site's own declarations — spec.routing.advertisedPrefixes, its tunnel pair, and the ownership declared by Resources, Prefixes and Site Edges. Declare those to make a prefix reachable; a RoutePolicy alone will not.

NATPolicy

A NATPolicy controls source NAT behavior between a site and destination networks. It is a deployment-scoped kind at <deployment>/natpolicies/<name>.yaml.

NAT is never implicit. NAT occurs only when an administrator explicitly declares a NATPolicy. Zero NAT policies means zero NAT rules.

apiVersion: janusaccess.net/v1alpha1
kind: NATPolicy
metadata:
  name: branch-special
spec:
  site: leipzig-warehouse
  mode: snat
  source:
    prefixes:
      - 10.50.0.0/16
  destination:
    prefixes:
      - 10.10.20.0/24
  snat:
    address: 192.0.2.10
Field Type Required Meaning
metadata.name string yes Policy identifier, deployment-scoped.
spec.site string yes The Site this policy belongs to, in the same deployment.
spec.mode string yes none, masquerade or snat.
spec.source.prefixes []string no Optional source scope. Empty means any source.
spec.destination.prefixes []string one of Destination prefixes this policy matches (CIDR).
spec.destination.internet bool one of Matches the deployment's Internet destinations.
spec.snat.address string for snat The explicit source address to translate to.

Mode semantics.

Mode Behavior
none No source NAT for matching traffic. The original routed source address is preserved.
masquerade The kernel selects the source address from the outgoing interface/route. IPv4 only.
snat Translate the source address to the explicitly configured snat.address. IPv4 only.

none is an operational rule, not merely the absence of one: it is applied as an explicit no-NAT escape so a later, less-specific masquerade or SNAT rule cannot still translate the traffic.

Destination and precedence. NAT selection is based on the destination prefix. Where several policies match a destination, the most-specific destination prefix wins; for equal destination specificity the most specific source prefix wins, then policy name. The compiler resolves this once and emits the rules in evaluation order. List order in Git is never packet-rule precedence.

# 10.0.0.0/8     -> masquerade
# 10.10.0.0/16   -> none
# 10.10.20.0/24  -> snat 192.0.2.10
Traffic to Result
10.20.1.1 masquerade
10.10.30.1 none (no NAT)
10.10.20.5 snat to 192.0.2.10

Same-prefix conflicts. Two enabled NAT policies in the same deployment and site that share an identical effective (masked) destination prefix and the same source scope are ambiguous — whichever were evaluated first would win. This is rejected at validation time, whether the effects are identical ("duplicate NAT intent") or different ("different NAT effects"). Overlapping but distinct prefixes (for example 10.0.0.0/8 and 10.10.0.0/16) are valid: specificity resolves them deterministically.

IPv4 only; no NAT66. none, masquerade and snat are fully supported for IPv4. masquerade and snat may not target an IPv6 destination; such a policy fails validation. Public IPv6 stays routed, never translated — no NAT66 is ever synthesized as a fallback. none remains valid for IPv6 (it is a no-NAT rule). A single policy must not mix IPv4 and IPv6 destination prefixes, and its source and destination prefixes must be the same address family.

Internet NAT. With destination.internet, an snat address must be a public IPv4 address the deployment owns — inside an enabled Gateway's allowed public address space. An unowned address is rejected. Internet NAT is the least-specific NAT entry, so it can never pre-empt an explicit, more specific rule.

NAT is not authorization.

AccessPolicy decides whether traffic is allowed.
NATPolicy decides how already-authorized traffic is translated.

A NAT rule never grants access to a destination the firewall policy denies. If no AccessPolicy allows the traffic, a matching NATPolicy changes nothing: the traffic remains denied.

Validation

  • spec.site must resolve to an existing Site of the same deployment;
  • spec.mode must be none, masquerade or snat;
  • spec.destination.prefixes and spec.destination.internet are mutually exclusive, and at least one destination prefix is required;
  • spec.snat.address is required for mode: snat; it must be a single IPv4 address (never a prefix); it is rejected with a non-snat mode;
  • a malformed, undecodable or empty destination prefix is rejected;
  • an IPv6 destination with masquerade or snat is rejected (no NAT66);
  • mixed IPv4/IPv6 destinations, or a cross-family source/destination pair, is rejected;
  • a same-deployment, same-site, same-source, identical-destination conflict is rejected;
  • an Internet snat address that is not within an enabled Gateway's allowed public address space is rejected.

Relationships and ordering

Reference resolution is within-deployment, fail-closed. Creating a referencing object before its referent exists produces a validation error; there is no partial or silent resolution. In practice you author in dependency order:

Referencing object Referent that must exist first
Deployment.spec.tenant Tenant, by its immutable uuid (identity-bearing reference; a name-only reference is refused)
Deployment.spec.placement.gateways GatewayNode (enabled; dedicated nodes must admit the tenant)
Deployment.spec.capabilities node capability and tenant entitlement and placement
Gateway (fabric target) must be enabled and declare a spec.fabric block before it can be a SiteEdge attachment
Device.spec.owner User
Group.spec.members User
AccessPolicy.spec.subject.user User
AccessPolicy.spec.subject.group Group
AccessPolicy.spec.subject.device Device
AccessPolicy.spec.subject.prefix Prefix (site-covered or JANUS-known space)
Device.spec.gateway.primary/eligible, Site.spec.gateway.primary, Resource.spec.gateway.primary Gateway
Resource.spec.siteEdge SiteEdge (plus its Site and an enabled fabric Gateway)
AccessPolicy.spec.destination.resource Resource
RoutePolicy.spec.site, NATPolicy.spec.site, SiteEdge.spec.site Site
RoutePolicy.spec.export[].prefix Prefix

Cross-object references that fail closed. A reference that does not resolve in the referencing object's own deployment is always an error. There is no cross-deployment reference syntax: an object in deployment A can never name an object in deployment B, even if the name exists there. The reserved default tenant is the one implicit resolution — a deployment scope with no Deployment object is owned by default.

Concurrent uniqueness and conflict constraints. Besides per-scope name uniqueness, these cross-object constraints are enforced:

  • metadata.uuid is unique globally;
  • a destination prefix must be originated by exactly one fabric participant of a deployment;
  • two enabled sites must not advertise the same or overlapping prefix;
  • two enabled Site Edges must not accept the same prefix;
  • two NAT policies with the same site, source scope and identical destination prefix conflict.

A worked example

A fictional operator, Northwind Logistics, runs one deployment northwind-prod owned by tenant northwind. The provider has one node fra-01 running one gateway fra-01-gw1. A warehouse site in Leipzig is connected both as a Site-to-Site peer and through a Site Edge, and a Frankfurt file server is an internal resource. All addressing below is documentation or private-use space.

repository-root/
  tenants/northwind.yaml
  gatewaynodes/fra-01.yaml
  deployments/northwind-prod.yaml
  northwind-prod/
    gateways/fra-01-gw1.yaml
    sites/leipzig-warehouse.yaml
    siteedges/leipzig-edge1.yaml
    prefixes/leipzig-public-v4.yaml
    resources/frankfurt-fileserver.yaml
    resources/leipzig-scada.yaml
    users/alice.yaml
    groups/logistics.yaml
    devices/alice-laptop.yaml
    accesspolicies/alice-fileserver-ssh.yaml
    accesspolicies/logistics-internet.yaml
    accesspolicies/alice-scada-https.yaml
    routepolicies/leipzig-routes.yaml
    natpolicies/leipzig-internet-nat.yaml

Tenant — tenants/northwind.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Tenant
metadata:
  name: northwind
  uuid: 0191f0aa-7c3e-7b21-9f4a-1a2b3c4d5e6f
  displayName: Northwind Logistics
spec:
  enabled: true
  entitlements:
    - remote-access
    - connector:hpe-aruba

GatewayNode — gatewaynodes/fra-01.yaml

apiVersion: janusaccess.net/v1alpha1
kind: GatewayNode
metadata:
  name: fra-01
spec:
  enabled: true
  country: DE
  region: HE
  city: Frankfurt
  sharing: shared
  capabilities:
    - remote-access
    - connector:hpe-aruba

Deployment — deployments/northwind-prod.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Deployment
metadata:
  name: northwind-prod
spec:
  tenant:
    uuid: 0191f0aa-7c3e-7b21-9f4a-1a2b3c4d5e6f
    name: northwind
  capabilities:
    - remote-access
  placement:
    gateways:
      - fra-01
  network:
    internalPrefixes:
      - 10.0.0.0/8

Gateway — northwind-prod/gateways/fra-01-gw1.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Gateway
metadata:
  name: fra-01-gw1
spec:
  enabled: true
  location:
    country: DE
    region: HE
    city: Frankfurt
  wireguard:
    listenPort: 51820
    publicKey: AwoRGB8mLTQ7QklQV15lbHN6gYiPlp2kq7K5wMfO1dw=
    endpoint: gw.example.net:51820
  capabilities:
    remoteAccess: true
    siteToSite: true
    bgp: false
    publicPrefixes: true
    nat: true
  network:
    allowedPublicIPv4:
      - 203.0.113.0/24
  fabric:
    publicKey: BRAbJjE8R1JdaHN+iZSfqrXAy9bh7PcCDRgjLjlET1o=

Site — northwind-prod/sites/leipzig-warehouse.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Site
metadata:
  name: leipzig-warehouse
spec:
  enabled: true
  gateway:
    primary: fra-01-gw1
  wireguard:
    publicKey: AwoRGB8mLTQ7QklQV15lbHN6gYiPlp2kq7K5wMfO1dw=
  tunnel:
    ipv4:
      local: 10.255.10.1/31
      remote: 10.255.10.0/31
  routing:
    mode: static
    advertisedPrefixes:
      - 198.51.100.0/24

SiteEdge — northwind-prod/siteedges/leipzig-edge1.yaml

apiVersion: janusaccess.net/v1alpha1
kind: SiteEdge
metadata:
  name: leipzig-edge1
spec:
  enabled: true
  site: leipzig-warehouse
  roles: [ingress, egress]
  attachment:
    primary: fra-01-gw1
  identity:
    publicKey: CRYjMD1KV2RxfouYpbK/zNnm8wANGic0QU5baHWCj5w=
  wireguard:
    publicKey: AwoRGB8mLTQ7QklQV15lbHN6gYiPlp2kq7K5wMfO1dw=
  lan:
    prefixes:
      - 198.51.100.0/24
  ha:
    precedence: 10

Prefix — northwind-prod/prefixes/leipzig-public-v4.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Prefix
metadata:
  name: leipzig-public-v4
spec:
  prefix: 203.0.113.0/24
  family: IPv4
  public: true
  site: leipzig-warehouse

Resource — northwind-prod/resources/frankfurt-fileserver.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Resource
metadata:
  name: frankfurt-fileserver
spec:
  type: host
  addresses:
    - 10.0.5.10/32
  services:
    - name: ssh
      protocol: tcp
      port: 22
  gateway:
    primary: fra-01-gw1

Resource — northwind-prod/resources/leipzig-scada.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Resource
metadata:
  name: leipzig-scada
spec:
  type: network
  prefixes:
    - 198.51.100.0/24
  services:
    - name: https
      protocol: tcp
      port: 443
  siteEdge: leipzig-edge1

leipzig-scada declares 198.51.100.0/24 and binds to leipzig-edge1, whose spec.lan.prefixes also declares 198.51.100.0/24 — so that prefix is accepted for provider transit. It sets no spec.gateway.primary, which is required: the two fields are mutually exclusive.

User — northwind-prod/users/alice.yaml

apiVersion: janusaccess.net/v1alpha1
kind: User
metadata:
  name: alice
spec:
  displayName: Alice Example
  email: alice@example.net
  enabled: true

Group — northwind-prod/groups/logistics.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Group
metadata:
  name: logistics
spec:
  members:
    - alice

Device — northwind-prod/devices/alice-laptop.yaml

apiVersion: janusaccess.net/v1alpha1
kind: Device
metadata:
  name: alice-laptop
spec:
  owner: alice
  enabled: true
  wireguard:
    publicKey: AwoRGB8mLTQ7QklQV15lbHN6gYiPlp2kq7K5wMfO1dw=
    ipv4: 10.255.0.10/32
  gateway:
    primary: fra-01-gw1
    eligible:
      - fra-01-gw1

AccessPolicy — northwind-prod/accesspolicies/alice-fileserver-ssh.yaml

apiVersion: janusaccess.net/v1alpha1
kind: AccessPolicy
metadata:
  name: alice-fileserver-ssh
spec:
  subject:
    user: alice
  destination:
    resource: frankfurt-fileserver
  services:
    - protocol: tcp
      port: 22
  enabled: true

AccessPolicy — northwind-prod/accesspolicies/logistics-internet.yaml

apiVersion: janusaccess.net/v1alpha1
kind: AccessPolicy
metadata:
  name: logistics-internet
spec:
  subject:
    group: logistics
  destination:
    internet: true
  services:
    - protocol: udp
      port: 53
    - protocol: tcp
      port: 443
  enabled: true

AccessPolicy — northwind-prod/accesspolicies/alice-scada-https.yaml

apiVersion: janusaccess.net/v1alpha1
kind: AccessPolicy
metadata:
  name: alice-scada-https
spec:
  subject:
    device: alice-laptop
  destination:
    resource: leipzig-scada
  services:
    - protocol: tcp
      port: 443
  enabled: true

RoutePolicy — northwind-prod/routepolicies/leipzig-routes.yaml

apiVersion: janusaccess.net/v1alpha1
kind: RoutePolicy
metadata:
  name: leipzig-routes
spec:
  site: leipzig-warehouse
  import:
    - 198.51.100.0/24
  export:
    - prefix: 203.0.113.0/24

The warehouse prefix that is actually reachable is declared on the Site (spec.routing.advertisedPrefixes) and by the Prefix and SiteEdge objects that own it; the RoutePolicy records the import/export intent and is validated, but it does not itself create reachability in this release.

NATPolicy — northwind-prod/natpolicies/leipzig-internet-nat.yaml

apiVersion: janusaccess.net/v1alpha1
kind: NATPolicy
metadata:
  name: leipzig-internet-nat
spec:
  site: leipzig-warehouse
  mode: snat
  source:
    prefixes:
      - 198.51.100.0/24
  destination:
    internet: true
  snat:
    address: 203.0.113.10

203.0.113.10 lies within fra-01-gw1's allowed public space (203.0.113.0/24), so the Internet SNAT address is owned by the deployment as required. The policy translates already-authorized traffic only: the logistics-internet policy decides whether the flow is allowed.