Skip to main content
A cluster rarely needs just one chart. Monitoring needs a namespace, Prometheus, Grafana and an ingress rule, and they have to go on in the right order. A Stack is how you describe that set once in Ankra and deploy it as one unit, to one cluster or to many. How Ankra Works shows where Stacks sit in the overall model.

What a Stack contains

  • Add-ons - Helm charts, each with a pinned chart version and its values.
  • Applications - applications you registered in Ankra, each pinned to a version.
  • Manifests - your own Kubernetes YAML: namespaces, Secrets, CRDs, RBAC, custom resources.
  • Variables - Stack-level values referenced as ${{ ankra.name }}. A Stack variable overrides a cluster or organisation variable of the same name.
  • Dependency edges - which member has to succeed before another one starts.
A cluster usually has several Stacks, one concern each (ingress, observability, a database), rather than one Stack that holds everything, so each one changes and rolls back on its own.

Deployment order

Members that do not depend on anything deploy in parallel. A member with parents waits until they have succeeded, so a namespace manifest goes before the add-ons and resources that live in it, and an operator goes before the custom resources it reconciles. Here the namespace deploys first, then the ConfigMap, then the add-on that reads both. Between Stacks, the order comes from each Stack’s Deploy wave, set in Stack settings: Stacks in lower waves deploy first, and the dependencies inside each Stack still order its members.

Manifests

A manifest is a YAML document of Kubernetes resources, written by you, that Ankra applies as part of a Stack. Use one for anything a Helm chart does not create for you: the namespace a chart installs into, a Secret it reads, the RBAC your team needs, or the custom resources an operator add-on reconciles. Manifests always live inside a Stack, so they deploy in order with the add-ons that need them. A single manifest can hold several resources separated by ---:
Secrets in manifests. A password or key does not belong in a manifest as plain text. Store it as an organisation secret under Infrastructure → Variables and secrets and put its reference, ${SECRET_SLOT:<id>}, where the value goes; the editor shows the reference with a lock and the secret’s name, and Ankra writes the value into a SOPS-encrypted file, so Git never holds the value in plain text, and the cluster decrypts it when it deploys. This needs the organisation’s SOPS encryption: without it, Ankra refuses to save the reference. See Organisation Secrets. When the cluster is connected to Git, the keys to encrypt with SOPS are declared in the manifest’s encrypted_paths, for example stringData.admin-user; the Stack editor has no field for it, so declare it in the cluster YAML or with ankra cluster encrypt. Ankra encrypts those values before it writes the manifest to Git and decrypts them when it deploys. SOPS needs a one-time setup for the organisation - see SOPS. Operational notes. Every member has a Notes tab holding its Operational notes · AGENTS.md, where you and Ankra AI record what matters when changing it, such as upgrade order or fields that must stay pinned. The notes are stored in Git with the member, as a plain markdown file, and the Stack editor refuses notes that look like they carry a credential. See Teach Your Agents with AGENTS.md.

Building a Stack

Stacks live under Infrastructure → Clusters → <your cluster> → Stacks, in the cluster menu’s Technical details. Create a stack offers three starts:
  • Compose a stack - add Helm add-ons and manifests yourself, and connect what depends on what.
  • Use a stack profile - start from a versioned stack profile, answering the inputs this cluster needs.
  • Bring a Git definition - use a Stack already declared in the cluster’s connected repository. There is nothing to import: Ankra adds every Stack declared there on its next sync.
Composing asks for a Stack name, which is also the Stack’s name in Git, and an optional Description. Start the draft opens the Stack editor. In the editor, Add offers Helm add-on, Application and Manifest. Each member opens in its own resource editor; for an add-on its tabs are described in Add-ons. A dependency is drawn on the graph, from a prerequisite’s right handle to a dependent’s left handle, or ticked on the dependent’s Parents tab. The Stack’s own description, variables and deploy wave are in More → Stack settings.

Drafts, review and deployment

Every change to a Stack starts as a shared draft and deploys only after it is reviewed. Everyone who opens the Stack edits the same draft, and the editor shows the changes others save as they happen. While a draft is open, the Stack reads Shared draft; a Stack that has never been deployed reads Draft only, not deployed; otherwise it shows its Deployed definition. Review changes lists every change in the draft. Deploying it is one confirmation:
  • Create and deploy stack, for a new Stack: it is committed to Git and its members deploy in dependency order.
  • Deploy reviewed changes: only the changed members are applied.
  • Deploy changes and removals, when the draft removes members: the whole draft is written to Git, and removed members are uninstalled from the cluster. Their data is treated as uninstalling a Stack treats it: a PersistentVolumeClaim a removed manifest declares is deleted, and so is whatever a chart or operator removes with its workload. See Protect Persistent Data before you deploy a removal.
More → Discard draft throws the draft away without deploying anything. You can also ask Ankra AI to do the editing: More → Edit with Ankra asks it to stage the changes in the Stack’s draft for your review. A prompt such as this one works the same from chat:
I need a monitoring stack with Prometheus, Grafana and alerting for this cluster.
In chat every change needs your confirmation. The same Stack tools are available to MCP clients with the mcp:write scope - see the MCP Tool Reference.

What a Stack is running

The Stack page has four views. Graph and Table show the members and their dependencies, Changes lists what the open draft would change, and Deployments shows the deployments that applied the Stack. What a member actually put on the cluster is on its Live state tab: the last state the cluster reported for it, its health, and the time of its last job update. For a deployed member it also reads the member’s namespace: its pods with their phase, readiness and restarts, the warnings reported for those pods, and the logs of a pod you pick, including the previous container instance. The evidence is namespace-wide, so pods of other resources in the same namespace appear too, and it refreshes every 15 seconds while the tab is visible. A member that exists only in the draft has no runtime evidence until it is deployed. More → History and rollback lists every recorded version of each member, lets you compare two versions, and restores the one you pick. Restoring needs the clusters.operate permission.

Stacks in Git

When the cluster has a repository connected, each Stack is written to its own directory, by default clusters/<cluster-name>-<short-id>/stacks/<stack>/, with one values.yaml per add-on and one YAML file per manifest. Commits to those files are applied to the cluster. See GitOps.

Uninstalling a Stack

Uninstall stack takes a Stack off the cluster without deleting it. Every add-on, manifest and application in it leaves the cluster, in reverse dependency order. The Stack and every member’s definition and values stay in Ankra and in the cluster’s GitOps repository, and nothing is committed to Git. Install stack deploys it again.
Back up the Stack before you uninstall it. Data is treated exactly as a delete treats it: what a chart or operator removes together with its workload is removed too, and installing the Stack again does not bring it back. Some charts and operators delete their volumes, and the data on them, with their workloads. A manifest that declares a PersistentVolumeClaim directly has that claim deleted. Protect the Stack or take a restore point first, and see Protect Persistent Data for when a deleted claim takes its disk with it.
In the portal, Uninstall stack is in the Stack’s More menu. The dialog asks you to type the Stack’s name and links to Back up this stack. While a draft is open on the Stack, it asks you to deploy or discard the draft first and changes nothing. From the CLI:
Both commands need the cluster named with --cluster. They never act on the cluster ankra cluster select saved, which every shell and agent session on the machine shares. uninstall says what it removes and asks first: --yes answers, and without a terminal --yes is required. With -o json, both print the platform’s answer: the Stack, whether it is installed now, and the members the call moved.

While a Stack is uninstalled

  • Its members stay off the cluster through cluster starts and Git syncs.
  • Changes you make to the Stack and its members are saved, and deployed when you install it.
  • Retrying an earlier deployment of one of its members is refused. Install the Stack instead.
  • Until the uninstall has removed a member, Ankra refuses a change that would alter what that removal deletes: the member’s own definition, moving it to another Stack, or the Stack’s variables or name.
  • Ankra keeps the uninstalled state itself. It is not written to Git, and a Git commit cannot uninstall or install a Stack.
The Stack page reads Uninstalling while members are being removed and Uninstalled once they are all off the cluster, and the Stacks list reads Uninstalled. ankra cluster stacks list shows the Stack as uninstalled, and its -o json output carries "uninstalled": true. If an uninstall did not finish, the Stack page reads Partly uninstalled and names the members Ankra still records as on the cluster. Uninstall again removes only those.

Installing it again

Install stack, on the Stack page or under More, deploys the Stack again in dependency order, with what it holds now. That includes members added or edited while it was uninstalled. A member that was already off the cluster before the uninstall, such as an add-on you uninstalled on its own, stays off it. Data the uninstall removed does not come back.

When Ankra refuses

A refused uninstall or install changes nothing, and the reason says what to do first. Before an install, deploying the open draft keeps its changes for the install.

Uninstall or delete

Delete stack removes the Stack itself: its resources leave the cluster, and the deletion is committed to the cluster’s GitOps repository when one is connected. Uninstalling keeps the Stack in Ankra and in Git so you can install it again. Both treat data the same way. Uninstalling needs the stacks.delete permission on the cluster, as deleting does, and installing needs stacks.deploy. The portal offers each action only to people who may use it. See Roles & Access.

Reusing a Stack

  • More → Clone to another cluster copies a Stack to another cluster, including one in another organisation, and Clone stacks on the Stacks list copies several at once. Encrypted values are not copied. See Clone Stacks.
  • Create a reusable profile from this stack, at the foot of the Stack editor, opens a stack profile draft built from the Stack: a versioned, parameterised template you can deploy on any cluster. See Stack Profiles.

Next

Add-ons explains how a Helm chart becomes an add-on and how its values are managed.