Install

Arion installs from source: one Cargo build produces a single binary named arion, and the repo's Dockerfile wraps the same build in a container image. Use this page to build either one; the quickstart then gets a first config running.

There are no published binaries, container images or Helm charts yet — every install starts from the source tree.

Before you begin

Rust 1.89 or newer (the workspace sets rust-version = "1.89").
protoc, the protobuf compiler — the build generates the configuration model from Envoy's protobuf definitions.
git, with submodule support. Docker builds need Docker; nothing else does.

Get the source

git clone https://github.com/arion-gateway/arion
cd arion
git submodule update --init --recursive

The submodules contain Envoy's data-plane API protos; the build fails without them.

Build and run

Standalone

Build the release binary:

cargo build --release -p arion-proxy

The binary lands at target/release/arion. Point it at a config file with --config (short -c):

./target/release/arion --config arion-proxy/conf/arion-runtime.yaml

To run an unmodified Envoy bootstrap file instead of an Arion config, pass it with --with-envoy-bootstrap <file>.

Or build and run the Docker image, which bakes in that same sample config at /etc/arion/arion-runtime.yaml:

docker build -t arion-proxy -f docker/Dockerfile .
docker run -d -p 8000:8000 --name arion-proxy arion-proxy

Mount your own config over the baked-in one with -v "$PWD/arion.yaml:/etc/arion/arion-runtime.yaml". In containers, set the ARION_CPU_LIMIT environment variable to tell Arion how many cores to size its worker threads for.

Kubernetes

There is no published image, Helm chart or manifest yet: build the image locally and load it into your cluster, then run it with the config in a ConfigMap.

docker build -t arion-proxy:dev -f docker/Dockerfile .
kind load docker-image arion-proxy:dev   # or: minikube image load arion-proxy:dev

The image reads /etc/arion/arion-runtime.yaml, so mount the ConfigMap there:

apiVersion: v1
kind: ConfigMap
metadata:
  name: arion-config
data:
  arion-runtime.yaml: |
    envoy_bootstrap:
      static_resources:
        listeners:
          - name: listener_http
            address:
              socket_address: { address: 0.0.0.0, port_value: 8080 }
            filter_chains:
              - name: http_chain
                filters:
                  - name: http_gateway
                    typed_config:
                      "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
                      http_filters:
                        - name: envoy.filters.http.router
                          typed_config:
                            "@type": type.googleapis.com/envoy.extensions.filters.http.router.v3.Router
                      route_config:
                        name: placeholder
                        virtual_hosts:
                          - name: all_hosts
                            domains: ["*"]
                            routes:
                              - match: { prefix: "/" }
                                direct_response:
                                  status: 200
                                  body: { inline_string: "arion is up\n" }
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: arion
spec:
  replicas: 1
  selector:
    matchLabels: { app: arion }
  template:
    metadata:
      labels: { app: arion }
    spec:
      containers:
        - name: arion
          image: arion-proxy:dev
          imagePullPolicy: IfNotPresent
          ports:
            - containerPort: 8080
          env:
            - name: ARION_CPU_LIMIT
              value: "2"
          volumeMounts:
            - name: config
              mountPath: /etc/arion
      volumes:
        - name: config
          configMap: { name: arion-config }

kubectl apply -f arion-k8s.yaml

Replace the placeholder route with your real configuration — the file from the quickstart works as the ConfigMap value, once its cluster endpoints point at Services instead of 127.0.0.1. ARION_CPU_LIMIT sizes the worker thread pool where the container cannot read the host's CPU topology.

Cargo features

The default build enables none of the optional features. Add them at build time with --features:

cargo build --release -p arion-proxy --features wasm,prometheus,access-log

Feature	What it enables
`wasm`	The Wasm HTTP filter host (Wasmtime). Required to load Wasm filters at runtime.
`codemode`	The sandbox (Wasmtime and QuickJS) behind MCP code mode. Required for an MCP gateway configured with `code_mode`.
`metrics`	Metrics collection.
`prometheus`	Prometheus metrics export. Implies `metrics`.
`access-log`	Access logging.
`tracing`	Distributed tracing.
`config-dump`	Config dump support on the admin interface.
`jemalloc`	jemalloc as the global allocator.
`instrumentation`	Internal instrumentation.
`dhat-heap`	Heap profiling with dhat, for development.

The Docker image builds with the default feature set; edit docker/Dockerfile if you need extras such as wasm or codemode in the image.

Verify

Standalone

Start Arion with the sample config, then curl its direct-response route from a second terminal:

curl -i http://localhost:8000/direct-response

HTTP/1.1 200 OK
...
meow! 🐱