Manage Nodes on Huawei DCS

This document explains how to manage worker nodes using Cluster API Machine resources.

Prerequisites

WARNING

Important Prerequisites

  • The control plane must be deployed before performing node operations. See Create Cluster for setup instructions.
  • Ensure you have proper access to the DCS platform and required permissions.
  • To manage the nodes of the global cluster itself, the provider must be installed on global first; see Manage Nodes on Alauda OS Clusters.
INFO

Configuration Guidelines When working with the configurations in this document:

  • Only modify values enclosed in <> brackets
  • Replace placeholder values with your environment-specific settings
  • Preserve all other default configurations unless explicitly required
  • A cluster created with ac names the MachineDeployment and the DCSIpHostnamePool of a node group <cluster-name>-<group>, where <group> is computes[].name. A cluster not created with ac may use other names; read them from its MachineDeployment resources

Overview

Worker nodes are managed through Cluster API Machine resources, providing declarative and automated node lifecycle management. A worker node pool is built from four resources:

  1. IP-Hostname Pool Configuration - Network settings for worker nodes
  2. Machine Template Setup - VM specifications
  3. Bootstrap Configuration - Node initialization and join settings
  4. Machine Deployment - Orchestration of node creation and management
Clusters created with ac

ac adm alpha cluster create and ac adm alpha global create only create a cluster. To change a running cluster, change its objects as described on this page; do not change install-config.yaml and run create again. ac adm alpha cluster destroy deletes only the objects that ac rendered, so delete the templates that you created yourself.

To add another worker node group, see Adding a Worker Node Group.

Node Management Operations

This section covers common operational tasks for managing worker nodes, including scaling, machine infrastructure changes, and bootstrap template updates.

INFO

Cluster API Framework Node management operations are based on the Cluster API framework. For detailed information, refer to the official Cluster API documentation.

Scaling Worker Nodes

Worker node scaling allows you to adjust cluster capacity based on workload demands. The Cluster API manages the node lifecycle automatically through the MachineDeployment resource.

Adding Worker Nodes

Increase the number of worker nodes to handle increased workload or add new capacity.

Use Case: Scale up cluster to add more compute resources

Prerequisites:

  • Verify the IP pool has sufficient available IP addresses for new nodes
  • Ensure the DCS platform has adequate resources to provision new VMs

Procedure:

  1. Check Current Node Status

    View the current machines in the cluster:

    ac config use-cluster global
    # List all machines in the cluster
    ac get machines.cluster.x-k8s.io -n cpaas-system
    
    # List machines for a specific MachineDeployment
    ac get machines.cluster.x-k8s.io -n cpaas-system -l cluster.x-k8s.io/deployment-name=<cluster-name>-<group>
  2. Extend IP Pool

    Before scaling up, add new IP configurations to the pool for the additional nodes.

    INFO

    IP Pool Expansion The IP pool must contain at least as many entries as the desired replica count. Add new IP entries for each additional worker node you plan to deploy.

    Add IP entries to the pool:

    First, export the current pool configuration to preserve existing entries:

    ac config use-cluster global
    ac get dcsiphostnamepool <cluster-name>-<group> -n cpaas-system -o yaml

    Then use the following command to add new IP configurations. The pool array must include all existing entries plus the new entries:

    ac config use-cluster global
    ac patch dcsiphostnamepool <cluster-name>-<group> -n cpaas-system \
      --type='merge' -p='
    {
      "spec": {
        "pool": [
          {
            "ip": "<existing-ip-1>",
            "mask": "<worker-cidr-prefix-length>",
            "gateway": "<worker-gateway>",
            "dns": "<worker-dns>",
            "hostname": "<existing-hostname-1>",
            "machineName": "<existing-machine-name-1>",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "<datastore-cluster-name>",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          },
          {
            "ip": "<existing-ip-2>",
            "mask": "<worker-cidr-prefix-length>",
            "gateway": "<worker-gateway>",
            "dns": "<worker-dns>",
            "hostname": "<existing-hostname-2>",
            "machineName": "<existing-machine-name-2>",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "<datastore-cluster-name>",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          },
          {
            "ip": "<new-worker-ip-1>",
            "mask": "<worker-cidr-prefix-length>",
            "gateway": "<worker-gateway>",
            "dns": "<worker-dns>",
            "hostname": "<new-worker-hostname-1>",
            "machineName": "<new-worker-machine-name-1>",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "<datastore-cluster-name>",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          },
          {
            "ip": "<new-worker-ip-2>",
            "mask": "<worker-cidr-prefix-length>",
            "gateway": "<worker-gateway>",
            "dns": "<worker-dns>",
            "hostname": "<new-worker-hostname-2>",
            "machineName": "<new-worker-machine-name-2>",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "<datastore-cluster-name>",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          }
        ]
      }'
    WARNING

    Important Notes

    • The pool array must include all existing entries plus the new entries you want to add
    • Copy the existing entries from the exported YAML to avoid data loss
    • ac patch --type='merge' replaces the entire spec.pool array, so copy every existing persistentDisk block unchanged, including isThin if it is present, unless you are intentionally adding new disks
    • Ensure each new entry has unique ip, hostname, and machineName values
    • If new worker nodes also need the platform-required /var/cpaas disk, declare it in each new entry's persistentDisk
    • Network parameters (mask, gateway, dns) typically match existing entries

    Example: Adding 2 new nodes to an existing pool of 3 nodes

    ac config use-cluster global
    # Current pool has 3 entries (10.0.1.11, 10.0.1.12, 10.0.1.13)
    # Adding 2 more entries for nodes 4 and 5
    ac patch dcsiphostnamepool worker-pool-1-ippool -n cpaas-system \
      --type='merge' -p='
    {
      "spec": {
        "pool": [
          {
            "ip": "10.0.1.11",
            "mask": "24",
            "gateway": "10.0.1.1",
            "dns": "10.0.0.2",
            "hostname": "worker-node-1",
            "machineName": "worker-vm-1",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "shared-datastore-cluster",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          },
          {
            "ip": "10.0.1.12",
            "mask": "24",
            "gateway": "10.0.1.1",
            "dns": "10.0.0.2",
            "hostname": "worker-node-2",
            "machineName": "worker-vm-2",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "shared-datastore-cluster",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          },
          {
            "ip": "10.0.1.13",
            "mask": "24",
            "gateway": "10.0.1.1",
            "dns": "10.0.0.2",
            "hostname": "worker-node-3",
            "machineName": "worker-vm-3",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "shared-datastore-cluster",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          },
          {
            "ip": "10.0.1.14",
            "mask": "24",
            "gateway": "10.0.1.1",
            "dns": "10.0.0.2",
            "hostname": "worker-node-4",
            "machineName": "worker-vm-4",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "shared-datastore-cluster",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          },
          {
            "ip": "10.0.1.15",
            "mask": "24",
            "gateway": "10.0.1.1",
            "dns": "10.0.0.2",
            "hostname": "worker-node-5",
            "machineName": "worker-vm-5",
            "persistentDisk": [
              {
                "slot": 0,
                "quantityGB": 40,
                "datastoreClusterName": "shared-datastore-cluster",
                "path": "/var/cpaas",
                "format": "xfs"
              }
            ]
          }
        ]
      }'
  3. Verify IP Pool Capacity

    After extending the IP pool, verify it has sufficient entries for the desired replica count:

    ac config use-cluster global
    ac get dcsiphostnamepool -n cpaas-system <cluster-name>-<group> -o yaml

    Check that the pool contains at least as many entries as the desired replica count.

  4. Scale Up the MachineDeployment

    Update the replicas field to the desired number of nodes:

    ac config use-cluster global
    ac patch machinedeployment <cluster-name>-<group> -n cpaas-system \
      --type='json' -p='[{"op": "replace", "path": "/spec/replicas", "value": <new-replica-count>}]'

    Example: Scale from 3 to 5 nodes

    ac config use-cluster global
    ac patch machinedeployment worker-pool-1 -n cpaas-system \
      --type='json' -p='[{"op": "replace", "path": "/spec/replicas", "value": 5}]'
  5. Monitor the Scaling Progress

    Watch the machine creation process:

    ac config use-cluster global
    # Watch machines being created
    ac get machines.cluster.x-k8s.io -n cpaas-system -w
    
    # Check MachineDeployment status
    ac get machinedeployment <cluster-name>-<group> -n cpaas-system

    The Cluster API controller will automatically create new machines based on the MachineDeployment template.

  6. Verify Nodes Joined the Cluster

    Verify the new nodes:

    ac config use-cluster global
    # Check all nodes are Ready
    ac config sync
    ac config use-cluster <cluster-name>
    ac get nodes
    ac config use-cluster global

    The new nodes should appear in the list and transition to Ready status.

INFO

Rolling Update Behavior When scaling up, new nodes are created immediately without affecting existing nodes. This ensures zero-downtime scaling.

Removing Worker Nodes

Decrease the number of worker nodes to reduce cluster capacity or remove underutilized resources. The Cluster API supports two removal strategies:

  1. Random removal: Reduce replicas, the platform randomly selects and deletes machines
  2. Targeted removal: Mark specific machines for deletion, then reduce replicas (recommended for IP recovery)
INFO

IP Recovery Scenario When you need to recycle specific machine IPs (e.g., for reassignment or IP pool management), use the targeted removal method. The deletion annotation ensures the platform deletes the marked machines, not random ones.

WARNING

Data Loss Warning Scaling down removes nodes and their associated VMs. Ensure:

  • Workloads can tolerate node loss through proper replication
  • No critical data is stored only on the nodes being removed
  • Applications are designed for horizontal scaling

Declared persistent disks in DCSIpHostnamePool.spec.pool[].persistentDisk are not deleted just because a Machine is replaced. They remain available for reuse while the corresponding IP slot stays in the pool. Removing the IP slot from the pool, deleting the pool, or deleting the cluster can trigger persistent-volume cleanup.

Random Removal

Use Case: Scale down cluster where any node can be removed (no specific IP requirements)

Procedure:

  1. Identify Current Machine Status

    View the current machines in the MachineDeployment:

    ac config use-cluster global
    ac get machines.cluster.x-k8s.io -n cpaas-system -l cluster.x-k8s.io/deployment-name=<cluster-name>-<group>
  2. Scale Down the MachineDeployment

    Update the replicas field to reduce the node count:

    ac config use-cluster global
    ac patch machinedeployment <cluster-name>-<group> -n cpaas-system \
      --type='json' -p='[{"op": "replace", "path": "/spec/replicas", "value": <new-replica-count>}]'

    Example: Scale from 5 to 3 nodes

    ac config use-cluster global
    ac patch machinedeployment worker-pool-1 -n cpaas-system \
      --type='json' -p='[{"op": "replace", "path": "/spec/replicas", "value": 3}]'

    The Cluster API controller will randomly select and delete machines to match the desired replica count.

  3. Monitor the Removal Progress

    Watch the machine deletion process:

    ac config use-cluster global
    ac get machines.cluster.x-k8s.io -n cpaas-system -w

    The Cluster API controller will:

    • Drain the selected nodes (evict pods if possible)
    • Delete the underlying VMs from the DCS platform
    • Remove the machine resources
  4. Verify Nodes Removed

    Verify the nodes:

    ac config sync
    ac config use-cluster <cluster-name>
    ac get nodes
    ac config use-cluster global

    The removed nodes should no longer appear in the list.

Targeted Removal

Use Case: Remove specific machines (e.g., for IP recovery, replace unhealthy nodes)

Procedure:

  1. Identify Machines to Remove

    View the current machines:

    ac config use-cluster global
    ac get machines.cluster.x-k8s.io -n cpaas-system -l cluster.x-k8s.io/deployment-name=<cluster-name>-<group>

    Note the <machine-name> of the machines you want to remove.

  2. Annotate Machines for Deletion

    Mark the specific machines for deletion:

    ac config use-cluster global
    ac patch machine <machine-name> -n cpaas-system \
      --type='merge' -p='{"metadata": {"annotations": {"cluster.x-k8s.io/delete-machine": "true"}}}'

    Repeat for each machine you want to remove.

    Example: Remove two specific machines

    ac config use-cluster global
    ac patch machine worker-pool-1-abc123 -n cpaas-system \
      --type='merge' -p='{"metadata": {"annotations": {"cluster.x-k8s.io/delete-machine": "true"}}}'
    
    ac patch machine worker-pool-1-def456 -n cpaas-system \
      --type='merge' -p='{"metadata": {"annotations": {"cluster.x-k8s.io/delete-machine": "true"}}}'
  3. Scale Down the MachineDeployment

    After annotating the machines, reduce the replica count:

    INFO

    Replica Count Must Match Annotated Machines Reduce replicas by exactly the number of annotated machines.

    • If you reduce by fewer, not all annotated machines will be removed
    • If you reduce by more, additional machines will be randomly selected for deletion
    ac config use-cluster global
    ac patch machinedeployment <cluster-name>-<group> -n cpaas-system \
      --type='json' -p='[{"op": "replace", "path": "/spec/replicas", "value": <new-replica-count>}]'

    Example: If you annotated 2 machines, reduce replicas by exactly 2 (e.g., from 5 to 3)

    The platform will delete the annotated machines, not randomly selected ones.

  4. Monitor the Removal Progress

    Watch the machine deletion process:

    ac config use-cluster global
    ac get machines.cluster.x-k8s.io -n cpaas-system -w
  5. Verify Nodes Removed

    Verify the nodes:

    ac config sync
    ac config use-cluster <cluster-name>
    ac get nodes
    ac config use-cluster global

    The removed nodes should no longer appear in the list.

Adding a Worker Node Group

Add workers that have their own IP pool or VM specification.

In the following steps, <group> is an existing worker node group and <new-group> is the new one, a DNS-1123 label that no other group uses. control-plane is reserved.

Procedure:

  1. Read the values of an existing group

    ac config use-cluster global
    ac -n cpaas-system get machinedeployment <cluster-name>-<group> \
      -o jsonpath='{.spec.template.spec.version}{"\n"}{.spec.template.spec.infrastructureRef.name}{"\n"}{.spec.template.spec.bootstrap.configRef.name}{"\n"}'
    ac -n cpaas-system get dcsmachinetemplate <machine-template-name> -o yaml
    ac -n cpaas-system get kubeadmconfigtemplate <bootstrap-template-name> -o yaml

    The first command prints <kubernetes-version>, <machine-template-name>, and <bootstrap-template-name>.

  2. Write the worker objects

    new-worker-group.yaml
    apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
    kind: DCSIpHostnamePool
    metadata:
      labels:
        cluster.x-k8s.io/cluster-name: <cluster-name>
      name: <cluster-name>-<new-group>
      namespace: cpaas-system
    spec:
      pool:
      - hostname: <worker-hostname-1>
        ip: <worker-ip-1>
        mask: "<worker-cidr-prefix-length>"
        gateway: <worker-gateway>
        dns: <worker-dns>
        persistentDisk:
        - path: /var/cpaas
          quantityGB: 100
          slot: 0
          datastoreName: <datastore-name>
          format: xfs
          isThin: false
          pciType: VIRTIO
    ---
    apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
    kind: DCSMachineTemplate
    metadata:
      labels:
        cluster.x-k8s.io/cluster-name: <cluster-name>
      name: <cluster-name>-<new-group>
      namespace: cpaas-system
    spec:
      template:
        spec:
          vmTemplateName: <vm-template-name>
          ipHostPoolRef:
            name: <cluster-name>-<new-group>
          location:
            type: folder
            name: <folder-name>
          vmConfig:
            dvSwitchName: <dv-switch-name>
            portGroupName: <port-group-name>
            cdRomDatastoreName: <cd-rom-datastore-name>
            dcsMachineCpuSpec:
              quantity: <worker-cpu>
            dcsMachineMemorySpec: # MB
              quantity: <worker-memory>
            dcsMachineDiskSpec: # GB
            - quantity: <worker-system-disk-size>
              datastoreName: <datastore-name>
              systemVolume: true
            - quantity: 100
              datastoreName: <datastore-name>
              path: /var/lib/containerd
              format: xfs
            - quantity: 100
              datastoreName: <datastore-name>
              path: /var/lib/kubelet
              format: xfs
    ---
    apiVersion: bootstrap.cluster.x-k8s.io/v1beta1
    kind: KubeadmConfigTemplate
    metadata:
      labels:
        cluster.x-k8s.io/cluster-name: <cluster-name>
      name: <cluster-name>-<new-group>-config
      namespace: cpaas-system
    spec:
      template:
        spec:
          format: ignition
          files:
          - content: |
              {
                "apiVersion": "kubelet.config.k8s.io/v1beta1",
                "kind": "KubeletConfiguration",
                "protectKernelDefaults": true,
                "staticPodPath": null,
                "streamingConnectionIdleTimeout": "5m",
                "tlsCertFile": "/etc/kubernetes/pki/kubelet.crt",
                "tlsPrivateKeyFile": "/etc/kubernetes/pki/kubelet.key"
              }
            owner: root:root
            path: /etc/kubernetes/patches/kubeletconfiguration0+strategic.json
            permissions: "0644"
          joinConfiguration:
            nodeRegistration:
              kubeletExtraArgs:
                node-ip: NODE_IP
                protect-kernel-defaults: "true"
                provider-id: PROVIDER_ID
                volume-plugin-dir: /opt/libexec/kubernetes/kubelet-plugins/volume/exec/
            patches:
              directory: /etc/kubernetes/patches
          postKubeadmCommands:
          - chmod 600 /var/lib/kubelet/config.yaml
          preKubeadmCommands:
          - while ! ip route | grep -q "default via"; do sleep 1; done; echo "NetworkManager started"
          - mkdir -p /run/cluster-api && restorecon -Rv /run/cluster-api
          - if [ -f /etc/disk-setup.sh ]; then bash /etc/disk-setup.sh; fi
          users:
          - name: boot
            sshAuthorizedKeys:
            - <ssh-public-key>
    ---
    apiVersion: cluster.x-k8s.io/v1beta1
    kind: MachineDeployment
    metadata:
      labels:
        cluster.x-k8s.io/cluster-name: <cluster-name>
      name: <cluster-name>-<new-group>
      namespace: cpaas-system
    spec:
      clusterName: <cluster-name>
      replicas: <replicas>
      selector: {}
      strategy:
        type: RollingUpdate
        rollingUpdate:
          maxSurge: 0
          maxUnavailable: 1
      template:
        metadata:
          labels:
            cluster.x-k8s.io/cluster-name: <cluster-name>
            pool.name: <cluster-name>-<new-group>
        spec:
          clusterName: <cluster-name>
          version: <kubernetes-version>
          nodeDeletionTimeout: 5m
          nodeDrainTimeout: 1m
          bootstrap:
            configRef:
              apiVersion: bootstrap.cluster.x-k8s.io/v1beta1
              kind: KubeadmConfigTemplate
              name: <cluster-name>-<new-group>-config
              namespace: cpaas-system
          infrastructureRef:
            apiVersion: infrastructure.cluster.x-k8s.io/v1beta1
            kind: DCSMachineTemplate
            name: <cluster-name>-<new-group>
            namespace: cpaas-system
    • Give the pool at least replicas entries, one per node, with hostnames and addresses that no other pool uses. Repeat the persistentDisk entry for each host.
    • Take vmTemplateName from <machine-template-name>, so that the VM template matches <kubernetes-version>. Take dvSwitchName, portGroupName, and cdRomDatastoreName from it as well, and leave out the ones it does not set. For the disk fields, see Disks.
    • When <bootstrap-template-name> has fields that differ from spec.template.spec above, use its values. For example, on Kubernetes 1.35 and later the kubelet configuration patch needs "imagePullCredentialsVerificationPolicy": "NeverVerify"; earlier versions do not accept this field.
  3. Apply the objects and monitor the group

    ac config use-cluster global
    ac apply -f new-worker-group.yaml
    ac -n cpaas-system get machines.cluster.x-k8s.io \
      -l cluster.x-k8s.io/deployment-name=<cluster-name>-<new-group> -w

    Continue when every Machine of the group is Running; then confirm that the nodes are Ready on the cluster.

Changing Machine Infrastructure

To change the machine specification of worker nodes (CPU, memory, disk, VM template), create a new machine template, then point the MachineDeployment at it. The worker nodes are replaced one by one.

  1. Create a New Machine Template

    Export the DCSMachineTemplate referenced by your MachineDeployment to a new file:

    ac config use-cluster global
    ac get dcsmachinetemplate <current-template-name> -n cpaas-system -o yaml > new-template.yaml

    In the new file:

    • Set metadata.name to a unique name
    • Modify the required values (spec.template.spec.vmTemplateName, spec.template.spec.vmConfig.dcsMachineCpuSpec.quantity, spec.template.spec.vmConfig.dcsMachineMemorySpec.quantity, spec.template.spec.vmConfig.dcsMachineDiskSpec)
    • Remove the server-generated metadata (resourceVersion, uid, generation, creationTimestamp, managedFields, the kubectl.kubernetes.io/last-applied-configuration annotation) and the entire status field
    • Leave spec.template.spec.providerID unset

    Keep pool-managed persistent disks, including /var/cpaas, in DCSIpHostnamePool.spec.pool[].persistentDisk and additional NICs in DCSIpHostnamePool.spec.pool[].additionNic[]. Use dcsMachineDiskSpec only for the system disk and template-local disks.

    Apply the new template:

    ac config use-cluster global
    ac apply -f new-template.yaml -n cpaas-system
  2. Update Machine Deployment

    Point the MachineDeployment at the new template:

    ac config use-cluster global
    ac patch machinedeployment <cluster-name>-<group> -n cpaas-system \
      --type='merge' -p='{"spec":{"template":{"spec":{"infrastructureRef":{"name":"<new-template-name>"}}}}}'
  3. Monitor the Rolling Update

    • Worker nodes are replaced one by one with the new specification

    • Any disks declared in DCSIpHostnamePool.spec.pool[].persistentDisk are detached from the old VM and reattached to the replacement VM when the replacement takes over the IP entry of the old VM, which is guaranteed only when the pool has no free entry. If the pool uses persistent disks, keep spec.strategy.rollingUpdate.maxSurge at 0 on the MachineDeployment, and do not leave free entries in the pool

    • Monitor the progress:

      ac config use-cluster global
      ac get machinedeployment <cluster-name>-<group> -n cpaas-system
      ac get machines.cluster.x-k8s.io -n cpaas-system -w

To change the machine specification of control plane nodes, use the same steps and patch KubeadmControlPlane.spec.machineTemplate.infrastructureRef.name instead.

In these steps, change only the machine specification. Do not change spec.version of the KubeadmControlPlane or MachineDeployment, and do not switch to a VM template of another Kubernetes version.

If you are migrating an existing cluster from the old template-disk layout to pool-managed persistent disks, follow Migrate to Pool-Managed Persistent Disks before you rely on data preservation during node replacement.

Updating Bootstrap Templates

Bootstrap templates (KubeadmConfigTemplate) are used by MachineDeployment and MachineSet resources. Changes to existing templates do not automatically trigger rollouts of existing machines; only new machines use the updated template.

Update Process:

  1. Export Existing Template

    ac config use-cluster global
    ac get KubeadmConfigTemplate <template-name> -n cpaas-system -o yaml > new-template.yaml
  2. Modify Configuration

    • Update the desired fields in the exported YAML
    • For Kubernetes 1.35 or later, add the required kubelet patch settings to /etc/kubernetes/patches/kubeletconfiguration0+strategic.json
    • Change the metadata.name to a new unique name
    • Remove extraneous metadata fields (resourceVersion, uid, creationTimestamp, etc.)
  3. Create New Template

    ac config use-cluster global
    ac apply -f new-template.yaml -n cpaas-system
  4. Update MachineDeployment

    • Modify the MachineDeployment resource
    • Update spec.template.spec.bootstrap.configRef.name to reference the new template
    • Apply the changes to trigger a rolling update
INFO

Template Rollout Behavior Existing machines continue using the old bootstrap configuration. Only newly created machines (during scaling or rolling updates) will use the updated template.


Troubleshooting

A new or replacement Machine that stays in Provisioning while its DCS VM stays in creating is a DCS placement issue; see VM Stuck in creating. For control plane spread across hosts, see Control Plane HA.