OpsMill InfraHub: Deep Dive

These components form the foundation of InfraHub’s architecture and workflow automation capabilities:

• Graph Database Engine: InfraHub models all infrastructure resources, relationships, and metadata within a native graph database, enabling efficient querying, dynamic dependency mapping, and advanced analytics for complex networks.
• infrahubctl CLI Tool: The official command-line utility, infrahubctl, is used for managing environments, importing schemas, orchestrating assets, and running infrastructure tasks. For examples and usage, visit the CLI documentation.
• GraphQL API: InfraHub exposes a flexible GraphQL endpoint for all resource management and data retrieval. This API design allows users to query and manipulate infrastructure objects, topologies, and status with custom payloads. See API queries and mutations at the GraphQL API reference.
• Schema Library: All resource definitions, device types, and connectivity models are structured as YAML schemas designed for graph storage and traversal. Explore schema formats and customization in the Schema Library.

Quick Tips:
— Always interact with the platform using infrahubctl for local automation and scripting.
— Consult the GraphQL API for integrations with other apps and data feeds.
— Validate all YAML schemas against InfraHub’s supported syntax before deployment.

OpsMill InfraHub stands apart from other network automation and infrastructure management platforms due to its graph database foundation, flexible schema design, and modern integration model. Below is a detailed comparison to illustrate these fundamental differences.

For technical details and usage, see the official documentation:

• CLI Tool: infrahubctl
• GraphQL API Reference
• Schema Library

OpsMill InfraHub’s approach—centered around a graph database, open schema models, and extensible integrations—enables a broad range of automation and orchestration scenarios across IT infrastructure and network domains. Here are some representative use cases:

• Network Source of Truth: Consolidate device, interface, IP address, and topology data in a single, queryable graph-backed repository that supports version control, branching, and rich access control models.
• CI/CD for Network and Cloud Automation: Drive configuration, provisioning, and compliance updates through Git-like workflows, automated CI validation, and artifact generation—empowering teams to test and merge changes safely.
• Resource Pool Management: Allocate and track shared infrastructure resources (such as IPs, VLANs, or compute nodes) using branch-agnostic, idempotent policies—via the resource manager with tracking for allocation states.
• API-Driven Integrations: Query and mutate infrastructure data using the built-in GraphQL API, enabling seamless integration with automation frameworks, dashboards, and external databases.
• Extensible Schemas for Custom Models: Evolve or define new schemas for unique business requirements—covering everything from custom device types to non-network assets—all stored with their relationships in the graph.
• Event-Driven Automation: Orchestrate workflows and remediation actions based on triggers using webhooks, computed attributes, and event-handling extensions that tie into configuration automation or security responses.
• Data Synchronization & Federation: Sync and aggregate data across sources-of-truth such as Netbox, Nautobot, or CMDBs using the infrahubctl CLI and automated integration flows.

For workflow automation examples, schema design, and integration guides, see:

• CLI Tool: infrahubctl
• GraphQL API Reference
• Schema Library

InfraHub’s development continues at a fast pace, with enhancements targeting automation scalability, developer productivity, and streamlined infrastructure management through its graph database–driven core.

• Recent Features:
  • Templates for Object Creation: Speed up recurring infrastructure tasks with reusable templates, enabling standardized creation of complex network or system objects from blueprints.
  • Integrated Activity Logging: Gain complete visibility with detailed audit trails and per-object change histories built directly into the platform.
  • Advanced Webhook & Event Triggers: Enable richer event-driven automation and external system integration using expanded webhook configurations and payload options.
  • Performance and UI Optimizations: Benefit from improved list retrieval, query speeds, and an updated, streamlined user interface for high-volume operations.
• Next Steps (Planned Enhancements):
  • Expanded Generator Functions: Enhance automation by generating more complex infrastructure objects and topologies directly from service models, all mapped and versioned within the graph.
  • Deeper Platform Engineering Features: Support hybrid and multi-cloud workflows with improved integrations for public cloud and on-premises automation, enabling unified infrastructure as a service catalog—including support for AI and GPU data center modeling.
  • Broader Schema Blueprint Library: Roll out pre-built blueprints and example schemas for common domains, expansively growing out-of-box options for rapid onboarding and experimentation.
  • Greater Federation and Synchronization: Improve interoperability with existing tools and sources-of-truth through enhanced data sync and schema mapping features.
  • Collaborative Validation and Peer Review: Build on proposed change workflows by enhancing support for reviews, validations, and in-platform approvals before data is merged to production.

Stay up to date with current and future features at:

• CLI Tool: infrahubctl
• GraphQL API Reference
• Schema Library

InfraHub schemas define infrastructure objects, attributes, and relationships as first-class nodes within a flexible graph. Below is a guided workflow for building and evolving a device and interface schema that aligns with the actual Infrahub platform.

1. Define the core nodes and attributes:
   Create a schema_guide.yml file and add these entities in the Network namespace:

   version: "1.0"
   nodes:
     - name: Device
       namespace: Network
       human_friendly_id: ['hostname__value']
       attributes:
         - name: hostname
           kind: Text
           unique: true
         - name: model
           kind: Text
     - name: Interface
       namespace: Network
       attributes:
         - name: name
           kind: Text
         - name: description
           kind: Text
           optional: true
   

2. Load the schema branch with infrahubctl:

   infrahubctl branch create network-device-schema
   infrahubctl schema load --branch network-device-schema /tmp/schema_guide.yml

3. Add relationships between nodes:
   Update your schema to link devices and interfaces:

   version: "1.0"
   nodes:
     - name: Device
       namespace: Network
       human_friendly_id: ['hostname__value']
       attributes:
         - name: hostname
           kind: Text
           unique: true
         - name: model
           kind: Text
       relationships:
         - name: interfaces
           cardinality: many
           peer: NetworkInterface
           kind: Component
     - name: Interface
       namespace: Network
       attributes:
         - name: name
           kind: Text
         - name: description
           kind: Text
           optional: true
       relationships:
         - name: device
           cardinality: one
           peer: NetworkDevice
           kind: Parent
           optional: false
   

   Reload for relationship updates:

   infrahubctl branch create network-device-relations
   infrahubctl schema load --branch network-device-relations /tmp/schema_guide.yml

4. Test with GraphQL:

   mutation {
     NetworkDeviceCreate(data: {hostname: {value: "atl1-edge1"}, model: {value: "Cisco ASR1002-HX"}}) {
       ok object { id }
     }
     NetworkInterfaceCreate(data: {name: {value: "Ethernet1"}, description: {value: "WAN interface"}, device: {hfid: "atl1-edge1"}}) {
       ok object { id }
     }
   }
       

5. Iterate and migrate your schema: Refine by adding generic nodes, abstraction, uniqueness constraints, and new attributes. Preview and apply migrations using:

   infrahubctl schema check --branch network-device-generics /tmp/schema_guide.yml
   infrahubctl schema load --branch network-device-generics /tmp/schema_guide.yml
       

For advanced concepts, best practices, and ready-to-use models, see:

• Infrahub Schema Library
• Official Schema Design Guide

OpsMill InfraHub is built around a graph database that enables dynamic modeling and versioned control of infrastructure data. The following steps walk through the process to install, configure, and begin using InfraHub in a real scenario.

1. Install and configure Infrahubctl:
   • Install the Infrahub Python SDK and CLI (infrahubctl) on the local workstation.
   • Configure connectivity in infrahubctl.toml or with environment variables:

     INFRAHUB_ADDRESS=http://:8000
     INFRAHUB_API_TOKEN=
             

2. Start the InfraHub server:
   • Deploy InfraHub via the provided installer, container image, or as a Python package as outlined in the official guides.
   • Access the WebUI at http://:8000 for documentation, search, and the integrated GraphQL sandbox.
3. Load and validate your schema:
   • Define schema elements and relationships in YAML, matching the format shown in the Schema Design Example above.
   • Load your schema with infrahubctl schema load --branch .yml
   • Validate using infrahubctl schema check
4. Populate and query data via the GraphQL API:
   • Use the in-browser GraphQL sandbox or the CLI to create and retrieve objects (see the previous section for actual mutation/query examples).
   • Integrate automation frameworks (Ansible, Nornir) by using InfraHub as an inventory source or to trigger deployments through webhooks and plugins.
5. Explore and expand:
   • Experiment with branch management, schema evolution, and building workflows, using the graph’s version control features.
   • Review advanced guides and schema blueprints for production adoption and integration with existing automation tooling.

For full configuration, CLI reference, and integration walkthroughs, see:

• CLI Tool: infrahubctl
• GraphQL API Reference
• Schema Library

This step-by-step walkthrough shows how InfraHub's graph database foundation and unified toolset support a full infrastructure automation workflow. The example covers schema design and loading, data creation via GraphQL, and using `infrahubctl` for operational branching and CI/CD with infrastructure data.

1. Prepare a schema for network devices and interfaces:

   version: "1.0"
   nodes:
     - name: Device
       namespace: Network
       human_friendly_id: ['hostname__value']
       attributes:
         - name: hostname
           kind: Text
           unique: true
         - name: model
           kind: Text
       relationships:
         - name: interfaces
           cardinality: many
           peer: NetworkInterface
           kind: Component
     - name: Interface
       namespace: Network
       attributes:
         - name: name
           kind: Text
         - name: description
           kind: Text
           optional: true
       relationships:
         - name: device
           cardinality: one
           peer: NetworkDevice
           kind: Parent
           optional: false
       

2. Load schema into a feature branch:

   infrahubctl branch create edge-network
   infrahubctl schema load --branch edge-network ./network_schema.yml
       

3. Create initial device and interface data with GraphQL:

   mutation {
     NetworkDeviceCreate(data: {hostname: {value: "access-01"}, model: {value: "Arista 7050SX"}}) {
       ok object { id }
     }
     NetworkInterfaceCreate(data: {name: {value: "Ethernet1"}, description: {value: "WAN Interface"}, device: {hfid: "access-01"}}) {
       ok object { id }
     }
   }
       

4. Propose changes and run CI checks:
   • All changes exist in feature branches—run validation before merging:

   infrahubctl branch check edge-network
   infrahubctl branch propose edge-network --title "Add access switch and WAN interface"
         

5. Integrate with automation tooling:
   • Use Nornir or Ansible modules to query and deploy device configuration based on approved InfraHub inventory, either with GraphQL queries or Python SDK.
   • All resource states, templates, and relationships remain tracked in the graph, versioned and auditable.

To deepen practical expertise, review these official guides:

• CLI Tool: infrahubctl
• GraphQL API Reference
• Schema Library