Kibana Object Manager

A Git-inspired CLI tool for managing Kibana saved objects in version control. Built with Rust for reliability, speed, and modern DevOps workflows.

What is kibob?

kibob (Kibana Object Manager) helps you manage Kibana dashboards, visualizations, and other saved objects using a familiar Git-like workflow. Version control your Kibana artifacts alongside your application code, deploy them across environments, and collaborate with your team using standard Git practices.

Key Features

Git-like workflow - pull, push, and version control your Kibana objects
Spaces management - Version control and deploy Kibana spaces alongside objects
Workflows management - Version control and deploy Kibana workflows
Environment management - Easy deployment across dev, staging, and production
Manifest-based tracking - Explicitly define which objects, spaces, and workflows to manage
Managed vs. unmanaged - Control whether objects can be edited in Kibana UI
Modern architecture - Built with async Rust, no external dependencies
Fast and reliable - ETL pipeline design with proper error handling

Installation

Published on:

Homebrew: https://formulae.brew.sh/formula/kibob
crates.io: https://crates.io/crates/kibana-object-manager

From Homebrew

brew install kibob

From Cargo

cargo install kibana-object-manager

From Source

git clone https://github.com/VimCommando/kibana-object-manager.git
cd kibana-object-manager
cargo build --release
# Binary will be at target/release/kibob

Quick Start

1. Set up environment variables

export KIBANA_URL=http://localhost:5601
export KIBANA_USERNAME=elastic
export KIBANA_PASSWORD=changeme
# OR use API key authentication:
# export KIBANA_APIKEY=your_api_key_here

2. Test your connection

kibob auth

3. Initialize a project from an export

First, export your dashboards from Kibana UI (Stack Management → Saved Objects → Export).

kibob init export.ndjson ./my-dashboards
cd my-dashboards

This creates:

default/manifest/saved_objects.json - Tracks which objects to manage
default/objects/ - Directory with your objects organized by type

Optional: Add spaces management

Create a spaces.yml to also manage Kibana spaces:

spaces:
  - id: default
    name: Default
  - id: marketing
    name: Marketing
  - id: engineering
    name: Engineering

Now pull and push will also manage spaces! Each space's definition will be stored at {space_id}/space.json. See Spaces Guide for details.

Optional: Add workflows management

Create per-space workflow manifests like default/manifest/workflows.yml:

workflows:
  - id: workflow-123
    name: my-workflow
  - id: workflow-456
    name: alert-workflow
  - id: workflow-789
    name: data-pipeline

Now pull and push will also manage workflows!

4. Version control with Git

git init
git add .
git commit -m "Initial dashboard import"

5. Pull changes from Kibana

kibob pull .
git diff  # Review changes
git add . && git commit -m "Update from Kibana"

6. Push to another environment

# Set production credentials
export KIBANA_URL=https://prod-kibana.example.com
export KIBANA_APIKEY=prod_api_key

# Deploy as managed objects (read-only in Kibana UI)
kibob push . --managed true

CLI Commands

`kibob auth`

Test connection to Kibana with current credentials.

`kibob init <export.ndjson> <output_dir>`

Initialize a new project from a Kibana export file.

`kibob pull <dir> [--space <name>]`

Fetch saved objects from Kibana (specified in manifest) and save to local files. Also pulls spaces if spaces.yml exists and workflows if per-space manifest/workflows.yml files exist.

--space <name>: Override the Kibana space (overrides KIBANA_SPACE env var)

`kibob push <dir> [--managed true|false] [--space <name>]`

Upload local objects to Kibana. Also pushes spaces if spaces.yml exists and workflows if per-space manifest/workflows.yml files exist.

--managed true (default): Objects are read-only in Kibana UI
--managed false: Objects can be edited in Kibana UI
--space <name>: Override the Kibana space (overrides KIBANA_SPACE env var)

`kibob add <api> <dir> [options]`

Add items to an existing manifest. Supports: objects, workflows, spaces

For Workflows:

kibob add workflows . - Search and add all workflows
kibob add workflows . --query "alert" - Search workflows matching "alert"
kibob add workflows . --include "^prod" - Include workflows matching regex "^prod"
kibob add workflows . --exclude "test" - Exclude workflows matching regex "test"
kibob add workflows . --include "(?i)prod" - Case-insensitive include
kibob add workflows . --file export.json - Add from API response file
kibob add workflows . --file bundle.ndjson - Add from bundle file

For Spaces:

kibob add spaces . - Fetch and add all spaces
kibob add spaces . --include "prod|staging" - Include spaces matching pattern
kibob add spaces . --exclude "(?i)test" - Exclude test spaces (case-insensitive)
kibob add spaces . --file spaces.json - Add from API response file
kibob add spaces . --file bundle.ndjson - Add from bundle file

For Objects (legacy):

kibob add objects . --objects "dashboard=abc123,visualization=xyz789"
kibob add objects . --file export.ndjson

Regex Filtering:

--include and --exclude accept standard Rust regex patterns
Include filter is applied first, then exclude filter
Use (?i) prefix for case-insensitive matching
Examples: ^prod, test$, (?i)staging, dev|test

`kibob togo <dir>`

Bundle objects into a distributable bundle/ directory containing NDJSON files:

bundle/{space_id}/saved_objects.ndjson - Per-space saved objects
bundle/spaces.ndjson - Spaces (if spaces.yml exists)
bundle/{space_id}/workflows.ndjson - Per-space workflows (if manifest/workflows.yml exists)

The bundle directory can be easily zipped for distribution.

`kibob migrate <dir>`

Migrate legacy manifest.json to new manifest/saved_objects.json format.

Use Cases

For Kibana Admins

Back up and version control your dashboards. Easily restore or roll back changes.

For Developers

Store dashboards in your application's Git repository. Deploy observability alongside code.

For DevOps Engineers

Automate dashboard deployments in CI/CD pipelines. Consistent environments from dev to production.

Documentation

User Guide - Comprehensive command reference and workflows
Architecture - Technical deep-dive for contributors
Examples - Real-world usage scenarios
Migration Guide - Migrating from legacy format
Quick Reference - Command cheat sheet
Contributing - Development guidelines

Agent Skill

This repository includes a Codex skill for kibob workflows:

skills/kibob/SKILL.md
skills/kibob/references/kibob-commands.md

The skill is designed to help with:

Selecting the right kibob command and flags
Environment promotion workflows (pull -> git commit -> push)
Managed mode policy by environment:
- Production: --managed true
- Dev/test: --managed false

Example promotion flow:

# Pull from dev
kibob pull . --env .env.dev --space dev --api saved_objects,workflows,agents,tools
git add .
git commit -m "Sync from dev"

# Push to stage (dev/test posture)
kibob push . --env .env.stage --space stage --api saved_objects,workflows,agents,tools --managed false

# Promote to production (production posture)
kibob push . --env .env.prod --space prod --api saved_objects,workflows,agents,tools --managed true

Authentication

kibob supports multiple authentication methods:

Basic Authentication

export KIBANA_USERNAME=elastic
export KIBANA_PASSWORD=changeme

API Key

export KIBANA_APIKEY=your_base64_encoded_key

Architecture

kibob uses a modern ETL (Extract-Transform-Load) pipeline architecture:

Pull: Kibana → Extract → Transform → Store Files
Push: Read Files → Transform → Load → Kibana

Built with:

Rust - Memory-safe, fast, reliable
Tokio - Async runtime for efficient I/O
reqwest - HTTP client with connection pooling
Clap - Modern CLI framework
serde - Robust JSON serialization

Project Structure

my-dashboards/
├── spaces.yml                # Global: managed spaces list
├── default/                  # Default space (self-contained)
│   ├── space.json           # Space definition
│   ├── manifest/            # Per-space manifests
│   │   ├── saved_objects.json
│   │   ├── workflows.yml
│   │   └── agents.yml
│   ├── objects/             # Saved objects organized by type
│   │   ├── dashboard/
│   │   │   ├── abc-123.json
│   │   │   └── xyz-789.json
│   │   ├── visualization/
│   │   │   └── def-456.json
│   │   └── index-pattern/
│   │       └── logs-*.json
│   ├── workflows/           # Workflow configurations
│   │   ├── my-workflow.json
│   │   └── alert-workflow.json
│   └── agents/              # Agent configurations
│       └── my-agent.json
├── marketing/               # Marketing space (self-contained)
│   ├── space.json
│   ├── manifest/
│   │   └── workflows.yml
│   └── workflows/
│       └── campaign-workflow.json
└── bundle/                  # (Generated by 'togo' command)
    ├── default/
    │   ├── saved_objects.ndjson
    │   ├── workflows.ndjson
    │   └── agents.ndjson
    ├── marketing/
    │   └── workflows.ndjson
    └── spaces.ndjson        # All space definitions

Managing Kibana Spaces

kibob can also manage Kibana Spaces alongside saved objects. Create a spaces.yml:

spaces:
  - id: default
    name: Default
  - id: marketing
    name: Marketing
  - id: engineering
    name: Engineering

Then use the same workflow:

kibob pull .    # Pulls space definitions to {space_id}/space.json
kibob push .    # Creates/updates spaces in Kibana
kibob togo .    # Bundles to bundle/spaces.ndjson

Each space's definition is stored in its own directory as {space_id}/space.json. For example:

default/space.json
marketing/space.json
engineering/space.json

See the Spaces Guide for complete documentation.

Migrating from Bash Version

If you have an existing project using the old Bash script:

# The new Rust version uses a different manifest format
kibob migrate ./my-project

# Review the migrated manifest
cat manifest/saved_objects.json

# Test by pulling from Kibana
kibob pull ./my-project

See Migration Guide for details.

Environment Variables Reference

Variable	Description	Default
`KIBANA_URL`	Kibana base URL	Required
`KIBANA_USERNAME`	Basic auth username	Optional
`KIBANA_PASSWORD`	Basic auth password	Optional
`KIBANA_APIKEY`	API key (conflicts with user/pass)	Optional

Support

Issues: https://github.com/VimCommando/kibana-object-manager/issues
Discussions: https://github.com/VimCommando/kibana-object-manager/discussions

Contributing

Contributions are welcome! See CONTRIBUTING.md for development setup and guidelines.

License

Licensed under the Apache License, Version 2.0. See LICENSE for details.

kibana-object-manager 0.2.0