Operator

Operator mode is Kanvas’s view of what is running. Designer mode works on what you intend to run. Operator draws the Kubernetes resources found in your connected clusters on the same canvas, shows each one’s recorded state, and gives you actions against the live workloads: open a shell, follow logs, run a load test, or jump back to the design that produced a resource.

Where Operator data comes from 🔗

Kanvas does not talk to your clusters directly. Four pieces sit between a cluster and the canvas:

1. Meshery Operator runs in each connected cluster. It deploys MeshSync and a message broker.
2. MeshSync discovers the cluster’s resources and records them. It also carries out terminal and log requests inside the cluster.
3. Meshery Server stores the discovered inventory and relays terminal and log traffic through the broker. Kanvas runs inside the Meshery you operate.
4. Kanvas queries Meshery Server and draws the result.

This is why Operator mode needs a Meshery deployment that can reach your clusters, and why the hosted kanvas.new site does not offer it. Design, validate, and deploy do not depend on Meshery Operator. Operator mode does, and so do the terminal and log actions. See How Kanvas Works with Meshery and Layer5 Cloud for the wider picture.

The canvas is a snapshot 🔗

Operator draws a snapshot of Meshery Server’s inventory, not a continuous feed. MeshSync keeps that inventory current in Meshery, but Kanvas re-reads it only when you:

• load or create a view,
• change a filter, or
• change the selected clusters.

Resources that appear, change, or disappear in the cluster show up on the canvas after one of those triggers. The Details panel works the same way: it fetches a resource once when you open it. When you need current state, change a filter or reselect the cluster.

What one snapshot contains 🔗

Meshery turns the inventory into a design: each resource becomes a component, and Meshery evaluates relationships between them to draw edges. Kanvas then lays the result out with a force-directed layout. Each snapshot is limited to 100 resources, the first page, with no paging and no notice that anything was left out. The Layers panel counts every matching resource, so a count can exceed what is drawn. Narrow the filters, or use a view for one slice, until the resources you need are within 100.

Resources deployed from a Kanvas design carry a design identity label. Those nodes show a Meshery badge that opens the source design. Container nodes with an open terminal or log session show a terminal badge.

Choosing what to draw 🔗

Cluster selection comes from the Meshery context selector, not from Kanvas. Everything else is a filter, set in the Layers panel or in the typing filter at its top.

Filter types combine with AND, and values within a type combine with OR. A new view starts with kinds Node and Namespace so the first snapshot is small. The Layers panel groups kinds, each with a count, so you can toggle them without typing:

Every filter change refetches the snapshot and autosaves the open view. Selecting a resource opens the Details panel; search narrows what is drawn and does not select anything. See Resource Details for the panel.

When the canvas is empty 🔗

Kanvas shows no separate notice when a cluster disconnects or MeshSync is missing. An empty canvas is the signal. While a snapshot loads, a Fetching resources notice shows; a failure shows Failed to fetch resources.

Operating on running workloads 🔗

Three actions send requests back down the same path. Each is offered on specific kinds.

For a terminal or log session, Kanvas asks Meshery Server, which signals MeshSync through the broker. MeshSync opens the shell or log stream in the cluster and sends output back over the broker. Meshery Server preprocesses it and delivers it to your browser over a WebSocket subscription. Input travels the opposite way. Each session has its own identifier, so streams for several open sessions stay separate.

A performance test is different: Meshery Server generates the load itself against the URL you give it. It does not go through MeshSync.

Why terminal and log errors are quiet 🔗

Meshery Server reports failures such as an unready broker or a missing container, but Kanvas does not request or display those error fields for terminal and log sessions. A failed start looks like an empty tab. When a session is blank, check the cluster connection, Meshery Operator, and MeshSync first.

Views 🔗

A view saves a set of filters so a slice of your infrastructure comes back on demand. The Operator view for a design shows only the resources that design deployed. See Operator Views.

Where Operator is available 🔗

Kanvas gates Operator mode on the provider enabling the Operator capability. It does not apply role or plan checks to the mode switch itself. See Feature Availability and Permissions by Role for the role and plan matrix.

What Operator does not do 🔗

• It does not stream continuous updates to the canvas.
• It does not show live CPU or memory utilization, per-pod metrics, or time series.
• It does not change cluster resources. Deploy and undeploy run from Designer. See Validate and Deploy.

Related 🔗

• Operate Infrastructure
• Resource Details
• Operator Views

Related Reading

• Open an Interactive Terminal
• Operate Infrastructure
• Operator Views
• Resource Details
• Run a Performance Test
• Stream Container Logs

Related Videos

Kanvas Operator Overview

Previous Next