llmstxt-state.json

{
  "version": 1,
  "generator_version": 3,
  "project_name": "Immutable Infrastructure Documentation",
  "summary": "Immutable Infrastructure product documentation covering Cluster API-based Kubernetes cluster lifecycle management, provider support, installation, upgrades, node operations, machine configuration, and Kubernetes API references.",
  "generated_at": "2026-05-16T06:24:44Z",
  "include_patterns": [
    "docs/en/*.md",
    "docs/en/*.mdx",
    "docs/en/**/*.md",
    "docs/en/**/*.mdx"
  ],
  "exclude_patterns": [
    "README.md",
    "**/README.md",
    "node_modules/**",
    "**/node_modules/**",
    ".git/**",
    "**/.git/**",
    ".llmstxt-cache/**",
    "**/.llmstxt-cache/**",
    "**/__pycache__/**",
    "**/*.pyc",
    ".venv/**",
    "**/.venv/**",
    "venv/**",
    "**/venv/**",
    "dist/**",
    "**/dist/**",
    "build/**",
    "**/build/**",
    "**/.DS_Store",
    ".next/**",
    "**/.next/**",
    "llms.txt",
    "**/llms.txt",
    "llmstxt-state.json",
    "**/llmstxt-state.json"
  ],
  "grouping_base_path": "docs/en",
  "description_max_words": 150,
  "files": {
    "docs/en/apis/cluster_api/addons/clusterresourceset.mdx": {
      "sha256": "f82b021bac70a666d155112c54dc306d7ebc3ab4de2b3572953434debc140e57",
      "size": 285,
      "description": "CRD reference page for `ClusterResourceSet` in the `addons.cluster.x-k8s.io/v1beta1` API group, rendered from the live `clusterresourcesets.addons.cluster.x-k8s.io` CRD schema. ClusterResourceSet selects workload clusters via label selectors and applies a set of ConfigMap/Secret-packaged resources (CNI plugins, storage drivers, other add-ons) to them.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/addons/clusterresourcesetbinding.mdx": {
      "sha256": "308893c7df078c1ad50e1f8500f449c13e1c7dd98972580c49a42cf20dc80dd5",
      "size": 327,
      "description": "CRD reference page for `ClusterResourceSetBinding` in the `addons.cluster.x-k8s.io/v1beta1` API group, generated from the `clusterresourcesetbindings.addons.cluster.x-k8s.io` CRD. Each binding tracks, per workload cluster, which ClusterResourceSet resources have already been applied and their hashes so add-ons aren't re-applied on every reconciliation.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/addons/index.mdx": {
      "sha256": "cbf6a96571c037762c70585f925cba0b210ceffc140b2eee76467b6a8faa1ae6",
      "size": 127,
      "description": "Index for the Cluster API Add-on APIs section, covering the `addons.cluster.x-k8s.io/v1beta1` CRDs (`ClusterResourceSet`, `ClusterResourceSetBinding`) used to distribute Kubernetes add-on manifests to fleets of Cluster API workload clusters.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/cluster.mdx": {
      "sha256": "6e1c94455805345cb9a69015adb78ca754fe085f899be7a8228c45636487d0f0",
      "size": 198,
      "description": "CRD reference page for the core `Cluster` resource in `cluster.x-k8s.io/v1beta1`, rendered from the `clusters.cluster.x-k8s.io` schema. The Cluster object is the top-level Cluster API resource that ties together an infrastructure provider reference, a control plane reference, networking configuration (pod/service CIDRs, service domain), and topology when using ClusterClass.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/clusterclass.mdx": {
      "sha256": "fa6f58890ec5215aaa625be30b57405f855a277771d03fb28ac345a85a43992a",
      "size": 230,
      "description": "CRD reference page for `ClusterClass` in `cluster.x-k8s.io/v1beta1`, generated from `clusterclasses.cluster.x-k8s.io`. ClusterClass defines a reusable cluster template with infrastructure/control-plane/worker class references, variables, and JSON-patch-based variants, enabling managed-topology clusters to be instantiated declaratively from a single class.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/index.mdx": {
      "sha256": "5407e6e4103e34feb9d59727160c1c9326501bfcbc81890876036457f09ebdfc",
      "size": 123,
      "description": "Index for the Cluster API Core APIs section, listing the `cluster.x-k8s.io/v1beta1` CRDs: `Cluster`, `ClusterClass`, `Machine`, `MachineSet`, `MachineDeployment`, `MachinePool`, `MachineHealthCheck`, and `MachineDrainRule`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/machine.mdx": {
      "sha256": "397e28334e05ac3547f222ef6e9855b64945caad65921363818ea8770a96d658",
      "size": 198,
      "description": "CRD reference page for `Machine` in `cluster.x-k8s.io/v1beta1`, rendered from the `machines.cluster.x-k8s.io` schema. A Machine represents the desired state of one Kubernetes node, pairing an infrastructure-provider machine reference with a bootstrap data source and surfacing provider IDs, node refs, and conditions for that node's lifecycle.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/machinedeployment.mdx": {
      "sha256": "53db5a2d404af9692126e8f0eadf442613fc07463a0cc4190d9e1992367a5776",
      "size": 258,
      "description": "CRD reference page for `MachineDeployment` in `cluster.x-k8s.io/v1beta1`, generated from `machinedeployments.cluster.x-k8s.io`. MachineDeployment provides rolling-update and rollback semantics for worker nodes by managing the underlying MachineSets, analogous to how Kubernetes Deployments manage ReplicaSets of Pods.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/machinedrainrule.mdx": {
      "sha256": "679eaa1f081068906fb3018e3ccbc62eab5055fc436f84b4fc2bc5f55f26a8d0",
      "size": 252,
      "description": "CRD reference page for `MachineDrainRule` in `cluster.x-k8s.io/v1beta1`, rendered from `machinedrainrules.cluster.x-k8s.io`. MachineDrainRule customises how Cluster API drains nodes during deletion or upgrade, letting operators match pods (by namespace/label selectors) and override the default drain behaviour with `Drain`, `Skip`, or `WaitCompleted` semantics.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/machinehealthcheck.mdx": {
      "sha256": "76b710e51870a3b5708d05ec6497b04304a91d5a1f486add838bd3b72eb8fb44",
      "size": 264,
      "description": "CRD reference page for `MachineHealthCheck` in `cluster.x-k8s.io/v1beta1`, generated from `machinehealthchecks.cluster.x-k8s.io`. MachineHealthCheck watches Machines against unhealthy-condition rules (e.g. `Ready=False` for N minutes) and triggers automatic remediation, deleting unhealthy Machines so the owning MachineSet/MachineDeployment can re-provision replacements.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/machinepool.mdx": {
      "sha256": "473c2051448de6e25c478afbb23190bef1af9605c70fd7396f4240dcfe8403c6",
      "size": 222,
      "description": "CRD reference page for `MachinePool` in `cluster.x-k8s.io/v1beta1`, rendered from `machinepools.cluster.x-k8s.io`. MachinePool delegates lifecycle management of a group of worker nodes to the underlying cloud provider's native scaling primitives (e.g. AWS ASGs, Azure VMSS), instead of representing each node as an individual Machine.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/core/machineset.mdx": {
      "sha256": "5f55c70cebdf89b399a0814bfb4271442568a115f742637964d3ec0915b1d36f",
      "size": 216,
      "description": "CRD reference page for `MachineSet` in `cluster.x-k8s.io/v1beta1`, generated from `machinesets.cluster.x-k8s.io`. MachineSet ensures a specified number of Machine replicas matching a template are running at any time, providing the lower-level replica-management primitive that MachineDeployment builds on for rolling updates.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/hosted_control_plane/datastore.mdx": {
      "sha256": "c3eb3e6d42612fe434f35fc66c8c0c46a1cd146e3a0ce3a95709913d38f7129e",
      "size": 247,
      "description": "CRD reference page for `DataStore` in the Kamaji API group `kamaji.clastix.io/v1alpha1`, rendered from `datastores.kamaji.clastix.io`. DataStore declares an external etcd, MySQL, PostgreSQL, or NATS backend that Kamaji uses to persist the Kubernetes state of hosted tenant control planes, with TLS/credentials configured via referenced Secrets.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/hosted_control_plane/index.mdx": {
      "sha256": "d721f74d7e5486ed9e8cf5ad58af0233269999603242ffec87892e278abd3cbc",
      "size": 245,
      "description": "Index for the Hosted Control Plane APIs section, covering the Kamaji-based (`kamaji.clastix.io`) CRDs such as `DataStore` that back Cluster API hosted-control-plane deployments where tenant Kubernetes control planes run as pods on a management cluster.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/hosted_control_plane/kamajicontrolplane.mdx": {
      "sha256": "7c45cceaf18c26cc617945bc29d4b9607eef5176facf5ffb623add225bb5b436",
      "size": 337,
      "description": "CRD reference for `kamajicontrolplanes.controlplane.cluster.x-k8s.io` (`controlplane.cluster.x-k8s.io/v1alpha1`), the Cluster API control-plane provider resource that bridges a CAPI `Cluster` to a Kamaji-hosted Kubernetes control plane. Used to declaratively spin up hosted control planes for tenant clusters without dedicated control-plane nodes; the rendered K8sCrd component lists the full field schema.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/hosted_control_plane/kamajicontrolplanetemplate.mdx": {
      "sha256": "8ee03b84066eab02cae1dde8644e2cf3c5ade8d7803c0bb21ebc23466edd7188",
      "size": 385,
      "description": "CRD reference for `kamajicontrolplanetemplates.controlplane.cluster.x-k8s.io` (`controlplane.cluster.x-k8s.io/v1alpha1`), the template object referenced by `ClusterClass` to generate `KamajiControlPlane` instances when creating clusters via topology/managed-topology workflows. Holds the reusable spec for hosted control planes.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/hosted_control_plane/tenantcontrolplane.mdx": {
      "sha256": "923b90ee68650049fea8a7891d703f1efce5cb1347abc4436be08becb4a757cc",
      "size": 301,
      "description": "CRD reference for `tenantcontrolplanes.kamaji.clastix.io` (`kamaji.clastix.io/v1alpha1`), the Kamaji-native object that represents the actual hosted Kubernetes control plane (kube-apiserver, controller-manager, scheduler, etcd backend) running as pods on the management cluster. This is the lower-level resource that `KamajiControlPlane` reconciles into.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/index.mdx": {
      "sha256": "e79b256d713fdb969ddfcc6f5294d8a8d2223794feb09c557e3d2f7ab9c04f56",
      "size": 239,
      "description": "Top-level index for the Cluster API reference section, scoping the CRD documentation that follows to the cluster-lifecycle resources Immutable Infrastructure consumes (bootstrap, control-plane, IPAM, runtime extension groups under `*.cluster.x-k8s.io`).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/ipam/index.mdx": {
      "sha256": "264dccae967f2f410f6816992b385a2c9a22ff15b11252b8329e91cc14ce884a",
      "size": 123,
      "description": "Section overview for the Cluster API IPAM CRDs (`ipam.cluster.x-k8s.io`), the provider-agnostic API used to claim and allocate static IP addresses for cluster machines from in-cluster IP pools.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/ipam/ipaddress.mdx": {
      "sha256": "d16a087b867d0d61455653cc55e9ea07ea10f8c70c754c3deee0688981cb4803",
      "size": 228,
      "description": "CRD reference for `ipaddresses.ipam.cluster.x-k8s.io` (`ipam.cluster.x-k8s.io/v1alpha1`), the resource an IPAM provider writes to bind an allocated IP, gateway, prefix, and DNS settings to a satisfied `IPAddressClaim`. Consumers (typically infra-provider machines) read it to wire static networking.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/ipam/ipaddressclaim.mdx": {
      "sha256": "85dee7d7dbf8b0db0f11aae47df40ee89bbc0d64a3b5180e72b1e6558754af2c",
      "size": 256,
      "description": "CRD reference for `ipaddressclaims.ipam.cluster.x-k8s.io` (`ipam.cluster.x-k8s.io/v1alpha1`), the claim object a machine or template creates against a named IP pool; an IPAM provider watches claims and responds by creating a matching `IPAddress`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/kubeadm_bootstrap/index.mdx": {
      "sha256": "7096da3a05b8e1a8cd836757addf79c07b59aa6252ec965817970e66a8afb9a1",
      "size": 125,
      "description": "Section overview for the Kubeadm bootstrap-provider CRDs (`bootstrap.cluster.x-k8s.io`), which generate the cloud-init/ignition userdata that turns a fresh node into a kubeadm-joined Kubernetes member.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/kubeadm_bootstrap/kubeadmconfig.mdx": {
      "sha256": "f24233a27b3e78f3c96aa31363c8d0bd4385443243388a6daace64a7316289d4",
      "size": 297,
      "description": "CRD reference for `kubeadmconfigs.bootstrap.cluster.x-k8s.io` (`bootstrap.cluster.x-k8s.io/v1beta1`), the per-machine bootstrap config consumed by the Kubeadm bootstrap provider; encapsulates `InitConfiguration`/`JoinConfiguration`, files, preKubeadm/postKubeadm commands, users, NTP, and produces the rendered userdata secret used by the infrastructure machine.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/kubeadm_bootstrap/kubeadmconfigtemplate.mdx": {
      "sha256": "fa5f0c83fbd014956b6938b519b9f4e606e3c98876bad164d3e359f0ed0d7462",
      "size": 345,
      "description": "CRD reference for `kubeadmconfigtemplates.bootstrap.cluster.x-k8s.io` (`bootstrap.cluster.x-k8s.io/v1beta1`), the template referenced by `MachineDeployment`, `MachinePool`, and `ClusterClass` to stamp out worker `KubeadmConfig` instances with a shared bootstrap recipe.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/kubeadm_control_plane/index.mdx": {
      "sha256": "2941a4c1c7ece7735240bcaefecbde5499b877131ed1fbeb986ab547d6c6af36",
      "size": 133,
      "description": "Section overview for the Kubeadm control-plane provider CRDs (`controlplane.cluster.x-k8s.io`), the stacked-etcd kubeadm-based alternative to hosted control planes used when control-plane nodes run on dedicated machines.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/kubeadm_control_plane/kubeadmcontrolplane.mdx": {
      "sha256": "72dc902f74bb5ea22cd878f93875971b4f521d531330b5b2e93daf17c7fc4cb2",
      "size": 342,
      "description": "CRD reference for `kubeadmcontrolplanes.controlplane.cluster.x-k8s.io` (`controlplane.cluster.x-k8s.io/v1beta1`), the control-plane provider object that owns control-plane `Machine` objects, drives kubeadm init/join, manages rolling updates of the kube-apiserver/etcd, and exposes replica/version fields for upgrades and scaling.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/kubeadm_control_plane/kubeadmcontrolplanetemplate.mdx": {
      "sha256": "c9a6c2be11ea8a8a66e72da247dff9dd1a5b8277c7dc943cec248254862d4dfe",
      "size": 390,
      "description": "CRD reference for `kubeadmcontrolplanetemplates.controlplane.cluster.x-k8s.io` (`controlplane.cluster.x-k8s.io/v1beta1`), the template referenced by `ClusterClass` to instantiate `KubeadmControlPlane` objects for clusters created through the managed-topology flow.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/runtime/extensionconfig.mdx": {
      "sha256": "1431ba6839386511458375553e329efa1a59a92b6d984d7e1b3671c019dc355c",
      "size": 271,
      "description": "CRD reference for `extensionconfigs.runtime.cluster.x-k8s.io` (`runtime.cluster.x-k8s.io/v1alpha1`), the registration object that wires a Runtime SDK extension server (lifecycle hooks, topology mutation, etc.) into the Cluster API runtime so reconcilers will dispatch hook calls to it.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/cluster_api/runtime/index.mdx": {
      "sha256": "ef9f3d2388a5ce502bd4a15d7ca43a71d9d1a4a493dbf194cab8ccc61a58e805",
      "size": 129,
      "description": "Section overview for the Cluster API Runtime SDK CRDs (`runtime.cluster.x-k8s.io`), which let operators plug in external webhook-style extensions that intercept cluster lifecycle hooks and topology mutations.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/index.mdx": {
      "sha256": "4bcd357fc96a51b3b593ac85ee840ea9f73c2ff4db23fd71b29ddf9a0b9a6f9b",
      "size": 70,
      "description": "Top-level landing page for the API Reference section of Alauda Container Platform's Immutable Infrastructure docs, rendering an auto-generated overview of every CRD group documented under apis/ (Cluster API core, addons, IPAM, hosted/kubeadm control plane and bootstrap, runtime, machine configuration, and per-provider resources).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/intro.mdx": {
      "sha256": "ba573e272a43d002cda4be47046ab94646c34a62222106375a4e866a83493722",
      "size": 55,
      "description": "Introduction page for the ACP Immutable Infrastructure API surface that injects the shared <AcpApisOverview /> component, summarizing the Kubernetes-native CRDs the product exposes for declarative cluster and node lifecycle management.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/machine_configuration/index.mdx": {
      "sha256": "178000c3dfbc06a7e4b7fa59bc1eb20085b2b031f86402305284e0d2f493668b",
      "size": 286,
      "description": "Section landing page for the machineconfiguration.alauda.io API group, framing MachineConfig, MachineConfigPool, and MachineConfiguration as the CRDs that declaratively describe node operating system state (files, units, kernel arguments) for Immutable Infrastructure nodes.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/machine_configuration/machineconfig.mdx": {
      "sha256": "fd83e50544421673e0fb21c22de88ada583e5b82464630680cfc6a425213c65f",
      "size": 277,
      "description": "Renders the auto-generated CRD reference for `machineconfigs.machineconfiguration.alauda.io/v1alpha1`, the resource that carries individual OS-level configuration fragments (ignition-style files, systemd units, kernel arguments, SSH keys) that the Machine Config Operator merges and applies to nodes selected via MachineConfigPool labels.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/machine_configuration/machineconfigpool.mdx": {
      "sha256": "e94f6793fbfbf5b5552cccee88179ae55b52957be0c6a1f5a95615e1899849aa",
      "size": 301,
      "description": "CRD reference for `machineconfigpools.machineconfiguration.alauda.io/v1alpha1`, the pool resource that groups nodes by label selector, aggregates matching MachineConfigs into a rendered configuration, and drives rolling, controlled rollouts of OS changes across that node set.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/machine_configuration/machineconfiguration.mdx": {
      "sha256": "d2b4529aab092d422a2abacb017ac0207fda2e74145aa35d96170224598f7d60",
      "size": 319,
      "description": "CRD reference for the cluster-singleton `machineconfigurations.machineconfiguration.alauda.io/v1alpha1` resource, which holds top-level operator settings (such as managed component behavior and global rollout policy) for the Machine Config Operator controlling all MachineConfigPools.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/bare-metal/index.mdx": {
      "sha256": "c068bf351dbbc4f1c73e263244e552a2cf53d5da3255f70495c780f1ac7fff0d",
      "size": 373,
      "description": "Placeholder landing page marking the Bare Metal infrastructure provider as Planned; lists the upcoming `MetalCluster`, `MetalMachine`, and `MetalMachineTemplate` CRDs that will model Kubernetes cluster infrastructure and individual servers on bare metal hardware.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-cloud-stack/hcscluster.mdx": {
      "sha256": "00bd4960440f3d9579155c661a3166675d5ed2ff0baf22c5aa861a97f0e0cb9c",
      "size": 291,
      "description": "CRD reference for `hcsclusters.infrastructure.cluster.x-k8s.io/v1beta1`, the Cluster API infrastructure resource representing a Kubernetes cluster's networking and control-plane endpoint on Huawei Cloud Stack (VPC, subnets, security groups, load balancer) and reconciled by the HCS infrastructure provider.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-cloud-stack/hcsmachine.mdx": {
      "sha256": "d8a7ee557a1d3b79a9342839f61f3d7cdb0bae80752cc9f0d002e3578087ef51",
      "size": 285,
      "description": "CRD reference for `hcsmachines.infrastructure.cluster.x-k8s.io/v1beta1`, the per-instance Cluster API infrastructure resource that maps a Cluster API Machine onto a concrete HCS ECS virtual machine (flavor, image, volumes, network ports) and tracks its provider ID and readiness.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-cloud-stack/hcsmachineconfigpool.mdx": {
      "sha256": "d02455b24f521864e545bc5c8a4b5ab6022599c74546599ca6f6d40661fc622e",
      "size": 318,
      "description": "CRD reference for `hcsmachineconfigpools.infrastructure.cluster.x-k8s.io/v1beta1`, the HCS pool resource that holds pre-allocated IP addresses, hostnames, and related per-node configuration drawn down when HCSMachineTemplate instantiates new VMs.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-cloud-stack/hcsmachinetemplate.mdx": {
      "sha256": "15fb2bb25ed005a536d347df2165d5e0bc684a971403f8de5919945a9ec69505",
      "size": 309,
      "description": "CRD reference for `hcsmachinetemplates.infrastructure.cluster.x-k8s.io/v1beta1`, the immutable template consumed by Cluster API MachineDeployments and KubeadmControlPlanes to stamp out identically configured HCSMachine VMs (flavor, image, disks, network).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-cloud-stack/index.mdx": {
      "sha256": "a0c8115ea69d9bc746c72139e310a98493f21e1d9ced65032cfc2a6a94cd44fe",
      "size": 948,
      "description": "Index page for the Huawei Cloud Stack infrastructure provider, enumerating its four CRDs (HCSCluster, HCSMachine, HCSMachineTemplate, HCSMachineConfigPool) under the API group `infrastructure.cluster.x-k8s.io/v1beta1` and linking to each detailed reference.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-dcs/dcscluster.mdx": {
      "sha256": "033a380ed05b31bbdfba871b164ef741e3c868a136919fa67a6a14adafb517bc",
      "size": 171,
      "description": "CRD reference for `dcsclusters.infrastructure.cluster.x-k8s.io/v1beta1`, the Cluster API infrastructure resource representing the cluster-level networking (VPC, subnets, security groups, load balancer endpoint) of a Kubernetes cluster running on the Huawei DCS platform.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-dcs/dcsiphostnamepool.mdx": {
      "sha256": "89b34440b1b7e1688e67d2504c949bad53b69784bf0853d607daa6264cb89f78",
      "size": 185,
      "description": "CRD reference for `dcsiphostnamepools.infrastructure.cluster.x-k8s.io/v1beta1`, the DCS pool resource that pre-allocates static IP addresses and hostnames so that newly created DCSMachine instances receive deterministic network identities at provisioning time.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-dcs/dcsmachine.mdx": {
      "sha256": "ea4825e7587c440bd7e00d61cbdfdd226054c54a92ed9d728a04913b23014ca9",
      "size": 171,
      "description": "CRD reference for `dcsmachines.infrastructure.cluster.x-k8s.io/v1beta1`, the per-instance Cluster API infrastructure resource that maps a Cluster API Machine onto a concrete DCS virtual machine (image, flavor, volumes, network attachments) and tracks its lifecycle state.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-dcs/dcsmachinetemplate.mdx": {
      "sha256": "1f77e190d7793d5257f34109df19c926e02df917007da6c74a2650fac911ca62",
      "size": 187,
      "description": "CRD reference for `DCSMachineTemplate` (`dcsmachinetemplates.infrastructure.cluster.x-k8s.io/v1beta1`), the template resource consumed by Cluster API to stamp out `DCSMachine` instances when scaling node pools on Huawei DCS infrastructure. Schema is rendered live via the `K8sCrd` component from the cluster.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/huawei-dcs/index.mdx": {
      "sha256": "569f41d2bea6c52ba5ae62d7f9c40d0eecec5bde03e4148048fc5fc393a6642e",
      "size": 773,
      "description": "Landing page for the Huawei DCS Infrastructure Provider API group `infrastructure.cluster.x-k8s.io/v1beta1`, indexing the four custom resources it ships: `DCSCluster` (cluster infrastructure), `DCSMachine` (a DCS virtual machine), `DCSMachineTemplate` (machine creation template), and `DCSIpHostnamePool` (pool of IPs and hostnames). Each row links to the per-CRD reference page.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/index.mdx": {
      "sha256": "b2ec9fa69f737fef4b9911144be685e1a57de0934536620f9875de8e2b5f47fc",
      "size": 50,
      "description": "Top-level entry point for the Provider APIs section of the reference, rendered through the `Overview` component to surface child pages for each Cluster API infrastructure provider (DCS, SSH, user-provisioned, VMware vSphere).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/ssh/index.mdx": {
      "sha256": "914f53c598fd3819ac95d2f992c6b32929cf92b88d5fda4b43c660abf723ba0c",
      "size": 222,
      "description": "Landing page for the SSH Infrastructure Provider API reference, which defines custom resources for installing and operating Kubernetes on pre-provisioned hosts reached over SSH. Aggregates links to the `SSHCluster`, `SSHMachine`, `SSHMachineTemplate`, and `SSHHost` CRD pages.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/ssh/sshcluster.mdx": {
      "sha256": "0cbedbcab5349fca3dc4eda80160362a4e17a16b4efd210ff6f5fe46d19976f9",
      "size": 261,
      "description": "CRD reference for `SSHCluster` (`sshclusters.infrastructure.cluster.x-k8s.io/v1beta1`), the infrastructure object that backs a Cluster API `Cluster` when the control plane and workers are provisioned on user-managed Linux hosts via SSH. Schema is auto-rendered through the `K8sCrd` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/ssh/sshhost.mdx": {
      "sha256": "f4228b30eaafb859abceca68fbd7c487a4ffd375f4330d1d2fa852a0ea1b810c",
      "size": 243,
      "description": "CRD reference for `SSHHost` (`sshhosts.infrastructure.cluster.x-k8s.io/v1beta1`), describing an individual reachable host inventory entry (address, credentials, labels) that the SSH provider can consume when binding an `SSHMachine` to physical or virtual hardware.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/ssh/sshmachine.mdx": {
      "sha256": "6238234a70eae1a8ff7e9e3990fafa2e05476ad3e9b26db1726b52672c06cde1",
      "size": 261,
      "description": "CRD reference for `SSHMachine` (`sshmachines.infrastructure.cluster.x-k8s.io/v1beta1`), the per-node infrastructure object the SSH provider reconciles against a target host to bootstrap kubelet and join the cluster. Live schema rendered through `K8sCrd`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/ssh/sshmachinetemplate.mdx": {
      "sha256": "b1ddc3d6fe6d7e1118f7be3c25bef8b04f234eda2bcb3fa74173f1c62dac6549",
      "size": 309,
      "description": "CRD reference for `SSHMachineTemplate` (`sshmachinetemplates.infrastructure.cluster.x-k8s.io/v1beta1`), the template stamped by Cluster API control plane and `MachineDeployment` controllers to produce new `SSHMachine` instances when scaling node pools backed by SSH-reachable hosts.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/user_provisioned/index.mdx": {
      "sha256": "196836337d9d86bd8b529670f3ac575a8e0216f259fad0f758dfb6198835eed6",
      "size": 304,
      "description": "Landing page for the User-Provisioned Infrastructure Provider API reference, covering the CRDs used to model clusters where the customer brings their own machines and the provider only orchestrates Kubernetes lifecycle on top.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/user_provisioned/userprovisionedcluster.mdx": {
      "sha256": "dfe3231ec1d8d99a379e1fca1a3b833d1268d5dbda380670900853aecadc4aff",
      "size": 333,
      "description": "CRD reference for `UserProvisionedCluster` (`userprovisionedclusters.infrastructure.cluster.x-k8s.io/v1beta1`), the infrastructure object that fronts a Cluster API `Cluster` when the user supplies their own physical or virtual machines instead of letting a cloud provider create them.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/user_provisioned/userprovisionedmachine.mdx": {
      "sha256": "f95c9c4b36b4ab79c2bca07c08873b322801d152a7f8f8172725450f97c2ae5d",
      "size": 333,
      "description": "CRD reference for `UserProvisionedMachine` (`userprovisionedmachines.infrastructure.cluster.x-k8s.io/v1beta1`), the per-node infrastructure object representing a customer-supplied machine that the user-provisioned provider tracks as a Cluster API `Machine`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/user_provisioned/userprovisionedmachinepool.mdx": {
      "sha256": "6670c96a9bde465c16e2735589ee405a822a839e028331b169ea6435673903ae",
      "size": 357,
      "description": "CRD reference for `UserProvisionedMachinePool` (`userprovisionedmachinepools.infrastructure.cluster.x-k8s.io/v1beta1`), the pool-based infrastructure object used with Cluster API `MachinePool` to manage a collection of user-supplied nodes as a single scalable unit.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/index.mdx": {
      "sha256": "82e8492ab7823a14260cc5bb03bc6174b55a81fe0eb273857bcc95fe321effa7",
      "size": 1881,
      "description": "Landing page indexing the VMware vSphere Infrastructure Provider's nine CRDs under `infrastructure.cluster.x-k8s.io/v1beta1`, including `VSphereCluster`, `VSphereClusterIdentity`, `VSphereMachine`, low-level `VSphereVM`, `VSphereMachineTemplate`, `VSphereMachineConfigPool` (pre-defined node slots with static IPs and persistent disks), `VSphereFailureDomain`, `VSphereDeploymentZone`, and `VSphereClusterTemplate` for ClusterClass-driven managed topologies.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vspherecluster.mdx": {
      "sha256": "2030af7224d47545816fea124cb6d538be9d61da7484f1af493e07a718007d60",
      "size": 306,
      "description": "CRD reference for `VSphereCluster` (`vsphereclusters.infrastructure.cluster.x-k8s.io/v1beta1`), the infrastructure object that ties a Cluster API `Cluster` to a vCenter server, control-plane endpoint, and `identityRef`-bound vCenter credentials. Schema is rendered live via the `K8sCrd` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vsphereclusteridentity.mdx": {
      "sha256": "2862e8edf4a7261808279ea7f4df796b96e3331b96090fdd6b957c78123806a9",
      "size": 842,
      "description": "CRD reference and explanation for `VSphereClusterIdentity` (`vsphereclusteridentities.infrastructure.cluster.x-k8s.io/v1beta1`), a cluster-scoped credential that lets multiple `VSphereCluster` objects across namespaces share a single vCenter credential gated by namespace selectors, as an alternative to per-cluster `Secret`-based `identityRef`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vsphereclustertemplate.mdx": {
      "sha256": "54599a6c5307d6ca25304fc04bae7ab0fe8019d6b458f4a1bbe124367549c2e8",
      "size": 332,
      "description": "API reference page for the `VSphereClusterTemplate` CRD (`vsphereclustertemplates.infrastructure.cluster.x-k8s.io/v1beta1`) used to define reusable VSphereCluster topologies for Cluster API ClusterClass-based provisioning. Renders the live CRD schema via the `<K8sCrd>` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vspheredeploymentzone.mdx": {
      "sha256": "b38a88660416f536cdecb2735d992bb7fce365eb026a084a6d0678f0c1ee1ae6",
      "size": 329,
      "description": "API reference page for the `VSphereDeploymentZone` CRD (`vspheredeploymentzones.infrastructure.cluster.x-k8s.io/v1beta1`), which pairs a `VSphereFailureDomain` with placement constraints (such as `resourcePool`) to target a specific vCenter deployment target for control plane or worker nodes. Renders the live CRD schema via the `<K8sCrd>` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vspherefailuredomain.mdx": {
      "sha256": "495b441dff63bc6d4f29499370da76595073614a56b0457d35436409940109f0",
      "size": 320,
      "description": "API reference page for the `VSphereFailureDomain` CRD (`vspherefailuredomains.infrastructure.cluster.x-k8s.io/v1beta1`), which models a vSphere region/zone topology spanning datacenter, compute cluster, datastore, and networks for failure-domain-aware machine placement. Renders the live CRD schema via the `<K8sCrd>` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vspheremachine.mdx": {
      "sha256": "41e7ff5395cfdee7690aa323859500697a5d62464a9d90fdf9c96bca0ec5bd51",
      "size": 300,
      "description": "API reference page for the `VSphereMachine` CRD (`vspheremachines.infrastructure.cluster.x-k8s.io/v1beta1`), the per-node CAPV infrastructure resource that links a Cluster API `Machine` to its backing vCenter VM. Renders the live CRD schema via the `<K8sCrd>` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vspheremachineconfigpool.mdx": {
      "sha256": "a9f95353eef9f97eb358f63d47ae6eea31e26c30432006805544eed884d4d04b",
      "size": 333,
      "description": "API reference page for the `VSphereMachineConfigPool` CRD (`vspheremachineconfigpools.infrastructure.cluster.x-k8s.io/v1beta1`), which predefines node slots with hostname, datacenter, static-IP NIC layout (primary plus additional), and `persistentDisks` for CAPV machines. Renders the live CRD schema via the `<K8sCrd>` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vspheremachinetemplate.mdx": {
      "sha256": "6553a382d15c297240f162927db9fc58045af5a9b49e455786c67104ac25ed9d",
      "size": 324,
      "description": "API reference page for the `VSphereMachineTemplate` CRD (`vspheremachinetemplates.infrastructure.cluster.x-k8s.io/v1beta1`), the template referenced by `KubeadmControlPlane` and `MachineDeployment` to clone VMs with fields such as `server`, `template`, `cloneMode`, `diskGiB`, `numCPUs`, and `machineConfigPoolRef`. Renders the live CRD schema via the `<K8sCrd>` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/apis/providers/vmware-vsphere/vspherevm.mdx": {
      "sha256": "66e31639c0248ec382f228783a7d58aa5016171e3a128ab54dc3e0b2da888f9b",
      "size": 552,
      "description": "API reference page for the `VSphereVM` CRD (`vspherevms.infrastructure.cluster.x-k8s.io/v1beta1`), the low-level controller-managed resource that represents the in-vCenter virtual machine backing a `VSphereMachine`; operators inspect it directly to troubleshoot cloning, IP allocation, and power-state issues. Renders the live CRD schema via the `<K8sCrd>` component.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/bare-metal.mdx": {
      "sha256": "e44e193a6e40f99c0206e122a1b9297fca98f3752763dbf44b51a4266a996d6d",
      "size": 549,
      "description": "Placeholder page for creating Kubernetes clusters on bare-metal servers, marked Planned. Lists future feature areas such as BMC/IPMI remote management, in-place upgrade support, hardware inventory, and bare-metal network configuration, and links to the Bare Metal Provider overview.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/huawei-cloud-stack.mdx": {
      "sha256": "98d9b70bd852bf377a2e28ccc91fe93ba7818d897845fa4a32d79372c88a6ed0",
      "size": 25287,
      "description": "End-to-end guide for provisioning a Cluster API workload cluster on Huawei Cloud Stack using the Alauda Container Platform HCS Infrastructure Provider and Kubeadm Provider plugins. Walks through HCS credential `Secret` setup, building `HCSMachineConfigPool` (hostnames, subnets, static IPs), `HCSMachineTemplate` (`imageName`/`flavorName`/`availabilityZone`, root/data volumes for `/var/lib/etcd`, `/var/lib/kubelet`, `/var/lib/containerd`, `/var/cpaas`), a hardened `KubeadmControlPlane` (PSA admission, audit policy, encryption-at-rest, TLS 1.2+), the `HCSCluster` (provider-created ELB with Hybrid Load Balancing, `vipAddress`, L4/L7 virsubnet IPs, kube-ovn `networkType`, VPC, subnet inventory, security group), and the top-level `Cluster` with annotations such as `cpaas.io/kube-ovn-join-cidr` and `cluster-type: HCS`, ending with kubectl verification of `KubeadmControlPlane` and `ClusterModule` status.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/huawei-dcs.mdx": {
      "sha256": "6e4f6de592c5d54556da0f2b0c7cd0ed456cab73146dcd31f6c09b1396abcc55",
      "size": 37799,
      "description": "Comprehensive how-to for creating Kubernetes clusters on Huawei DCS via both the web UI 5-step wizard (Basic Info, Control Plane Node Pool, Worker Node Pools, Networking, Review) and YAML manifests. Covers the DCS Provider plugin version gates (1.0.13 for UI, 1.0.16 for pool-managed `persistentDisk`), `DCSCluster`/`KubeadmControlPlane`/`DCSMachineTemplate`/`DCSIpHostnamePool`/`MachineDeployment` resources, the `PROVIDER_ID`/`NODE_IP` magic tokens substituted at join time, the `cpaas.io/dcs-vm-template` ConfigMap that supplies Kubernetes/CoreDNS/etcd version values, the `dcs-kubernetes-<version>-files` Secret for shared admission/audit/kubelet patch content, single-control-plane (`replicas: 1`) layout where `controlPlaneLoadBalancer.host` equals the master node IP, and required cluster annotations (`cpaas.io/kube-ovn-join-cidr`, `cpaas.io/kube-ovn-version`, `cpaas.io/registry-address`, `cpaas.io/nodes-mode: self-managed`).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/index.mdx": {
      "sha256": "e22256ba29501e369bc97b97524c633c193e20bd14ad964eeb849e4eecab78e8",
      "size": 1448,
      "description": "Landing page for the Creating Clusters section, summarizing prerequisites (infrastructure resources, x86-64-v2 ISA baseline for x86_64 nodes running ACP MicroOS images) and routing to provider-specific guides for Huawei DCS, Huawei Cloud Stack, VMware vSphere (all Available), and Bare Metal (Planned).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/vmware-vsphere/create-cluster-in-global.mdx": {
      "sha256": "e7af0ab4a2cb58ffe3dcb6f1d6560fdb4334c9ba30a699ffea562100d5b1f404",
      "size": 44145,
      "description": "Step-by-step baseline workflow for creating a CAPV-managed VMware vSphere workload cluster from the `global` cluster using standard CAPV mode (direct vCenter connection, one datacenter, one NIC per node, static IP via `VSphereMachineConfigPool`). Details the eight numbered manifests in a `capv-cluster/` directory (namespace, vCenter `Secret`, control-plane and worker `VSphereMachineConfigPool` with `var-cpaas`/`var-lib-containerd`/`var-lib-etcd` persistent disks, `Cluster`+`VSphereCluster`, `ClusterResourceSet` delivering the vSphere CPI ConfigMap/Secret/manifests with `vsphere-cloud-controller-manager` DaemonSet, `VSphereMachineTemplate`+`KubeadmControlPlane`, and `VSphereMachineTemplate`+`KubeadmConfigTemplate`+`MachineDeployment` for workers), the `capv-load-local-images.sh` script that imports `/root/images/*.tar` into containerd including the matching `sandbox_image`, validation of `ClusterResourceSet=true` and the `public-registry-credential` Secret, plus extensive troubleshooting for CPI delivery, slot binding, IP allocation, and `linkedClone` vs `fullClone` system-disk sizing.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/vmware-vsphere/extension-scenarios.mdx": {
      "sha256": "2cbc57a147fa1def8475d48550ecb39c560c010be771a2be5ad78f98801247a5",
      "size": 12187,
      "description": "How-to for extending a running baseline CAPV vSphere cluster with optional features: adding a second NIC via `network.additional` in `VSphereMachineConfigPool` and a second device in `VSphereMachineTemplate` (plus `VSphereFailureDomain.spec.topology.networks` when failure domains are on), enabling multiple datacenters by creating per-DC `VSphereFailureDomain` and `VSphereDeploymentZone` objects and setting `VSphereCluster.spec.failureDomainSelector: {}` for control planes plus `MachineDeployment.spec.template.spec.failureDomain` (using the deployment-zone name) for workers, appending extra data disks (including raw `/dev/disk/by-capv/<name>` symlinks when `mountPath` is omitted), and scaling out workers by first adding `VSphereMachineConfigPool` node slots before raising `MachineDeployment.spec.replicas`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/vmware-vsphere/index.mdx": {
      "sha256": "8a617d030eb30ef97780312032c5f8acca7ffd3c28bacf8815dcc825e4aedb64",
      "size": 1427,
      "description": "Index for the VMware vSphere cluster creation section, prescribing the reading order: Parameter Checklist, the baseline create-in-global workflow, and Extension Scenarios. States the baseline scope (one datacenter, one NIC per node, three control plane nodes, one worker, static IP via `VSphereMachineConfigPool`) and directs operators to extension scenarios for larger topologies.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/create-cluster/vmware-vsphere/parameter-checklist.mdx": {
      "sha256": "48101f61980312cf8a92ef9750caf7dd0418cdd65983f00da2e0f478cd10cd52",
      "size": 25898,
      "description": "Pre-deployment checklist that enumerates every placeholder needed by the CAPV baseline manifests and extension scenarios, with example values, validation commands, and a blank `Actual Value` column. Covers management-cluster prerequisites (`cluster-api-provider-vsphere`/`cluster-api-provider-kubeadm` plugins, `ClusterResourceSet=true`), vCenter connection details, VM template requirements (cloud-init, open-vm-tools, containerd, pre-loaded `/root/images/*.tar` matching the configured `sandbox_image`), `<clone_mode>` and `<power_off_mode>` semantics, control-plane VIP/port 6443 readiness, cluster baseline parameters (Pod/Service CIDRs, kube-ovn join CIDR, image registry, CoreDNS/etcd image tags, AES encryption-provider secret), the openssl command to obtain the vCenter thumbprint, single-datacenter NIC and node-slot values, required persistent disks per role (`var-cpaas`, `var-lib-containerd`, and `var-lib-etcd` with `wipeFilesystem: true`), vSphere CPI parameters, and optional extension parameters for multi-datacenter failure domains and second-NIC topology.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/global/disaster_recovery.mdx": {
      "sha256": "c7b83e02f640b486c8f804096ab78d28bd902221c2d03f30905dafc8fe162137",
      "size": 3600,
      "description": "Entry point for disaster recovery of a `global` cluster running on Immutable Infrastructure, covering the deploy-time DR configuration that ties primary and standby clusters together: shared Kubernetes API server encryption provider, etcd `serverCertSANs` including the DR VIP, `DCSCluster.spec.encryptionProviderConfigRef` for Huawei DCS, the `/etc/kubernetes/encryption-provider.conf` file entry written via `KubeadmControlPlane.kubeadmConfigSpec.files` for Huawei Cloud Stack, and the `global-etcd-sync` plugin installed on the standby. Lists post-install operational tasks (verifying replication lag, decrypting Secrets, validating the DR VIP, executing failover and failback) and notes that VMware vSphere and bare-metal DR are planned.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/global/index.mdx": {
      "sha256": "43a15b39a4002f8e8464a52597dc02dd5c3e2cfecd2b60e761dd67f16863339f",
      "size": 1112,
      "description": "Section landing page introducing the `global` cluster — the platform's control plane that hosts the registry, base operator, cluster registry, and identity stack — and scoping the Immutable Infrastructure subsection to the `global` cluster's own lifecycle (install, upgrade, DR). Cross-links out to provider plugin installation, infrastructure resources, workload cluster creation, and workload cluster upgrades for topics that fall outside this section.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/global/install.mdx": {
      "sha256": "f62dcaf6ecad4f3a46427fbabbc9d6401dee64ccdf9bbd99437c92daa693b724",
      "size": 39431,
      "description": "End-to-end procedure for installing the `global` control-plane cluster onto MicroOS via Cluster API on Huawei DCS or Huawei Cloud Stack, including KIND bootstrap (`minialauda`), uploading the Core Package, applying `AppRelease` manifests for `cluster-api-provider-kubeadm` plus `cluster-api-provider-dcs`/`cluster-api-provider-hcs`, authoring the provider-specific `Cluster`/`KubeadmControlPlane`/`DCSCluster`/`HCSCluster` manifest with `is-global: true` labels and `format: ignition`, posting the installer JSON to `/cpaas-installer/api/config/dcs`, and optional DR additions (shared encryption Secret, DR VIP in `serverCertSANs`, `dcs-import-extra-resources` ConfigMap, and `global-etcd-sync` ModuleInfo on the standby).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/global/upgrade.mdx": {
      "sha256": "2486f49d01bf7b068fb773f4f3084aedc4638904aa27b8d96cc94e2ee797ae93",
      "size": 10489,
      "description": "Procedure for the Kubernetes/OS-image phase (Phase 2) of upgrading a `global` cluster on Immutable Infrastructure: create new `DCSMachineTemplate` or `HCSMachineTemplate` resources with the target MicroOS `vmTemplateName`/`imageName`, retarget `KubeadmControlPlane.spec.machineTemplate.infrastructureRef` and each `MachineDeployment` to the new templates, keep `rollingUpdate.maxSurge: 0` so fixed IPs and pool-managed persistent disks (`/var/cpaas` declared in `DCSIpHostnamePool.spec.pool[].persistentDisk`) can be reused, then monitor rolling node replacement via `kubectl get machines`/`kubeadmcontrolplane`. Includes rollback notes (etcd backup restore, manifest revert) and warns that single-control-plane HCS clusters are not supported by this workflow.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/how-to/dcs_persistent_disk_upgrade.mdx": {
      "sha256": "fd1de8ba44c36c8eb8d7bcb8b52474a01cae63ed0162d9f2dd87be2b2bc0626e",
      "size": 10755,
      "description": "Migration runbook for moving an existing Huawei DCS cluster from the legacy template-disk layout (data disks declared in `DCSMachineTemplate`) to the pool-managed persistent-disk model in `DCSIpHostnamePool.spec.pool[].persistentDisk`, required on ACP `v4.2.1`+/DCS provider `v1.0.16`+. Walks through inspecting current `sequenceNum` values, computing the `slot = oldSequenceNum - 1 - newTemplateDataDiskCount - 1` formula to identify tail-contiguous claimable disks, editing the existing `DCSMachineTemplate` in place to drop preserved disks, declaring them on the IP pool (including the platform-required `/var/cpaas`), patching `rolloutAfter` on `KubeadmControlPlane`/`MachineDeployment` with `maxSurge: 0`, and verifying claim/detach/convert/reattach via `status.persistentDiskStatus` phases (`Attached`, `Available`, `Error`).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/how-to/index.mdx": {
      "sha256": "399c78c59b6b3bee3cf5e191b85cc95998b720889513f6321dc3192f300b9cf1",
      "size": 78,
      "description": "Section landing page that aggregates the how-to runbooks (machine health checks, node label/annotation/taint propagation, DCS persistent-disk migration, cluster-stuck-in-`Provisioned` troubleshooting) via the `<Overview />` component; no procedural content of its own.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/how-to/machine-health-check.mdx": {
      "sha256": "fd0b240d2f60e57d841e47bc33b564799511872a4b1fb208d2a49525dc52de56",
      "size": 3339,
      "description": "Walks through creating Cluster API `MachineHealthCheck` resources in the `cpaas-system` namespace of the management cluster, both for `MachineDeployment`-owned workers (using `cluster.x-k8s.io/deployment-name` selectors and `nodeStartupTimeout`) and for control planes (selecting `cluster.x-k8s.io/control-plane: \"\"` with `maxUnhealthy: 1`). Defines `Ready=Unknown`/`Ready=False` unhealthy conditions with 600s timeouts and calls out the etcd-leader-with-kubelet-down failure mode plus the quorum-loss risk for aggressive control-plane MHC settings; reminds readers that remediation deletes the Machine and any node-local disks attached to it.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/how-to/node-configuration.mdx": {
      "sha256": "414535f7434db563b169a863af011abd46d61ed13740c4cfb742cd13c9001964",
      "size": 6397,
      "description": "Shows how to propagate Cluster API Machine metadata onto Kubernetes Nodes by passing `--additional-sync-machine-labels` and `--additional-sync-machine-annotations` (both regex-capable) to `capi-controller-manager`, then declaring the keys on `MachineDeployment.spec.template.metadata.labels`/`annotations` and `KubeadmControlPlane.spec.machineTemplate.metadata.labels`/`annotations`. Also documents declaring taints on `.spec.template.spec.taints` (workers) or `.spec.machineTemplate.taints` (control plane) so they apply during node registration, with `kubectl get machine/node -o jsonpath` verification commands; requires Alauda Container Platform v4.2.0+.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/how-to/troubleshoot-cluster-not-ready.mdx": {
      "sha256": "1c038cb1c0dbfbb8e342ae89ef8219ebc916b569d60e822222e41d985d916dcd",
      "size": 8762,
      "description": "Diagnoses a workload cluster that reaches `Cluster.status.phase=Provisioned` and `KubeadmControlPlane.status.ready=true` but whose nodes stay `NotReady` because the CNI (`KubeOvn` on DCS, equivalent on HCS) is never deployed. Identifies the signature in the infrastructure-provider reconciler logs (`ServiceAccount \"sentry\" not found`) and validates the four import invariants on the `global` cluster: `clusters.platform.tkestack.io/<name>` exists, `capi.cpaas.io/imported` label is present (use `jq`, not jsonpath), exactly one `ClusterCredential` is labelled for the cluster, and the workload-cluster `cpaas-system/sentry` ServiceAccount exists. Notes that restarting `cluster-transformer` does not retry a failed import — recovery requires platform support, orphan-credential cleanup, and recreating the workload cluster.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/index.mdx": {
      "sha256": "ea8d719fb06b69c8f8fa90c79d3ec2a67457c854f2c664fb78f523febe3f6960",
      "size": 48,
      "description": "Top-level English documentation landing page for the Immutable Infrastructure platform, rendering a navigation overview component that links to the major sections (overview, install, create-cluster, manage-nodes, upgrade-cluster, machine-configuration, infrastructure, how-to, global, and the Cluster API reference).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/infrastructure/huawei-cloud-stack.mdx": {
      "sha256": "5ead440bddf10d79d702f579d199d6fa38f48bdce373c41a5a280d82d97cae61",
      "size": 11775,
      "description": "Pre-YAML preparation checklist for Huawei Cloud Stack clusters covering every input consumed by the `Secret`, `HCSMachineConfigPool`, `HCSMachineTemplate`, `KubeadmControlPlane`, and `HCSCluster` manifests in `cpaas-system`: `accessKey`/`secretKey`/`projectID`/`externalGlobalDomain`/`region` for the credential Secret; API-recognized `imageName`/`flavorName`/`availabilityZone` (which tenants cannot read from the UI); root and data volume layout (`/var/lib/etcd`, `/var/lib/kubelet`, `/var/lib/containerd`, `/var/cpaas`); VPC, security group, and full subnet inventory (`name`, `id`, `neutronSubnetId`, `cidr`, `gatewayIp`, DNS); and the fixed-address control plane ELB plan (`vipAddress`, `vipSubnetName`, two-entry `elbVirsubnetL4Ips`/`L7Ips`, optional `vipDomainName`). Also documents multi-NIC limitations and that `spec.controlPlaneEndpoint` is controller-filled.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/infrastructure/huawei-dcs.mdx": {
      "sha256": "ba6ca1ce90750efc979b99acb211dd9c871c8a3af45ed59571eaa025459f736f",
      "size": 32639,
      "description": "Reference for the three Huawei DCS infrastructure CRDs in `cpaas-system`: the `Secret` (`Opaque`, `authUser`/`authKey`/`endpoint` plus optional `userType: interconnect`|`domain`) created via web UI or YAML/`stringData`; `DCSIpHostnamePool` for per-node IP/mask/gateway/DNS/hostname/`machineName` and (YAML-only since provider `v1.0.16`) `persistentDisk` entries that bind disks like `/var/cpaas` to an `(ip, slot)` identity so they survive VM replacement; and `DCSMachineTemplate` for VM template name, `location`, `resource` (`type: cluster|host`), CPU/memory, and `dcsMachineDiskSpec` for system/`/var/lib/kubelet`/`/var/lib/containerd`/`/var/lib/etcd` disks. Includes DCS-side preflight guidance (`datastoreClusterName` vs `datastoreName`, capacity checks, DRS host placement, diagnosing VMs stuck in `creating`/`Provisioning`).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/infrastructure/index.mdx": {
      "sha256": "ca94e1e8ceeddb373fa5c2c95a77b2ed329335c12107aadb03ac45419aa95408",
      "size": 1414,
      "description": "Index page for the Infrastructure Resources section that enumerates the per-provider preparation pages (Huawei DCS, Huawei Cloud Stack) and the four resource categories — cloud credentials, IP pools, machine templates, and network/load-balancer plans — that must be configured before creating clusters. Links downstream to cluster creation, node management, and upgrade sections.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/install/bare-metal.mdx": {
      "sha256": "12ea618bec2c7c326c95fc7c339da6b2403ee4ed4933cb8036525e06d6725df3",
      "size": 407,
      "description": "Placeholder for the Bare Metal Infrastructure Provider installation; documentation is marked `Planned` pending development and links to the bare-metal provider overview.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/install/huawei-cloud-stack.mdx": {
      "sha256": "c841b42763c88609af5f1c457590a6af56bd3e827f29091c5bcdfa2582a7757a",
      "size": 1913,
      "description": "Installation procedure for the Huawei Cloud Stack Infrastructure Provider as a cluster plugin on the `global` cluster: download the **Alauda Container Platform Kubeadm Provider** and **Alauda Container Platform HCS Infrastructure Provider** from Customer Portal, follow the shared ACP `upload_package` and `cluster_plugin` flows, then verify by checking `kubectl get pods -n cpaas-system | grep hcs` and confirming the `hcsclusters`/`hcsmachines`/`hcsmachinetemplates`/`hcsmachineconfigpools.infrastructure.cluster.x-k8s.io` CRDs are registered.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/install/huawei-dcs.mdx": {
      "sha256": "4eab90d16619577b2b631c8738d8214b0c665e882b1d4f310a83a17c827df5a0",
      "size": 1687,
      "description": "Installation procedure for the Huawei DCS Infrastructure Provider as a cluster plugin on the `global` cluster: download the **Alauda Container Platform Kubeadm Provider** and **Alauda Container Platform DCS Infrastructure Provider** from Customer Portal, follow the shared ACP `upload_package` and `cluster_plugin` flows, then verify by checking `kubectl get pods -n cpaas-system | grep dcs` and confirming the `dcsclusters`/`dcsmachines`/`dcsmachinetemplates`/`dcsiphostnamepools.infrastructure.cluster.x-k8s.io` CRDs are registered.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/install/index.mdx": {
      "sha256": "6982824e204ce92bfa62e139a3c984205a7b009fc27df29353967213d3979279",
      "size": 1251,
      "description": "Landing page for installing infrastructure provider plugins on the `global` cluster, listing the universal Alauda Container Platform Kubeadm Provider requirement and the three-step workflow (download from Customer Portal, upload, install). Links out to platform-specific guides for Huawei DCS, Huawei Cloud Stack, and VMware vSphere; Bare Metal is marked as planned.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/install/vmware-vsphere.mdx": {
      "sha256": "3fb8e98b7f1174cde00f08a239a0bfb5db506043178e5b84de631eca5e3f1acb",
      "size": 2365,
      "description": "How-to for installing the Alauda Container Platform VMware vSphere Infrastructure Provider (CAPV) alongside the Kubeadm Provider on the `global` cluster. Covers downloading both plugin packages from Customer Portal, uploading them, installing them as cluster plugins, and verifying with `kubectl get minfo -l cpaas.io/module-name=cluster-api-provider-vsphere`, the matching kubeadm-provider module, and the presence of `vsphere*.infrastructure.cluster.x-k8s.io` CRDs.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/machine-configuration/index.mdx": {
      "sha256": "c23b548347e97a7165f001a6570bf92105328d29bbb9bf471e56664bd6350fbc",
      "size": 108,
      "description": "Top-level index page for the Machine Configuration section, rendering the auto-generated overview of child pages (overview, managing node configuration, node disruption policies).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/machine-configuration/managing.mdx": {
      "sha256": "25f9123d00d22be8cb9d5df00d225dec031f40dc39a809f6a46b1b13e2515e67",
      "size": 6061,
      "description": "Task-oriented recipes for authoring `MachineConfig` objects (apiVersion `machineconfiguration.alauda.io/v1alpha1`, Ignition 3.4.0) targeted at machine-config pools via the `machineconfiguration.alauda.io/role` label. Shows three concrete examples: deploying a custom `/etc/chrony.conf` via base64-encoded Ignition file source, disabling `chronyd.service` through a systemd unit override, and installing an SSH authorized key for the `boot` user. Also explains how to recover a `Degraded` node from configuration drift either by hand-reverting files or by creating `/run/machine-config-daemon-force` to force the daemon to re-apply and reboot.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/machine-configuration/node_disruption.mdx": {
      "sha256": "40b4aebca96f57f78be03040156a22dc184bb97969e911c1553d9e89b23a3187",
      "size": 4586,
      "description": "Explains how to author `nodeDisruptionPolicy` and `defaultNodeDisruptionPolicySpecAction` fields on the cluster-wide `MachineConfiguration` CR (kind `MachineConfiguration`, name `cluster`) to control what happens when files, systemd units, or SSH keys change. Enumerates the available actions (`Reboot`, `None`, `Drain`, `Restart`, `DaemonReload`), shows the installed defaults (no action for files, drain+reboot for units, no action for sshkey), and gives examples for switching all file changes to `Reboot` or routing a specific path such as `/usr/local/bin/myapp.sh` to `DaemonReload` plus a targeted `Restart` of `myapp.service` without rebooting.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/machine-configuration/overview.mdx": {
      "sha256": "afb34f519a57178f2199fb9730990b5a49606ce8d9058a44523cd8ab3735a3f2",
      "size": 7165,
      "description": "Conceptual reference for Machine Configuration, defining the `MachineConfig` and `MachineConfigPool` CRDs, the auto-created `master`/`worker` pools and `00-master`/`00-worker` configs, custom worker pool inheritance, the rendered `render-<pool>-<hash>` config flow, the cordon/drain/apply/reboot/uncordon update sequence executed by `machine-config-daemon`, drift detection that marks nodes `Degraded`, and the `kubectl get machineconfigpool` / `kubectl get machineconfig` / per-node annotation queries used to inspect status (`Done`, `Working`, `Degraded`).",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/manage-nodes/bare-metal.mdx": {
      "sha256": "6238cd6ef02cc7a11c25a68082a955af3b3cb59511b00d407431258c3af5fa36",
      "size": 224,
      "description": "Placeholder page for managing worker nodes on bare metal servers. Marked `Planned`; full content will be added once development begins.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/manage-nodes/huawei-cloud-stack.mdx": {
      "sha256": "58cdc7d82b5efbb05e5307be1ef196cd674d63a930f7364dc341e437cea5744c",
      "size": 17139,
      "description": "Workflow for managing HCS worker nodes through Cluster API `Machine` resources. Walks through building an `HCSMachineConfigPool` (per-VM hostname, subnet selector with `subnetName`/`subnetId`, static IP), an `HCSMachineTemplate` (provider-recognized `flavorName`/`availabilityZone`, root volume, mandatory data volumes for `/var/lib/kubelet`, `/var/lib/containerd`, `/var/cpaas`), a `KubeadmConfigTemplate` that wires the controller-injected `kubelet.crt`/`kubelet.key` via a kubelet `KubeletConfiguration` patch, and a `MachineDeployment` to orchestrate replicas. Also covers scaling up/down with `kubectl patch`, upgrading specs by minting a new template, the Kubernetes version upgrade procedure, and verification/troubleshooting with `kubectl logs -n cpaas-system deployment/hcs-controller-manager`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/manage-nodes/huawei-dcs.mdx": {
      "sha256": "e92259636801bc58a21ae0a7d3536976ba3f8a9393ea31e17e76ab9a9c019306",
      "size": 38320,
      "description": "Operations guide for DCS worker nodes via Cluster API. Defines `DCSIpHostnamePool` (per-IP `ip`/`mask`/`gateway`/`dns`/`hostname`/`machineName`, plus `persistentDisk` entries that survive VM replacement for `/var/cpaas` and other preserved paths, requiring DCS provider `v1.0.16`+), `DCSMachineTemplate` (mandatory disks for system volume, `/var/lib/kubelet`, `/var/lib/containerd`, `vmTemplateName`, `dcsMachineCpuSpec`/`dcsMachineMemorySpec`/`dcsMachineDiskSpec`), the `KubeadmConfigTemplate` with `PROVIDER_ID`/`NODE_IP` magic tokens and optional `dcs-kubernetes-<version>-files` Secret reference for `worker-kubelet-patch.json`, and `MachineDeployment` with `maxSurge: 0` for persistent-disk pools. Covers scaling (random vs. targeted removal via `cluster.x-k8s.io/delete-machine` annotation), template upgrades, the web-UI Node Pools workflow (requires provider `1.0.13`+), and troubleshooting VMs stuck in `creating`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/manage-nodes/index.mdx": {
      "sha256": "a5f05dea989ff06854920da5ef1c8184e09dc7fd36e3c040e47df14a7fd86a53",
      "size": 661,
      "description": "Section index for managing worker nodes in Immutable Infrastructure clusters, linking to platform-specific guides for Huawei DCS, Huawei Cloud Stack, and VMware vSphere (Bare Metal planned), and cross-referencing upgrade-cluster and machine-configuration sections.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/manage-nodes/vmware-vsphere.mdx": {
      "sha256": "74dbd836f22c71e453bc3622e90d04b19d988e635bfb69576fa6656a63d266c8",
      "size": 7173,
      "description": "Day-2 procedures for vSphere worker nodes managed via `VSphereMachineConfigPool`, `VSphereMachineTemplate`, `KubeadmConfigTemplate`, and `MachineDeployment`. Documents scale-out by extending pool slots in `03-vspheremachineconfigpool-worker.yaml` before bumping `30-workers-md-0.yaml` `replicas`, the immutable-template rollout pattern (export, rename to `<cluster>-worker-v2`, strip server-generated fields, apply, then patch `MachineDeployment.spec.template.spec.infrastructureRef.name`) for changing `numCPUs`/`memoryMiB`/`diskGiB`/`dataDisks`, the analogous bootstrap-template swap, monitoring commands (`get machinedeployment,machine,vspheremachine,vspherevm`), and troubleshooting via `MachineConfigPoolReady` reasons such as `PoolBoundToOtherConsumer` and `NoAvailableSlots`.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/architecture.mdx": {
      "sha256": "be3dace31f1830bb79de4afd63206f29d3edd82d560e8b47e6596454bd0e3c28",
      "size": 2323,
      "description": "Describes the three-provider Cluster API (CAPI) architecture used by the platform: the Kubeadm Bootstrap Provider handles node initialization/kubelet config/join tokens/certificate rotation, the Kubeadm Control Plane Provider deploys and rolls upgrades for the API server and etcd with HA load balancing and health monitoring, and a pluggable Infrastructure Provider (such as DCS) handles VM provisioning, networking, and resource management on the target IaaS. Includes the CAPI architecture diagram.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/feature.mdx": {
      "sha256": "dae0a7109d741875e5fc8c156d499e63eea6f0557bcdf5c54ac0fe0d7203548e",
      "size": 5989,
      "description": "Catalogs Immutable Infrastructure capabilities: full cluster lifecycle (immutable-OS creation, deletion with provider resource release, horizontal scaling, Kubernetes upgrades), the pluggable infrastructure-provider model (DCS and VMware vSphere shipped, more on roadmap), and VM compute lifecycle/instance flavor/storage/network configuration options. Walks through four use cases — 3-node HA control plane with automatic failover, `MachineDeployment.replicas` based horizontal scaling, zero-downtime rolling upgrades governed by `maxSurge`/`maxUnavailable`, and multi-node-pool layouts (general-purpose, compute-optimized, memory-optimized) using separate `MachineDeployment`s, labels, and taints.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/index.mdx": {
      "sha256": "f2173503b518976d2ce0b364648e0aec87c10f0ae2f33957a7f310f0521283fd",
      "size": 44,
      "description": "Top-level overview landing page that renders the auto-generated `<Overview />` for the introduction, architecture, feature, and providers child pages.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/intro.mdx": {
      "sha256": "1a76316d8678f1a54a8e117d29a403484117b53e942406964427028b9c27f6fa",
      "size": 618,
      "description": "Brief introduction to Immutable Infrastructure on the Alauda Container Platform, naming Cluster API as the underlying mechanism and listing the four guiding principles: declarative configuration, version control, reproducible deployments, and rollback capability.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/os-support-matrix.mdx": {
      "sha256": "79e3470817c4403877261db4962d5fa4b2613e4d28191ca2447a438e029c20f8",
      "size": 1073,
      "description": "Maps each ACP release (v4.0.9 through v4.3.0) to its MicroOS image version and bundled component versions including Kubernetes (v1.31.14-2 through v1.34.5), coredns, etcd (v3.5.25 through v3.5.28), and pause 3.10. Documents the x86-64-v2 ISA CPU baseline requirement for ACP-provided MicroOS images on x86_64 when creating or upgrading cluster nodes.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/providers/bare-metal.mdx": {
      "sha256": "eec623fe894f5737e211001f53d98400980aec2a64395937cbe2487a896ed898",
      "size": 1315,
      "description": "Placeholder page announcing the planned Bare Metal Infrastructure Provider, which will manage physical servers directly without virtualization for performance-critical scenarios or 3-5 machine deployments. Contrasts the upcoming in-place upgrade path with VM providers' rolling-replace approach, highlighting requirements for data persistence on undetachable disks and BMC-based self-healing through reboot or reprovision.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/providers/huawei-cloud-stack.mdx": {
      "sha256": "1524e2a33c2cba775deb28cec9ef89f0c01d39697b955a75d993e182bfaae0ed",
      "size": 2185,
      "description": "Introduces the Huawei Cloud Stack (HCS) infrastructure provider for hybrid cloud Kubernetes clusters via Cluster API, covering its Kube-OVN integration, ELB-backed control plane HA, static IP allocation, availability-zone selection, and kubeadm-based control-plane security bootstrap (audit, admission, encryption, kubelet certs). Lists the provider's CRDs: HCSCluster, HCSMachine, HCSMachineTemplate, and HCSMachineConfigPool.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/providers/huawei-dcs.mdx": {
      "sha256": "5548de37b188a6f31ab195f61e3e416e2536219119047eb0379f796016ade276",
      "size": 6044,
      "description": "Describes the Huawei DCS Infrastructure Provider's Cluster API integration with the Datacenter Virtualization Solution platform, covering YAML-based management via DCSCluster, DCSMachine, DCSMachineTemplate, and DCSIpHostnamePool resources, and Fleet Essentials UI workflows for cloud credentials, IP pools, machine templates, and node pool lifecycle. Notes v1.0.16 first-class support for pool-managed persistent disks (`DCSIpHostnamePool.spec.pool[].persistentDisk`) that survive rolling upgrades by detach/reattach, with persistent-disk declaration remaining YAML-only in v1.0.16.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/providers/index.mdx": {
      "sha256": "ee3a7187aecb883bae504e9f5b6aee577730fdefa0fbf395197e3fcf39f56193",
      "size": 3155,
      "description": "Lists the four pluggable infrastructure providers (Huawei DCS, Huawei Cloud Stack, VMware vSphere as Available; Bare Metal as Planned) and explains the Fleet Essentials core plugin that adds a shared web UI framework providers can extend via anchors. Outlines the provider architecture splitting Infrastructure Provider, Kubeadm Bootstrap Provider, and Kubeadm Control Plane Provider, with notes on which Fleet Essentials UI extensions are GA versus coming soon per provider.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/providers/vmware-vsphere.mdx": {
      "sha256": "6c1b965564ee5a7bfb098cef50b490ea0f3ee4eaf332e118849723690137b87c",
      "size": 3823,
      "description": "Introduces the VMware vSphere Infrastructure Provider built on Cluster API Provider vSphere (CAPV) with declarative node-slot allocation via VSphereMachineConfigPool, multi-NIC support driving kubelet node-ip from the primary interface, multi-datacenter failure domains through VSphereFailureDomain/VSphereDeploymentZone, and raw-device persistent disks exposed at `/dev/disk/by-capv/<name>`. Lists primary user-facing CRDs (VSphereCluster, VSphereMachine, VSphereMachineTemplate, VSphereMachineConfigPool, VSphereFailureDomain, VSphereDeploymentZone) used in documented workflows.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/overview/release_notes.mdx": {
      "sha256": "a926f91586f6e3c1e549dcdc81f3057e7e656d2f4657c5db67a7badff9297792",
      "size": 2633,
      "description": "Chronicles ACP DCS Infrastructure Provider release history: v1.0.16 (2026-04-30) adds pool-managed persistent disks via `DCSIpHostnamePool.persistentDisk`/`persistentDiskStatus` with detach-and-reattach across rolling upgrades and moves `/var/cpaas` from `DCSMachineTemplate` to IP-slot configuration; v1.0.9 (2026-01-15) adds automatic etcd encryption configuration generation, multi-NIC VM support, and MachineDeployment/KubeadmControlPlane labels/annotations/taints (ACP 4.2.0+); plus the initial release feature set.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/upgrade-cluster/bare-metal.mdx": {
      "sha256": "57b841f2f85f5d39b7f894c56d11c9d2d23e503c3216b9a7e609e226dc4b8c90",
      "size": 457,
      "description": "Placeholder noting that bare-metal cluster upgrade documentation is planned and will describe the in-place upgrade approach used to avoid lengthy physical-machine reinstallation, with critical data preserved on local disks during the upgrade.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/upgrade-cluster/huawei-cloud-stack.mdx": {
      "sha256": "a465152517d8d215a0f771ba7057ce5ecdf2bfe32d89992731665aa6518a255f",
      "size": 6070,
      "description": "Step-by-step Phase 2 Kubernetes upgrade procedure for HCS clusters covering control-plane image updates by creating new HCSMachineTemplate resources, patching KubeadmControlPlane's infrastructureRef and spec.version, and monitoring rolling upgrades via `kubectl get kubeadmcontrolplane -w`. Explicitly warns that HCS does not preserve data disks across node replacement (move stateful data to external storage first), restricts the workflow to HA control planes, and requires keeping `rollingUpdate.maxSurge: 0` for fixed-size `HCSMachineConfigPool`-backed control planes.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/upgrade-cluster/huawei-dcs.mdx": {
      "sha256": "241bce744ed0420d524a859e337f082ec7030ad4d349ff0610455c66aaf90911",
      "size": 11264,
      "description": "Walks through the Phase 2 Kubernetes upgrade for Huawei DCS clusters in the required management-cluster-first sequence, both via YAML (new DCSMachineTemplate, patched KubeadmControlPlane spec.version, MachineDeployment rollouts) and via the Fleet Essentials UI (Node Pools tab, Upgrade button, Control Plane before Workers). Details what persistent-disk preservation guarantees apply (`DCSIpHostnamePool.spec.pool[].persistentDisk` detach/reattach), mandates `maxSurge=0` for one-by-one replacement, requires DCS provider v1.0.16+ and VM templates 4.2.1+ for guest-tool-driven safe shutdown, and notes cross-version upgrades must step through each minor version.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/upgrade-cluster/index.mdx": {
      "sha256": "40d3a40e8cc34191b5fd427d474017c9133bb808f9f3745f86a4d31007de30ad",
      "size": 4025,
      "description": "Lays out the two-phase cluster upgrade model: Phase 1 upgrades the Distribution Version (ACP platform / Aligned Extensions, L3 and L4 plugins) through the cluster's Aligned Extensions tab, requiring acknowledgment of Medium/High plugin impact assessments; Phase 2 upgrades Kubernetes per Node Pool using provider-specific procedures. Directs readers to the Huawei DCS, Huawei Cloud Stack, and VMware vSphere platform guides for Phase 2 steps.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    },
    "docs/en/upgrade-cluster/vmware-vsphere.mdx": {
      "sha256": "46ce8b5fb6821462efd55147cec1367ac7cf799da0ac28dc1ca163ccab1f08ce",
      "size": 6477,
      "description": "Documents the post-distribution-upgrade Kubernetes upgrade procedure on vSphere by creating new VSphereMachineTemplate resources (since templates are immutable) for both control plane and workers, then patching KubeadmControlPlane's `spec.version`, `machineTemplate.infrastructureRef.name`, and image tags such as `dns.imageTag`/`etcd.local.imageTag`, followed by MachineDeployment updates referencing the new worker template and KubeadmConfigTemplate. Covers monitoring rollouts via `kubectl get kubeadmcontrolplane/machinedeployment -w`, rollback by reverting template references, and verification that the vSphere CPI daemonset stays available.",
      "generation_method": "ai_agent_reading",
      "updated_at": "2026-05-16T06:24:44Z"
    }
  }
}