Visual Designer

Design and manage cloud native infrastructure visually with Meshery’s powerful visual designer interface

Meshery’s visual designer provides an intuitive, drag-and-drop interface for designing, configuring, and managing cloud native infrastructure. Moving beyond YAML files, the visual designer enables you to create complex Kubernetes-based deployments through a collaborative canvas that intelligently understands relationships between components.

Overview

The visual designer transforms infrastructure-as-code into infrastructure-as-diagrams, allowing you to:

• Design infrastructure visually without writing YAML
• Leverage intelligent component relationships
• Collaborate in real-time with team members
• Validate configurations before deployment
• Version control your infrastructure designs

Component Library

Access 300+ integrations and thousands of pre-configured components from the Meshery component library

Relationship Mapping

Meshery automatically infers and displays relationships between infrastructure components

Real-time Validation

Validate designs against best practices and policies as you build

GitOps Ready

Export designs to YAML or integrate directly with your GitOps workflows

Key Capabilities

Drag-and-Drop Interface

Build infrastructure designs by dragging components from the component library onto the canvas. The visual designer provides:

• Component Palette: Browse and search 300+ integrations including Kubernetes, Istio, Prometheus, and more
• Properties Panel: Configure component settings with auto-generated forms based on component schemas
• Canvas Controls: Zoom, pan, and navigate large infrastructure designs
• Multi-select: Select and manipulate multiple components simultaneously

Intelligent Relationships

Meshery understands how infrastructure components relate to each other and automatically applies these relationships:

1. Edge Relationships

   Visual connections showing dependencies between components (e.g., Service → Deployment)

2. Mount Relationships

   Components that mount or attach to others (e.g., PersistentVolume → Pod)

3. Hierarchical Relationships

   Parent-child relationships for component organization (e.g., Namespace contains Pods)

4. Network Relationships

   Traffic flow and network policies between components

Design Validation

Validate your infrastructure designs before deployment:

• Schema Validation: Ensure all component configurations match their JSON schemas
• Policy Validation: Check designs against Open Policy Agent (OPA) policies
• Relationship Validation: Verify all component relationships are valid
• Best Practice Checks: Identify anti-patterns and configuration issues

Validation runs automatically as you design, providing immediate feedback on configuration issues.

Working with Designs

Creating a New Design

1. Open Designer

   Navigate to the Designs page and click “Create Design” or use the visual designer directly

2. Add Components

   Drag components from the component palette onto the canvas

3. Configure Components

   Click on components to open the properties panel and configure settings

4. Connect Components

   Meshery automatically creates relationships, or manually connect components by dragging edges

5. Save Design

   Save your design with a descriptive name for later use or sharing

Importing Existing Infrastructure

Import existing infrastructure configurations into the visual designer:

• Kubernetes YAML: Import existing K8s manifests
• Helm Charts: Convert Helm charts to visual designs
• Docker Compose: Import Docker Compose files
• From Cluster: Discover and import running infrastructure from connected clusters

# Import from file using mesheryctl
mesheryctl pattern import -f my-app.yaml

Component Configuration

Each component in the designer exposes its configuration through auto-generated forms:

1. Click a component to open the properties panel
2. Configure settings using form fields generated from the component’s JSON schema
3. Set labels and annotations for Kubernetes resources
4. Define resource limits for compute resources
5. Configure relationships manually if needed

Use the search function in the component palette to quickly find specific components from the 300+ available integrations.

Collaboration Features

The visual designer supports real-time collaboration:

Multi-user Editing

• Presence Indicators: See who else is viewing or editing the design
• Cursors: View other users’ cursors and selections in real-time
• Comments: Add comments to specific components for team discussion
• Change Tracking: View a history of changes made to the design

Workspace Integration

Designs are organized within Workspaces for team collaboration:

• Assign designs to specific workspaces
• Control access through workspace permissions
• Share designs with team members
• Organize related designs together

Design Lifecycle

Dry Run

Before deploying, perform a dry run to preview changes:

1. Initiate Dry Run

   Click the “Dry Run” button to validate the design against target clusters

2. Select Target

   Choose which Kubernetes contexts to validate against

3. Review Results

   Examine validation results, including any errors or warnings

4. Fix Issues

   Address any issues identified during dry run validation

Deployment

Deploy validated designs to Kubernetes clusters:

Direct Deployment

Deploy directly from the UI to connected Kubernetes clusters

GitOps Integration

Export to Git repositories for GitOps-based deployments

Multi-cluster

Deploy the same design to multiple clusters simultaneously

Rollback

Undeploy designs with a single click if issues arise

Export and Integration

Export Formats

Export designs in multiple formats:

• Kubernetes YAML: Standard K8s manifests
• Helm Chart: Package as a Helm chart
• Docker Compose: Convert to Docker Compose format
• Meshery Design: Native Meshery design format (JSON)
• OCI Artifact: Package as an OCI artifact for distribution

API Access

Programmatically interact with designs:

# GraphQL query to fetch designs
query GetDesigns {
  patterns(selector: {}) {
    id
    name
    pattern_file
    visibility
    catalog_data {
      content_class
      type
    }
  }
}

Best Practices

Organize with Namespaces

Use Kubernetes namespaces to logically separate components within your designs

Use Descriptive Names

Name components and designs clearly to improve team collaboration

Leverage Patterns

Start from catalog patterns for common infrastructure configurations

Validate Early

Run validation and dry runs frequently to catch issues early

Version Control

Save design versions and use git integration for change tracking

Related Features

• Kanvas - Extended visual and collaborative designer
• Design Catalog - Reusable design patterns and templates
• GitOps - GitOps workflows and snapshots
• Multi-cluster Management - Deploy across multiple clusters