Skip to main content
Ankra provisions and manages Cloud Managed Kubernetes - the create dialog’s term for clusters whose control plane your cloud provider runs. Ankra handles everything on top: node pools, Kubernetes upgrades, add-ons, stacks, GitOps, and AI-assisted operations. This page is the shared overview. Each provider has its own guide with the specifics:

DigitalOcean (DOKS)

UpCloud (UKS)

Google (GKE)

OVHcloud (MKS)

Azure (AKS)

Amazon (EKS)

Scaleway Kapsule (Closed Beta)

Ankra Cloud Kubernetes (Closed Beta)

Closed beta. Scaleway - Kapsule and Ankra Managed clusters on Scaleway Instances alike - is in closed beta and enabled per organisation on request; until it is, Scaleway does not appear as a provider. Contact support to have it turned on for your organisation.Closed beta. Ankra Cloud - Ankra Cloud Kubernetes and Ankra Managed clusters on Ankra Cloud servers alike - is in closed beta and enabled per organisation on request; until it is, Ankra Cloud does not appear as a provider. Contact support to have it turned on for your organisation.

Cloud Managed or Ankra Managed

The create dialog offers two kinds of cluster. Cloud Managed (this page) is usually the fastest path when your provider offers it. Ankra Managed clusters are built by Ankra on your own servers or cloud account, give you full control of the control plane, and run anywhere you have compute - see Build a new cluster and Operate an Ankra Managed Cluster. Both kinds get the same Ankra surface on top: stacks, GitOps, add-ons, node groups or pools, upgrades, and AI-assisted operations.
Surface coverage. The portal, API, and AI assistant cover all eight providers. The ankra CLI covers them too (--provider doks|uks|gke|ovh_mks|aks|eks|kapsule|ankracloud_k8s, Ankra Cloud Kubernetes from v0.24.0): create, delete, stop and start (where the provider supports it), node-pool add, scale, update, and delete with autoscaling bounds, upgrades, and cluster discovery and import (ankra cluster managed discover|import, v0.11.0 or later). AKS control-plane options (network plugin, SKU tier, private cluster, maintenance window) are CLI flags from v0.14.0; other providers’ control-plane options (HA, release channel, and so on) are set from the portal or the API.

Prerequisites

One provider credential, stored in Ankra. See Credentials for the per-provider setup: GitOps is optional: connect a repository during creation and Ankra commits the cluster’s stack definitions to Git.

Live options and pricing

Every choice in the create flow is fetched live from the provider with your credential - regions, Kubernetes versions (with support windows), node sizes, and prices, including spot capacity and quota-aware availability where the provider exposes it. Nothing is hardcoded, so new instance families and price changes show up automatically. The create wizard renders these options for you; you can also fetch them from the API:
The response lists locations, versions / version_options (with supported_until where the provider publishes it), sizes (vCPUs, memory, disk, GPU, monthly price), cluster_plans, and capabilities (spot, autoscaling, autopilot, private endpoint, HA control plane).

Creating a managed cluster

Via the Platform UI

1

Navigate to Clusters

Go to Clusters → Create Cluster and pick your provider’s Cloud Managed action.
2

Credential & Location

Select the provider credential and a region. Locations load live from the provider.
3

Node Pools

Define one or more worker pools: name, node size (with live pricing and a monthly cost summary), count, labels, and - where supported - autoscaling bounds.
4

Kubernetes

Pick a Kubernetes version (or keep the provider default) and any provider-specific control plane options - HA (DOKS), control-plane plan (UKS), release channel / Autopilot (GKE), plan and update policy (OVH MKS), network plugin, private cluster and SKU tier (AKS), or subnets and control-plane logging (EKS).
5

GitOps (optional)

Connect a Git repository so the cluster’s stacks are committed to Git.
6

Preflight & Create

Ankra runs provider preflight checks (credential validity, quota, name availability) before submitting. Failures block creation; warnings are shown for review. A live progress view then tracks control plane provisioning, node pools, kubeconfig retrieval, and Ankra Agent installation.

Via the CLI

The latest stable CLI’s --provider flag accepts doks, uks, gke, ovh_mks, aks, eks and kapsule. Optional flags include --kubernetes-version, the GitOps trio (--gitops-credential-name, --gitops-repository, --gitops-branch), and --autoscaling with --autoscaling-min/--autoscaling-max for the initial pool. The CLI create sends a single initial node pool. AKS takes its control-plane options as flags (--network-plugin, --sku-tier, --private-cluster, --maintenance-window); other providers’ control-plane options (HA, release channel, and so on) are set from the portal or the API below. See the CLI reference for every flag.

Via the API

Run the same payload against POST /org/clusters/managed/{provider}/preflight first to get the provider checks without creating anything.

Provider-specific options

Each provider takes its own control-plane and networking options - HA (DOKS), control-plane plan (UKS), release channel and Autopilot (GKE), plan and update policy (OVH MKS), network plugin and SKU tier (AKS), or subnets and control-plane logging (EKS). The exact fields for each are documented on the per-provider pages and in the Managed Kubernetes reference: DOKS · UKS · GKE · OVH MKS · AKS · EKS

Importing existing clusters

Already running managed Kubernetes? Discover clusters at the provider and adopt them into Ankra without touching them. Discovery and import run from the portal, the CLI or the API for every provider:
In the portal, click Create cluster in Clusters and choose Import existing at the bottom of the dialog. Discovery marks clusters that are already imported, so you can’t adopt the same cluster twice. After import, Ankra fetches the kubeconfig, installs the Ankra Agent, and the cluster gains the same day-2 operations as clusters Ankra created.

Scaleway Kapsule (Closed Beta)

Closed beta. Scaleway Kapsule is in closed beta. The workflow is stable but the surface may still change, and it is enabled per organisation on request - until it is, Kapsule does not appear in the create dialog and its endpoints are not served. Contact support to have it turned on for your organisation.
Scaleway runs the Kapsule control plane; Ankra creates the cluster and its pools in your Scaleway Project, or imports one you already run. For Kubernetes that Ankra builds on Scaleway Instances instead, see Scaleway Clusters. Before you create:
  • A Scaleway credential whose IAM application carries the Kapsule permission sets.
  • An existing Private Network in the same Project and region. Kapsule clusters always attach to one, and Ankra refuses a network that belongs to an Ankra Managed cluster’s own infrastructure (tagged ankra-cluster-<id>), because it is deleted with that cluster.
  • For pools without public IPs (public_ip: false), a Public Gateway attached to that Private Network with masquerade on and the default route pushed. Ankra does not create it; preflight checks for it.
  • CNI is one of the available_cnis the chosen Kubernetes version offers (cilium, cilium_native or calico) and cannot be changed later.
  • Pools take zone, root_volume_type (l_ssd, b_ssd, sbs_5k, sbs_15k), root_volume_size_gb, security_group_id, public_ip, autohealing and upgrade_policy (surge, unavailable, balanced). Autoscaling needs a minimum of at least 1.
  • Private API endpoints are refused; leave private_endpoint false or out.
  • Stop and start are not offered for Kapsule.
Import. ankra cluster managed discover --provider kapsule --credential-id <id> scans fr-par, nl-ams and pl-waw. When a region cannot be read, the result is marked incomplete; fix access to that region before you import, because a partial scan cannot tell whether a cluster is already imported.

Day-2 operations

Node pools

The CLI scales node pools to a fixed count on any provider, and ankra cluster managed node-pool add|update take --autoscaling with --autoscaling-min/--autoscaling-max. Autoscaling bounds are available on every provider except UKS, where Ankra does not manage autoscaling; see externally managed node pools. AKS pool names are lowercase alphanumeric and at most 12 characters.

Externally managed node pools

Ankra never changes a managed pool’s node count on its own. There is no drift correction on node counts and no scheduled job that writes them, and a Kubernetes upgrade only sets the version. The count changes only when someone scales the pool, sends a PATCH with a count, or replaces the pool with a different size (which recreates it at the count Ankra has stored). When something outside Ankra owns a pool’s count, such as a cluster autoscaler you run yourself on a provider where Ankra does not manage autoscaling, mark the pool as externally managed so those explicit writes are refused too:
externally_managed is sent on its own, not combined with other pool fields, and setting it makes no call to the provider. While it is set:
  • Scale, a count update, delete and size replacement on that pool are refused with Node pool is externally managed; clear externally_managed before changing it through Ankra. This covers the portal, the CLI, the API and Ankra AI, which has no way to clear the flag itself.
  • The pool listing returns externally_managed: true and an observed_count read live from the provider. count stays the last value Ankra wrote, and Ankra never copies the observed count over it.
Send {"externally_managed": false} to hand the pool back. A pool created directly at the provider after the cluster was imported is not in Ankra’s definition at all, so Ankra cannot change it either way.

Kubernetes upgrades

Ankra lists the upgrade targets the provider actually offers for your cluster’s current version. In the portal, Settings → General → Kubernetes Version shows available upgrades with their support windows. You can also upgrade any provider from the CLI:
The provider upgrades the control plane first, then rolls node pools. Downgrades are not supported.

Stopping and starting

Stop/start is capability-gated per provider and is available for AKS only today. In the portal, use Settings → General → Danger Zone, or use the CLI:
Stopping an AKS cluster deallocates its compute while preserving its configuration. Starting brings the same managed cluster back. The portal, CLI, API, and AI/MCP surfaces only offer these actions when the provider reports supports_stop_start.

Deleting

Deleting a managed cluster destroys it at the provider - control plane, node pools, and workloads. Clean up provider-created LoadBalancers and volumes first if the CCM/CSI created any outside the cluster’s own resource group or VPC.

What does not apply to managed clusters

Because the provider owns the control plane, some lifecycle operations that exist for Ankra Managed clusters are not applicable here:
  • Stop / start - capability-gated and currently available only for AKS, as described above.
  • Control-plane topology editing (controller count, control-plane instance type) - the provider sizes and manages the control plane. HA control planes, where offered, are selected at creation.
  • Instance-type upgrade in place - change node sizing by editing or replacing a node pool, not by resizing individual nodes.

Ankra AI

Ankra’s AI can operate Cloud Managed Kubernetes on every provider - DOKS, UKS, GKE, OVHcloud MKS, AKS, EKS, Scaleway Kapsule and Ankra Cloud Kubernetes (the closed-beta providers only where they are enabled). Ask it to:
  • “What does a 3-node e2-standard-4 GKE cluster in europe-west1 cost?” - it fetches live options and pricing with your credential
  • “Create an AKS cluster in West Europe with autoscaling 2 to 5 nodes” - it proposes the create for your confirmation
  • “What EKS clusters exist in our AWS account?” - it discovers clusters at the provider and shows which are already imported
  • “Import the staging GKE cluster” - it adopts a discovered cluster after you confirm
  • “Stop the development AKS cluster” - it proposes the capability-gated stop operation for your confirmation
Creates, imports, and lifecycle writes always require an explicit confirmation in chat before anything is submitted.

Troubleshooting