Skip to main content
A Stack Profile is a reusable template captured from a real stack. Build a stack once, save it as a profile, and instantiate it on any cluster - with parameters filled in per environment. Profiles are versioned, so you can publish updates, diff versions, and see which deployments have drifted behind the latest.
A profile is a template, not a running deployment. Instantiating a profile produces a stack draft on a target cluster, which you then review and commit like any other stack change.

​
Why use profiles

  • Standardise a golden stack (monitoring, ingress, security baseline) and reuse it across clusters.
  • Parameterise the bits that differ per environment - domains, replica counts, sizes - instead of copy-pasting YAML.
  • Version changes with a changelog and channels, and diff any two versions.
  • Track drift: a profile shows how many instantiations are behind its latest version.

​
Anatomy of a profile

Secret-typed parameters and other sensitive values are redacted when a profile is captured, so credentials are never baked into a shared template.

​
Create a profile

You can create a profile two ways:

From an existing stack

Capture a profile directly from a stack already running on a cluster. Optionally include addon configurations. This is the fastest path - build and validate the stack first, then snapshot it.

Import

Import a profile from exported IaC content, for sharing across organisations or storing in Git.

​
Build with drafts

For more control, work in a draft: create a draft (optionally seeded from a cluster’s stack), edit its spec and parameters, validate it, then publish it as a new version.
1

Create a draft

POST /org/stack-profiles/drafts - optionally seeded from an existing profile or a source cluster stack.
2

Edit and validate

Update the draft’s spec and parameters, then POST /org/stack-profiles/drafts/{draft_id}/validate to surface any issues before publishing.
3

Publish a version

POST /org/stack-profiles/drafts/{draft_id}/publish with a channel and changelog. This creates the profile (or a new version of it).

​
Instantiate a profile

Instantiating turns a profile into a stack on a target cluster:
1

Choose a profile and version

Pick the profile and, optionally, a specific version. When no version is given, the profile’s current version is used - the pinned version, which can be older than latest after a rollback.
2

Bind parameters

Supply values for the profile’s parameters. Required parameters must be set; others fall back to their defaults.
3

Review the draft

Instantiation creates a stack draft on the cluster (with the resolved addons and manifests). Review it.
4

Commit

Commit the draft to deploy, exactly like any other stack change.

​
From the CLI

The Ankra CLI can instantiate a profile directly. Inspect a profile’s parameters first, then apply it to a cluster as a draft (or pass --deploy to deploy in one step):
For secret parameters use --set-file <name=path> or --set-env <name=ENV_VAR> rather than --set so the value never appears in your shell history or process list.

​
Share with specific organisations

Making a profile public exposes it to everyone. When you want to share a golden stack with one partner, customer, or sibling organisation - and nobody else - share it directly instead:
  • Shared organisations can list, view, diff, export, and instantiate every version of the profile. They cannot edit, delete, or re-share it.
  • The profile keeps its organisation visibility; sharing is an explicit per-organisation grant.
  • The target organisation is identified by its organisation slug (found under organisation settings). Ask the other organisation for theirs.
  • Only organisation admins can grant or revoke shares, and a grant re-runs the plaintext-secret scan over every published version - a profile that still carries plaintext secrets cannot be shared. Grants and revokes are recorded in the audit log.
  • Revoking a share hides the profile from the other organisation again. Stacks they already deployed from it keep running - they just stop seeing profile updates.
In the portal, open a profile you own and use Share. Via the API:
Profiles shared with your organisation show up in your profile list marked “Shared with you”.

​
Versioning, diffing, and updates

  • Save a new version from an updated source stack, or by publishing an edited draft.
  • Diff any two versions to see what changed: GET /org/stack-profiles/{profile_id}/diff?from_version=1&to_version=2.
  • Update tracking: a profile reports outdated_instantiation_count and has_update_available so you can find deployments that are behind and re-instantiate them on the newer version.
  • Export IaC for a version to store the template in Git or move it between organisations.

​
API

All endpoints are under /org/stack-profiles and require authentication; write operations require a CSRF header for browser-originated requests. See Stacks for the deploy/commit flow and the API Reference for full schemas.