Creating a machine set on Azure

You can create a different machine set to serve a specific purpose in your OKD cluster on Microsoft Azure. For example, you might create infrastructure machine sets and related machines so that you can move supporting workloads to the new machines.

Machine API overview

The Machine API is a combination of primary resources that are based on the upstream Cluster API project and custom OKD resources.

For OKD 4.11 clusters, the Machine API performs all node host provisioning management actions after the cluster installation finishes. Because of this system, OKD 4.11 offers an elastic, dynamic provisioning method on top of public or private cloud infrastructure.

The two primary resources are:

Machines

A fundamental unit that describes the host for a node. A machine has a providerSpec specification, which describes the types of compute nodes that are offered for different cloud platforms. For example, a machine type for a worker node on Amazon Web Services (AWS) might define a specific machine type and required metadata.

Machine sets

MachineSet resources are groups of machines. Machine sets are to machines as replica sets are to pods. If you need more machines or must scale them down, you change the replicas field on the machine set to meet your compute need.

The following custom resources add more capabilities to your cluster:

Machine autoscaler

The MachineAutoscaler resource automatically scales machines in a cloud. You can set the minimum and maximum scaling boundaries for nodes in a specified machine set, and the machine autoscaler maintains that range of nodes. The MachineAutoscaler object takes effect after a ClusterAutoscaler object exists. Both ClusterAutoscaler and MachineAutoscaler resources are made available by the ClusterAutoscalerOperator object.

Cluster autoscaler

This resource is based on the upstream cluster autoscaler project. In the OKD implementation, it is integrated with the Machine API by extending the machine set API. You can set cluster-wide scaling limits for resources such as cores, nodes, memory, GPU, and so on. You can set the priority so that the cluster prioritizes pods so that new nodes are not brought online for less important pods. You can also set the scaling policy so that you can scale up nodes but not scale them down.

Machine health check

The MachineHealthCheck resource detects when a machine is unhealthy, deletes it, and, on supported platforms, makes a new machine.

In OKD version 3.11, you could not roll out a multi-zone architecture easily because the cluster did not manage machine provisioning. Beginning with OKD version 4.1, this process is easier. Each machine set is scoped to a single zone, so the installation program sends out machine sets across availability zones on your behalf. And then because your compute is dynamic, and in the face of a zone failure, you always have a zone for when you must rebalance your machines. In global Azure regions that do not have multiple availability zones, you can use availability sets to ensure high availability. The autoscaler provides best-effort balancing over the life of a cluster.

Sample YAML for a machine set custom resource on Azure

This sample YAML defines a machine set that runs in the 1 Microsoft Azure zone in a region and creates nodes that are labeled with node-role.kubernetes.io/<role>: "".

In this sample, <infrastructure_id> is the infrastructure ID label that is based on the cluster ID that you set when you provisioned the cluster, and <role> is the node label to add.

apiVersion: machine.openshift.io/v1beta1
kind: MachineSet
metadata:
  labels:
    machine.openshift.io/cluster-api-cluster: <infrastructure_id> (1)
    machine.openshift.io/cluster-api-machine-role: <role> (2)
    machine.openshift.io/cluster-api-machine-type: <role> (2)
  name: <infrastructure_id>-<role>-<region> (3)
  namespace: openshift-machine-api
spec:
  replicas: 1
  selector:
    matchLabels:
      machine.openshift.io/cluster-api-cluster: <infrastructure_id> (1)
      machine.openshift.io/cluster-api-machineset: <infrastructure_id>-<role>-<region> (3)
  template:
    metadata:
      creationTimestamp: null
      labels:
        machine.openshift.io/cluster-api-cluster: <infrastructure_id> (1)
        machine.openshift.io/cluster-api-machine-role: <role> (2)
        machine.openshift.io/cluster-api-machine-type: <role> (2)
        machine.openshift.io/cluster-api-machineset: <infrastructure_id>-<role>-<region> (3)
    spec:
      metadata:
        creationTimestamp: null
        labels:
          machine.openshift.io/cluster-api-machineset: <machineset_name> (4)
          node-role.kubernetes.io/<role>: "" (2)
      providerSpec:
        value:
          apiVersion: azureproviderconfig.openshift.io/v1beta1
          credentialsSecret:
            name: azure-cloud-credentials
            namespace: openshift-machine-api
          image:
            offer: ""
            publisher: ""
            resourceID: /resourceGroups/<infrastructure_id>-rg/providers/Microsoft.Compute/images/<infrastructure_id> (5)
            sku: ""
            version: ""
          internalLoadBalancer: ""
          kind: AzureMachineProviderSpec
          location: <region> (6)
          managedIdentity: <infrastructure_id>-identity (1)
          metadata:
            creationTimestamp: null
          natRule: null
          networkResourceGroup: ""
          osDisk:
            diskSizeGB: 128
            managedDisk:
              storageAccountType: Premium_LRS
            osType: Linux
          publicIP: false
          publicLoadBalancer: ""
          resourceGroup: <infrastructure_id>-rg (1)
          sshPrivateKey: ""
          sshPublicKey: ""
          subnet: <infrastructure_id>-<role>-subnet  (1) (2)
          userDataSecret:
            name: worker-user-data (2)
          vmSize: Standard_D4s_v3
          vnet: <infrastructure_id>-vnet (1)
          zone: "1" (7)

$ oc get -o jsonpath=’{.status.infrastructureName}{“\n”}’ infrastructure cluster

$  oc -n openshift-machine-api \
    -o jsonpath=’{.spec.template.spec.providerSpec.value.subnet}{“\n”}’ \
    get machineset/<infrastructure_id>-worker-centralus1

$  oc -n openshift-machine-api \
    -o jsonpath=’{.spec.template.spec.providerSpec.value.vnet}{“\n”}’ \
    get machineset/<infrastructure_id>-worker-centralus1

Creating a machine set

In addition to the ones created by the installation program, you can create your own machine sets to dynamically manage the machine compute resources for specific workloads of your choice.

Prerequisites

• Deploy an OKD cluster.

• Install the OpenShift CLI (oc).

• Log in to oc as a user with cluster-admin permission.

Procedure

1. Create a new YAML file that contains the machine set custom resource (CR) sample and is named <file_name>.yaml.

   Ensure that you set the <clusterID> and <role> parameter values.

   1. If you are not sure which value to set for a specific field, you can check an existing machine set from your cluster:

      $ oc get machinesets -n openshift-machine-api

      Example output

      NAME                                DESIRED   CURRENT   READY   AVAILABLE   AGE
      agl030519-vplxk-worker-us-east-1a   1         1         1       1           55m
      agl030519-vplxk-worker-us-east-1b   1         1         1       1           55m
      agl030519-vplxk-worker-us-east-1c   1         1         1       1           55m
      agl030519-vplxk-worker-us-east-1d   0         0                             55m
      agl030519-vplxk-worker-us-east-1e   0         0                             55m
      agl030519-vplxk-worker-us-east-1f   0         0                             55m

   2. Check values of a specific machine set:

      $ oc get machineset <machineset_name> -n \
           openshift-machine-api -o yaml

      Example output

      ...
      template:
          metadata:
            labels:
              machine.openshift.io/cluster-api-cluster: agl030519-vplxk (1)
              machine.openshift.io/cluster-api-machine-role: worker (2)
              machine.openshift.io/cluster-api-machine-type: worker
              machine.openshift.io/cluster-api-machineset: agl030519-vplxk-worker-us-east-1a

      1	The cluster ID.
      2	A default node label.

2. Create the new MachineSet CR:

   $ oc create -f <file_name>.yaml

3. View the list of machine sets:

   $ oc get machineset -n openshift-machine-api

   Example output

   NAME                                DESIRED   CURRENT   READY   AVAILABLE   AGE
   agl030519-vplxk-infra-us-east-1a    1         1         1       1           11m
   agl030519-vplxk-worker-us-east-1a   1         1         1       1           55m
   agl030519-vplxk-worker-us-east-1b   1         1         1       1           55m
   agl030519-vplxk-worker-us-east-1c   1         1         1       1           55m
   agl030519-vplxk-worker-us-east-1d   0         0                             55m
   agl030519-vplxk-worker-us-east-1e   0         0                             55m
   agl030519-vplxk-worker-us-east-1f   0         0                             55m

   When the new machine set is available, the DESIRED and CURRENT values match. If the machine set is not available, wait a few minutes and run the command again.

Machine sets that deploy machines as Spot VMs

You can save on costs by creating a machine set running on Azure that deploys machines as non-guaranteed Spot VMs. Spot VMs utilize unused Azure capacity and are less expensive than standard VMs. You can use Spot VMs for workloads that can tolerate interruptions, such as batch or stateless, horizontally scalable workloads.

Azure can terminate a Spot VM at any time. Azure gives a 30-second warning to the user when an interruption occurs. OKD begins to remove the workloads from the affected instances when Azure issues the termination warning.

Interruptions can occur when using Spot VMs for the following reasons:

• The instance price exceeds your maximum price

• The supply of Spot VMs decreases

• Azure needs capacity back

When Azure terminates an instance, a termination handler running on the Spot VM node deletes the machine resource. To satisfy the machine set replicas quantity, the machine set creates a machine that requests a Spot VM.

Creating Spot VMs by using machine sets

You can launch a Spot VM on Azure by adding spotVMOptions to your machine set YAML file.

Procedure

• Add the following line under the providerSpec field:

  providerSpec:
    value:
      spotVMOptions: {}

  You can optionally set the spotVMOptions.maxPrice field to limit the cost of the Spot VM. For example you can set maxPrice: '0.98765'. If the maxPrice is set, this value is used as the hourly maximum spot price. If it is not set, the maximum price defaults to -1 and charges up to the standard VM price.

  Azure caps Spot VM prices at the standard price. Azure will not evict an instance due to pricing if the instance is set with the default maxPrice. However, an instance can still be evicted due to capacity restrictions.

Machine sets that deploy machines on Ephemeral OS disks

You can create a machine set running on Azure that deploys machines on Ephemeral OS disks. Ephemeral OS disks use local VM capacity rather than remote Azure Storage. This configuration therefore incurs no additional cost and provides lower latency for reading, writing, and reimaging.

Additional resources

• For more information, see the Microsoft Azure documentation about Ephemeral OS disks for Azure VMs.

Creating machines on Ephemeral OS disks by using machine sets

You can launch machines on Ephemeral OS disks on Azure by editing your machine set YAML file.

Prerequisites

• Have an existing Microsoft Azure cluster.

Procedure

1. Edit the custom resource (CR) by running the following command:

   $ oc edit machineset <machine-set-name>

   where <machine-set-name> is the machine set that you want to provision machines on Ephemeral OS disks.

2. Add the following to the providerSpec field:

   providerSpec:
     value:
       ...
       osDisk:
          ...
          diskSettings: (1)
            ephemeralStorageLocation: Local (1)
          cachingType: ReadOnly (1)
          managedDisk:
            storageAccountType: Standard_LRS (2)
          ...

   1	These lines enable the use of Ephemeral OS disks.
   2	Ephemeral OS disks are only supported for VMs or scale set instances that use the Standard LRS storage account type.

   The implementation of Ephemeral OS disk support in OKD only supports the CacheDisk placement type. Do not change the placement configuration setting.

3. Create a machine set using the updated configuration:

   $ oc create -f <machine-set-config>.yaml

Verification

• On the Microsoft Azure portal, review the Overview page for a machine deployed by the machine set, and verify that the Ephemeral OS disk field is set to OS cache placement.

Machine sets that deploy machines with ultra disks as data disks

You can create a machine set running on Azure that deploys machines with ultra disks. Ultra disks are high-performance storage that are intended for use with the most demanding data workloads.

You can also create a persistent volume claim (PVC) that dynamically binds to a storage class backed by Azure ultra disks and mounts them to pods.

Additional resources

• Microsoft Azure ultra disks documentation

• Machine sets that deploy machines on ultra disks using CSI PVCs

• Machine sets that deploy machines on ultra disks using in-tree PVCs

Creating machines with ultra disks by using machine sets

You can deploy machines with ultra disks on Azure by editing your machine set YAML file.

Prerequisites

• Have an existing Microsoft Azure cluster.

Procedure

1. Create a custom secret in the openshift-machine-api namespace using the worker data secret by running the following command:

   $ oc -n openshift-machine-api \
   get secret worker-user-data \
   --template='{{index .data.userData | base64decode}}' | jq > userData.txt

   where userData.txt is the name of the new custom secret.

2. In a text editor, open the userData.txt file and locate the final } character in the file.

   1. On the immediately preceding line, add a ,.

   2. Create a new line after the , and add the following configuration details:

      "storage": {
        "disks": [ (1)
          {
            "device": "/dev/disk/azure/scsi1/lun0", (2)
            "partitions": [ (3)
              {
                "label": "lun0p1", (4)
                "sizeMiB": 1024, (5)
                "startMiB": 0
              }
            ]
          }
        ],
        "filesystems": [ (6)
          {
            "device": "/dev/disk/by-partlabel/lun0p1",
            "format": "xfs",
            "path": "/var/lib/lun0p1"
          }
        ]
      },
      "systemd": {
        "units": [ (7)
          {
            "contents": "[Unit]\nBefore=local-fs.target\n[Mount]\nWhere=/var/lib/lun0p1\nWhat=/dev/disk/by-partlabel/lun0p1\nOptions=defaults,pquota\n[Install]\nWantedBy=local-fs.target\n", (8)
            "enabled": true,
            "name": "var-lib-lun0p1.mount"
          }
        ]
      }

      1	The configuration details for the disk that you want to attach to a node as an ultra disk.
      2	Specify the lun value that is defined in the dataDisks stanza of the machine set you are using. For example, if the machine set contains lun: 0, specify lun0. You can initialize multiple data disks by specifying multiple “disks” entries in this configuration file. If you specify multiple “disks” entries, ensure that the lun value for each matches the value in the machine set.
      3	The configuration details for a new partition on the disk.
      4	Specify a label for the partition. You might find it helpful to use hierarchical names, such as lun0p1 for the first partition of lun0.
      5	Specify the total size in MiB of the partition.
      6	Specify the filesystem to use when formatting a partition. Use the partition label to specify the partition.
      7	Specify a systemd unit to mount the partition at boot. Use the partition label to specify the partition. You can create multiple partitions by specifying multiple “partitions” entries in this configuration file. If you specify multiple “partitions” entries, you must specify a systemd unit for each.
      8	For Where, specify the value of storage.filesystems.path. For What, specify the value of storage.filesystems.device.

3. Extract the disabling template value to a file called disableTemplating.txt by running the following command:

   $ oc -n openshift-machine-api get secret worker-user-data \
   --template='{{index .data.disableTemplating | base64decode}}' | jq > disableTemplating.txt

4. Combine the userData.txt file and disableTemplating.txt file to create a data secret file by running the following command:

   $ oc -n openshift-machine-api create secret generic worker-user-data-x5 \
   --from-file=userData=userData.txt \
   --from-file=disableTemplating=disableTemplating.txt

   where worker-user-data-x5 is the name of the secret.

5. Copy an existing Azure MachineSet custom resource (CR) and edit it by running the following command:

   $ oc edit machineset <machine-set-name>

   where <machine-set-name> is the machine set that you want to provision machines with ultra disks.

6. Add the following lines in the positions indicated:

   apiVersion: machine.openshift.io/v1beta1
   kind: MachineSet
     ...
   spec:
     ...
     template:
       ...
       spec:
         metadata:
           ...
           labels:
             ...
             disk: ultrassd (1)
             ...
         providerSpec:
           value:
             ...
             ultraSSDCapability: Enabled (2)
             dataDisks: (2)
             - nameSuffix: ultrassd
               lun: 0
               diskSizeGB: 4
               deletionPolicy: Delete
               cachingType: None
               managedDisk:
                 storageAccountType: UltraSSD_LRS
             userDataSecret:
               name: worker-user-data-x5 (3)
                ...

   1	Specify a label to use to select a node that is created by this machine set. This procedure uses disk.ultrassd for this value.
   2	These lines enable the use of ultra disks. For dataDisks, include the entire stanza.
   3	Specify the user data secret created earlier.

7. Create a machine set using the updated configuration by running the following command:

   $ oc create -f <machine-set-name>.yaml

Verification

1. Validate that the machines are created by running the following command:

   $ oc get machines

   The machines should be in the Running state.

2. For a machine that is running and has a node attached, validate the partition by running the following command:

   $ oc debug node/<node-name> -- chroot /host lsblk

   In this command, oc debug node/<node-name> starts a debugging shell on the node <node-name> and passes a command with --. The passed command chroot /host provides access to the underlying host OS binaries, and lsblk shows the block devices that are attached to the host OS machine.

Next steps

• To use an ultra disk from within a pod, create workload that uses the mount point. Create a YAML file similar to the following example:

  apiVersion: v1
  kind: Pod
  metadata:
    name: ssd-benchmark1
  spec:
    containers:
    - name: ssd-benchmark1
      image: nginx
      ports:
        - containerPort: 80
          name: "http-server"
      volumeMounts:
      - name: lun0p1
        mountPath: "/tmp"
    volumes:
      - name: lun0p1
        hostPath:
          path: /var/lib/lun0p1
          type: DirectoryOrCreate
    nodeSelector:
      disktype: ultrassd

Troubleshooting resources for machine sets that enable ultra disks

Use the information in this section to understand and recover from issues you might encounter.

Incorrect ultra disk configuration

If an incorrect configuration of the ultraSSDCapability parameter is specified in the machine set, the machine provisioning fails.

For example, if the ultraSSDCapability parameter is set to Disabled, but an ultra disk is specified in the dataDisks parameter, the following error message appears:

StorageAccountType UltraSSD_LRS can be used only when additionalCapabilities.ultraSSDEnabled is set.

• To resolve this issue, verify that your machine set configuration is correct.

Unsupported disk parameters

If a region, availability zone, or instance size that is not compatible with ultra disks is specified in the machine set, the machine provisioning fails. Check the logs for the following error message:

failed to create vm <machine_name>: failure sending request for machine <machine_name>: cannot create vm: compute.VirtualMachinesClient#CreateOrUpdate: Failure sending request: StatusCode=400 -- Original Error: Code="BadRequest" Message="Storage Account type 'UltraSSD_LRS' is not supported <more_information_about_why>."

• To resolve this issue, verify that you are using this feature in a supported environment and that your machine set configuration is correct.

Unable to delete disks

If the deletion of ultra disks as data disks is not working as expected, the machines are deleted and the data disks are orphaned. You must delete the orphaned disks manually if desired.

Enabling customer-managed encryption keys for a machine set

You can supply an encryption key to Azure to encrypt data on managed disks at rest. You can enable server-side encryption with customer-managed keys by using the Machine API.

An Azure Key Vault, a disk encryption set, and an encryption key are required to use a customer-managed key. The disk encryption set must preside in a resource group where the Cloud Credential Operator (CCO) has granted permissions. If not, an additional reader role is required to be granted on the disk encryption set.

Prerequisites

• Create an Azure Key Vault instance.

• Create an instance of a disk encryption set.

• Grant the disk encryption set access to key vault.

Procedure

• Configure the disk encryption set under the providerSpec field in your machine set YAML file. For example:

  ...
  providerSpec:
    value:
      ...
      osDisk:
        diskSizeGB: 128
        managedDisk:
          diskEncryptionSet:
            id: /subscriptions/<subscription_id>/resourceGroups/<resource_group_name>/providers/Microsoft.Compute/diskEncryptionSets/<disk_encryption_set_name>
          storageAccountType: Premium_LRS
  ...

Additional resources

• You can learn more about customer-managed keys in the Azure documentation.

Accelerated Networking for Microsoft Azure VMs

Accelerated Networking uses single root I/O virtualization (SR-IOV) to provide Microsoft Azure VMs with a more direct path to the switch. This enhances network performance. This feature can be enabled during or after installation.

Limitations

Consider the following limitations when deciding whether to use Accelerated Networking:

• Accelerated Networking is only supported on clusters where the Machine API is operational.

• Although the minimum requirement for an Azure worker node is two vCPUs, Accelerated Networking requires an Azure VM size that includes at least four vCPUs. To satisfy this requirement, you can change the value of vmSize in your machine set. For information about Azure VM sizes, see Microsoft Azure documentation.

• When this feature is enabled on an existing Azure cluster, only newly provisioned nodes are affected. Currently running nodes are not reconciled. To enable the feature on all nodes, you must replace each existing machine. This can be done for each machine individually, or by scaling the replicas down to zero, and then scaling back up to your desired number of replicas.

Additional resources

• Enabling Accelerated Networking during installation

Enabling Accelerated Networking on an existing Microsoft Azure cluster

You can enable Accelerated Networking on Azure by adding acceleratedNetworking to your machine set YAML file.

Prerequisites

• Have an existing Microsoft Azure cluster where the Machine API is operational.

Procedure

1. List the machine sets in your cluster by running the following command:

   $ oc get machinesets -n openshift-machine-api

   The machine sets are listed in the form of <cluster-id>-worker-<region>.

   Example output

   NAME                                DESIRED   CURRENT   READY   AVAILABLE   AGE
   jmywbfb-8zqpx-worker-centralus1     1         1         1       1           15m
   jmywbfb-8zqpx-worker-centralus2     1         1         1       1           15m
   jmywbfb-8zqpx-worker-centralus3     1         1         1       1           15m

2. For each machine set:

   1. Edit the custom resource (CR) by running the following command:

      $ oc edit machineset <machine-set-name>

   2. Add the following to the providerSpec field:

      providerSpec:
        value:
          ...
          acceleratedNetworking: true (1)
          ...
          vmSize: <azure-vm-size> (2)
          ...

      1	This line enables Accelerated Networking.
      2	Specify an Azure VM size that includes at least four vCPUs. For information about VM sizes, see Microsoft Azure documentation.

3. To enable the feature on currently running nodes, you must replace each existing machine. This can be done for each machine individually, or by scaling the replicas down to zero, and then scaling back up to your desired number of replicas.

Verification

• On the Microsoft Azure portal, review the Networking settings page for a machine provisioned by the machine set, and verify that the Accelerated networking field is set to Enabled.

Additional resources

• Manually scaling a machine set