---
title: "Quickstart"
url: "/docs/get-started/quickstart/"
kind: "feature"
summary: "Run an echo upstream, write a thirty-line arion.yaml, start Arion and proxy your first request — about five minutes end to end."
---

> Arion site index: [/llms.txt](/llms.txt)

# Quickstart

Run an echo upstream, write a thirty-line arion.yaml, start Arion and proxy your first request — about five minutes end to end.

This page takes you from an installed binary to a working proxy: one listener, one route, one cluster, with an echo server behind it. Use it as your first contact with Arion's configuration, or as a smoke test after [installing](@/docs/get-started/install.md).

## Before you begin

- The `arion` binary — from the [install page](@/docs/get-started/install.md), it sits at `target/release/arion`.
- Docker, for the echo upstream (any HTTP server on `127.0.0.1:5678` works instead).
- `curl`.

## 1. Start an echo upstream

```bash
docker run -d --rm --name echo -p 5678:5678 hashicorp/http-echo -text="hello from echo"
```

Confirm it answers before putting a proxy in front of it:

```bash
curl -s http://localhost:5678/
```

```text
hello from echo
```

## 2. Write the configuration

Save this as `arion.yaml`. It is a complete config: a listener on port 8080 whose filter chain runs the HTTP connection manager, one route that sends everything to the `echo` cluster, and that cluster's single static endpoint.

```yaml,name=arion.yaml,arion=full
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: quickstart_routes
                    virtual_hosts:
                      - name: all_hosts
                        domains: ["*"]
                        routes:
                          - match:
                              prefix: "/"
                            route:
                              cluster: echo
    clusters:
      - name: echo
        type: STATIC
        connect_timeout: 0.25s
        load_assignment:
          endpoints:
            - lb_endpoints:
                - endpoint:
                    address:
                      socket_address:
                        address: 127.0.0.1
                        port_value: 5678
```

Everything under `envoy_bootstrap` is standard Envoy `static_resources`. Two defaults keep the file short: the codec is auto-detected and the cluster load-balances round robin. One Arion particular: every filter chain must have a `name`.

## 3. Start Arion

{% <variant mode="standalone" label="Standalone"> %}
```bash
arion --config arion.yaml
```

Arion runs in the foreground. To use the Docker image instead, mount the config over the baked-in one — host networking lets the container reach the echo server on `127.0.0.1`, though it does not work on all Docker setups:

```bash
docker run --rm --network host -v "$PWD/arion.yaml:/etc/arion/arion-runtime.yaml" arion-proxy
```
{% </variant> %}

{% <variant mode="kubernetes" label="Kubernetes"> %}
Run the quickstart on one machine first; it assumes the echo server is on the proxy's localhost. On a cluster, put this `arion.yaml` into the ConfigMap from the [install page](@/docs/get-started/install.md) (as the `arion-runtime.yaml` key) and point the cluster's endpoint at an echo Service's address instead of `127.0.0.1`.
{% </variant> %}

## 4. Send a request through the proxy

```bash
curl -i http://localhost:8080/
```

```text
HTTP/1.1 200 OK
...
hello from echo
```

The request entered the listener on 8080, passed the HTTP connection manager and the router, matched the `/` route, and was forwarded to the `echo` cluster's endpoint on 5678.

> [!NOTE]
> If you mistype a field, or use an Envoy feature Arion does not support, Arion refuses to start and the error names the offending field. It never silently ignores configuration — that is the [compatibility promise](@/docs/concepts/envoy-compatibility.md).

When you are done, `docker stop echo` removes the upstream.

## Next

- [Build an L7 load balancer](@/guides/proxy/l7-load-balancer.md) — the same shape with real backends, spread across endpoints.
- [Routing](@/docs/traffic/routing.md) — match on paths, headers and domains, and split traffic.
- [The filter chain](@/docs/concepts/filter-chain.md) — where JWT, rate limiting and your own filters slot in.