The Arista AVD Reference Design models a full Arista datacenter fabric in Infrahub — topology, addressing pools, EVPN configuration, and per-device intent as structured, queryable data. The whole team can browse, filter, and query the fabric through the web UI, GraphQL API, or MCP interface; every change runs through Infrahub branches and proposed changes, with a complete audit trail before it reaches a device.
Designed for network automation teams running AVD with static variable files who need a shared source of truth, API access, and branch-based change control — and for teams evaluating how to operate AVD at scale with a ready-made source of truth and generation pipeline.
Jump to: What it's for · How it works · Quick start · What's included · Documentation
- Generate a complete fabric from a design — define topology parameters and addressing pools; generators create all super-spines, spines, and leaves, allocate loopback, interconnect, and management addresses, BGP ASNs, and node IDs, and cable devices together automatically.
- Render EOS device configurations and documentation — PyAVD runs inside Infrahub workers and produces EOS CLI configurations, per-device and fabric-level Markdown documentation, and a cabling plan CSV as downloadable artifacts.
- Make incremental day-two changes — edit the design and regenerate; checksum-based idempotency applies changes only to affected objects; branch-aware pools prevent collisions across parallel work.
- Give other teams access to network data — the fabric is queryable through the Infrahub Web UI, GraphQL API, and MCP interface; the Streamlit service portal provides guided workflows for stakeholders without API or CLI access.
- Track and review every change — all changes run through Infrahub branches and proposed changes, with a full diff before any change reaches a device.
The full pipeline, from a high-level fabric design to versioned, deployable configuration:
- Docker and Docker Compose
- uv (Python package manager)
- Python 3.14 (3.14.7 by default)
- PyAVD >= 6.4.0, < 6.5.0 (bundled in the custom Docker image -- no separate install required)
# Install Python dependencies, including PyAVD and the Infrahub SDK
uv sync --all-packages
# Build the custom Infrahub image (extends the base image with PyAVD — run once)
export INFRAHUB_BASE_VERSION=1.11.7
uv run invoke build
# Start all services: Infrahub, Neo4j, PostgreSQL, Redis, RabbitMQ, service portal, Semaphore
uv run invoke start
# Load schemas, UI menu, seed data, register the repository, and load event triggers
uv run invoke loadOpen the Infrahub UI at http://localhost:8000 and the service portal at http://localhost:8501.
Set INFRAHUB_SEED_FABRICS in .env or the shell to select examples, such as
l3ls-multi-domain or l2ls,campus. The default all loads seven fabrics; none loads Common only.
See the seed selection and example catalog.
Then follow Provision Your First Fabric to run the generator chain and reach rendered EOS artifacts.
After invoke load completes and you run the generator chain on a fabric:
- Seed data appears in the UI — manufacturers, device types, addressing pools, device templates, the selected example fabrics (all seven by default) with pods and racks, and seed VLANs are loaded.
- FabricGenerator runs — super-spine devices appear on the branch, with loopback and management addresses allocated from pools.
- PodGenerator and RackGenerator trigger automatically — spine and leaf devices appear, cabled to their uplinks, with interconnect addresses, BGP ASNs, and node IDs assigned.
- AVD generators run — each device's PyAVD host_vars and structured configuration are stored as
AvdArtifactgraph objects. - Transforms produce artifacts — EOS device configuration, per-device Markdown documentation, fabric documentation, and a cabling plan CSV are available as downloadable artifacts on each device and fabric object.
- Propose and review — open a proposed change from the branch; the UI shows a diff of every new object and the rendered artifacts for review before any configuration reaches production.
- Deploy to devices — apply the rendered configurations to the fabric through the bundled Ansible runner (Semaphore) or CloudVision (CVP/CVaaS).
- Schemas — 20 schema files covering the full fabric data model:
- Topology: NetworkFabric, NetworkPod, NetworkDevice, NetworkInterface, NetworkLink
- IPAM: prefixes and addresses with role tagging (loopback, interconnect, management, server)
- EVPN: tenants, VRFs, SVIs, L2 VLANs
- MLAG: domain and peer pool definitions
- AVD types:
AvdArtifactfor per-device hostvar and structured config tracking with checksums
- Generators — six checksum-based, idempotent generators:
- FabricGenerator, PodGenerator, RackGenerator — device creation, addressing, and cabling
- GenerateAVDDeviceHostvar — assembles per-device PyAVD input from the source of truth
- AvdDeviceStructuredConfigGenerator — runs PyAVD to produce structured configuration
- GenerateServerCabling — handles server attachment
- Transforms — render structured data into downloadable artifacts:
- EOS device configuration (via PyAVD, running inside Infrahub workers)
- Per-device and fabric-level Markdown documentation
- Cabling plan CSV
- ANTA test catalogs and on-demand post-deployment validation through Semaphore
- Computed interface descriptions
- Seed data — manufacturers, device types, addressing and number pools (loopback, interconnect, management, ASN, node ID), device profiles and templates, seven independently selectable fabrics with pods and racks, and seed VLANs.
- Service portal — Streamlit application with guided day-2 workflows:
- Add network segment (VRF, VLAN, SVI)
- Provision server into a rack
- Create EVPN tenant
- Fabric Design visualization (topology, cabling, settings, EVPN)
- Stack — Docker Compose extending Infrahub 1.11.7 with PyAVD. Includes Infrahub UI, service portal, Semaphore (bundled Ansible runner for deployment and ANTA validation), and Neo4j.
| File | What it does |
|---|---|
.infrahub.yml |
Registers all generators, transforms, queries, and artifact definitions with Infrahub |
schemas/ |
YAML schema definitions for the full data model |
generators/ |
Python generators (fabric, pod, rack, AVD hostvars, structured config, server cabling) |
transforms/ |
Python and Jinja2 transforms (EOS config, docs, cabling plan, ANTA catalog, interface descriptions) |
objects/ |
Seed YAML: shared data in common/, then one directory per fabric |
triggers.yml |
Event trigger rules wiring schema changes to generator runs |
service_catalog/ |
Streamlit service portal |
docker-compose.yml |
Stack definition; docker-compose.override.yml adds the portal and Semaphore |
Dockerfile |
Custom Infrahub image with PyAVD |
tasks.py |
Invoke task definitions (build, start, stop, load, lint, test) |
Note: Brownfield import (modeling an existing fabric and importing configurations via Infrahub Sync) is available in a guided engagement today — it is not yet a self-serve path.
The full documentation is under docs/. Key entry points:
| Get the stack running | Quick Start — prerequisites, install steps, and first load |
| Provision a fabric end-to-end | Provision Your First Fabric — step-by-step walkthrough from seed data to rendered EOS artifacts |
| Check what's supported | Supported Capabilities — the AVD scenarios, services, and workflows supported today |
| Run a day-two workflow | Add a Network Segment — and the other how-to guides |
| Understand the generator pipeline | Architecture Overview — system components, data model, and generator chain |
| Understand the AVD pipeline | AVD Pipeline Overview — two-phase pipeline, hostvars reference, role mapping |
| Extend the pipeline | Extending the Pipeline — new device roles, transform outputs, schema fields |
| Debug pipeline issues | Debugging the Pipeline — intermediate-file inspection, single-generator re-runs, common failure modes |
- Questions and discussion: GitHub Discussions
- Bugs and feature requests: GitHub Issues
| Project | Description |
|---|---|
| Infrahub | The infrastructure data management and automation platform this reference design runs on |
| Arista AVD | Arista Validated Design — the collection and PyAVD engine that render EOS configurations |
| AVD documentation | Upstream AVD reference and PyAVD documentation |
Infrahub is an open source infrastructure data management and automation platform (Apache 2.0), developed by OpsMill. It gives infrastructure and network teams a unified, schema-driven source of truth for all infrastructure data — devices, topology, IP space, configuration — with built-in version control, a generator framework for automation, and native integrations with Git, Ansible, Terraform, and CI/CD pipelines.