Skip to main content

ankra cluster

Commands for managing and operating on clusters. Flags

ankra cluster access

List, grant, and revoke per-user access to a cluster’s Kubernetes API through the Ankra gateway (the access used by ‘ankra cluster kubeconfig’ and ‘ankra cluster kube-token’). Managing access requires organisation admin rights. Grants apply to one cluster and one organisation member, identified by email. A grant can be time-boxed with --expires and carry a --reason; the organisation access policy (‘ankra org access-policy’) may require both. A service account has no email: ‘list’ names it “service account <name>”, and it gets access with ‘elevate’, run with its own token. Break-glass: ‘elevate’ gives the caller itself time-boxed access, within the policy. It needs only the kube_access.elevate permission, so automation running as a service account can use it without being able to grant anyone else. ‘list’ shows where each grant came from (Source: manual, creator, role, elevated) and whether the current policy would refuse it today (Over policy). A grant whose source is “role” comes from the member’s organisation role and cannot be revoked here: the platform refuses it, because the role sync would re-create it. Change the member’s role, or the role’s Kubernetes access, to remove it. Exit codes:
Examples:

ankra cluster access elevate

Give the identity this CLI runs as - you, or a service account’s token - time-boxed access to a cluster through the kube gateway. This is break-glass within the organisation access policy: the access must end (--expires, at most the policy’s limit or 4 hours) and needs a --reason, and it can never go above the policy’s ceiling. It needs the kube_access.elevate permission, which grants nothing else: no access for anyone else, no standing access, and no way to change the policy. Running it again with a new --expires extends your own elevation; end it early with ‘ankra cluster access revoke <grant-id>’. The binding reaches the cluster within about 30 to 60 seconds; until then kubectl may still answer 403 Forbidden, so retry it. Every elevation is recorded in the audit log and notifies the organisation’s notification routes. Exits 2 when --expires or --reason is missing or a flag is invalid, and when the organisation access policy refuses the request; 7 when your role lacks kube_access.elevate. See ‘ankra cluster access --help’ for every code.
Examples
Flags

ankra cluster access grant

Grant an organisation member access to a cluster’s Kubernetes API through the Ankra gateway. The grant is cluster-wide by default; pass --namespace to limit it to one namespace. Roles map to the standard Kubernetes ClusterRoles: view, edit, admin, cluster-admin. Exits 2 when a flag is invalid or the organisation access policy refuses the grant (change --role, --expires or --reason), and 7 when your role does not allow managing kubectl access. See ‘ankra cluster access --help’ for every code.
Flags

ankra cluster access list

List access grants for a cluster
Flags

ankra cluster access revoke

Revoke gateway access from a cluster. Pass a grant ID (from ‘ankra cluster access list’) to revoke a single grant, or an email address to revoke every grant that member has on the cluster. A grant whose Source is “role” in ‘ankra cluster access list’ comes from the member’s organisation role and cannot be revoked here: the platform refuses it, because the role sync would re-create it. Change the member’s role, or the role’s Kubernetes access, to remove it. Revoking by email still revokes the member’s other grants, then names the ones it kept and exits 2, so a script never reads the member’s access as gone while a role grant remains. Exits 2 when a grant comes from an organisation role, 3 when no grant matches, and 7 when your role does not allow managing kubectl access.
Flags

ankra cluster addons

Commands to list, manage settings, and uninstall addons.

ankra cluster addons available

List addons available for installation
Flags

ankra cluster addons list

List addons for the active cluster; or show details for a single addon
Flags

ankra cluster addons settings

Read and write an addon’s settings
Flags

ankra cluster addons settings get

Get settings for an addon
Flags

ankra cluster addons settings set

Change one or more settings on an addon without resending the rest. Each flag is applied to the addon’s stored settings; anything you do not pass is left as it is. To replace the whole document instead, use ‘ankra cluster addons update <addon> -f settings.json’. Backup settings override the add-on’s stack backup policy for this add-on only - use them for the one add-on in a protected stack that should be captured differently:
Flags

ankra cluster addons uninstall

Uninstall an addon from the cluster
Flags

ankra cluster addons update

Update addon settings by providing a JSON file that conforms to the settings schema. Example JSON file:
Usage:
Flags

ankra cluster addons upgrade

Upgrade an addon by patching just the fields you supply. At least one mutating flag is required. Examples:
--set* and --values-from-file are mutually exclusive: --set* mutates the existing values document while --values-from-file replaces it. Changing --namespace is destructive (Helm reinstall in the new namespace, leaves the old release orphaned). Use --yes to skip the confirmation prompt or interactively confirm.
Flags

ankra cluster addons values

Print the current Helm values document for an addon. By default the decoded YAML is written to stdout, making it easy to pipe into a file or edit and re-apply with --values-from-file:
Flags

ankra cluster agent

Commands to view agent status, get tokens, and upgrade agents.

ankra cluster agent auto-upgrade

The platform rolls new agent releases out to every online agent automatically, as soon as the cluster has no write execution running. Disabling that here fences this cluster’s agent off from the rollout - for a freeze window or a migration night - and enabling it puts the agent back in. Either way ‘ankra cluster agent upgrade’ still applies the latest release on demand, and ‘ankra cluster agent status’ shows the current setting. Every change is recorded in the organisation audit log with who made it and the setting it replaced; --reason adds your own words for why, so the next person to look can tell a deliberate fence from an accident. Examples

ankra cluster agent auto-upgrade disable

Fence the cluster agent off from the automatic fleet rollout
Flags

ankra cluster agent auto-upgrade enable

Put the cluster agent back into the automatic fleet rollout
Flags

ankra cluster agent ci

The cluster agent runs Ankra Pipelines steps itself, and these settings size that: how many steps it runs at once, and the storage class its step workspaces are carved from. The worker count is the agent’s CI slots: each slot is one pipeline step the agent watches at a time, not a node. The nodes those steps run on come from the cluster’s node group autoscaler (‘ankra cluster node-group autoscaling get’), so a cluster whose steps wait for a slot needs more workers, and one whose step pods sit Pending needs more nodes. Both are stored on the platform, so every install or upgrade command Ankra generates for this cluster carries them - unlike a hand-run ‘helm upgrade --set ci_worker_count=…’, which the next agent upgrade renders away again. The placement says which nodes every pipeline pod runs on - step pods, their cache and artifact helpers, and image builds - so CI can live on a dedicated, tainted node group without editing any pipeline’s runs_on. The run reservation decides whether a run first reserves the room its later steps need on its node, so another run’s pods cannot take it between two steps: off (the default), shadow (sized and recorded, nothing held) or on. The image pre-pull decides whether the agent keeps the images the platform’s own steps run in - the checkout’s git client, the scanners, the rootless builder - pulled on every node pipeline steps can land on, so a node that just joined pulls them as it joins rather than while a step waits: off (the default) or on. The step workspaces setting decides whether a pipeline that declares workspace.mode: per_step gets a workspace for each step, so its steps can run on different nodes, rather than one volume that keeps the whole run on one node: off (the default), shadow (recorded, nothing changes) or on. The Ankra Workspace class is the storage class the cluster’s Ankra Workspaces cut their volume from, when they cannot share the one pipeline steps use. Left empty, they inherit it.

ankra cluster agent ci get

Show the stored worker count, storage class and placement, the agent version that has to honour them, whether that agent currently advertises it can run pipeline steps, and how the last write was applied. The placement block names the node group, node selector, tolerations and mode, and how many Ready nodes it admits right now. The run reservation, image pre-pull and step workspaces modes are shown with whether the agent advertises each; a platform that predates a setting shows neither of its lines. The Ankra Workspace class is the storage class the cluster’s Ankra Workspaces use, and says when they inherit it; a platform that predates it shows no such line. An agent that has not yet re-rendered its release reports pipeline steps as not advertised even with a non-zero worker count stored: the capability is what the agent reported on its last check-in, not what the settings ask for.
Examples
Flags

ankra cluster agent ci set

Store how many pipeline steps this cluster’s agent runs at once, the storage class its step workspaces are carved from, and where its pipeline pods run. --workers 0 disables the agent’s pipeline-step scheduler; the cluster keeps its agent and everything else it does. --storage-class is only sent when you pass it, so setting the worker count alone keeps the storage class already stored; pass an empty value to fall back to the cluster’s default class. --storage-class reaches two things at different times. Pipeline steps take it at the agent’s next re-render. Ankra Workspaces on the cluster that have no workspace class of their own read it at their next use, so changing it replaces each of them then, and whatever runs in one stops. An Ankra Workspace stays off the nodes pipeline steps run on, so a class only those nodes can use would leave it Pending for good. --ankra-workspace-storage-class gives the cluster’s Ankra Workspaces a class of their own, so that cannot happen. To move pipeline steps to such a class with no workspace replaced, first pass the class the workspaces use now, which changes nothing for them, and then change --storage-class. Naming a different class replaces each workspace at its next use. It reaches no pipeline step and restarts no agent. Pass an empty value to inherit --storage-class again; a workspace is replaced then if that is a different class. --workers is the agent’s CI slots: how many pipeline steps it watches at once. A slot is not a node; the nodes steps run on come from the cluster’s node group autoscaler. Agents that support live resize accept up to 128 workers, older agents up to 32. The write always stores the values. Whether they reach the agent now depends on the agent: an agent that supports live resize takes a new worker count on its next job pull without restarting, an online agent new enough to accept chart values re-renders its release immediately, an older one picks them up at its next upgrade, and an offline one when it reconnects. The command says which happened. Placement puts every pipeline pod of the cluster - step pods, their cache and artifact helpers, and image builds - on chosen nodes. --node-group names one of the cluster’s Ankra node groups: the platform selects its nodes by the ankra.cloud/node-group label (or the labels the group declares) and tolerates every taint the group carries, so a dedicated, tainted pool needs nothing else. --node-selector and --toleration add to it, or stand alone on a cluster without Ankra node groups. --placement required (the default) keeps pods on those nodes; preferred favours them and lets pods run elsewhere when they have no room, and still carries the tolerations. The placement is replaced whole by any placement flag, applies to the next step dispatched with no agent restart, and is never held to the organisation’s runs_on allow-lists. --clear-placement removes it. --workers is optional when only the storage class or the placement changes. On a cluster with pipeline steps off (0 workers), ‘set’ with no flags turns them on with 50 workers. On a cluster that already runs steps, it names nothing to change and asks for a flag. --run-reservation off|shadow|on decides whether each run first reserves, on its node, the room its later steps will need, held by one placeholder pod per run, so another run’s pods cannot take that room between two steps. off (every cluster’s default) reserves nothing. shadow sizes each run’s reservation and records it beside what its steps requested, and holds nothing: use it to check the estimate first. on holds it, which can add a node or keep one up while a run is between steps; it needs an agent that advertises run reservation, and until the agent does, on behaves as shadow. Like the placement it applies to the next step dispatched, with no agent restart, and off is the way back. --image-prepull off|on decides whether the agent keeps the platform’s own step images (the checkout’s git client, the trivy, checkov and semgrep scanners, the rootless builder) pulled on every node pipeline steps can land on, honouring the placement, with one DaemonSet in the agent’s namespace. A node that just joined then pulls them as it joins instead of while a checkout, scan or build waits. The images are pinned by digest and follow the platform: a platform release that moves one moves the pre-pull with the next step dispatched. Each node keeps about 0.9 GB of images it would otherwise pull on demand. It needs an agent that advertises image pre-pull; off (the default) removes it with the next step dispatched. --step-workspaces off|shadow|on decides whether a pipeline that declares workspace.mode: per_step gets a workspace for each step, so its steps can run on different nodes, rather than one volume that keeps the whole run on one node. off (every cluster’s default) runs every pipeline on the shared volume, whatever it declares. shadow still does, and records the mode each per_step run would have taken under on: use it to check a cluster first. on gives each step its own workspace; it needs an agent that advertises step workspaces and a ready backup vault to hand files between steps through, and a run without either stays on the shared volume. A pipeline that does not declare per_step never changes. A run takes its mode at its first step, with no agent restart, and keeps it, so off is the way back for new runs and a run already started finishes in the mode it has. --build-apparmor-profile <name> runs the rootless image builder under a Localhost AppArmor profile installed on the cluster’s nodes under that name. On nodes whose container runtime confines the builder with its default AppArmor profile (containerd on Ubuntu denies the builder its mount), builds otherwise fail in-cluster and fall back to Ankra’s builders. The build namespace’s Pod Security Baseline admits a Localhost profile, so nothing else is relaxed. Install the profile on every node builds can run on first: a node without it makes the build wait rather than run. The name is a DNS-1123 subdomain other than unconfined; pass an empty value to go back to the runtime’s default. It needs an agent that advertises the capability, applies to the next build dispatched with no agent restart, and the next build is probed in-cluster again even if the cluster was known to confine the builder.
Examples
Flags

ankra cluster agent resources

The cluster agent runs as one pod in the cluster, and these settings size it: its memory limit and request and its CPU limit and request, as Kubernetes quantities (“2Gi”, “500m”). They are stored on the platform, so every install or upgrade command Ankra generates for this cluster carries them - unlike a hand-run ‘helm upgrade --set resources.limits.memory=…’, which the next agent upgrade renders away again. A member the cluster does not set uses the agent chart’s default.

ankra cluster agent resources get

Show the stored memory and CPU limits and requests of the cluster’s agent, when they last changed, and how the platform applied them. A member the cluster does not set reads “chart default”: the agent chart’s own value applies.
Examples
Flags

ankra cluster agent resources set

Store the memory and CPU limits and requests of this cluster’s agent, as Kubernetes quantities (“2Gi”, “512Mi”, “1”, “500m”). Only the flags you pass are sent, so setting the memory limit alone keeps every other member as stored. Pass an empty value ("") to clear a member: the agent goes back to the chart’s default for it. At least one flag is required. The write always stores the values. Whether they reach the agent now depends on the agent: an online agent new enough to accept them re-renders its release immediately, an older one picks them up at its next upgrade, and an offline one when it reconnects. The command prints the platform’s sentence saying which happened. The platform validates the values - a malformed quantity, or a request above its limit - and its refusal is printed as it came.
Examples
Flags

ankra cluster agent status

Get agent status for the selected cluster
Flags

ankra cluster agent token

Get or generate agent token for the selected cluster
Flags

ankra cluster agent upgrade

Upgrade the Ankra agent on the selected cluster now, instead of waiting for the fleet rollout. Without --version the platform installs the newer of the release the agent runs and the latest stable release, so this never moves an agent backwards: an agent already on a newer release (a release candidate) is re-rendered where it is. --version installs that exact published release. A version older than the one the agent runs is refused unless --allow-downgrade is also given, so a downgrade only ever happens when both flags say so. A version that is neither published nor the running one is refused.
Examples
Flags

ankra cluster alertmanager

Work with the Alertmanager running in the active cluster (the one kube-prometheus-stack or the Alertmanager chart installs), through the cluster’s Ankra agent.

ankra cluster alertmanager silences

List, create and expire silences on the active cluster’s Alertmanager. Listing needs clusters.read on the cluster; creating and expiring need alerts.write there. The Alertmanager is discovered by its labels; when the cluster runs several, or a non-standard install, pass --namespace (and --service, --port).

ankra cluster alertmanager silences create

Create a silence on the active cluster’s Alertmanager. An alert is silenced while every --matcher matches it: name=value is an exact match, name=~regex a regular expression, and at least one must be exact so a silence cannot mute everything. --duration takes a number and a unit (s, m, h, d, w) from 5m to 30d, 2h by default. --comment says why; operators see it in Alertmanager. The silence starts at once and is attributed to you.
Flags

ankra cluster alertmanager silences expire

Expire one silence on the active cluster’s Alertmanager; the alerts it muted notify again. ‘list’ shows the ids. The command asks first (--yes skips, declining exits 4); a silence Alertmanager does not have exits 3.
Flags

ankra cluster alertmanager silences list

List the silences on the active cluster’s Alertmanager, newest ending first. --state picks active (the default), pending, expired or all.
Flags

ankra cluster ankracloud

Manage kubeadm or k3s clusters Ankra builds on Ankra Cloud servers. For Ankra Cloud Kubernetes, where the Ankra team runs the control plane, use ‘ankra cluster managed … --provider ankracloud_k8s’ instead. Both take the same Ankra Cloud credential (‘ankra credentials ankracloud create’).

ankra cluster ankracloud bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster ankracloud bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster ankracloud bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’.
Flags

ankra cluster ankracloud bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster ankracloud control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster ankracloud control-plane get

Show the current control plane configuration
Flags

ankra cluster ankracloud control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster ankracloud control-plane set-instance-type

Change the instance type of every controller in a Ankra Cloud cluster. The instance type is stored as given; it is not checked against Ankra Cloud’s catalog. A name that does not exist is rejected by Ankra Cloud itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline. List the instance types that do exist with:
Flags

ankra cluster ankracloud cpu-pools

List the CPU pools of an Ankra Cloud zone: compute nodes grouped by exact CPU. A server is placed in one pool and only moves within it, and its guest sees the host’s CPU, so the pool decides which instructions a workload may use. The x86-64 level column is the microarchitecture level every CPU of the pool meets: 3 or more has AVX2, which images built for x86-64-v3 (duckdb, pyarrow, numba wheels and many ML runtimes) need or they crash with SIGILL. Pin a node group to a pool with ‘ankra cluster node-group add --cpu-pool <name>’. Pass --cluster to list the pools of an existing cluster’s zone under its own credential, or --credential-id with --zone to browse before creating one.
Flags

ankra cluster ankracloud create

Create an Ankra-managed kubeadm (default) or k3s cluster on Ankra Cloud servers. Ankra builds the private network (unless --private-network-id adopts one), the per-server firewalls, a bastion, and the control plane and worker servers. The kube-apiserver stays private and is reached through the bastion. The network mode is ipv6_only unless --network-mode says otherwise (the server default): no NAT router, the bastion holds only a public IPv6 address and is reached through the Cloud’s port forward, and the nodes reach IPv4 through the zone’s NAT64. --network-mode ipv4_nat adds a NAT router for the nodes’ IPv4 egress and gives the bastion a public IPv4 address; public IPv4 is a paid add-on under a per-account quota. The preflight says whether a zone can serve the mode you chose. --credential-id may be left out where the platform provides a built-in Ankra Cloud credential, which it then uses; a platform without one refuses the create. Without --ssh-key-credential-id the cluster uses an SSH key Ankra generates for it; add your own later with ‘ankra cluster ssh-keys set’. Servers are sized by plan: list them with ‘ankra cluster ankracloud plans’. Each server’s root disk is its plan’s included disk unless a —-disk-gib flag sizes it, on the zone’s default storage tier unless a —-disk-tier flag chooses one (local-nvme, standard, maxiops or hdd). CI workers belong on small local-nvme disks when their data lives on persistent volumes. Run ‘preflight’ first to check the zone, plans, network and quota, which counts the chosen disk sizes against the account’s storage. Examples:
Flags

ankra cluster ankracloud deprovision

Permanently delete an Ankra Cloud cluster and the servers, network, router and firewall rules Ankra created for it. An adopted private network is left in place. Volumes follow the cluster’s retention_policy: ‘retain’ keeps them, ‘delete’ sweeps them. A ‘delete’ cluster’s persistent volumes are named first and deleted only when you accept that: answer the prompt on a terminal, or pass --accept-volume-data-loss (--yes does not imply it).
Flags

ankra cluster ankracloud etcd

Read the cluster’s etcd membership from one control-plane node, and remove the stale member a dead control-plane node left behind so its replacement can join. Both run over the platform’s bastion SSH lane as tracked operations and need clusters.operate on the cluster. Find node ids with ‘nodes list’.

ankra cluster ankracloud etcd members

Run ‘etcdctl member list’ and the endpoint health check on the control-plane node named and report every member (hex and decimal id), its health, any alarms and the quorum summary with its failure tolerance. Nothing changes. Run it on a healthy control-plane node when another one is dead.
Flags

ankra cluster ankracloud etcd remove

Remove one etcd member, named by the hex or decimal id ‘etcd members’ reported, executing on the healthy control-plane node named. The platform re-reads live membership first and refuses a healthy member, a member whose health it cannot read, the node’s own member, an ambiguous id, and any removal that would break quorum. This is destructive and cannot be undone: the command asks first (--yes skips, declining exits 4).
Flags

ankra cluster ankracloud k8s-version

Get current Kubernetes version for an Ankra Cloud cluster
Flags

ankra cluster ankracloud networks

List the Ankra Cloud private networks a cluster can adopt
Flags

ankra cluster ankracloud nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster ankracloud nodes cloud-init-log

Fetch ‘cloud-init status --long’ and the tail of /var/log/cloud-init-output.log from the node over the platform’s bastion SSH lane, as a tracked read-only operation. This is the debug surface for node-group user-data: it shows whether the first-boot document ran and what it printed, without needing the cluster’s SSH key. Repeated calls attach to an in-flight fetch instead of dispatching duplicates. Find node ids with ‘nodes list’.
Flags

ankra cluster ankracloud nodes diagnose

Dispatch the platform’s read-only node diagnose job and wait for its report: over the bastion SSH lane it snapshots the node’s OS-level state - the Kubernetes service unit and its journal, disk, memory, uptime, the kernel log and the firewall path to the API server - and names the symptoms it finds. Nothing on the node is changed. This is what to reach for when a node is NotReady or its kubelet stopped posting status, below what ‘cluster get’ can see. The same diagnosis the Ankra assistant runs as ssh_diagnose_node. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’, and repeated calls attach to the run already in flight. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster ankracloud nodes get

Show full spec and metadata for a single node
Flags

ankra cluster ankracloud nodes list

List all nodes for the cluster
Flags

ankra cluster ankracloud nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster ankracloud os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster ankracloud os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster ankracloud os-patches plan

Run the dry run on every host and report what each would install, which held-back security updates are pending, whether a reboot would follow, and the order ‘run’ would take. The platform waits about 40 seconds; a slower plan hands back its operation id, and ‘status’ shows it once it finishes. Needs clusters.operate.
Flags

ankra cluster ankracloud os-patches policy

Show or change the cluster’s OS patch policy

ankra cluster ankracloud os-patches policy get

Show the OS patch policy and its maintenance window
Flags

ankra cluster ankracloud os-patches policy set

Change the cluster’s OS patch policy. Only the flags passed are changed. Turning the policy off also removes the node OS update hold from every host, and is refused while a run or a node OS policy operation is in flight. Needs clusters.write.
Flags

ankra cluster ankracloud os-patches run

Start the rolling patch: each host is drained, patched, rebooted when the packages ask for it, and returned to service before the next. Workloads move between nodes while it runs, so the command asks first (--yes skips, declining exits 4). Outside the policy’s maintenance window the platform refuses unless --outside-window is passed. Stateful nodes follow the policy unless --include-stateful-nodes or --exclude-stateful-nodes says otherwise; the bastion is patched last unless --exclude-bastion. Follow the run with ‘status’ or ‘ankra cluster operations list’. Needs clusters.operate.
Flags

ankra cluster ankracloud os-patches status

Show the OS patch policy, the newest run and the security-lag verdict
Flags

ankra cluster ankracloud plans

List the server plans (sizes) the create and node-group flags take. Pass --credential-id to browse before creating a cluster, or --cluster to list the plans under an existing cluster’s own credential (for node groups and control-plane or bastion resizes).
Flags

ankra cluster ankracloud preflight

Run the Ankra Cloud create preflight: credential, zone, plan and template availability and the network, without building anything. Takes the same flags as ‘create’.
Flags

ankra cluster ankracloud pricing

Show Ankra Cloud storage and public IPv4 prices
Flags

ankra cluster ankracloud quota

Show the limits of the Ankra Cloud account behind an Ankra Cloud cluster, what the account already holds, and what is left: servers, cores, memory, storage, floating IPs, private networks and routers. Storage is shared by server disks and every PersistentVolumeClaim the Ankra Cloud CSI provisions, so a claim larger than what is left stays Pending. Applies and stack deploys that need more storage than is left say so in their warnings. Quota applies to Ankra Cloud clusters only: a cluster built on another provider, or imported, is refused with exit code 2.
Flags

ankra cluster ankracloud start

Start a stopped Ankra Cloud cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster ankracloud stop

Stop an Ankra Cloud cluster. A plain stop powers the servers off and keeps them with their disks; only a forced stop or a deprovision deletes servers.
Flags

ankra cluster ankracloud templates

List the operating-system templates Ankra Cloud servers boot
Flags

ankra cluster ankracloud workers

Get current worker count for an Ankra Cloud cluster
Flags

ankra cluster ankracloud zones

List the Ankra Cloud zones a credential can use
Flags

ankra cluster apply

Apply an ImportCluster YAML to the Ankra API
Flags

ankra cluster audit-logs

Show the newest audit log entries for one cluster: the organisation’s trail narrowed to the cluster, the same rows as the cluster’s Audit tab. Without a cluster argument it uses the selected cluster. Without --since or --until it reads the last 7 days. To download a cluster’s trail, use ankra org audit-logs export --cluster <cluster>.
Flags

ankra cluster aws

Manage the lifecycle of self-managed Kubernetes clusters Ankra builds on EC2. These are k3s (or kubeadm) clusters on plain EC2 instances, not EKS. By default Ankra creates the whole network for the cluster (VPC, subnets, internet gateway, route tables, NAT) and removes it with the cluster; pass --vpc-id to build inside a VPC you already own instead. For an EKS control plane use ‘ankra cluster managed’.

ankra cluster aws access-info

Show the bastion and control plane IPs plus ready-to-use SSH jump and Kubernetes API port-forward commands.
Flags

ankra cluster aws availability-zones

List the availability zones of a region
Flags

ankra cluster aws bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster aws bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster aws bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. On AWS <instance_type> is an EC2 instance type such as t3.medium; list them with ‘ankra cluster aws instance-types’.
Flags

ankra cluster aws bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster aws control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster aws control-plane get

Show the current control plane configuration
Flags

ankra cluster aws control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster aws control-plane set-instance-type

Change the instance type of every controller in a AWS cluster. The instance type is stored as given; it is not checked against AWS’s catalog. A name that does not exist is rejected by AWS itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline. List the instance types that do exist with:
Flags

ankra cluster aws create

Create an Ankra-managed k3s or kubeadm cluster on EC2 instances. By default Ankra creates the whole network: a VPC from --network-ip-range (default 10.0.0.0/16) with a public bastion subnet and private node subnets in each of --availability-zones (default: one zone, or three when the control plane has 3 or more nodes), an internet gateway, route tables and the nodes’ egress - ‘nat_gateway’ (the default; one NAT gateway per zone, or one in total with --nat-gateway-single-zone) or ‘bastion_nat’ (the bastion is the nodes’ NAT, the cheapest option). The created network is Ankra’s and is deleted with the cluster. Pass --vpc-id to build inside a VPC you already own instead: Ankra adopts the VPC, --node-subnet-ids and --bastion-subnet-id and never creates or deletes networking there. Egress is then detected from the node subnets’ route tables unless --egress-mode pins it: ‘existing’ uses the NAT gateway or internet gateway the subnets already route through, ‘bastion_nat’ makes the bastion the NAT. --network-ip-range, --availability-zones and --nat-gateway-single-zone do not apply to an adopted VPC. In both modes Ankra owns the instances, security groups, the generated SSH key and the bastion. Run ‘preflight’ first to check the region, the network (ownership, zones, CIDR or the adopted subnets), instance-type availability and the resolved egress mode. Examples:
Flags

ankra cluster aws deprovision

Permanently delete an AWS cluster and the provider resources Ankra created for it: the instances, security groups, bastion and generated SSH key, and - when Ankra created the network - the VPC, subnets, internet gateway, NAT gateways, route tables and elastic IPs. An adopted VPC and its subnets are never touched. EBS volumes and load balancers follow the cluster’s retention_policy: ‘retain’ keeps them (forced or not, for the volumes), ‘delete’ sweeps them. A ‘delete’ cluster’s persistent volumes are named first and deleted only when you accept that: answer the prompt on a terminal, or pass --accept-volume-data-loss (--yes does not imply it).
Flags

ankra cluster aws etcd

Read the cluster’s etcd membership from one control-plane node, and remove the stale member a dead control-plane node left behind so its replacement can join. Both run over the platform’s bastion SSH lane as tracked operations and need clusters.operate on the cluster. Find node ids with ‘nodes list’.

ankra cluster aws etcd members

Run ‘etcdctl member list’ and the endpoint health check on the control-plane node named and report every member (hex and decimal id), its health, any alarms and the quorum summary with its failure tolerance. Nothing changes. Run it on a healthy control-plane node when another one is dead.
Flags

ankra cluster aws etcd remove

Remove one etcd member, named by the hex or decimal id ‘etcd members’ reported, executing on the healthy control-plane node named. The platform re-reads live membership first and refuses a healthy member, a member whose health it cannot read, the node’s own member, an ambiguous id, and any removal that would break quorum. This is destructive and cannot be undone: the command asks first (--yes skips, declining exits 4).
Flags

ankra cluster aws images

List the Ubuntu series and CPU architectures a create may ask for with --ubuntu-series and --architecture. The platform resolves the actual AMI at build time, so there is no AMI id to pick.
Flags

ankra cluster aws instance-types

List EC2 instance types available in a region
Flags

ankra cluster aws k8s-version

Get current Kubernetes version for an AWS cluster
Flags

ankra cluster aws nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster aws nodes cloud-init-log

Fetch ‘cloud-init status --long’ and the tail of /var/log/cloud-init-output.log from the node over the platform’s bastion SSH lane, as a tracked read-only operation. This is the debug surface for node-group user-data: it shows whether the first-boot document ran and what it printed, without needing the cluster’s SSH key. Repeated calls attach to an in-flight fetch instead of dispatching duplicates. Find node ids with ‘nodes list’.
Flags

ankra cluster aws nodes diagnose

Dispatch the platform’s read-only node diagnose job and wait for its report: over the bastion SSH lane it snapshots the node’s OS-level state - the Kubernetes service unit and its journal, disk, memory, uptime, the kernel log and the firewall path to the API server - and names the symptoms it finds. Nothing on the node is changed. This is what to reach for when a node is NotReady or its kubelet stopped posting status, below what ‘cluster get’ can see. The same diagnosis the Ankra assistant runs as ssh_diagnose_node. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’, and repeated calls attach to the run already in flight. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster aws nodes get

Show full spec and metadata for a single node
Flags

ankra cluster aws nodes list

List all nodes for the cluster
Flags

ankra cluster aws nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster aws os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster aws os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster aws os-patches plan

Run the dry run on every host and report what each would install, which held-back security updates are pending, whether a reboot would follow, and the order ‘run’ would take. The platform waits about 40 seconds; a slower plan hands back its operation id, and ‘status’ shows it once it finishes. Needs clusters.operate.
Flags

ankra cluster aws os-patches policy

Show or change the cluster’s OS patch policy

ankra cluster aws os-patches policy get

Show the OS patch policy and its maintenance window
Flags

ankra cluster aws os-patches policy set

Change the cluster’s OS patch policy. Only the flags passed are changed. Turning the policy off also removes the node OS update hold from every host, and is refused while a run or a node OS policy operation is in flight. Needs clusters.write.
Flags

ankra cluster aws os-patches run

Start the rolling patch: each host is drained, patched, rebooted when the packages ask for it, and returned to service before the next. Workloads move between nodes while it runs, so the command asks first (--yes skips, declining exits 4). Outside the policy’s maintenance window the platform refuses unless --outside-window is passed. Stateful nodes follow the policy unless --include-stateful-nodes or --exclude-stateful-nodes says otherwise; the bastion is patched last unless --exclude-bastion. Follow the run with ‘status’ or ‘ankra cluster operations list’. Needs clusters.operate.
Flags

ankra cluster aws os-patches status

Show the OS patch policy, the newest run and the security-lag verdict
Flags

ankra cluster aws preflight

Run the AWS create preflight: credential and region reachability, the network (a free CIDR and the zones for a created network; VPC and subnet membership and bastion subnet routing for an adopted one), instance-type and AMI availability, and what the server resolved - the network ownership (created or adopted), the availability zones the network will span, and the egress mode when --egress-mode is left unset. Takes the same flags as ‘create’.
Flags

ankra cluster aws pricing

Show the on-demand prices a cluster in a region is estimated from
Flags

ankra cluster aws regions

List AWS regions available to a credential
Flags

ankra cluster aws start

Re-provision a stopped AWS cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster aws stop

Stop an AWS cluster by terminating its EC2 instances while preserving its configuration so it can be re-provisioned later.
Flags

ankra cluster aws subnets

List the subnets of a VPC with their availability zone, how their route table reaches the internet (egress: internet_gateway, nat_gateway, nat_instance, transit, none or unknown) and how many instances Ankra did not create already live in them. Nodes go in private subnets (egress via a NAT gateway, or via the bastion with --egress-mode bastion_nat, which is refused when a node subnet carries foreign instances); the bastion needs a public one (internet_gateway).
Flags

ankra cluster aws vpcs

List the VPCs of a region with their CIDR and DHCP domain name. The DHCP domain column is the domain the VPC’s DHCP option set hands to instances; “(none)” means the option set names no domain and ”?” means it could not be read, which is not the same thing.
Flags

ankra cluster aws workers

Get current worker count for an AWS cluster
Flags

ankra cluster backups

Read the cluster’s backup posture: which stacks are protected, which hold data and are not, what each one can be restored from, and whether the backup components are installed on the cluster.

ankra cluster backups status

Show what this cluster is backing up, one row per stack. The verdict has three values, not two: “unknown” is a stack Ankra could not assess - its inventory has not landed, or its backup settings could not be read - and it is deliberately not reported as unprotected. Examples:
Flags

ankra cluster baseline

Show the cluster’s Ankra Baseline score: the latest nightly evaluation of the Baseline checks (metrics and logs, service-level alerts, backups with a tested restore, requests and limits, probes, PodDisruptionBudgets, pinned images, supported versions, certificate automation, no critical or known-exploited CVEs), each pass, fail or unknown with the evidence it rests on. The score is passed weight over decided weight. An unknown check, one whose data was absent or stale, is never a pass: it leaves the score and is reported as coverage. A cluster the nightly recorder has not scored yet has no score, which is not a score of zero. The cluster is --cluster or the one ‘ankra cluster select’ saved. -o json prints the platform’s answer as it is.
Examples
Flags

ankra cluster clear

Clear the active cluster selection

ankra cluster clone

Clone stacks from an existing cluster ImportCluster YAML to a new cluster. The source can be either a local file path or a URL (http/https). Examples:
Flags:
Without flags: Merge stacks, skipping any with conflicting names
Flags

ankra cluster control-plane-heal

When a control plane node has been NotReady for several minutes while every other control plane node is Ready and etcd keeps quorum without it, Ankra can restart that one node through your cloud provider. It never stops, scales or deletes anything, and it shows each step on the cluster in the product. The switch is per cluster and on by default. Turning it off stops the restart only: the NotReady card is still shown. Changing it needs permission to change cluster settings (clusters.write). Examples

ankra cluster control-plane-heal get

Show whether Ankra may restart a NotReady control plane of the cluster, and the latest episode: which node, how it ended or why Ankra is not restarting it yet, and whether the platform acted or only recorded what it would have done (shadow). -o json prints the platform’s answer as it is.
Examples
Flags

ankra cluster control-plane-heal set

Turn Ankra’s automatic restart of a NotReady control plane on or off for the cluster. --enabled is required, so a change is always explicit. Turning it off sends nothing anywhere, so this does not ask for confirmation.
Examples
Flags

ankra cluster cordon

Mark a node unschedulable so no new pods land on it. Pods already running stay where they are; ‘cluster drain’ moves them off. ‘cluster uncordon’ puts the node back into service. Example:

ankra cluster custom-dns-zones

Declare, list, and withdraw the DNS zones a cluster serves with one of the organisation’s own DNS credentials - an external-dns webhook credential or a Cloudflare credential - alongside the generated domain Ankra serves itself. The external-dns Ankra manages publishes only under the cluster’s generated subdomain: its credential is scoped to that zone by the DNS provider, so ingress hostnames on your own zones are dropped silently. Declaring a zone here has Ankra render and reconcile a separate external-dns for it, using a credential you supply (‘ankra org dns credentials’, or ‘ankra org cloudflare connect’ for a Cloudflare zone). Each controller is pinned to exactly its zone with its own record ownership, so it can never fight Ankra’s controller or another cluster’s. To serve a zone from every cluster in the organisation - including clusters created later - declare it once with ‘ankra org custom-dns-zones add’ instead. ‘list’ shows those inherited zones with source ‘organisation’; a zone declared here on the cluster itself takes precedence over the organisation’s on this cluster, which is how one cluster serves a zone with a different credential. Withdrawing a zone removes the controller Ankra rendered; the zone’s records are yours and are left untouched.

ankra cluster custom-dns-zones add

Declare a zone the cluster also serves, with the DNS credential that can publish into it. Ankra renders an external-dns for the zone on the next reconciler pass, scoped to exactly that zone. Use --cloudflare-credential for a zone hosted at Cloudflare: it names an organisation Cloudflare credential (‘ankra org cloudflare connect’) and the zone is published by external-dns’s native Cloudflare provider. Before storing anything Ankra checks with Cloudflare that the credential’s token can reach the zone with DNS edit. That controller runs upsert-only: it creates and updates only the records it owns and never changes or deletes a record someone else made, so hand-made records in the zone are safe. Opt an Ingress host into Cloudflare’s proxy with the external-dns.alpha.kubernetes.io/cloudflare-proxied annotation.
Refused when the zone is not a domain name, when the organisation has no credential of that name (or, with --cloudflare-credential, no Cloudflare credential of that name), when a Cloudflare token cannot reach the zone or may not edit its DNS, or when the zone overlaps the generated domain Ankra already serves for this cluster - that would put a second controller on names Ankra’s own external-dns publishes.
Flags

ankra cluster custom-dns-zones list

List the zones declared on a cluster
Flags

ankra cluster custom-dns-zones remove

Withdraw a declared zone. Ankra removes the controller it rendered on the next reconciler pass. The zone’s records are yours and are left untouched.
Flags

ankra cluster debug

Debug pods are pods Ankra creates on your behalf, in any namespace of the active cluster, from an image chosen for its tools rather than for the workload. Point one at an existing pod with --from-pod and it impersonates that pod: the same service account, node, volumes and volume mounts, environment variables and envFrom sources, tolerations and security context - under an image that actually has curl, dig, psql or strace in it. The workload itself is never touched. Labels are never copied, so a debug pod never sits behind the workload’s Service. Every debug pod carries a lifetime the kubelet enforces on its own, and every terminal session into one is recorded to the audit log.

ankra cluster debug create

Create a debug pod in a namespace of the active cluster and wait for it to start. With --from-pod the pod impersonates the named pod - its service account, node, volumes and mounts, environment - so what the workload’s container sees, the debug pod sees. Without --from-pod it is a plain pod of the chosen image with no service-account token. The command prints the portal link to the new pod’s terminal; every session opened there is recorded to the audit log. Creating a debug pod needs the kubernetes.write and kubernetes.exec permissions. Examples:
Flags

ankra cluster debug delete

Delete a debug pod before its lifetime ends. Only a pod carrying the ankra.io/debug-pod label can be deleted this way; a workload pod answers not found.
Flags

ankra cluster debug images

List the tag-pinned images the platform offers for debug pods. Any image reference is accepted by “debug create --image”; the catalogue is the set that ships with tools and is known to pull.
Flags

ankra cluster debug list

List the debug pods on the active cluster
Flags

ankra cluster decrypt

Decrypt SOPS-encrypted values stored on a cluster or in a local cluster.yaml.

ankra cluster decrypt addon

Decrypt a SOPS-encrypted addon’s Helm values and print the result to stdout. Two modes: Cluster mode (default): fetch the addon values from a live cluster, decrypt, and print to stdout. File mode (-f cluster.yaml): read the addon values file referenced from a local cluster.yaml, decrypt, and print to stdout. Examples:
Flags

ankra cluster decrypt manifest

Decrypt a SOPS-encrypted manifest and print the result to stdout. Two modes: Cluster mode (default): fetch the manifest from a live cluster, decrypt it, and print to stdout. File mode (-f cluster.yaml): read the manifest file referenced from a local cluster.yaml, decrypt it, and print to stdout. Examples:
Flags

ankra cluster delete

Delete one or more Kubernetes resources from the active cluster. The kind takes the kubectl spellings - pod, pods, po, deployment, deploy, statefulset, sts, configmap, cm, namespace, node, pvc, … - and a custom resource is reachable with --group and --api-version, exactly like ‘cluster get resources’ and ‘cluster describe’. Cluster-scoped built-in kinds (namespace, node, storageclass, crd, priorityclass, the webhook configurations, …) need no namespace; a cluster-scoped custom kind such as a ClusterIssuer or a ClusterPolicy takes --cluster-scoped instead. A pod owned by a controller (Deployment, StatefulSet, DaemonSet, Job) is recreated by that controller, so deleting it is how you restart a single replica; ‘cluster restart’ rolls a whole workload. The delete goes through the cluster’s Ankra agent: no kubeconfig is needed and the same organisation permissions as the portal apply. Each object reports its own outcome. The command exits 0 when everything was deleted, 3 when one of the objects did not exist, and 1 when the cluster refused a delete. Examples:
Flags

ankra cluster deprovision

Tear down a managed cluster: everything it runs on is released. Whether the cluster survives as a record depends on its kind, and the two outcomes are very different:
  • cloud clusters (hetzner, ovh, upcloud, digitalocean, scaleway, ankracloud, aws, proxmox, morpheus) go to the provider-specific endpoint, which DELETES the cluster. The record does not survive, “ankra cluster provision” cannot bring it back, and the cluster id, its stacks and anything referencing them are gone. Rebuilding means creating a new cluster;
  • imported clusters keep their record, so “ankra cluster provision” can rebuild them from the stored stack definition later.
This is a teardown, not a power-off:
  • all cloud resources are released (servers, networks, SSH keys);
  • every stack resource on the cluster is uninstalled;
  • on hetzner, ovh, upcloud, digitalocean, scaleway, ankracloud, aws and proxmox the cluster’s persistent volumes (the cloud volumes or, on proxmox, the disks its CSI driver provisioned) are deleted with it, and the data on them. The command names them first and deletes them only when you accept that: answer the prompt on a terminal, or pass --accept-volume-data-loss (--yes does not imply it). A cluster whose retention_policy is retain (aws, scaleway, ankracloud) keeps its volumes, which keep billing in your cloud account.
To power a cluster off and back on while keeping its state, use its provider’s stop and start commands (for example “ankra cluster hetzner stop” and “ankra cluster hetzner start”) or “ankra cluster power-schedules” instead. Name the cluster as the argument or with --cluster. Deprovision never falls back to the cluster selected with ‘ankra cluster select’: that selection is shared by every shell and agent session on the machine.
Flags

ankra cluster describe

Show a single Kubernetes resource together with the events scoped to it. This answers the question a failing workload raises - why is it not ready? - in one call: the object’s conditions, a pod’s per-container state (probe failures, image-pull errors, OOMKills, exit codes), and the events whose involvedObject is this resource, rather than a namespace-wide event list you have to filter by eye. Kinds outside the built-in set need --group (and sometimes --api-version), exactly like ‘cluster get resources’. --managed-fields reads the object live from the cluster and adds who last wrote it: each field manager with its operation, subresource and time. It is how to see what resized a pod in place (subresource “resize”), scaled a workload or changed its spec. Kubernetes keeps one entry per manager and subresource, so this is the most recent write of each, not a full history. The cached copy other reads are served from does not keep them, and -o json|yaml then carry them under object.metadata.managedFields. --kubelet-config, on a node, adds the kubelet’s live configuration as the kubelet reports it on /configz: the values in force once its flags and config file were merged (eviction thresholds, reserved resources, image garbage collection, max pods), which the Node object does not carry. A kubelet the read cannot reach is reported with the reason in place of the configuration, never as an empty one; -o json|yaml carry it as kubelet_config, or kubelet_config_error. Examples:
Flags

ankra cluster digitalocean

Commands to create, deprovision, and scale DigitalOcean clusters.

ankra cluster digitalocean bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster digitalocean bastion allowed-ips

Replace the bastion/gateway’s SSH source allowlist. Only the listed IPv4 addresses or CIDRs, the platform’s own egress addresses and private network sources can then reach port 22; every other source is dropped. The platform’s egress is always added by the platform itself, so it can never be locked out. The list you give is the complete new list: entries may be separated by spaces or commas. --clear removes the allowlist and makes the bastion reachable from anywhere again (key-only SSH, rate-limited). IPv6 entries and 0.0.0.0/0 are refused; at most 64 entries. The platform applies the list through the bastion update operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. Examples:
Flags

ankra cluster digitalocean bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster digitalocean bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’.
Flags

ankra cluster digitalocean bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster digitalocean control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster digitalocean control-plane get

Show the current control plane configuration
Flags

ankra cluster digitalocean control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster digitalocean control-plane set-instance-type

Change the instance type of every controller in a DigitalOcean cluster. The instance type is stored as given; it is not checked against DigitalOcean’s catalog. A name that does not exist is rejected by DigitalOcean itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline. List the instance types that do exist with:
Flags

ankra cluster digitalocean create

Create a new DigitalOcean cluster
Flags

ankra cluster digitalocean etcd

Read the cluster’s etcd membership from one control-plane node, and remove the stale member a dead control-plane node left behind so its replacement can join. Both run over the platform’s bastion SSH lane as tracked operations and need clusters.operate on the cluster. Find node ids with ‘nodes list’.

ankra cluster digitalocean etcd members

Run ‘etcdctl member list’ and the endpoint health check on the control-plane node named and report every member (hex and decimal id), its health, any alarms and the quorum summary with its failure tolerance. Nothing changes. Run it on a healthy control-plane node when another one is dead.
Flags

ankra cluster digitalocean etcd remove

Remove one etcd member, named by the hex or decimal id ‘etcd members’ reported, executing on the healthy control-plane node named. The platform re-reads live membership first and refuses a healthy member, a member whose health it cannot read, the node’s own member, an ambiguous id, and any removal that would break quorum. This is destructive and cannot be undone: the command asks first (--yes skips, declining exits 4).
Flags

ankra cluster digitalocean k8s-version

Get current Kubernetes version for an DigitalOcean cluster
Flags

ankra cluster digitalocean node-group

List, add, scale, upgrade, and delete node groups.

ankra cluster digitalocean nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster digitalocean nodes cloud-init-log

Fetch ‘cloud-init status --long’ and the tail of /var/log/cloud-init-output.log from the node over the platform’s bastion SSH lane, as a tracked read-only operation. This is the debug surface for node-group user-data: it shows whether the first-boot document ran and what it printed, without needing the cluster’s SSH key. Repeated calls attach to an in-flight fetch instead of dispatching duplicates. Find node ids with ‘nodes list’.
Flags

ankra cluster digitalocean nodes diagnose

Dispatch the platform’s read-only node diagnose job and wait for its report: over the bastion SSH lane it snapshots the node’s OS-level state - the Kubernetes service unit and its journal, disk, memory, uptime, the kernel log and the firewall path to the API server - and names the symptoms it finds. Nothing on the node is changed. This is what to reach for when a node is NotReady or its kubelet stopped posting status, below what ‘cluster get’ can see. The same diagnosis the Ankra assistant runs as ssh_diagnose_node. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’, and repeated calls attach to the run already in flight. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster digitalocean nodes get

Show full spec and metadata for a single node
Flags

ankra cluster digitalocean nodes list

List all nodes for the cluster
Flags

ankra cluster digitalocean nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster digitalocean os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster digitalocean os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster digitalocean os-patches plan

Run the dry run on every host and report what each would install, which held-back security updates are pending, whether a reboot would follow, and the order ‘run’ would take. The platform waits about 40 seconds; a slower plan hands back its operation id, and ‘status’ shows it once it finishes. Needs clusters.operate.
Flags

ankra cluster digitalocean os-patches policy

Show or change the cluster’s OS patch policy

ankra cluster digitalocean os-patches policy get

Show the OS patch policy and its maintenance window
Flags

ankra cluster digitalocean os-patches policy set

Change the cluster’s OS patch policy. Only the flags passed are changed. Turning the policy off also removes the node OS update hold from every host, and is refused while a run or a node OS policy operation is in flight. Needs clusters.write.
Flags

ankra cluster digitalocean os-patches run

Start the rolling patch: each host is drained, patched, rebooted when the packages ask for it, and returned to service before the next. Workloads move between nodes while it runs, so the command asks first (--yes skips, declining exits 4). Outside the policy’s maintenance window the platform refuses unless --outside-window is passed. Stateful nodes follow the policy unless --include-stateful-nodes or --exclude-stateful-nodes says otherwise; the bastion is patched last unless --exclude-bastion. Follow the run with ‘status’ or ‘ankra cluster operations list’. Needs clusters.operate.
Flags

ankra cluster digitalocean os-patches status

Show the OS patch policy, the newest run and the security-lag verdict
Flags

ankra cluster digitalocean regions

List the DigitalOcean regions the supplied credential can deploy in.
Flags

ankra cluster digitalocean sizes

List DigitalOcean droplet sizes. Pass --region to filter by region availability.
Flags

ankra cluster digitalocean start

Start (re-provision) a stopped DigitalOcean cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster digitalocean stop

Stop an DigitalOcean cluster’s compute while keeping its configuration so it can be started again later.
Flags

ankra cluster digitalocean workers

Get current worker count for an DigitalOcean cluster
Flags

ankra cluster dns-token

The cluster’s external-dns publishes into the cluster’s generated DNS zone (‘ankra cluster domain’) with a write token Ankra minted for it. Rotating it is three steps, so the cluster never stops publishing:
  1. ‘ankra cluster dns-token rotate’ asks Ankra for a replacement. Ankra mints it within about a minute and republishes the external-dns Secret. The replaced token stays valid.
  2. Restart external-dns on the cluster so it reads the new Secret, and confirm records still publish.
  3. ‘ankra cluster dns-token revoke-previous’ revokes the replaced token.
‘ankra cluster dns-token status’ says where a rotation stands. No command here shows a token.

ankra cluster dns-token revoke-previous

Ask Ankra to revoke the DNS write token the last rotation replaced. Run it only once the cluster publishes with the new token: a cluster whose external-dns still uses the replaced token stops publishing DNS records when it is revoked. That is why this asks for confirmation; --yes skips the question and is required when there is no terminal to ask on. The platform refuses (409) while the replacement token is not minted yet, or when there is no replaced token to revoke. Asking again once requested changes nothing. The cluster is --cluster or the one ‘ankra cluster select’ saved.
Examples
Flags

ankra cluster dns-token rotate

Ask Ankra to replace the write token the cluster’s external-dns publishes with. Ankra mints the replacement within about a minute and republishes the external-dns Secret; the replaced token stays valid until you revoke it, so the cluster keeps publishing meanwhile. Asking again while a rotation is pending changes nothing. The platform refuses (409) while the zone is not active, or while the token the last rotation replaced has not been revoked yet. The cluster is --cluster or the one ‘ankra cluster select’ saved.
Examples
Flags

ankra cluster dns-token status

Show whether a rotation is waiting for its replacement token, and whether the token the last rotation replaced is still valid and waiting to be revoked. The cluster is --cluster or the one ‘ankra cluster select’ saved. A cluster without a DNS zone exits 3.
Examples
Flags

ankra cluster domain

Show the cluster’s generated public domain. The domain nests under the organisation’s Ankra-managed root - ankra.cc by default, or the organisation’s own domain when one is registered (portal: AI > Settings > Workspaces, field “Custom Ankra domain”; CLI: ‘ankra org domain’). The read also reports the cluster’s PUBLIC domain: the domain hostnames on the cluster are published under, and what ${{ ankra.cluster_domain }} resolves to in stacks and stack profiles. It is the organisation’s preview domain (‘ankra org ai-environment set --demo-base-domain’) whenever a custom DNS zone declared for the organisation or the cluster (‘ankra org custom-dns-zones’, ‘ankra cluster custom-dns-zones’) covers it - the cluster’s own external-dns then publishes every hostname under it - and the generated domain otherwise. An organisation whose domain cannot be registered as the Ankra root (it lives in its own DNS account) gets its own domain as the cluster domain this way. The plain command is a read: it never creates a zone. A cluster that has no domain reports state “none”, and ‘ankra org dns zones’ lists every cluster in the organisation that does have one. The read falls back to the cluster selected with ‘ankra cluster select’; --enable and --remove never do, and need the cluster named as the argument or with --cluster. --enable queues the zone for a cluster that has none. It is idempotent: a cluster that already has a zone reports its existing domain unchanged. A fresh zone reads “pending” until it is published to the authoritative nameservers and then turns “active”; external-dns is wired to it on the next cloud-provider pass, after which any ingress hostname under the domain resolves with TLS. --remove hands the zone back for teardown: the removal step before an organisation switches its Ankra root domain (the switch is refused while cluster zones still live under the old root). The removal is then HELD - nothing re-creates the zone, including the external-dns Ankra runs on the cluster and the discovery that mints zones for clusters that lack one - until you ask for it back. A read reports “opted out” for as long as the hold stands. --enable withdraws the hold and re-creates the zone under the organisation’s current root. The cluster’s label is derived from its id, so the zone comes back under exactly the name it had before, and the external-dns Ankra manages for it keeps the same --txt-owner-id.
Flags

ankra cluster draft

Stage all changes in an ImportCluster YAML as drafts on the cluster without deploying anything. The local checks run first (the same ones as ‘ankra cluster apply --dry-run’), then the stacks in the file are saved as resource drafts you can review, edit, and deploy from the Ankra stack builder. The file lands whole or not at all: if the platform refuses any stack, it says everything it found and nothing is staged, so you fix the file and run the same command again. A stack that already has a draft is refused. --replace discards that draft and stages the file’s version instead, including any edits made to the draft since it was staged, so it asks first; without a terminal to ask on, it needs --yes. A draft a data run is still waiting on, or one that is not yours to discard, is refused either way. If the cluster does not exist yet it is imported first without its stacks, since drafts can only be attached to an existing cluster; every stack in the file is then staged as a draft. Stacks that already match the cluster’s desired state are reported as “no changes” rather than creating an empty draft.
Flags

ankra cluster drain

Cordon a node, then delete every pod scheduled on it so its controller reschedules the pod elsewhere. DaemonSet pods are left alone (they would come straight back on the same node) and so are the static pods the kubelet runs from disk. A pod without a controller is deleted like any other and is not recreated - the plan names every pod before anything happens, and --dry-run stops after printing it. Unlike ‘kubectl drain’, the pods are deleted rather than evicted: the Ankra agent has no eviction relay yet, so PodDisruptionBudgets are not consulted and a budget at its limit does not hold the drain back. Check the budgets in the namespaces you care about (‘cluster get resources PodDisruptionBudget --group policy’) before draining a node that carries a quorum member. The node stays cordoned afterwards; run ‘cluster uncordon’ to put it back into service. Examples:
Flags

ankra cluster encrypt

Encrypt sensitive values in manifest or addon configuration files using SOPS.

ankra cluster encrypt addon

Encrypt one or more keys in an addon’s Helm values using SOPS. --key takes the YAML key name whose values should be encrypted. Repeat --key to encrypt several keys in a single run; all keys are encrypted in one SOPS pass and one write. SOPS matches key names anywhere in the document, not dotted paths; a dotted --key is normalised to its last segment. A key whose own name starts with a dot (such as “.dockerconfigjson”) is kept literally. After encrypting, the CLI verifies every value is actually ENC[…] ciphertext and fails if any is not. --key glob:<pattern> encrypts every key whose name matches the pattern, now and on every later platform re-encrypt - including keys added afterwards. Only ”*” is a wildcard; everything else is literal. The entry is recorded in encrypted_paths as written (“glob:*Password”). A pattern that matches no key fails, the same way a misspelled exact key does. Requires cluster#1867 on the platform. Two modes: Cluster mode (default): fetch the addon’s values from a live cluster, encrypt the key together with every key the addon already declares in encrypted_paths (a declared value can still be stored as plaintext until the next GitOps push seals it), and push the result back via the partial-stack PATCH endpoint. The owning stack is resolved automatically. File mode (-f cluster.yaml): rewrite the local addon values file referenced by the cluster.yaml in place, adding the key to encrypted_paths. Keys the file already declares are sealed together with --key. Examples:
Flags

ankra cluster encrypt manifest

Encrypt one or more keys in a manifest using SOPS. --key takes the YAML key name whose values should be encrypted (for a Secret’s data.password, that is “password”). Repeat --key to encrypt several keys in a single run; all keys are encrypted in one SOPS pass and one write. SOPS matches key names anywhere in the document, not dotted paths; a dotted --key is normalised to its last segment. A key whose own name starts with a dot (such as “.dockerconfigjson” in a kubernetes.io/dockerconfigjson Secret) is kept literally. After encrypting, the CLI verifies every value is actually ENC[…] ciphertext and fails if any is not. --key glob:<pattern> encrypts every key whose name matches the pattern, now and on every later platform re-encrypt - including keys added afterwards. Only "" is a wildcard (any run of characters); everything else is literal, and a leading “data.” or “stringData.” is accepted and ignored, exactly as for an exact key. The entry is recorded in encrypted_paths as written (“glob:stringData.DB_”), which is the form the platform re-expands into the SOPS encrypted_regex on every push. A pattern that matches no key fails, the same way a misspelled exact key does. Requires cluster#1867 on the platform. --all-data selects every key under data and stringData of a Kubernetes Secret manifest instead of naming keys individually; keys whose values are already encrypted are skipped. The manifest must be a Secret. --all-data and --key are mutually exclusive. Two modes: Cluster mode (default): fetch the manifest from a live cluster, encrypt the key, and push the result back via the partial-stack PATCH endpoint. The owning stack is resolved automatically. File mode (-f cluster.yaml): rewrite a local cluster.yaml’s referenced from_file in place, adding the key to encrypted_paths in the file. Used by GitOps workflows where the source of truth is on disk. Every key the file already declares in encrypted_paths is sealed together with --key, so a document decrypted with “ankra cluster decrypt” (which leaves the declaration in place) is sealed whole again. In cluster mode, --set applies value edits in-memory BEFORE encrypting, so the new secret value and its encryption land in a single commit - the plaintext value never reaches git history. This is the recommended way to set a new secret value:
(compared to “manifests upgrade --set” followed by “encrypt manifest”, which commits the plaintext value first). --set also replaces a value that is already encrypted, which is how a sealed credential is rotated in place. A manifest that carries SOPS metadata is decrypted in memory, the edits are applied, and every key that was encrypted is encrypted again together with --key, still in a single write. A key whose name starts with a dot is escaped in the --set path:
In cluster mode every key the manifest already declares in encrypted_paths is sealed together with --key. A value declared in the portal or through the API is stored as plaintext until the next GitOps push seals it, and a document that carries SOPS metadata with plaintext under a declared path is refused by the platform, so sealing only the new key would be rejected. Examples:
Flags

ankra cluster events

List Kubernetes events from the active cluster. --for scopes the listing to a single object’s involvedObject, which is what turns “the pod is Pending” into “no node matches the nodeSelector”. This is a server-side field selector, not a substring match on the event text, so an object whose name is a prefix of another object’s name is not conflated with it. Examples:
Flags

ankra cluster exec

Run a single command in a container of the named pod, through the platform
  • no kubeconfig and no port-forward - and exit with the command’s own exit code, so a script or CI job can branch on it.
Everything after — is the command and its arguments, passed to the container exactly as given: no shell re-parses it, so quote once for your local shell and not again. To use shell features (pipes, globs, variables) run a shell explicitly: — sh -c ‘echo “$HOSTNAME” | tr a-z A-Z’. stdout and stderr stream to your stdout and stderr as the command runs. The command gets no TTY and, unless --stdin is given, no input; with --stdin your input is forwarded and the command sees end-of-file when it ends. Like “ankra cluster terminal”, every run is recorded by the platform and linked from the cluster’s audit log as an open_pod_terminal event carrying the command; “ankra org terminal-session” replays it. Needs kubernetes.exec on the cluster, and a cluster agent recent enough to run one-off commands. Exit codes: the command’s own exit code when it ran; otherwise the CLI’s usual codes (6 for a refused credential, 7 for a missing kubernetes.exec, 1 when the command could not be started). With -o json nothing is streamed; one document is printed when the command ends: {“exit_code”, “stdout”, “stderr”, “stdout_truncated”, “stderr_truncated”}, each stream capped at 8 MiB.
Examples
Flags

ankra cluster export

Print the cluster’s whole specification as the ImportCluster YAML that ‘ankra cluster apply -f’ takes: its stacks with their add-ons, manifests and applications, variables and settings, as Ankra holds them now. Use it to start a GitOps repository from a cluster built in the portal, to review what a cluster declares, or to copy a definition to another cluster. The YAML goes to stdout, or to the file named with -f. The cluster is --cluster or the one ‘ankra cluster select’ saved. A cluster that declares nothing yet has nothing to export and exits 3.
Examples
Flags

ankra cluster gateway-api

The Traefik that Ankra installs as a cluster’s ingress can also serve the Kubernetes Gateway API, next to Ingress: a GatewayClass named traefik, a shared Gateway named traefik-gateway (HTTP on Traefik’s web entry point, routes from every namespace), a certificate from cert-manager, and HTTPRoute hostnames published by external-dns. Every Ingress keeps working. At create time the option is ‘--gateway-api’ on the create command. This command turns it on for a cluster that already exists, or shows where that stands. The platform answers one plan for both: whether the option is recorded, where the Gateway API CRDs come from and whether they are established, what the Traefik and cert-manager values still need, and who moves the enable on next. Run without a subcommand it shows the plan, like ‘status’. There is no ‘disable’: to stop the shared Gateway later, set gateway.enabled: false in Traefik’s values; routes and CRDs stay.
Examples
Flags

ankra cluster gateway-api enable

Turn the Gateway API on for a cluster Ankra built. The platform records the option on the cluster, installs the Gateway API CRDs through a gateway-api-crds addon in the networking stack (or uses the ones the cluster already carries), and, once it reads them as established, writes the Gateway API settings into the Traefik and cert-manager values through the ordinary stack write: one GitOps commit on a GitOps-backed cluster, then Traefik and the cert-manager controller each restart once to pick the settings up (a member whose values already carry them is left alone). Values you wrote yourself are never changed: a key that says the opposite of what the option needs is reported as a conflict and nothing is written until you decide. Because it changes what the cluster’s ingress serves, enable prints the plan and asks for confirmation first. --yes skips the question; without a terminal to ask on (a script, CI) it is required. The enable is idempotent and resumable. Without --wait it records the option and returns at once, saying what is next; run it again later to write the values once the CRDs are established, or check with ‘status’. With --wait it follows the phase, repeats the enable when the values are next, and returns once the Gateway API is enabled. Enabled means the cluster itself reports the Gateway as served: the platform reads GatewayClass ‘traefik’ as Accepted and Gateway ‘traefik-gateway’ as Programmed from the cluster’s synced state. Until it does, the phase stays applying, and --wait prints the platform’s note on what it is waiting for each time that note changes. When the platform holds the values back (a values hold: the cluster is offline, its GitOps sync is paused on open conflicts, or a Traefik or cert-manager values file was edited in git and is kept there until a person decides), nothing writes them until that is resolved, so --wait stops at once, names the hold and exits 1 instead of repeating the enable until --timeout. A passing platform fault while it follows (a 5xx, a dropped connection, one request timing out) is tried again on the next poll; five in a row end the follow. --timeout bounds --wait and is refused without it. The verdict is the same with or without --wait. Exit codes:
Examples
Flags

ankra cluster gateway-api status

Show the platform’s plan for the Gateway API on the cluster: whether the option is recorded, where the Gateway API CRDs come from and whether the platform reads them as established, what the Traefik and cert-manager values still need (with any key that says the opposite of what the option needs), the last apply of each, any hold on the values write and what it names, and the note saying who moves the enable on next. Reading Gateway API objects on the cluster afterwards takes the singular kind: ‘ankra cluster get resources gatewayclass --group gateway.networking.k8s.io’. -o json prints the platform’s answer as it is. Exit codes: 0 when the plan was read, whatever it says (including “not available”); 2 for a cluster Ankra did not build; 3 when the cluster is not in the selected organisation; 6 when the credentials are missing, expired or rejected; 7 when your role cannot read the cluster’s settings; 1 for any other failure, including a platform without this route.
Examples
Flags

ankra cluster get

Get Kubernetes resources from the active cluster. Examples:

ankra cluster get configmaps

List configmaps in the cluster
Flags

ankra cluster get cronjobs

List cronjobs in the cluster
Flags

ankra cluster get daemonsets

List daemonsets in the cluster
Flags

ankra cluster get deployments

List deployments in the cluster
Flags

ankra cluster get events

List events in the cluster
Flags

ankra cluster get ingresses

List ingresses in the cluster
Flags

ankra cluster get k8s-jobs

List Kubernetes jobs in the cluster
Flags

ankra cluster get namespaces

List namespaces in the cluster
Flags

ankra cluster get nodes

List nodes in the cluster
Flags

ankra cluster get pods

List pods or get a specific pod’s manifest
Flags

ankra cluster get resources

Fetch any Kubernetes resource type. Use for kinds not covered by dedicated commands. Built-in kinds resolve their own API group and version, the same as ‘cluster describe’. A custom resource needs --group (and --api-version if it is not v1). Example:
Flags

ankra cluster get secrets

List Secrets, or read one Secret by name. The platform returns every Secret value as a keyed digest (hmac-sha256: followed by 32 hex characters) unless you ask for the values, or as [withheld] when it has no digest key. Keys, type and metadata are readable; the values are not. A digest still changes when its value does, and the same value has a different digest on another cluster. --reveal prints the plaintext values of ONE named Secret. It needs the Secret’s namespace (-n), it is refused on a listing (no name, -A or -l), and it needs the kubernetes.secrets_reveal permission on the cluster, which the operator, admin and owner roles carry. The platform records every reveal in the organisation’s audit log. Values under data stay base64-encoded, as with kubectl. Exit codes with --reveal: 7 when your role lacks kubernetes.secrets_reveal, 3 when the Secret does not exist, 1 when the platform could not hand out live values (for example the cluster is unreachable), 2 for a reveal on a listing. Examples:
Flags

ankra cluster get services

List services in the cluster
Flags

ankra cluster get statefulsets

List statefulsets in the cluster
Flags

ankra cluster get storageclasses

List storage classes in the cluster
Flags

ankra cluster gitops

Commands for inspecting which GitOps repository a cluster syncs from, for listing and resolving the merge conflicts that pause its sync, and for listing and deciding its preserved paths: files edited in Git that Ankra keeps instead of overwriting.

ankra cluster gitops conflicts

A GitOps merge conflict is a resource that changed both in the cluster’s GitOps repository and on the platform (in the portal, the CLI or the API) since the two last agreed. Ankra does not pick a side on its own: while any conflict is undecided, GitOps sync applies nothing from Git, including commits pushed since. ‘list’ shows the open conflicts. ‘resolve’ records which side to keep, for one conflict or for all of them, and the next sync applies it:

ankra cluster gitops conflicts list

List the cluster’s open GitOps merge conflicts: the resource key of each, how Git and the cluster each changed it (added, modified or removed), when it was detected, and whether a resolution is already recorded and waiting for the next sync to apply it. If no cluster name is provided, uses the --cluster flag or the currently selected cluster. -o json|yaml prints the platform’s answer as it is.
Examples
Flags

ankra cluster gitops conflicts resolve

Record which side of a GitOps merge conflict to keep, for one conflict (by its resource key, as ‘ankra cluster gitops conflicts list’ prints it) or for every open conflict with --all. The next sync applies the choice and clears the conflict; resolve triggers that sync. --keep is required, because either side discards the other:
resolve lists what it is about to resolve and what each choice discards, then asks for confirmation. --yes skips the question; without a terminal to ask on (a script, CI) it is required. With --all, every conflict open when the platform receives the request is resolved the same way, including one detected after the list was shown. Resolving needs permission to change the cluster’s configuration (clusters.write). The cluster is the --cluster flag or the currently selected cluster.
Examples
Flags

ankra cluster gitops preserved

A preserved path is a file in the cluster’s GitOps repository that Ankra did not write, for example a cluster file someone edited by hand. Ankra keeps Git’s version instead of overwriting it, so Ankra’s own later changes to that file (a new add-on, a chart version it rolled) do not reach Git until a person decides which version wins. Nothing is paused: the rest of the cluster keeps syncing. These are not merge conflicts, so ‘ankra cluster gitops conflicts’ does not list or decide them. ‘list’ shows the preserved paths and how many differences each has, ‘show’ prints where one file’s two versions differ, key by key, and ‘resolve’ records a decision that the next sync runs:

ankra cluster gitops preserved list

List the files Git and Ankra are divided on: each file’s path, when it was detected, whether a decision is recorded, whether its content is withheld (and why), and how many differences the platform found between Git’s version and Ankra’s. If no cluster name is provided, uses the --cluster flag or the currently selected cluster. -o json|yaml prints the platform’s answer as it is, including each file’s two versions where the platform lists them.
Examples
Flags

ankra cluster gitops preserved resolve

Record which version of a preserved file wins. The next sync runs the decision; resolve triggers that sync. --keep is required, because either version discards the other:
resolve reads the file’s current state from the platform first, so the decision is recorded over exactly the two versions it shows you (the platform refuses it if either changed in between). It then lists what the choice discards, from the platform’s key-by-key difference, and asks for confirmation. --yes skips the question; without a terminal to ask on (a script, CI) it is required. --withdraw removes a recorded decision so the file awaits one again. It changes nothing in Git or on the cluster, so it asks nothing; a decision the platform already started running is not recalled. Deciding needs permission to change the cluster’s configuration (clusters.write). The cluster is the --cluster flag or the currently selected cluster.
Examples
Flags

ankra cluster gitops preserved show

Show one preserved file: when it was detected, its decision, whether its content is withheld, and every difference the platform found between Git’s version and Ankra’s, key by key, read from Git’s version to Ankra’s:
A value the platform does not show is printed as (masked): seeing values needs permission to reveal secrets on the cluster (kubernetes.secrets_reveal), and some files show no values to anyone. The platform lists at most 50 differences per file; the total is always given. The path is the full repository path, as ‘ankra cluster gitops preserved list’ prints it. The cluster is the --cluster flag or the currently selected cluster.
Examples
Flags

ankra cluster gitops status

Show the GitOps sync status of a cluster: the repository, branch, and credential it syncs from, the last synced commit, the commit the cluster is in step with and Git’s head as last checked, any pending commit or sync error, any open merge conflicts pausing the sync, and the files Git and the platform are divided on (preserved paths), with when each was detected and whether it is decided. If no cluster name is provided, uses the currently selected cluster.
Flags

ankra cluster held-updates

On a cluster that is production, or that nobody has confirmed is not production, Ankra holds every update of a platform add-on’s version or image and raises a “held platform update” card on the cluster instead of applying it. Taking the card is how you accept one set of those updates without editing YAML.

ankra cluster held-updates take

Take the updates one held platform update card names: Ankra applies exactly the platform add-on updates the card lists as waiting for your call, at the versions it shows, on the next publish of their stack. <notification-id> is the card’s id and --fingerprint is the card’s data.fingerprint as you read it. A card that changed since is refused (the platform answers 409), so you never take updates you have not seen. A version someone on your team chose is kept and listed under “Kept”, and an update still waits while the cluster’s agent or control plane cannot take it. A later, newer version is held again and raises a new card. Every take is recorded in the cluster’s audit log. It needs permission to change cluster settings (clusters.write). The cluster is --cluster or the one ‘ankra cluster select’ saved.
Examples
Flags

ankra cluster helm

Commands to list, inspect, roll back, upgrade and uninstall Helm releases running in the cluster.

ankra cluster helm get

Show one Helm release - the chart and revision it is on, when it was deployed, the values it was installed with and the chart’s notes. ‘-o values’ prints only the values the release was installed with, as YAML: edit that file and hand it back to ‘cluster helm upgrade --values’. Passwords, tokens and keys in a release’s values, the Secrets it renders and its notes are shown as [REDACTED:…] placeholders. ‘--reveal’ asks for them in plaintext: that needs the kubernetes.secrets_reveal permission on the cluster, and each reveal is written to the audit log. An upgrade whose values file still holds a placeholder is refused, so reveal before you edit a release that has credentials. Examples:
Flags

ankra cluster helm history

List a Helm release’s revisions, newest first, with the chart and status of each - the revision numbers ‘cluster helm rollback --revision’ takes. Example:
Flags

ankra cluster helm releases

List Helm releases in the cluster
Flags

ankra cluster helm rollback

Roll a Helm release back to one of its earlier revisions, as listed by ‘cluster helm history’. The rollback runs on the cluster’s Ankra agent and, by default, waits for the rolled-back resources to become ready before returning. A release that an Ankra addon manages is refused: change the addon’s values in the stack instead, so Git stays the source of truth. Examples:
Flags

ankra cluster helm uninstall

Uninstall a Helm release from the cluster
Flags

ankra cluster helm upgrade

Upgrade a Helm release in place: the agent runs ‘helm upgrade’ with the chart reference and the values file you pass. The values file REPLACES the release’s values wholesale - start from ‘cluster helm get <release> -o values’ so nothing you did not mean to change resets to a chart default. Without --version the release stays on the chart version it already runs. A release that an Ankra addon manages is refused: change the addon in the stack instead, so Git stays the source of truth. Examples:
Flags

ankra cluster hetzner

Commands to create, deprovision, and scale Hetzner clusters.

ankra cluster hetzner bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster hetzner bastion allowed-ips

Replace the bastion/gateway’s SSH source allowlist. Only the listed IPv4 addresses or CIDRs, the platform’s own egress addresses and private network sources can then reach port 22; every other source is dropped. The platform’s egress is always added by the platform itself, so it can never be locked out. The list you give is the complete new list: entries may be separated by spaces or commas. --clear removes the allowlist and makes the bastion reachable from anywhere again (key-only SSH, rate-limited). IPv6 entries and 0.0.0.0/0 are refused; at most 64 entries. The platform applies the list through the bastion update operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. Examples:
Flags

ankra cluster hetzner bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster hetzner bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’.
Flags

ankra cluster hetzner bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster hetzner control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster hetzner control-plane get

Show the current control plane configuration
Flags

ankra cluster hetzner control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster hetzner control-plane set-instance-type

Change the instance type of every controller in a Hetzner cluster. The instance type is stored as given; it is not checked against Hetzner’s catalog. A name that does not exist is rejected by Hetzner itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline. List the instance types that do exist with:
Flags

ankra cluster hetzner create

Create a new Hetzner cluster
Flags

ankra cluster hetzner etcd

Read the cluster’s etcd membership from one control-plane node, and remove the stale member a dead control-plane node left behind so its replacement can join. Both run over the platform’s bastion SSH lane as tracked operations and need clusters.operate on the cluster. Find node ids with ‘nodes list’.

ankra cluster hetzner etcd members

Run ‘etcdctl member list’ and the endpoint health check on the control-plane node named and report every member (hex and decimal id), its health, any alarms and the quorum summary with its failure tolerance. Nothing changes. Run it on a healthy control-plane node when another one is dead.
Flags

ankra cluster hetzner etcd remove

Remove one etcd member, named by the hex or decimal id ‘etcd members’ reported, executing on the healthy control-plane node named. The platform re-reads live membership first and refuses a healthy member, a member whose health it cannot read, the node’s own member, an ambiguous id, and any removal that would break quorum. This is destructive and cannot be undone: the command asks first (--yes skips, declining exits 4).
Flags

ankra cluster hetzner external-cloud-provider

Whether a Hetzner k3s cluster’s Kubernetes node definitions say its nodes run for the hcloud cloud controller manager (external_cloud_provider). The day-2 lanes read that flag, so a cluster whose nodes already run that way while its definitions say otherwise is converged with ‘converge’.

ankra cluster hetzner external-cloud-provider converge

Store external_cloud_provider=true on every Kubernetes node definition of a Hetzner k3s cluster whose definitions say false while its nodes already run for the hcloud cloud controller manager. The flag is only written when every node the platform has seen in the last 30 minutes already carries the external shape (the kubelet argument cloud-provider=external, on a k3s server also the disabled cloud controller and servicelb, and an hcloud:// provider id). Only the stored definitions change: no node is restarted, re-tainted or re-registered. A cluster that already stores true everywhere answers with nothing converged.
Examples
Flags

ankra cluster hetzner k8s-version

Get current Kubernetes version for a Hetzner cluster
Flags

ankra cluster hetzner locations

List the Hetzner Cloud locations the supplied credential can deploy in. Only these locations are valid for cluster creation.
Flags

ankra cluster hetzner node-group

List, add, scale, upgrade, and delete node groups.

ankra cluster hetzner nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster hetzner nodes cloud-init-log

Fetch ‘cloud-init status --long’ and the tail of /var/log/cloud-init-output.log from the node over the platform’s bastion SSH lane, as a tracked read-only operation. This is the debug surface for node-group user-data: it shows whether the first-boot document ran and what it printed, without needing the cluster’s SSH key. Repeated calls attach to an in-flight fetch instead of dispatching duplicates. Find node ids with ‘nodes list’.
Flags

ankra cluster hetzner nodes diagnose

Dispatch the platform’s read-only node diagnose job and wait for its report: over the bastion SSH lane it snapshots the node’s OS-level state - the Kubernetes service unit and its journal, disk, memory, uptime, the kernel log and the firewall path to the API server - and names the symptoms it finds. Nothing on the node is changed. This is what to reach for when a node is NotReady or its kubelet stopped posting status, below what ‘cluster get’ can see. The same diagnosis the Ankra assistant runs as ssh_diagnose_node. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’, and repeated calls attach to the run already in flight. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster hetzner nodes get

Show full spec and metadata for a single node
Flags

ankra cluster hetzner nodes list

List all nodes for the cluster
Flags

ankra cluster hetzner nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster hetzner os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster hetzner os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster hetzner os-patches plan

Run the dry run on every host and report what each would install, which held-back security updates are pending, whether a reboot would follow, and the order ‘run’ would take. The platform waits about 40 seconds; a slower plan hands back its operation id, and ‘status’ shows it once it finishes. Needs clusters.operate.
Flags

ankra cluster hetzner os-patches policy

Show or change the cluster’s OS patch policy

ankra cluster hetzner os-patches policy get

Show the OS patch policy and its maintenance window
Flags

ankra cluster hetzner os-patches policy set

Change the cluster’s OS patch policy. Only the flags passed are changed. Turning the policy off also removes the node OS update hold from every host, and is refused while a run or a node OS policy operation is in flight. Needs clusters.write.
Flags

ankra cluster hetzner os-patches run

Start the rolling patch: each host is drained, patched, rebooted when the packages ask for it, and returned to service before the next. Workloads move between nodes while it runs, so the command asks first (--yes skips, declining exits 4). Outside the policy’s maintenance window the platform refuses unless --outside-window is passed. Stateful nodes follow the policy unless --include-stateful-nodes or --exclude-stateful-nodes says otherwise; the bastion is patched last unless --exclude-bastion. Follow the run with ‘status’ or ‘ankra cluster operations list’. Needs clusters.operate.
Flags

ankra cluster hetzner os-patches status

Show the OS patch policy, the newest run and the security-lag verdict
Flags

ankra cluster hetzner server-types

List Hetzner Cloud server types. Pass --location to see which types are currently available for provisioning there, and --available-only to hide the rest.
Flags

ankra cluster hetzner start

Start (re-provision) a stopped Hetzner cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster hetzner stop

Stop a Hetzner cluster’s compute while keeping its configuration so it can be started again later.
Flags

ankra cluster hetzner workers

Get current worker count for a Hetzner cluster
Flags

ankra cluster info

Show details of a specific cluster, named by its name or its id. If no cluster is given, shows details for the currently selected cluster.
Flags

ankra cluster k3s-disabled-components

The k3s packaged components the platform keeps disabled on a running k3s cluster (k3s --disable), on top of the provider shape’s own defaults: for example traefik on a cluster that brings its own ingress. The components k3s packages are coredns, servicelb, traefik, local-storage, metrics-server and runtimes. The cloud provider is detected from the cluster. A kubeadm cluster has no k3s components and the platform refuses it (409).

ankra cluster k3s-disabled-components get

Show the k3s packaged components stored as disabled on the cluster’s Kubernetes node definitions, how many control planes the list is rendered on, and how the stored list reaches the nodes. An empty list means nothing is stored and the provider shape’s own defaults apply.
Examples
Flags

ankra cluster k3s-disabled-components set

Replace the list of k3s packaged components the platform keeps disabled on the cluster. --components is the complete list to store, and it has to contain every component already stored: a component can be added, never taken off the list, and a list that drops one is refused (409). Read the stored list first with ‘ankra cluster k3s-disabled-components get’. Within about five minutes the platform flags the control planes whose k3s server config is missing an entry, then patches the config and restarts k3s on one control plane at a time. Control planes that already carry every entry are not touched. The component’s workloads stop being managed by k3s, so this asks for confirmation; --yes skips the question and is required when there is no terminal to ask on.
Examples
Flags

ankra cluster k3s-versions

List the k3s versions the platform can provision or upgrade to. Use one of these values with ankra cluster upgrade <cluster_id> <target_version> (the provider is detected automatically).

ankra cluster kube-token

Print a short-lived Kubernetes ExecCredential so kubectl can authenticate to the Ankra cluster gateway. This command is intended to be invoked by kubectl as a client-go credential plugin, for example in a kubeconfig:
Pinning --org to the cluster’s organisation ID keeps the entry working when your selected organisation differs from the cluster’s (‘ankra cluster kubeconfig add’ writes it automatically). An entry written without --org still works: a cluster ID the selected organisation does not have is looked up across the organisations you belong to, and the token is minted against the one that owns it. Your selected organisation is not changed. It authenticates like every ankra command: a --token flag, else the saved ‘ankra login’ in ~/.ankra.yaml (or --config), else ANKRA_API_TOKEN from the environment kubectl runs it in. See ‘ankra cluster kubeconfig add --help’ for what that means for automation. kubectl runs this on every command, so the token is cached on disk (readable only by you) and reused while it has more than two minutes left and was minted less than five minutes ago; logging in again starts over. ANKRA_KUBE_TOKEN_CACHE=off mints a fresh token every time. It prints JSON to stdout and never prompts; run ‘ankra login’ first.
Flags

ankra cluster kubeadm-versions

List the upstream Kubernetes versions the platform can provision or upgrade kubeadm-distribution clusters to. Use one of these values with --kubernetes-version on ankra cluster <provider> create --distribution kubeadm, or with ankra cluster upgrade <cluster_id> <target_version>.

ankra cluster kubeconfig

Add, remove, and list the Ankra cluster contexts in your kubeconfig. By default ‘add’ writes an exec-based context that fetches a short-lived token on demand via ‘ankra cluster kube-token’, so credentials stay ephemeral and SSO-backed (run ‘ankra login’ once). Other clusters/users/contexts already in your kubeconfig are left untouched. These commands read and write a single file: --kubeconfig if given, otherwise the first entry of $KUBECONFIG, otherwise ~/.kube/config. Examples:

ankra cluster kubeconfig add

Add or update an Ankra context in your kubeconfig. The context’s user is an exec credential plugin: on every kubectl command, kubectl runs ‘ankra cluster kube-token --cluster <id> --org <organisation>’ (the executable is --exec-command) and uses the short-lived gateway token it prints. Pass --embed-token to write that token into the file instead; it stops working when it expires. Whose access kubectl gets is decided when kubectl runs the plugin, not when the context is added: kube-token authenticates like every ankra command, with the saved ‘ankra login’ in ~/.ankra.yaml first, and ANKRA_API_TOKEN from kubectl’s environment only when there is no saved login. On a machine where a person ran ‘ankra login’, kubectl therefore acts as that person even when ANKRA_API_TOKEN holds a service account’s token (kube-token prints a note on stderr when it ignores ANKRA_API_TOKEN this way). Automation that should act as a service account must run kubectl where nothing is logged in (no ~/.ankra.yaml for that user, or HOME pointing at a clean directory) and export the service token as ANKRA_API_TOKEN in the environment kubectl runs in. Without a grant, a service account gives itself time-boxed access with ‘ankra cluster access elevate’.
Examples
Flags

ankra cluster kubeconfig list

List Ankra-managed contexts in your kubeconfig
Flags

ankra cluster kubeconfig remove

Remove Ankra contexts from your kubeconfig
Flags

ankra cluster list

List all clusters
Examples
Flags

ankra cluster logs

Stream log output from the active cluster. By default the stream stays open and prints new lines as they arrive, like kubectl logs -f. Pass --follow=false to print the current backlog and exit, which is what a pipeline into grep or a script wants. --previous reads the log of the container instance that terminated. For a pod in CrashLoopBackOff that is the only log with the failure in it, and it is the case where reaching for kubectl through a broad access grant used to be the only option. A previous log is closed, so --previous always makes a bounded read. -l/--selector reads every pod matching a label selector instead of one pod name, and --all-containers expands each pod to all of its containers (init and ephemeral containers included). With more than one target each line is prefixed with [pod] or [pod/container] so the interleaved output stays attributable. Examples:
Flags

ankra cluster logs-ship

Ankra can keep a cluster’s container logs in its hosted log store, so they can be read from Ankra with no logging stack of your own to run or connect. Shipping is opt-in per cluster and off by default: no log content leaves the cluster until a member with permission to change cluster settings (clusters.write) turns it on, here or in the cluster’s settings in the portal. While it is on, the cluster’s agent sends the log lines of every running container to Ankra’s hosted log store, where they are kept for 7 days and can be read by the members of your organisation. ‘disable’ stops it at any time. The agent picks the switch up at its next check-in. An agent too old to follow it does not, and ‘status’ says so. Examples

ankra cluster logs-ship disable

Turn hosted log shipping off for the cluster. The agent stops sending log lines at its next check-in. Nothing is sent by turning it off, so this does not ask for confirmation.
Examples
Flags

ankra cluster logs-ship enable

Turn hosted log shipping on for the cluster. The log lines of every running container in the cluster are sent to Ankra’s hosted log store, where they are kept for 7 days and can be read by the members of your organisation. Turn it off any time with ‘ankra cluster logs-ship disable’. Because log content leaves the cluster, enable says what is sent and asks for confirmation first. --yes skips the question; without a terminal to ask on (a script, CI) it is required. If Ankra has not turned hosted logging on for the platform yet, the switch is stored and nothing ships until it does.
Examples
Flags

ankra cluster logs-ship status

Show whether the cluster ships its logs to Ankra’s hosted log store, whether hosted logging is available on this platform yet, whether the cluster’s agent is new enough to follow the switch, and when the switch was last changed. -o json prints the platform’s answer as it is.
Examples
Flags

ankra cluster managed

Create, delete, stop and start, scale node pools, and upgrade cloud-managed Kubernetes clusters on DOKS, UpCloud UKS, GKE, OVH MKS, AKS, EKS, Scaleway Kapsule, and Ankra Cloud Kubernetes.

ankra cluster managed create

Create a managed Kubernetes cluster
Flags

ankra cluster managed delete

Delete a managed Kubernetes cluster
Flags

ankra cluster managed discover

List the managed Kubernetes clusters that already run in the provider account behind a credential, marking the ones already imported into Ankra.
Flags

ankra cluster managed import

Adopt a managed Kubernetes cluster that already runs at the provider: Ankra fetches the kubeconfig through the provider API and installs the agent automatically, so there is nothing to run against the cluster.
Flags

ankra cluster managed node-pool

Manage managed cluster node pools

ankra cluster managed node-pool add

Add a node pool to a managed cluster
Flags

ankra cluster managed node-pool delete

Delete a managed cluster node pool
Flags

ankra cluster managed node-pool scale

Scale a managed cluster node pool
Flags

ankra cluster managed node-pool update

Update the node count or autoscaling settings of a managed cluster node pool. Pass at least one of --count, --autoscaling, --autoscaling-min, or --autoscaling-max; unspecified settings are left unchanged. Pass --externally-managed on its own to hand the pool’s node count to something outside Ankra, such as a cluster autoscaler you run yourself. While it is set, Ankra refuses to scale, update, replace or delete the pool; --externally-managed=false hands it back.
Flags

ankra cluster managed start

Start a stopped managed Kubernetes cluster. Currently only AKS supports stopping and starting managed clusters.
Flags

ankra cluster managed stop

Stop a managed Kubernetes cluster’s compute while keeping its configuration so it can be started again later. Currently only AKS supports stopping and starting managed clusters.
Flags

ankra cluster managed upgrade

Upgrade a managed cluster Kubernetes version
Flags

ankra cluster manifests

Commands to list, view, upgrade, and delete manifests.

ankra cluster manifests create

Add a NEW manifest to an existing stack, without touching any other member. Unlike ‘ankra cluster apply’, which is declarative over the WHOLE cluster and prunes anything the file does not mention, this sends only the new manifest. Every other stack, addon and manifest is left exactly as it is. Examples:
--from-file / --manifest - accept SOPS-encrypted content: when the file carries a top-level sops: metadata mapping, the keys holding ENC[…] ciphertext are detected and recorded as encrypted_paths automatically. Use --encrypted-path to declare keys explicitly when auto-detection cannot see them. To change a manifest that already exists, use ‘ankra cluster manifests upgrade’.
Flags

ankra cluster manifests delete

Disconnect a manifest from its stack. The manifest’s resources are removed from the cluster and dependent resources are reconnected to the manifest’s own parents. The owning stack is discovered automatically (manifest names are unique per cluster). Use --dry-run to preview the target without making changes.
Flags

ankra cluster manifests get

Print the current YAML content of a manifest. By default the decoded YAML is written to stdout, making it easy to pipe into a file or edit and re-apply with --from-file:
Flags

ankra cluster manifests list

List manifests for the active cluster; or show details for a single manifest
Flags

ankra cluster manifests upgrade

Upgrade a manifest by patching just the fields you supply. At least one mutating flag is required. Examples:
--set/--set-string/--set-file MUTATE the existing manifest YAML and address list items by a stable field (e.g. containers[name=app]) as well as by numeric index (containers[0]). --from-file / --manifest - REPLACE the whole manifest and are mutually exclusive with --set*. --from-file / --manifest - accept SOPS-encrypted content: when the file carries a top-level sops: metadata mapping, the keys holding ENC[…] ciphertext are detected and recorded as encrypted_paths automatically (merged with the manifest’s existing encrypted_paths). Use --encrypted-path to declare keys explicitly when auto-detection cannot see them. When no content or --set flag is supplied, the existing content is re-sent unchanged (only namespace is updated). This is required because the backend’s manifest validation rejects empty manifest_base64.
Flags

ankra cluster mesh

Manage Cilium ClusterMeshes: sets of Ankra clusters whose pods and services resolve each other. A cluster can join a mesh only if it was created on the platform’s WireGuard overlay with a unique network identity, so ankra cluster mesh readiness is the place to start - it says which of your clusters can mesh, and why the others cannot.

ankra cluster mesh create

Create an empty cluster mesh

ankra cluster mesh delete

Delete a cluster mesh. The mesh must be empty; remove its members first so their Cilium configuration is torn down rather than left pointing at a mesh that no longer exists.

ankra cluster mesh join

Add a cluster to a mesh. The platform mints the mesh’s shared certificate authority on the first join, hands it to the joining cluster, and re-renders every member’s peer list. A cluster that cannot mesh is refused with the reason; ankra cluster mesh readiness reports the same checks up front.

ankra cluster mesh leave

Remove a cluster from a mesh

ankra cluster mesh list

List the organisation’s cluster meshes

ankra cluster mesh make-ready

Turn an existing cluster mesh-capable, day-2: allocate its Cilium identity and overlay range, stamp the overlay onto its stored definitions, and set its resources converging so every node joins the platform WireGuard overlay. The node-IP switch restarts kubelets once; nothing is deleted or recreated. Two clusters prepared from the kubeadm default share one pod range and cannot mesh with each other. Moving a running cluster onto another pod range is disabled while it is redesigned - the platform refuses it, because a kube-controller-manager whose --cluster-cidr excludes a node’s range exits at start - so such a pair cannot mesh for now. --pod-cidr still accepts the kubeadm default 10.244.0.0/16, which puts a cluster an earlier move split back onto the range its nodes run. UpCloud clusters only. Proxmox clusters need --site-public-ip: the address other sites dial this cluster’s site gateway on.
Flags

ankra cluster mesh readiness

Check whether the given clusters could form one mesh. Each cluster is reported ready or not, with the failing checks spelled out. A missing Cilium identity and a node network no other cluster can reach are fixed in place by ankra cluster mesh make-ready; a pod range that overlaps another member’s is not, while moving a running cluster onto a fresh range is disabled. The cloud, the distribution and the container network are settled when the cluster is created, so a cluster failing those has to be rebuilt to mesh. ankra cluster mesh up runs the whole path for a set of clusters.

ankra cluster mesh show

Show one cluster mesh and its members

ankra cluster mesh up

Bring a set of clusters into one mesh from wherever they are: read their readiness, run make-ready on every cluster that only lacks its network identity or the overlay, join every cluster that is ready, and keep going until each member reports ready or --wait runs out. The mesh is created when no mesh of that name exists. Two clusters prepared from the kubeadm default share one pod range and cannot mesh with each other, and moving one onto a fresh range is disabled while it is redesigned, so up reports such a cluster blocked with the platform’s reason. --renumber-pods has no effect until that move returns. --plan prints what a pass would do and changes nothing. Re-running is safe: members are skipped and a make-ready re-arms a cluster whose nodes did not converge.
Flags

ankra cluster metrics

Query the Prometheus metrics source configured for a cluster. The query is proxied through the Ankra agent to the in-cluster Prometheus endpoint configured in Cluster Settings > Metrics. Flags

ankra cluster metrics query

Run an instant PromQL query against the cluster’s Prometheus source. Examples:
Flags

ankra cluster metrics query-range

Run a range PromQL query against the cluster’s Prometheus source. Provide either --range (a duration relative to now) or both --start and --end (Unix seconds). When --step is omitted a sensible step is chosen automatically. A series the platform returned fewer points of than the query produced is called out: the Points column reads “50 of 385”, and a note on stderr says how far apart the returned points really are. Read such a series as a sketch, since a spike between two points is not in it. Examples:
Flags

ankra cluster metrics source

Show the metrics source registered for the cluster, the one ‘ankra cluster metrics query’ and the platform’s metrics pages read: its provider, endpoint, state, flavor, the latest health probe and the credential it resolves to. The credential’s password and token are never returned. The source itself is declared in the cluster YAML (spec.prometheus_metrics) and changed with ‘ankra cluster apply’. A cluster without a metrics source exits 3.
Examples
Flags

ankra cluster morpheus

Commands to create, stop, start, and inspect HPE Morpheus clusters.

ankra cluster morpheus bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster morpheus bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster morpheus bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. On HPE Morpheus <instance_type> is the numeric ID of a service plan; list them with ‘ankra cluster morpheus plans’.
Flags

ankra cluster morpheus bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster morpheus clouds

List HPE Morpheus clouds available to a credential
Flags

ankra cluster morpheus control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster morpheus control-plane get

Show the current control plane configuration
Flags

ankra cluster morpheus control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster morpheus control-plane set-instance-type

Change the instance type of every controller in a HPE Morpheus cluster. The instance type is stored as given; it is not checked against HPE Morpheus’s catalog. A name that does not exist is rejected by HPE Morpheus itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline. List the instance types that do exist with:
Flags

ankra cluster morpheus create

Create a new HPE Morpheus cluster
Flags

ankra cluster morpheus groups

List HPE Morpheus groups available to a credential
Flags

ankra cluster morpheus k8s-version

Get current Kubernetes version for an HPE Morpheus cluster
Flags

ankra cluster morpheus layouts

List HPE Morpheus instance-type layouts available to a credential
Flags

ankra cluster morpheus networks

List HPE Morpheus networks available to a credential
Flags

ankra cluster morpheus nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster morpheus nodes get

Show full spec and metadata for a single node
Flags

ankra cluster morpheus nodes list

List all nodes for the cluster
Flags

ankra cluster morpheus os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster morpheus os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster morpheus plans

List HPE Morpheus service plans available to a credential
Flags

ankra cluster morpheus start

Start (re-provision) a stopped HPE Morpheus cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster morpheus stop

Stop an HPE Morpheus cluster’s instances while keeping its configuration so it can be started again later.
Flags

ankra cluster morpheus workers

Get current worker count for an HPE Morpheus cluster
Flags

ankra cluster move

Move a cluster into another existing organisation. Only an administrator of BOTH the current organisation and the destination can move a cluster. The cluster keeps its id, agent, executions, resources, security findings, insights, DNS records and variables. Bindings that belong to the current organisation are detached and reported: access grants, kube tokens, notification routes and mutes, security report schedules, trusted AI actions and cluster-group memberships. Billing, audit and chat history stay with the current organisation. Only imported clusters can be moved for now: Ankra-provisioned and managed Kubernetes clusters use a provider credential that belongs to the current organisation, so the platform refuses to move them. The platform also refuses the move while operations are running on the cluster, while the cluster is a member of a cluster mesh, while it has DNS zones bound to the current organisation (a published cluster domain or custom DNS zones), for playground and sandbox clusters, and when the destination already has a cluster with the same name. The destination is resolved among your organisations by id, slug or name. Name the cluster as the argument or with --cluster. A move never falls back to the cluster selected with ‘ankra cluster select’: that selection is shared by every shell and agent session on the machine.
Examples
Flags

ankra cluster node-group

List, add, scale, upgrade, and delete node groups on a cloud cluster. The cloud provider (Hetzner, OVH, UpCloud, DigitalOcean, Scaleway, Ankra Cloud, AWS, Proxmox VE, or HPE Morpheus) is detected automatically from the cluster.

ankra cluster node-group add

Add a node group
Flags

ankra cluster node-group autoscaling

Read or write the Cluster Autoscaler settings of a node group. When autoscaling is enabled, the Ankra-managed Cluster Autoscaler keeps the group’s node count within [min, max] based on pod demand. Manual scaling stays allowed but is clamped into the same bounds.

ankra cluster node-group autoscaling get

Show autoscaling settings for a node group
Flags

ankra cluster node-group autoscaling set

Enable autoscaling with --enabled --min <n> --max <n>, or disable it with --enabled=false. A --min or --max you leave out is read from the group first. The platform saves both bounds on every write, so this is what keeps --enabled=false on its own, or a change to one bound, from resetting the other:
  • A disable keeps the bounds exactly as the group reads, so --enabled=false
on its own changes nothing but the switch. Given only --min on a group with no bounds recorded, it sends max 5 rather than the 100 the group reads as, so a later --enabled never keeps a max of 100 nobody typed.
  • An enable keeps the bound recorded for the group, or takes min 1 and
max 5 when the group has none recorded. A disabled group that recorded exactly min 1 and max 100 reads the same as one with none, and gets the same. An enable without --max changes nothing and exits 8 when the group has more nodes than the max it would keep or take, since enabling would scale it down; it names the --max that keeps the group’s size. The command also changes nothing when the group’s current bounds or node count cannot be read. On a stopped cluster the platform does not answer the bounds read, so pass both --min and --max there. --min 0 (scale-to-zero) is accepted where the platform can size a node from the group’s instance type and the cluster’s ankra-agent serves the node template; the platform names what is missing otherwise. Enabling requires the cluster’s ankra-agent to be recent enough to serve the autoscaler, and installs the Cluster Autoscaler on first enable. Enabling with bounds the group is outside moves it inside them: a --max below the group’s node count scales it down to --max, removing the least busy nodes first, each cordoned and drained once the pipeline steps running on it finish (up to 15 minutes per node), one node at a time; a --min above the node count scales it up to --min. The command says what will happen and names the operation doing it; --wait waits for that operation to finish. Examples:
Flags

ankra cluster node-group delete

Delete a node group and every node in it. Each node removed is drained first, honouring its pods’ PodDisruptionBudgets. A node whose drain is refused (a budget allows no eviction, or the node cannot be drained at all) is kept in service instead of removed, and a notice on the cluster says why. Give the blocking workloads eviction headroom (more replicas or a looser budget) and run the command again, or pass --force-drain to remove the node anyway without honouring its PodDisruptionBudget. --force-drain applies to this request only; use it only for a node you have decided to lose. Examples:
Flags

ankra cluster node-group labels

Replace the labels on every node in the group. Pass --labels as a comma-separated list of key=value pairs, or --clear to remove all labels. The cloud provider is detected automatically from the cluster.
Flags

ankra cluster node-group list

List the node groups of a cloud cluster. The cluster is the argument, else --cluster, else the cluster selected with ‘ankra cluster select’.
Flags

ankra cluster node-group remove-node

Remove one named worker from its node group and delete its server. The group’s node count drops by one, so nothing recreates the node. A scale-down picks the nodes it removes itself; remove-node is the way to retire a particular one, such as a node on a failing host. <node> is the node’s server id (the ID column of ‘ankra cluster <provider> nodes list’, for example ‘ankra cluster hetzner nodes list’), its server name, its Kubernetes node name (the server name, on every provider but AWS) or the providerID its Kubernetes node reports, in any letter case. Before asking, the command looks the reference up and shows the node’s name, server id and providerID, or says that it could not tell which node the reference names. When it found the node, it sends that node’s server id, so the node removed is the node you approved; otherwise it sends the reference as typed, and the platform resolves it itself. With --yes the node is not looked up and the reference is sent as typed. A node that is already cordoned is removed the same way, but a refused drain makes the node it keeps schedulable again: cordon it again if it must stay out of service. Each node removed is drained first, honouring its pods’ PodDisruptionBudgets. A node whose drain is refused (a budget allows no eviction, or the node cannot be drained at all) is kept in service instead of removed, and a notice on the cluster says why. Give the blocking workloads eviction headroom (more replicas or a looser budget) and run the command again, or pass --force-drain to remove the node anyway without honouring its PodDisruptionBudget. --force-drain applies to this request only; use it only for a node you have decided to lose. The platform answers once it has marked the node for removal and started the operation that drains it and deletes its server; the drain and the delete run after that. The command prints the operation, and ‘ankra cluster operations list <operation_id> --watch’ follows it until it ends. --wait waits for the platform’s answer only, not for the drain or the delete. When the drain is refused, the operation fails and names what refused it, the node is kept and made schedulable again, and the group’s count goes back up. When the platform names no operation, the removal is still recorded: the platform could not start the operation with the request, for example because another node operation is still running or the cluster’s agent is offline, and its reconcile drains and deletes the node later. A stopped cluster’s nodes are not removed: the command refuses the removal before it looks the node up, asks or sends anything, as the platform refuses it, and exits 1. Start the cluster first. Every refusal of the platform’s exits 1 with its reason. Among them: a node that is not a worker, a node of another group, a node already marked for deletion or whose server is stopping, the last node of its group, which is not removed on its own (scale the node group to 0 or delete the node group instead), a removal that would take an autoscaling group below its min count (for both, only nodes that have joined the cluster count, so a node still being created does not keep the group), a reference several nodes answer to, even nodes already being removed (the reason lists each by its node id, which is the server id; the command’s lookup lists them too and sends the reference as typed), and a change while an identical one is in progress. A reference the platform cannot resolve is refused the same way: a providerID it cannot see on the cluster’s Kubernetes nodes, and on AWS a name that may be a Kubernetes node name it has not recorded yet. Name the node by its server name or its server id then; neither needs the Kubernetes nodes. A reference that names no node of the cluster exits 3 (the platform says it is not found in the node group); a node of another group is a refusal and exits 1. A group or node that is blank, has spaces around it, or is ’.’ or ’..’ (also percent-encoded), a ’/’ outside a providerID, a providerID with no id or with a ’.’ or ’..’ step, and an -o other than json or yaml exit 2 before anything is looked up or sent, and a node or group the platform cannot read (its 422) exits 2 too. Examples:
Flags

ankra cluster node-group scale

Scale a node group up or down to <count> nodes. A scale-down picks the nodes to remove. Each node removed is drained first, honouring its pods’ PodDisruptionBudgets. A node whose drain is refused (a budget allows no eviction, or the node cannot be drained at all) is kept in service instead of removed, and a notice on the cluster says why. Give the blocking workloads eviction headroom (more replicas or a looser budget) and run the command again, or pass --force-drain to remove the node anyway without honouring its PodDisruptionBudget. --force-drain applies to this request only; use it only for a node you have decided to lose. Examples:
Flags

ankra cluster node-group taints

Replace the taints on every node in the group. Pass --taints as a comma-separated list of key=value:Effect (value optional, effect defaults to NoSchedule), or --clear to remove all taints. The cloud provider is detected automatically from the cluster.
Flags

ankra cluster node-group upgrade

Change the instance type of every node in a node group. This cannot be reversed. The resize power-cycles each node, and each is drained first, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses those budgets for that drain, so a node is resized even if its pods’ disruption budget refuses the eviction. It applies to this request only. On UpCloud a plan is changed in place only within its plan family (STARTER, DEV, PREMIUM, GPU, or the unprefixed general-purpose plans such as 4xCPU-8GB). A new plan from another family replaces each node instead - drained, deleted and re-provisioned with the new plan - and the command says so. A control plane cannot be replaced that way, so a cross-family change there is refused. Examples:
Flags

ankra cluster operations

Commands to list, inspect, retry, and cancel executions and their steps. Every command that takes an execution id also accepts its first 6 or more characters. A short id is looked up among the most recent executions of the active cluster, or of the organisation when no cluster is selected.

ankra cluster operations cancel

Cancel one or more running executions
Flags

ankra cluster operations cancel-step

Cancel a specific step within an execution
Flags

ankra cluster operations hold

Set, read or lift a cluster’s operations hold. While a hold is in force the platform admits no new write operation on the cluster: reconciliation, retries, node remediation and Kubernetes upgrades all stop, while reads keep running. It is the lever that keeps the platform from undoing a manual recovery, for example after a failed Kubernetes version hop. These are Ankra staff operations. The platform refuses API tokens for them, so they do not use your saved login: set ANKRA_STAFF_SESSION to the session of your admin-portal sign-in, and pass the cluster by id. Every change is audited with your name and the reason.

ankra cluster operations hold get

Show the cluster’s operations hold and any pending version record check
Flags

ankra cluster operations hold lift

Lift the cluster’s operations hold, whatever set it. When a Kubernetes version record repair was made under the hold, the platform refuses the lift until its reads have confirmed every node at the version the record pins (‘hold get’ shows the check). --force overrides that refusal and is recorded on the audit row; it asks for confirmation unless --yes is given.
Flags

ankra cluster operations hold set

Hold the cluster for --for from now (1m to 24h). Running it again extends or shortens the hold to the new duration; both are audited. Examples:
Flags

ankra cluster operations list

List executions for the active cluster, or show one by ID (no cluster needed)
Flags

ankra cluster operations retry

Retry a failed, cancelled or critical execution
Flags

ankra cluster operations steps

List the steps of an execution with their status and error excerpt. --results additionally fetches each step’s job result - the structured payload the scheduler recorded when the step finished (for example the resources a teardown deleted, skipped, or failed to reclaim). Results are printed under each step, and merged into the steps in -o json|yaml output.
Flags

ankra cluster ovh

Commands to create, deprovision, and scale OVH Cloud clusters.

ankra cluster ovh access-info

Show the gateway (bastion) and control plane IPs plus ready-to-use SSH jump and Kubernetes API port-forward commands.
Flags

ankra cluster ovh bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster ovh bastion allowed-ips

Replace the bastion/gateway’s SSH source allowlist. Only the listed IPv4 addresses or CIDRs, the platform’s own egress addresses and private network sources can then reach port 22; every other source is dropped. The platform’s egress is always added by the platform itself, so it can never be locked out. The list you give is the complete new list: entries may be separated by spaces or commas. --clear removes the allowlist and makes the bastion reachable from anywhere again (key-only SSH, rate-limited). IPv6 entries and 0.0.0.0/0 are refused; at most 64 entries. The platform applies the list through the bastion update operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. Examples:
Flags

ankra cluster ovh bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster ovh bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’.
Flags

ankra cluster ovh bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster ovh control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster ovh control-plane get

Show the current control plane configuration
Flags

ankra cluster ovh control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster ovh control-plane set-instance-type

Change the instance type of every controller in a OVH cluster. The instance type is stored as given; it is not checked against OVH’s catalog. A name that does not exist is rejected by OVH itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline.
Flags

ankra cluster ovh create

Create a new OVH cluster
Flags

ankra cluster ovh etcd

Read the cluster’s etcd membership from one control-plane node, and remove the stale member a dead control-plane node left behind so its replacement can join. Both run over the platform’s bastion SSH lane as tracked operations and need clusters.operate on the cluster. Find node ids with ‘nodes list’.

ankra cluster ovh etcd members

Run ‘etcdctl member list’ and the endpoint health check on the control-plane node named and report every member (hex and decimal id), its health, any alarms and the quorum summary with its failure tolerance. Nothing changes. Run it on a healthy control-plane node when another one is dead.
Flags

ankra cluster ovh etcd remove

Remove one etcd member, named by the hex or decimal id ‘etcd members’ reported, executing on the healthy control-plane node named. The platform re-reads live membership first and refuses a healthy member, a member whose health it cannot read, the node’s own member, an ambiguous id, and any removal that would break quorum. This is destructive and cannot be undone: the command asks first (--yes skips, declining exits 4).
Flags

ankra cluster ovh gateway-model

Change the model (size) of the cluster’s OVH managed gateway: s, m, l, xl, 2xl or 3xl. The platform refuses (409) an unsupported model, a cluster with no recorded managed gateway and a cluster with no active network resource. Resizing a gateway can interrupt the cluster’s outbound internet access, so this asks for confirmation; --yes skips the question and is required when there is no terminal to ask on.
Examples
Flags

ankra cluster ovh k8s-version

Get current Kubernetes version for an OVH cluster
Flags

ankra cluster ovh node-group

List, add, scale, upgrade, label, taint, and delete node groups.

ankra cluster ovh nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster ovh nodes cloud-init-log

Fetch ‘cloud-init status --long’ and the tail of /var/log/cloud-init-output.log from the node over the platform’s bastion SSH lane, as a tracked read-only operation. This is the debug surface for node-group user-data: it shows whether the first-boot document ran and what it printed, without needing the cluster’s SSH key. Repeated calls attach to an in-flight fetch instead of dispatching duplicates. Find node ids with ‘nodes list’.
Flags

ankra cluster ovh nodes console-log

Read the newest lines of the node’s serial console from the cloud provider’s API, as a tracked read-only operation. It goes through neither the node over SSH nor the in-cluster agent, so it answers for a node that hung: a kernel soft lockup, hung-task warnings, an out-of-memory kill or a root filesystem gone read-only is often the last thing the console printed. Nothing on the node, the instance or the cluster’s credentials changes. The platform returns at most the newest 1000 lines (96 KiB); --lines shows fewer. The log goes to stdout and the heading and notes to stderr, so the output pipes cleanly into grep or a file. Repeated calls attach to a read in flight or a recent one. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster ovh nodes diagnose

Dispatch the platform’s read-only node diagnose job and wait for its report: over the bastion SSH lane it snapshots the node’s OS-level state - the Kubernetes service unit and its journal, disk, memory, uptime, the kernel log and the firewall path to the API server - and names the symptoms it finds. Nothing on the node is changed. This is what to reach for when a node is NotReady or its kubelet stopped posting status, below what ‘cluster get’ can see. The same diagnosis the Ankra assistant runs as ssh_diagnose_node. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’, and repeated calls attach to the run already in flight. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster ovh nodes get

Show full spec and metadata for a single node
Flags

ankra cluster ovh nodes list

List all nodes for the cluster
Flags

ankra cluster ovh nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster ovh os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster ovh os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster ovh os-patches plan

Run the dry run on every host and report what each would install, which held-back security updates are pending, whether a reboot would follow, and the order ‘run’ would take. The platform waits about 40 seconds; a slower plan hands back its operation id, and ‘status’ shows it once it finishes. Needs clusters.operate.
Flags

ankra cluster ovh os-patches policy

Show or change the cluster’s OS patch policy

ankra cluster ovh os-patches policy get

Show the OS patch policy and its maintenance window
Flags

ankra cluster ovh os-patches policy set

Change the cluster’s OS patch policy. Only the flags passed are changed. Turning the policy off also removes the node OS update hold from every host, and is refused while a run or a node OS policy operation is in flight. Needs clusters.write.
Flags

ankra cluster ovh os-patches run

Start the rolling patch: each host is drained, patched, rebooted when the packages ask for it, and returned to service before the next. Workloads move between nodes while it runs, so the command asks first (--yes skips, declining exits 4). Outside the policy’s maintenance window the platform refuses unless --outside-window is passed. Stateful nodes follow the policy unless --include-stateful-nodes or --exclude-stateful-nodes says otherwise; the bastion is patched last unless --exclude-bastion. Follow the run with ‘status’ or ‘ankra cluster operations list’. Needs clusters.operate.
Flags

ankra cluster ovh os-patches status

Show the OS patch policy, the newest run and the security-lag verdict
Flags

ankra cluster ovh regions

List the OVH Cloud regions the supplied credential’s project can deploy in. Only these regions are valid for cluster creation.
Flags

ankra cluster ovh ssh-keys

Get and set the SSH key credentials authorised to access an OVH cluster’s nodes.

ankra cluster ovh start

Start (re-provision) a stopped OVH cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster ovh stop

Stop an OVH cluster’s compute while keeping its configuration so it can be started again later.
Flags

ankra cluster ovh workers

Get current worker count for an OVH cluster
Flags

ankra cluster patch

Patch one or more live Kubernetes resources in the active cluster. This is ‘kubectl patch’: the document given with --patch (inline, JSON or YAML) or --patch-file is sent to the API server as a patch of the chosen --type - ‘strategic’ (the default, the kubectl default too), ‘merge’ (RFC 7386 JSON merge patch) or ‘json’ (RFC 6902 JSON patch, a list of operations). A patch changes only the fields it names and does not go through server-side apply, so it is the way to correct a field on an object another manager owns - a value the API server defaulted on an older chart, a label a release left behind - without taking that object over or deleting it. The kind takes the kubectl spellings - pod, deployment, deploy, service, svc, configmap, cm, node, … - and a custom resource is reachable with --group and --api-version, exactly like ‘cluster get resources’ and ‘cluster delete’. Cluster-scoped built-in kinds (node, namespace, crd, storageclass, …) need no namespace; a cluster-scoped custom kind takes --cluster-scoped instead. The patch goes through the cluster’s Ankra agent: no kubeconfig is needed and the same organisation permissions as the portal apply. Each object reports its own outcome. The command exits 0 when everything was patched, 3 when one of the objects did not exist, and 1 when the cluster refused a patch. Examples:
Flags

ankra cluster persistent-volumes

Delete PersistentVolumes on the active cluster through its Ankra agent. List them with ‘ankra cluster get persistentvolumes’. Needs kubernetes.write on the cluster.

ankra cluster persistent-volumes delete

Delete one or more PersistentVolumes. Each volume’s phase is read first: a Bound volume still backs a claim, and deleting it takes the claim’s data away from the workload using it, so the command refuses it (exit 8, nothing deleted) unless --force. Released, Available and Failed volumes are deleted; their storage is then released according to the reclaim policy. The command asks first (--yes skips, declining exits 4); each volume reports its own outcome, and one that did not exist exits 3.
Flags

ankra cluster playground

The playground is a real, writable Kubernetes cluster Ankra creates for your organisation on Ankra Cloud, with the Ankra agent already installed. Every organisation may hold one. With a payment method on the organisation’s Ankra Cloud account, Ankra Cloud bills the playground to that account. Without one, the account gets a free trial while Ankra Cloud still offers it one, and Ankra Cloud deletes the trial when it ends unless a payment method is added first.

ankra cluster playground create

Create the organisation’s playground on Ankra Cloud, at the size ankra cluster playground plans lists. Provisioning runs in the background: poll ankra cluster playground status <cluster_id> until the phase reaches ready.
Flags

ankra cluster playground destroy

Tear the organisation’s playground down. Everything deployed in it, including its storage, is deleted and cannot be recovered, so the command asks first; pass --yes to skip the prompt in scripts. Teardown runs in the background: poll ankra cluster playground status <cluster_id> until the phase reaches removed. This is also how a refused ankra org domain set is cleared. A playground publishes a wildcard DNS record in the organisation’s zone, and that record is reconciled rather than written once - deleting it with ankra org dns delete only lasts until the provisioner’s next pass. Destroying the environment is what removes it for good.
Flags

ankra cluster playground plans

List the size a new playground is created at; create it with ankra cluster playground create. The sizes an existing playground can move to are Ankra Cloud plans this list does not show: ankra cluster playground resize names them when it refuses a size.

ankra cluster playground resize

Move the playground’s server to another Ankra Cloud plan in place. Ankra Cloud stops the server, moves it to the new plan and starts it again, so nothing on the playground answers for a few minutes (Ankra Cloud allows up to 30). Ankra Cloud bills the new plan to your Ankra Cloud account from the change. A plan the playground cannot move to is refused with the plans it can. A free trial keeps its size: add a payment method to your Ankra Cloud account and it becomes an ordinary playground you can resize. Requires permission to manage the organisation’s billing.
Flags

ankra cluster playground status

Show the provisioning phase of a playground
Flags

ankra cluster power-schedules

Manage the cluster’s power schedules: scheduled stop or start actions that fire once at a chosen time or repeatedly on a cron expression, so a development cluster can park itself outside working hours. Power schedules are available for self-managed Hetzner, OVHcloud, UpCloud, DigitalOcean, Scaleway, AWS (EC2), Proxmox VE, and HPE Morpheus clusters - the same clusters that support manual stop and start. A scheduled stop behaves like stopping the cluster yourself: on Hetzner, OVHcloud, UpCloud and DigitalOcean the cluster’s state is captured first (an encrypted etcd snapshot the next start restores) unless --preserve-state=false; elsewhere the provider VMs are terminated and only the configuration is preserved. --stop-mode scale_to_zero deletes only the worker servers instead, and creates new ones at the next start: the control plane and etcd, cloud volumes and addresses are kept (and keep billing), and data on the workers’ own disks is lost at every stop. On a cluster whose volumes keep data there, the schedule needs --accept-node-local-data-loss (or a yes at the prompt). --stop-mode pause powers the servers off and keeps them. --stop-mode pause keeps the cluster’s state but saves no compute cost on Hetzner, DigitalOcean or UpCloud (Developer and General Purpose plans): they bill a powered-off server at its full price. To save money there, use scale_to_zero or delete_resources. On AWS and Scaleway a powered-off server stops billing compute; its disks and IPs keep billing. Examples:

ankra cluster power-schedules create

Create a scheduled stop or start on the active cluster. The schedule fires once at --at, or repeatedly per --cron evaluated in --timezone (UTC when omitted). A cluster can hold up to 20 schedules.
Flags

ankra cluster power-schedules delete

Delete a power schedule: it stops firing immediately and disappears from the cluster’s schedule list. The cluster itself is not touched. To pause a schedule while keeping its configuration, use ‘ankra cluster power-schedules update <schedule_id> … --enabled=false’.
Flags

ankra cluster power-schedules list

List the active cluster’s power schedules
Flags

ankra cluster power-schedules update

Replace a power schedule. This is a full replace, not a patch: pass the complete schedule as it should be afterwards - --action plus one of --at or --cron (with --timezone for cron schedules), and --enabled=false to leave it paused. A stop schedule’s --stop-mode and --preserve-state are the exception: when omitted, the schedule’s current choices are carried over, so a change of timing never silently turns a state-discarding stop into a preserving one. Use ‘ankra cluster power-schedules list’ for the schedule ID and the current values.
Flags

ankra cluster provision

Provision a managed cluster that is not running. This works for a cluster that was created but never built, and for an imported cluster that was deprovisioned. It cannot rebuild a deprovisioned cloud cluster (hetzner, ovh, upcloud, digitalocean, scaleway, ankracloud, aws, proxmox, morpheus): that deprovision deleted the record, so there is nothing left to provision - create a new cluster instead. Provisioning rebuilds the cluster’s infrastructure and then redeploys its stack resources from the cluster’s stored stack definition. Verify anything you patched in place afterwards - see “ankra cluster addons list <addon>” and “ankra cluster manifests list”. This is not a power-on. To resume a cluster you powered off, use its provider’s start command (for example “ankra cluster hetzner start”) or “ankra cluster power-schedules”. Name the cluster as the argument or with --cluster. Provisioning builds infrastructure that bills, so it never falls back to the cluster selected with ‘ankra cluster select’: that selection is shared by every shell and agent session on the machine.
Flags

ankra cluster proxmox

Commands to create, stop, start, and inspect Proxmox VE clusters.

ankra cluster proxmox bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster proxmox bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster proxmox bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. On Proxmox VE <instance_type> is an instance-size preset such as px-medium; list them with ‘ankra cluster proxmox sizes’.
Flags

ankra cluster proxmox bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster proxmox bridges

List Proxmox VE network bridges on a host node
Flags

ankra cluster proxmox control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster proxmox control-plane get

Show the current control plane configuration
Flags

ankra cluster proxmox control-plane set-count

Change the number of controllers (1, 3 or 5; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster proxmox control-plane set-instance-type

Change the instance type of every controller in a Proxmox VE cluster. The instance type is stored as given; it is not checked against Proxmox VE’s catalog. A name that does not exist is rejected by Proxmox VE itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline. List the instance types that do exist with:
Flags

ankra cluster proxmox create

Create a new Proxmox VE cluster
Flags

ankra cluster proxmox hosts

List the Proxmox VE host nodes the supplied credential can deploy virtual machines on.
Flags

ankra cluster proxmox k8s-version

Get current Kubernetes version for a Proxmox VE cluster
Flags

ankra cluster proxmox nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster proxmox nodes get

Show full spec and metadata for a single node
Flags

ankra cluster proxmox nodes list

List all nodes for the cluster
Flags

ankra cluster proxmox nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster proxmox os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster proxmox os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster proxmox sizes

List the instance-size presets (px-small, px-medium, …) accepted by the Proxmox VE instance-type flags.

ankra cluster proxmox start

Start (re-provision) a stopped Proxmox VE cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster proxmox stop

Stop a Proxmox VE cluster’s virtual machines while keeping its configuration so it can be started again later.
Flags

ankra cluster proxmox storages

List Proxmox VE storages on a host node
Flags

ankra cluster proxmox templates

List Proxmox VE VM templates on a host node
Flags

ankra cluster proxmox workers

Get current worker count for a Proxmox VE cluster
Flags

ankra cluster reconcile

Trigger a reconciliation for a cluster to sync desired state with actual state. If no cluster name is provided, uses the currently selected cluster. If a cluster name is provided, reconciles that specific cluster.
Flags

ankra cluster rename

Rename a cluster. The cluster is given by its current name or its id. The cluster is never taken from ‘ankra cluster select’: name it here, as the argument or with --cluster. A rename changes the name Ankra knows the cluster by: the portal, the cluster list, ‘ankra’ commands and Ankra AI all use the new name. Nothing is rebuilt or replaced, and the cluster id does not change. What keeps its old name:
  • server names, hostnames and Kubernetes node names, which were set when the nodes were created and cannot change on a running node;
  • the cluster’s DNS zone and the hosts of applications already deployed;
  • the GitOps directory (clusters/<old-name>-<suffix>/), which Ankra keeps using so stored paths stay valid;
  • existing kubeconfig contexts (‘ankra-<old-name>’). They keep working, because they reach the cluster by id; run ‘ankra cluster kubeconfig add <new-name>’ for a context with the new name.
API tokens, kube tokens, access grants, hosted metrics and logs, backups and alert routes are tied to the cluster id and keep working unchanged. An ImportCluster file that still says metadata.name: <old-name> is refused by ‘ankra cluster apply’ with a message naming the new name; it never creates a second cluster. Change metadata.name to the new name before the next apply, or apply with --cluster <new-name>. A cluster synced with a connected GitOps repository, and an Ankra Cloud cluster, cannot be renamed yet; the platform refuses and changes nothing. The name must be 1 to 53 lowercase letters, digits and hyphens, starting with a letter and ending with a letter or digit, and no other cluster in the organisation may have it.
Examples
Flags

ankra cluster restart

Rolling-restart one or more workloads in the active cluster. This is ‘kubectl rollout restart’: the pod template gets a fresh kubectl.kubernetes.io/restartedAt annotation, so the controller replaces every pod under its own rollout strategy - no downtime for a Deployment with more than one replica, one pod at a time for a StatefulSet. Nothing else in the spec changes. The kind is deployment, statefulset or daemonset; the kubectl short and plural spellings work too. Examples:
Flags

ankra cluster roll-to

Roll a cluster to a specific resource version. Uses the currently selected cluster unless --cluster is provided. Example:
Flags

ankra cluster scale

Scale the number of default-pool worker nodes up or down for a cloud cluster. The cloud provider (Hetzner, OVH, UpCloud, DigitalOcean, Scaleway, Ankra Cloud, AWS, Proxmox VE, or HPE Morpheus) is detected automatically from the cluster, so you do not need to remember which provider it runs on. To scale a named node group instead, use ‘ankra cluster node-group scale’. A scale-down picks the workers to remove. Each node removed is drained first, honouring its pods’ PodDisruptionBudgets. A node whose drain is refused (a budget allows no eviction, or the node cannot be drained at all) is kept in service instead of removed, and a notice on the cluster says why. Give the blocking workloads eviction headroom (more replicas or a looser budget) and run the command again, or pass --force-drain to remove the node anyway without honouring its PodDisruptionBudget. --force-drain applies to this request only; use it only for a node you have decided to lose. Examples:
Flags

ankra cluster scaleway

Manage the lifecycle of Scaleway clusters.

ankra cluster scaleway bastion

Inspect and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster scaleway bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. On Scaleway the bastion is the cluster’s managed Public Gateway, so <instance_type> is a gateway type such as VPC-GW-M; list them with ‘ankra cluster scaleway gateway-types’.
Flags

ankra cluster scaleway bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable. This provider has no bastion diagnose job lane, so the recorded verdict is all there is to read.
Flags

ankra cluster scaleway control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster scaleway control-plane get

Show the current control plane configuration
Flags

ankra cluster scaleway control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster scaleway control-plane set-instance-type

Change the instance type of every controller in a Scaleway cluster. The instance type is stored as given; it is not checked against Scaleway’s catalog. A name that does not exist is rejected by Scaleway itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline. List the instance types that do exist with:
Flags

ankra cluster scaleway create

Create an Ankra-managed kubeadm (default) or k3s cluster on Scaleway Instances. Ankra owns the server graph, security group, Public Gateway v2, generated SSH key and (unless --private-network-id adopts an existing one) the Private Network. Run ‘preflight’ first to check region, zone, CIDR and SKU availability - it proves availability, not project hard quota. Examples:
Flags

ankra cluster scaleway deprovision

Permanently delete a Scaleway cluster and the provider resources Ankra created for it. Volumes and load balancers follow the cluster’s retention_policy: ‘retain’ keeps them, ‘delete’ sweeps them. A ‘delete’ cluster’s persistent volumes are named first and deleted only when you accept that: answer the prompt on a terminal, or pass --accept-volume-data-loss (--yes does not imply it).
Flags

ankra cluster scaleway etcd

Read the cluster’s etcd membership from one control-plane node, and remove the stale member a dead control-plane node left behind so its replacement can join. Both run over the platform’s bastion SSH lane as tracked operations and need clusters.operate on the cluster. Find node ids with ‘nodes list’.

ankra cluster scaleway etcd members

Run ‘etcdctl member list’ and the endpoint health check on the control-plane node named and report every member (hex and decimal id), its health, any alarms and the quorum summary with its failure tolerance. Nothing changes. Run it on a healthy control-plane node when another one is dead.
Flags

ankra cluster scaleway etcd remove

Remove one etcd member, named by the hex or decimal id ‘etcd members’ reported, executing on the healthy control-plane node named. The platform re-reads live membership first and refuses a healthy member, a member whose health it cannot read, the node’s own member, an ambiguous id, and any removal that would break quorum. This is destructive and cannot be undone: the command asks first (--yes skips, declining exits 4).
Flags

ankra cluster scaleway gateway-types

List Scaleway Public Gateway types for a zone
Flags

ankra cluster scaleway instance-types

List Scaleway instance types (commercial types) for a zone
Flags

ankra cluster scaleway k8s-version

Get current Kubernetes version for a Scaleway cluster
Flags

ankra cluster scaleway locations

List Scaleway regions and zones available to a credential
Flags

ankra cluster scaleway networks

List Scaleway Private Networks a credential can adopt
Flags

ankra cluster scaleway nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster scaleway nodes cloud-init-log

Fetch ‘cloud-init status --long’ and the tail of /var/log/cloud-init-output.log from the node over the platform’s bastion SSH lane, as a tracked read-only operation. This is the debug surface for node-group user-data: it shows whether the first-boot document ran and what it printed, without needing the cluster’s SSH key. Repeated calls attach to an in-flight fetch instead of dispatching duplicates. Find node ids with ‘nodes list’.
Flags

ankra cluster scaleway nodes diagnose

Dispatch the platform’s read-only node diagnose job and wait for its report: over the bastion SSH lane it snapshots the node’s OS-level state - the Kubernetes service unit and its journal, disk, memory, uptime, the kernel log and the firewall path to the API server - and names the symptoms it finds. Nothing on the node is changed. This is what to reach for when a node is NotReady or its kubelet stopped posting status, below what ‘cluster get’ can see. The same diagnosis the Ankra assistant runs as ssh_diagnose_node. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’, and repeated calls attach to the run already in flight. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster scaleway nodes get

Show full spec and metadata for a single node
Flags

ankra cluster scaleway nodes list

List all nodes for the cluster
Flags

ankra cluster scaleway nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster scaleway os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster scaleway os-patches plan

Run the dry run on every host and report what each would install, which held-back security updates are pending, whether a reboot would follow, and the order ‘run’ would take. The platform waits about 40 seconds; a slower plan hands back its operation id, and ‘status’ shows it once it finishes. Needs clusters.operate.
Flags

ankra cluster scaleway os-patches policy

Show or change the cluster’s OS patch policy

ankra cluster scaleway os-patches policy get

Show the OS patch policy and its maintenance window
Flags

ankra cluster scaleway os-patches policy set

Change the cluster’s OS patch policy. Only the flags passed are changed. Turning the policy off also removes the node OS update hold from every host, and is refused while a run or a node OS policy operation is in flight. Needs clusters.write.
Flags

ankra cluster scaleway os-patches run

Start the rolling patch: each host is drained, patched, rebooted when the packages ask for it, and returned to service before the next. Workloads move between nodes while it runs, so the command asks first (--yes skips, declining exits 4). Outside the policy’s maintenance window the platform refuses unless --outside-window is passed. Stateful nodes follow the policy unless --include-stateful-nodes or --exclude-stateful-nodes says otherwise; the bastion is patched last unless --exclude-bastion. Follow the run with ‘status’ or ‘ankra cluster operations list’. Needs clusters.operate.
Flags

ankra cluster scaleway os-patches status

Show the OS patch policy, the newest run and the security-lag verdict
Flags

ankra cluster scaleway preflight

Run the Scaleway create preflight: region/zone reachability, CIDR overlap, gateway and instance-type availability. A quota warning means SKU stock was visible, not that project hard-quota headroom was proven. Takes the same flags as ‘create’.
Flags

ankra cluster scaleway start

Re-provision a stopped Scaleway cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster scaleway stop

Stop a Scaleway cluster by terminating its compute while preserving its configuration so it can be re-provisioned later.
Flags

ankra cluster scaleway workers

Get current worker count for a Scaleway cluster
Flags

ankra cluster select

Select a cluster and save it as the active cluster for subsequent commands. If a cluster name is provided, it will be selected directly without prompting. If no name is provided, an interactive picker is shown. Examples:

ankra cluster sops-config

Show the SOPS encryption configuration including the public key used for encrypting secrets.

ankra cluster ssh-keys

Get, set, and re-sync the SSH key credentials authorised to access a cloud cluster’s nodes. The cloud provider (Hetzner, OVH, UpCloud, DigitalOcean, Scaleway, Ankra Cloud, AWS, Proxmox VE, or HPE Morpheus) is detected automatically from the cluster.

ankra cluster ssh-keys get

Show SSH keys attached to a cluster
Flags

ankra cluster ssh-keys resync

Re-sync the cluster’s SSH key with the cloud provider. Use this to repair a stale provider-side SSH key reference (for example when the key was deleted and re-created in the provider console) that blocks new node creation, and to re-apply the authorised keys to running nodes.
Flags

ankra cluster ssh-keys set

Replace the SSH key credentials attached to a cluster. Changes take effect on the next reconciliation and are applied to running nodes. Pass --clear to remove all user SSH keys (the Ankra-managed key always remains).
Flags

ankra cluster stacks

Commands to list, create, delete, rename, redeploy, uninstall and install stacks, and view their history.

ankra cluster stacks clone

Clone a stack from the current cluster to a target cluster. The cloned stack is created as a draft on the target so it can be reviewed before it is deployed. Encrypted values are stripped during cloning and must be reconfigured on the target. With --with-data the clone also carries the stack’s data: a restore point is taken on the source and restored onto the target by a run the command names. The data moves after the clone, not during it, so the copy is a draft until the restore has landed - a with-data clone never deploys at clone time, and --deploy plans the deploy step rather than running it. Data flags need --with-data beside them. Databases travel by default and volumes only where named with --include-pvc namespace/name; --exclude-databases needs --confirm-exclude-databases. Naming any selection flag REPLACES the stack’s stored backup selection for this clone rather than narrowing it, so name the volumes to keep alongside --exclude-databases; leave every selection flag off and the stored selection decides. The vault resolves in order: --vault, the stack’s own backup policy, then the organisation’s single ready vault. With --from latest the restore point is read from the vault that holds it, so --vault is not accepted there. Carrying volume data keeps the stack, Helm release and namespace names, so the platform refuses --name for a clone whose plan holds volumes (a database-only clone may still be renamed), and a target that already has a stack of this name is refused rather than suffixed around. Examples:
Flags

ankra cluster stacks data

The stack’s data inventory: standalone persistent volume claims and database custom resources with their claims folded in, each with the engine that would capture it and the consistency that engine can promise.

ankra cluster stacks data list

List what a stack holds that a backup would have to carry. Each asset says which engine would capture it and what consistency that engine can promise: an engine either produces a consistent artifact or it declares itself crash-consistent, and there is no third answer. The live read of the database operators can come back unavailable - no relay, or an offline agent - in which case the command says so rather than presenting a partial inventory as the whole truth. Only data a member of the stack owns is listed as the stack’s, and each asset says why it is: the member that owns it, or a namespace only this stack uses. Data the sweep of the stack’s namespaces finds that no member owns - another stack’s database in a shared namespace, an orphan claim - is listed separately as not owned by this stack (unattributed). Unattributed data is never captured or restored as this stack’s, and the requested total does not count it. Example:
Flags

ankra cluster stacks delete

Delete a stack
Flags

ankra cluster stacks deploy-draft

Deploy the pending draft of a stack on the active cluster: a stack that exists only as a draft (what a clone or a stack-profile instantiation leaves behind), or the draft of edits ‘ankra cluster draft -f’ or the stack builder left on a stack that is already deployed. The draft’s contents are deployed exactly as they are stored. Review them first with ‘ankra cluster stacks show-draft <stack name>’, and edit them in the stack builder if the clone warned that something has to change before it can come up. For a stack that is already deployed only the members the draft changes are written; members it does not mention keep running untouched.
Flags

ankra cluster stacks history

Show history of changes for a stack
Flags

ankra cluster stacks install

Install a stack that was uninstalled: deploy its add-ons, manifests and applications to the cluster again, in dependency order, with the definitions the stack holds now, including members added or edited while it was uninstalled. A member that was already off the cluster when the stack was uninstalled, such as an add-on uninstalled on its own, stays off it. Name the cluster with --cluster. This command never uses the cluster ‘ankra cluster select’ saved, which every shell and agent session on this machine shares: a stack uninstalled on one cluster because it now runs on another must not come back on the wrong one. The platform refuses an install, and changes nothing, for a stack that is not uninstalled, one whose uninstall is still taking members off the cluster, one with an open draft or being deleted, and while the cluster is offline. The command then prints the platform’s reason and exits 8. It needs the stacks.deploy permission on the cluster (exit 7 without it), and a stack the cluster does not have exits 3.
Examples
Flags

ankra cluster stacks list

List stacks for the active cluster; or show details for a single stack
Flags

ankra cluster stacks protect

Turn on protection for a stack. Protection is a property of the stack, not a separate object: the command writes a backup block onto the stack’s definition, and the platform converges on it by installing the backup data plane on the cluster. Until that plane exists the command reports the backup stack as “installing” rather than claiming the stack is protected. --vault is required; a protected stack with nowhere to write to is not protected. --schedule takes hourly, daily, weekly, or a five-field cron expression. --retention takes the buckets to keep, as key=value pairs. Examples:
Flags

ankra cluster stacks redeploy

Re-run the deployment jobs of the members a redeploy of this stack picks on the active cluster. The result lists the operations it started and every member it skipped, with the reason. --force is for a manifest whose apply failed with an error reading conflict with “<manager>”. The manifests this redeploy re-runs apply with server-side apply force-conflicts, for this redeploy only, and nothing is stored on the stack. The result names the manifests it forced; members it does not re-run and add-ons are not forced, and an application member’s apply forces conflicts either way. It overwrites the conflicting fields on the live objects with the stack’s values, and that cannot be undone. before-first-apply is Kubernetes’ name for fields written before Ankra’s first server-side apply, not another controller, though the value may still be one a person set. --force needs clusters.write on the cluster on top of stacks.deploy, and asks for confirmation first: --yes answers it, and without a terminal --yes is required.
Examples
Flags

ankra cluster stacks rename

Rename a stack

ankra cluster stacks restore-points

A restore point is an immutable copy of a stack’s data in a backup vault, self-describing enough to be read without the cluster it came from. Backing up creates one; restoring applies one.

ankra cluster stacks restore-points create

Take a restore point of a stack now. The capture is dispatched by the platform, so the command answers with the restore point in ‘creating’ and the run that will seal it. With --wait it follows that run to completion and prints the sealed restore point. The vault is resolved in order: --vault, then the stack’s own backup policy, then the organisation’s single ready vault. With more than one ready vault and nothing naming which, the platform refuses rather than choosing for you. Examples:
Flags

ankra cluster stacks restore-points delete

Delete a restore point. The row goes either way, so a restore point whose cluster was destroyed is never undeletable; the objects in the bucket are swept by an execution on the source cluster, and when no sweep could be dispatched the command says why the objects were left behind rather than understating the storage bill. A restore point a backup, restore or clone is currently using is refused, and so is one that is still being taken. The id may be a prefix of the one the listing printed, at least 8 characters long (the uuid’s first group), checked for ambiguity against every restore point the stack has; a shorter prefix is refused because a delete cannot be undone, and the full id is always accepted.
Flags

ankra cluster stacks restore-points get

Describe one restore point: the manifest it carries, every asset in it, everything it does not carry, and the run that produced it. The id may be an unambiguous prefix of the one the listing printed; it is checked for ambiguity against every restore point the stack has, not just the newest page, and a prefix two of them share is refused with both named.
Flags

ankra cluster stacks restore-points list

List the restore points taken of a stack, newest first. The listing carries what each restore point does NOT contain as well as what it does: a backup listing that showed sizes and hid omissions would be exactly the silence this is here to remove. Examples:
Flags

ankra cluster stacks restore-points restore

Restore a restore point over the stack it was taken from. This destroys before it replaces. Typing the stack’s own name is what gates it - the sequence the platform will follow is printed from its answer, once the restore has been accepted and before any of its steps run:
  1. Scale down the workloads that own the data.
  2. Remove the volumes the restore point replaces.
  3. Restore the restore point’s assets onto the cluster.
  4. Scale the workloads back up over the restored data.
Confirmation is the typed stack name, not y/N; --yes skips it for scripts. A restore point carrying a CloudNativePG or Percona database is refused with the platform’s own reason - the ordinary restore path would report success over unchanged data, which is worse than refusing. A stack whose data has changed since the restore point was taken is refused unless --force. An inventory whose live database scan did not run counts as drift, because “we could not read it” is not “it is unchanged”. The id may be a prefix of the one the listing printed, at least 8 characters long (the uuid’s first group), checked for ambiguity against every restore point the stack has; a shorter prefix is refused because the stack’s volumes are removed before anything is written back, and the full id is always accepted.
Flags

ankra cluster stacks show-draft

Print the pending draft of a stack on the active cluster: every member, what it waits for, and the content it would deploy, decoded. Nothing is deployed or changed. Encrypted values are shown as they are stored, and variables are shown unresolved, because both are filled in when the draft deploys.
Examples
Flags

ankra cluster stacks uninstall

Uninstall a stack: take every add-on, manifest and application in it off the cluster. The stack itself is not deleted. It stays declared in Ankra and in your GitOps repository, nothing is committed to Git, and ‘ankra cluster stacks install <stack> --cluster <cluster>’ deploys it again. Members come off in reverse dependency order. Data is treated exactly as a delete treats it: whatever a chart or operator removes together with its workload is removed too, and installing the stack again does not bring that back. Back the stack up first: ‘ankra cluster stacks data list <stack>’ lists what it stores, and ‘ankra cluster stacks restore-points create <stack>’ takes a restore point. While the stack is uninstalled its members stay off the cluster through cluster starts and Git syncs, and edits to them are stored and deployed when the stack is installed again. Name the cluster with --cluster. This command never uses the cluster ‘ankra cluster select’ saved, which every shell and agent session on this machine shares. It says what it will do and asks first: --yes answers, and without a terminal --yes is required. The platform refuses an uninstall, and changes nothing, while the cluster is offline, while a member’s deployment is still running or has failed, while the stack has an open draft or is being deleted, and for a stack a managed service owns. The command then prints the platform’s reason and exits 8. It needs the stacks.delete permission on the cluster (exit 7 without it), and a stack the cluster does not have exits 3.
Examples
Flags

ankra cluster stacks unprotect

Turn off protection for a stack. Every restore point already taken is kept and stays restorable: removing protection is a decision about the future, not about the past. The scheduled backups and the rendered object stores disappear on the next render. Confirmation is typing the stack’s own name, not y/N; --yes skips it.
Flags

ankra cluster stacks variables

Manage variables on a specific stack. Stack variables are the most specific scope and shadow cluster and organisation variables of the same name when this stack’s manifests/addons are rendered.
Stack variables are stored on the stack spec itself; edits use the same partial-stack PATCH endpoint as manifests/addons upgrade.

ankra cluster stacks variables delete

Delete a variable from a stack
Flags

ankra cluster stacks variables get

Get a single stack variable
Flags

ankra cluster stacks variables list

List variables on a stack
Flags

ankra cluster stacks variables set

Create or update a stack variable. The value can be read from stdin by passing ”-”.
Flags

ankra cluster state-snapshots

Ankra backs up the etcd state of every running cluster it provisions - every Secret, ConfigMap, custom resource and PersistentVolume binding - every six hours, encrypted, to your organisation’s backup vault (or the Ankra-managed default vault). A start that finds the cluster’s etcd lost restores the newest backup. Examples

ankra cluster state-snapshots latest

Show the newest captured etcd state snapshot of the cluster that a start may restore: its id, what captured it (stop, power_schedule or scheduled), when, and the Kubernetes version it holds. Pass the id to the provider’s start command with --restore-snapshot-id to restore it. -o json prints the platform’s answer as it is.
Examples
Flags

ankra cluster state-snapshots retention

Show or set how many days of scheduled etcd backups Ankra keeps for the cluster. Ankra keeps the four newest backups, plus the newest backup of each UTC day for the retention window: 7 days unless you set another between 1 and 90. The newest backup from before the cluster’s last start or recovery incident is kept whatever the window. Without --days this shows the window. With --days it sets it; the next retention pass applies it. A longer window keeps backups from then on and cannot bring back ones already deleted. A shorter window deletes the daily backups outside it from the vault, so it asks for confirmation first (--yes skips it). Setting the window needs permission to change cluster settings (clusters.write). -o json prints the platform’s answer as it is.
Examples
Flags

ankra cluster storage-classes

Create or delete StorageClasses on the active cluster through its Ankra agent. List them with ‘ankra cluster get storageclasses’. Both need kubernetes.write on the cluster.

ankra cluster storage-classes create

Create a StorageClass from flags. --provisioner names the CSI driver that cuts the volumes (driver.longhorn.io, csi.hetzner.cloud, ebs.csi.aws.com, …); --parameter passes the driver’s own settings and repeats.
Flags

ankra cluster storage-classes delete

Delete one or more StorageClasses. Volumes already provisioned from a class keep running; new claims naming it stay Pending until a class of that name exists again. The command asks first (--yes skips, declining exits 4); each class reports its own outcome, and one that did not exist exits 3.
Flags

ankra cluster terminal

Open an interactive shell in a container of the named pod, through the platform - no kubeconfig and no port-forward. The local terminal is put in raw mode, so every keystroke (Ctrl-C included) reaches the remote shell; leave with exit or Ctrl-D. Window resizes follow the local terminal. Every session is recorded by the platform and linked from the cluster’s audit log as an open_pod_terminal event; “ankra org terminal-session” replays it. Needs kubernetes.exec on the cluster. With one container the shell opens there; a pod with several needs --container. Input that is not a terminal (a pipe) is forwarded as typed and should end with exit, since the remote shell cannot see the pipe close. To run one command non-interactively and get its exit code, use “ankra cluster exec <pod> -n <namespace> — <command> [args…]” instead; --shell names a shell binary and cannot carry arguments.
Examples
Flags

ankra cluster top

Show live resource usage measured by metrics-server. This is the “which container just got OOMKilled” view. It reads the aggregated metrics API directly, so it works on clusters where Prometheus was never installed. For trends over time use ‘ankra cluster metrics’, which queries Prometheus.

ankra cluster top nodes

Show live CPU and memory usage per node, measured by metrics-server. Percentages are computed against each node’s allocatable capacity. If the node list cannot be read the percentage columns are omitted rather than guessed. Examples:
Flags

ankra cluster top pods

Show live CPU and memory usage per pod, measured by metrics-server. Without -n or --all-namespaces this reads every namespace, unlike kubectl top, which defaults to the current one. Examples:
Flags

ankra cluster uncordon

Clear the unschedulable mark ‘cluster cordon’ or ‘cluster drain’ set, so the scheduler can place pods on the node again. Example:

ankra cluster upcloud

Commands to create, deprovision, and scale UpCloud clusters.

ankra cluster upcloud available-zones

List the public UpCloud zones the credential’s account can deploy in, read live from UpCloud: the values ‘ankra cluster upcloud create --zone’ and ‘ankra cluster upcloud zones’ take.
Examples
Flags

ankra cluster upcloud bastion

Inspect, diagnose, and resize the cluster’s single bastion/gateway node. Find its node ID with ‘nodes list’.

ankra cluster upcloud bastion allowed-ips

Replace the bastion/gateway’s SSH source allowlist. Only the listed IPv4 addresses or CIDRs, the platform’s own egress addresses and private network sources can then reach port 22; every other source is dropped. The platform’s egress is always added by the platform itself, so it can never be locked out. The list you give is the complete new list: entries may be separated by spaces or commas. --clear removes the allowlist and makes the bastion reachable from anywhere again (key-only SSH, rate-limited). IPv6 entries and 0.0.0.0/0 are refused; at most 64 entries. The platform applies the list through the bastion update operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’. Examples:
Flags

ankra cluster upcloud bastion diagnose

Dispatch the provider’s read-only bastion diagnose job and wait for its report: sshd configuration, failed-login volume, disk, failed units, journal errors, listening ports, and pending security updates. Nothing on the host is changed. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’.
Flags

ankra cluster upcloud bastion resize

Resize the bastion/gateway node. The provider’s bastion/gateway update job powers it off, resizes it, and powers it back on, causing brief SSH/NAT downtime for the cluster. --wait covers the platform write only; the cloud resize runs as the operation reported on success. Follow it with ‘ankra cluster operations list <operation_id>’.
Flags

ankra cluster upcloud bastion status

Report the verdict the platform’s bastion health loop last recorded for the cluster’s bastion/gateway: whether it is reachable, which hop a failed probe stopped at, and when it was last checked. Nothing is probed by this command, so it answers even while the bastion is unreachable - use ‘bastion diagnose’ to SSH in and collect a fresh report.
Flags

ankra cluster upcloud control-plane

Inspect and change the control plane configuration. The controller count is 1 or 3 (1, 3 or 5 on Proxmox VE): etcd needs an odd number of voting members for quorum. Growing the control plane may happen live on a running cluster: the new controllers join it one at a time, keeping the Kubernetes API up. The platform can refuse a live change (an operation already in flight, controllers still reconciling, a configuration that pins the API to one controller), and says why. Reducing it is applied offline: stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster either change applies at the next start. The instance type can also be changed on a running cluster that has three controllers: they are then resized one at a time, keeping the Kubernetes API up. With a single controller, resizing the only controller takes the API down for a few minutes while it reboots: where the platform supports that live resize it needs --accept-api-downtime, otherwise it needs a stopped cluster. Run “control-plane get” to see which of the two is available right now.

ankra cluster upcloud control-plane get

Show the current control plane configuration
Flags

ankra cluster upcloud control-plane set-count

Change the number of controllers (1 or 3; etcd needs an odd number of voting members for quorum). On a running cluster growing the count may happen live: the new controllers join one at a time and the command prints the operation to follow, unless the platform refuses the live change and says why. Reducing it is refused on a running cluster; stop the cluster (its state is preserved), change the count, then start it. On a stopped cluster the change applies at the next start. Run “control-plane get” to see whether a count change is possible right now.
Flags

ankra cluster upcloud control-plane set-instance-type

Change the instance type of every controller in a UpCloud cluster. The instance type is stored as given; it is not checked against UpCloud’s catalog. A name that does not exist is rejected by UpCloud itself, which on a stopped cluster is at the next start - after this command has already reported success. On a running cluster the rolling resize drains each controller before resizing it, honouring its pods’ PodDisruptionBudgets. --force-drain bypasses them for that drain, so pods whose budget refuses eviction are evicted anyway. It applies to this request only, and only a live rolling resize reads it: a stopped cluster’s offline resize drains nothing and ignores it, and so does a request the rolling resize refuses (fewer than three controllers) or has nothing to do for (the controllers already run that type). A running cluster with a single controller can be resized in place where the platform supports it, but the Kubernetes API is down for a few minutes while that server reboots on the new type. Workloads on the workers keep running; kubectl, deploys, the Ankra agent and controllers pause until it is back. That resize needs --accept-api-downtime: without it the command refuses before sending anything. Scale the control plane to three controllers first for a resize without downtime, or stop the cluster and resize it offline.
Flags

ankra cluster upcloud create

Create a new UpCloud cluster
Flags

ankra cluster upcloud etcd

Read the cluster’s etcd membership from one control-plane node, and remove the stale member a dead control-plane node left behind so its replacement can join. Both run over the platform’s bastion SSH lane as tracked operations and need clusters.operate on the cluster. Find node ids with ‘nodes list’.

ankra cluster upcloud etcd members

Run ‘etcdctl member list’ and the endpoint health check on the control-plane node named and report every member (hex and decimal id), its health, any alarms and the quorum summary with its failure tolerance. Nothing changes. Run it on a healthy control-plane node when another one is dead.
Flags

ankra cluster upcloud etcd remove

Remove one etcd member, named by the hex or decimal id ‘etcd members’ reported, executing on the healthy control-plane node named. The platform re-reads live membership first and refuses a healthy member, a member whose health it cannot read, the node’s own member, an ambiguous id, and any removal that would break quorum. This is destructive and cannot be undone: the command asks first (--yes skips, declining exits 4).
Flags

ankra cluster upcloud gateway-plan

Change the plan of the cluster’s UpCloud NAT gateways in place. --plan is a plan name from ‘ankra cluster upcloud gateway-plans’. This interrupts the cluster’s outbound internet access while UpCloud rebuilds the gateway: expect several minutes without outbound access, so choose a quiet time. That is why it asks for confirmation; --yes skips the question and is required when there is no terminal to ask on. The command returns once the change is recorded; the platform carries it out and reports it complete only after the gateway runs on the new plan and the cluster’s agent has checked in again. A stopped cluster’s gateways take the plan at the next start.
Examples
Flags

ankra cluster upcloud gateway-plans

List UpCloud’s NAT gateway plans, read live with the given credential: bandwidth, how many gateway servers the plan runs and whether it is highly available (two or more servers, which keeps egress up while UpCloud replaces one). It also names the plan a cluster created without one gets, and what a day-2 plan change does to a cluster’s outbound internet access.
Examples
Flags

ankra cluster upcloud k8s-version

Get current Kubernetes version for an UpCloud cluster
Flags

ankra cluster upcloud load-balancer-plan

The UpCloud plan of the load balancer in front of the cluster’s Ankra-managed ingress. ‘get’ shows the plan Ankra has recorded beside the plans the live load balancers run on; ‘set’ records a new plan and the balancer moves onto it in place.

ankra cluster upcloud load-balancer-plan get

Show the plan Ankra has recorded for the cluster’s ingress load balancer beside the plans its live load balancers run on. No recorded plan means none was ever set, and Ankra then leaves the balancer’s plan alone. When UpCloud cannot be read the live balancers are reported as not observed, never as none.
Examples
Flags

ankra cluster upcloud load-balancer-plan set

Record a new UpCloud plan for the cluster’s ingress load balancer. Ankra re-renders the ingress Service and UpCloud’s cloud controller moves the existing balancer onto the plan in place. --plan is a plan name from ‘ankra cluster upcloud load-balancer-plan get’ or ‘load-balancer-plans’. The platform checks the plan against UpCloud’s catalogue and refuses (409) an unknown plan, a cluster whose ingress load balancer Ankra does not render, and a cluster whose cloud provider stack has not settled. Naming the plan already recorded changes nothing.
Examples
Flags

ankra cluster upcloud load-balancer-plans

List UpCloud’s managed load balancer plans, read live with the given credential: the choices for a cluster’s ingress load balancer. A plan that runs more than one load balancer node is highly available.
Examples
Flags

ankra cluster upcloud node-group

List, add, scale, upgrade, and delete node groups.

ankra cluster upcloud nodes

Inspect every server Ankra manages for the cluster (control plane, workers, and bastion or gateway). Soft-deleted entries from a stopped cluster are included so the saved topology is visible before re-provisioning.

ankra cluster upcloud nodes cloud-init-log

Fetch ‘cloud-init status --long’ and the tail of /var/log/cloud-init-output.log from the node over the platform’s bastion SSH lane, as a tracked read-only operation. This is the debug surface for node-group user-data: it shows whether the first-boot document ran and what it printed, without needing the cluster’s SSH key. Repeated calls attach to an in-flight fetch instead of dispatching duplicates. Find node ids with ‘nodes list’.
Flags

ankra cluster upcloud nodes diagnose

Dispatch the platform’s read-only node diagnose job and wait for its report: over the bastion SSH lane it snapshots the node’s OS-level state - the Kubernetes service unit and its journal, disk, memory, uptime, the kernel log and the firewall path to the API server - and names the symptoms it finds. Nothing on the node is changed. This is what to reach for when a node is NotReady or its kubelet stopped posting status, below what ‘cluster get’ can see. The same diagnosis the Ankra assistant runs as ssh_diagnose_node. The platform waits up to two minutes for the job; a slower run hands back the operation id to poll with ‘cluster operations list’, and repeated calls attach to the run already in flight. Find node ids with ‘nodes list’. Needs the clusters.operate permission on the cluster.
Flags

ankra cluster upcloud nodes get

Show full spec and metadata for a single node
Flags

ankra cluster upcloud nodes list

List all nodes for the cluster
Flags

ankra cluster upcloud nodes restart

Schedule a native reboot (falling back to a power cycle) of the node as a tracked operation. The node must be in the ‘up’ state and have no restart already in flight. Workloads on the node are briefly unavailable while it reboots. Works for any node returned by ‘nodes list’, including the bastion/gateway.
Flags

ankra cluster upcloud os-patches

Unattended upgrades hold back the packages whose maintainer scripts restart networking in place; the rolling OS patch lane installs them instead, one host at a time, drained and returned to service before the next.

ankra cluster upcloud os-patches node-policy

Write the node OS update hold - the apt policy that keeps unattended upgrades away from the packages that restart networking - on the nodes named with --node, on every node with --all-nodes, and on the bastion with --include-bastion. The rolling OS patch lane writes and lifts it on its own; this is the by-hand route. Writing it is refused unless the cluster’s OS patch policy is enabled; --revert removes it and is always allowed. The command asks first (--yes skips, declining exits 4). Needs clusters.operate.
Flags

ankra cluster upcloud os-patches plan

Run the dry run on every host and report what each would install, which held-back security updates are pending, whether a reboot would follow, and the order ‘run’ would take. The platform waits about 40 seconds; a slower plan hands back its operation id, and ‘status’ shows it once it finishes. Needs clusters.operate.
Flags

ankra cluster upcloud os-patches policy

Show or change the cluster’s OS patch policy

ankra cluster upcloud os-patches policy get

Show the OS patch policy and its maintenance window
Flags

ankra cluster upcloud os-patches policy set

Change the cluster’s OS patch policy. Only the flags passed are changed. Turning the policy off also removes the node OS update hold from every host, and is refused while a run or a node OS policy operation is in flight. Needs clusters.write.
Flags

ankra cluster upcloud os-patches run

Start the rolling patch: each host is drained, patched, rebooted when the packages ask for it, and returned to service before the next. Workloads move between nodes while it runs, so the command asks first (--yes skips, declining exits 4). Outside the policy’s maintenance window the platform refuses unless --outside-window is passed. Stateful nodes follow the policy unless --include-stateful-nodes or --exclude-stateful-nodes says otherwise; the bastion is patched last unless --exclude-bastion. Follow the run with ‘status’ or ‘ankra cluster operations list’. Needs clusters.operate.
Flags

ankra cluster upcloud os-patches status

Show the OS patch policy, the newest run and the security-lag verdict
Flags

ankra cluster upcloud start

Start (re-provision) a stopped UpCloud cluster. Use --scope control_plane to bring up only the control plane.
Flags

ankra cluster upcloud stop

Stop an UpCloud cluster’s compute while keeping its configuration so it can be started again later. --force also deletes the cluster’s load balancers. The CSI storage volumes are kept, forced or not, and keep billing while the cluster is stopped; deprovision the cluster to delete them.
Flags

ankra cluster upcloud workers

Get current worker count for an UpCloud cluster
Flags

ankra cluster upcloud zones

Extend the zone pool of an UpCloud cluster created with --network-mode wireguard_mesh (or with --zones). Pass the full desired pool, primary zone first: zones can only be added, never removed, and the pool must keep at least 3 zones with 3 control planes. Every new zone gets its own private network and NAT gateway; node groups added or scaled afterwards spread across the grown pool, and the cloud-provider stack republishes with load balancers and volumes scoped to the primary zone.
Flags

ankra cluster update

Set the environment of an existing cluster - production, staging, development, testing, local, or a name of your own - and the reporting level its insights are graded at. The environment is what alert rules, dynamic cluster groups and the cluster list filter on; ‘local’ also stops offline alerts for the cluster. The reporting level decides how severe the cluster’s findings are graded: production reports everything the scan finds, and staging, development and disposable each need a wider blast radius before an issue is treated as critical. A preset environment brings its usual reporting level, the same pairing the portal writes: production, staging and development keep their own name, testing is graded as development and local as disposable. --criticality overrides it. An environment of your own leaves the reporting level as it is unless --criticality is given. An ImportCluster file can declare the environment too, as metadata.environment: ‘ankra cluster apply’ creates a new cluster with it, and fills it in on an existing cluster only where nobody chose the label yet. A value set here is never reverted by a file, so it stays until it is changed here or in the portal. Who chose a label is recorded from the credential: your own token records you, a service account records automation. The cluster is given by name or id, as the argument or with --cluster. An update never falls back to the cluster selected with ‘ankra cluster select’: that selection is shared by every shell and agent session on the machine, and the environment decides dynamic cluster groups and the access they grant, alert silencing (‘local’) and whether Ankra AI may remediate the cluster on its own (never on production), so a relabel aimed at the wrong cluster could switch that on for a production cluster.
Examples
Flags

ankra cluster upgrade

Upgrade the Kubernetes version on all nodes in a cloud cluster. The cloud provider (Hetzner, OVH, UpCloud, DigitalOcean, Scaleway, Ankra Cloud, AWS, Proxmox VE, or HPE Morpheus) is detected automatically from the cluster, so you do not need to remember which provider it runs on. Both kubeadm and k3s clusters are supported; list the available target versions with ‘ankra cluster kubeadm-versions’ or ‘ankra cluster k3s-versions’. Nodes upgrade one at a time (control plane first, then workers): each node is cordoned, drained respecting PodDisruptionBudgets, upgraded, and gated on being Ready at the target version before the rollout moves on. An etcd snapshot is taken before the control plane upgrade. A drain blocked by a PodDisruptionBudget aborts the rollout; pass --force to proceed anyway. Downgrades and skipping minor versions are not supported. The upgrade preflight runs first and is printed before anything changes (run it alone with ‘ankra cluster upgrade preflight’). A blocking check stops the upgrade with exit code 8 and nothing changed; --force goes past only the PodDisruptionBudget block, never the version, catalogue or restore-point checks. Examples:
Flags

ankra cluster upgrade preflight

Run the read-only upgrade preflight for a hop to <target_version>. Each check answers pass, warn, block or skipped, with a sentence and the evidence:
A warning or a skipped check whose evidence could not be read was NOT checked; it did not pass. ‘ankra cluster upgrade’ runs the same preflight first. Exit codes: 0 when the verdict is ready (warnings included), 8 when a check blocks. Examples:
Flags

ankra cluster upgrade rollback-record

Repair a cluster’s Kubernetes version record after its nodes were rolled back by hand from a failed version hop. A failed hop leaves the platform’s record pinning the new version, and the platform then re-runs the hop as soon as it may act again. This writes every control plane’s record back to <version> and up, each worker to <version> (or to the newer version it runs), and the cluster’s Kubernetes version to <version>. The platform refuses it unless an operations hold is in force with at least 10 minutes left, no write is running on the cluster, and its last read of every control plane shows exactly <version> (as the node reports it, e.g. v1.34.5+k3s1). Then wait for ‘ankra cluster operations hold get’ to show the record confirmed before lifting the hold. This is an Ankra staff operation: set ANKRA_STAFF_SESSION and pass the cluster by id. It asks for confirmation unless --yes is given. Examples:
Flags

ankra cluster validate

Validate an ImportCluster YAML file. The local structural, dependency, and YAML checks run first (the same ones as ‘ankra cluster apply --dry-run’), then the file is sent to the Ankra API for server-side validation that the offline checks cannot perform:
  • chart existence in the Helm registries connected to your organisation
  • plaintext Kubernetes Secret / unencrypted addon value detection
  • parent references resolved against a cluster’s existing resources
Nothing is applied. Use --cluster <name|id> to validate the spec against an existing cluster’s deployed resources, and --strict-secrets to treat plaintext secrets as errors instead of warnings.
Flags

ankra cluster variables

Manage cluster-scoped variables that are available to every stack on the cluster as template substitutions in manifests and addon values. Cluster variables shadow organisation variables of the same name on this cluster.
When --cluster is omitted, the active selection is used.

ankra cluster variables delete

Delete a cluster variable
Flags

ankra cluster variables get

Get a single cluster variable
Flags

ankra cluster variables list

List variables for a cluster
Flags

ankra cluster variables set

Create or update a cluster variable (upsert). The value can be read from stdin by passing ”-”.
Flags

ankra cluster worker-heal

When a worker node has been NotReady for about ten minutes while every control plane is Ready, Ankra can restart that one node through your cloud provider: one worker of a cluster at a time and at most once per node per day, only on a cluster Ankra provisioned. It never stops, deprovisions or scales anything, and when the restart does not bring the node back the cluster’s notifications name the node. The switch is per cluster and on by default. Turning it off leaves a NotReady worker for you to handle. Changing it needs permission to change cluster settings (clusters.write). Examples

ankra cluster worker-heal get

Show whether Ankra may restart a NotReady worker of the cluster, and the latest episode: which node, how it ended or why Ankra is not restarting it yet, and whether the platform acted or only recorded what it would have done (shadow). -o json prints the platform’s answer as it is.
Examples
Flags

ankra cluster worker-heal set

Turn Ankra’s automatic restart of a NotReady worker on or off for the cluster. --enabled is required, so a change is always explicit. Turning it off sends nothing anywhere, so this does not ask for confirmation. Every change is recorded in the organisation’s audit log.
Examples
Flags