What is Nantian Gateway

Nantian Gateway is a Kubernetes Gateway API implementation built as a split-plane gateway stack. The Go control plane watches Kubernetes resources, translates Gateway API and Nantian extension resources into internal routing state, reports status, and publishes runtime snapshots over gRPC/xDS. The Rust data plane receives those snapshots and handles live traffic.

Use Nantian Gateway when you want Kubernetes-native ingress and API routing with standard Gateway API resources, operational APIs, observability assets, and experimental extension points for AI and Wasm workloads.

Quick Example

Here’s what deploying Nantian Gateway and creating your first route looks like:

# 1. Install the gateway stack
helm repo add nantian-gw https://chart.nantian.dev
helm install nantian-gw nantian-gw/nantian-gw \
  --namespace nantian-gw --create-namespace

# 2. Create a Gateway (entry point)
kubectl apply -f - <<EOF
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: my-gateway
  namespace: default
spec:
  gatewayClassName: nantian-gw
  listeners:
  - name: http
    port: 80
    protocol: HTTP
EOF

# 3. Create an HTTPRoute (routing rule)
kubectl apply -f - <<EOF
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: my-route
  namespace: default
spec:
  parentRefs:
  - name: my-gateway
  rules:
  - matches:
    - path:
        type: PathPrefix
        value: /api
    backendRefs:
    - name: my-backend-service
      port: 8080
EOF

That’s it — traffic to /api is now routed to my-backend-service:8080. No custom CRDs, no proprietary config language.

What This Repository Set Contains

Nantian Gateway is split across several component repositories so each part can evolve with its own build, test, and release flow.

Repository	GitHub	Purpose
`gateway/`	nantian-gw/gateway	Go control plane — Kubernetes reconcilers, translators, CRD manifests, admin API, conformance tooling
`dataplane/`	nantian-gw/dataplane	Rust data plane — HTTP/gRPC/TCP/UDP proxy, AI gateway, Wasm runtime, xDS client
`helm-charts/`	nantian-gw/helm-charts	Helm chart published at `https://chart.nantian.dev`
`dashboard/`	nantian-gw/dashboard	Next.js admin UI for operators
`website/`	nantian-gw/website	This Astro/Starlight documentation site
`proto/`	nantian-gw/proto	Shared protobuf contract between control plane and data plane

How It Works

Gateway API resources are the source of truth. Users create resources such as Gateway, HTTPRoute, GRPCRoute, TCPRoute, UDPRoute, TLSRoute, ReferenceGrant, and Gateway API policies. When experimental features are enabled, Nantian extension resources can participate in the same workflow.

Gateway API resources -> Go control plane -> internal snapshot -> gRPC/xDS -> Rust data plane -> backends

The control plane watches Kubernetes resources, translates accepted objects into the runtime snapshot format, updates status conditions, and exposes admin and metrics endpoints for inspection. The data plane connects back to the control plane, receives snapshots over gRPC/xDS, and handles traffic on its runtime listener. The dashboard and admin APIs provide operator-facing visibility into the running system.

Stable And Experimental Capabilities

Gateway API routing is the primary capability. Read Gateway API support through the Gateway API support page and the generated support declarations in the gateway repository instead of relying on broad marketing claims.

Nantian also includes experimental APIs:

AIService uses gateway.nantian.dev/v1alpha1 and describes an AI provider/model target.
TokenPolicy uses gateway.nantian.dev/v1alpha1 and attaches token or request limits to local Gateway API targets.
WasmPlugin uses gateway.nantian.dev/v1alpha1 and binds Wasm modules to target resources.
BackendLBPolicy uses Gateway API experimental gateway.networking.k8s.io/v1alpha2 and configures backend load-balancing behavior.

Experimental features are disabled by default. Enable the relevant control plane and data plane feature flags before creating these resources, and expect schema or runtime behavior to change while the APIs are experimental.

Operator Surfaces

Helm is the recommended install path for users and operators. The chart installs the control plane, data plane, dashboard, services, RBAC, network policies, and a default GatewayClass named nantian-gw. Repository-local Kustomize overlays are also available for development and custom deployments.

The control plane exposes gRPC on 18080, the admin API on 18081, metrics on 18082, and health probes on 18083. The data plane listens for runtime HTTP traffic on 0.0.0.0:80 and exposes admin and metrics services on 19080. The dashboard service listens on chart port 3000.

For day-two operations, start with Kubernetes pod status, GatewayClass status, route attachment status, control plane and data plane logs, Prometheus metrics, Grafana dashboards, and the admin APIs.

Key Differentiators

Capability	Nantian Gateway	How it works
Split-plane architecture	Go control plane + Rust data plane	Control plane handles translation and orchestration (Go’s Kubernetes ecosystem). Data plane handles real-time traffic (Rust’s performance, no GC pauses).
Standard Gateway API	54+ supported features, v1.5.1	No proprietary CRDs for routing. Your routes are portable across Gateway API implementations.
AI Gateway native	Built-in AI proxy with 11 features	Model routing, semantic cache, PII masking, content safety, A/B testing, fallback, cost tracking — all at the proxy layer, no sidecar needed.
Wasm extensibility	Sandboxed plugin runtime	Write custom filters in Rust, compile to `wasm32-wasi`, deploy via CRD.
Production observability	Prometheus, Grafana, OpenTelemetry	Pre-built dashboards, 100+ metrics, audit logging, OpenTelemetry tracing across control and data planes.
O(1) control plane memory	State-of-the-World snapshots	Entire configuration is one atomic snapshot. No per-request control plane involvement — data plane handles all traffic autonomously.