Scaling VM instances in response to CPU load

Question

Pulumi · Accepted Answer

To scale virtual machine (VM) instances in response to CPU load, you can utilize an autoscaling group or similar managed service offered by cloud providers. An autoscaling group is a collection of VM instances that are treated as a logical grouping for the purposes of automatic scaling and management.

For our example, we will use the Google Cloud Platform (GCP) and set up a managed instance group with an autoscaler. The instance group will manage the VM instances, while the autoscaler will automatically adjust the number of instances in the group based on the observed CPU utilization.

In an autoscaler configuration, you can specify the target CPU utilization, which will trigger the scaling action when exceeded. You can also set a minimum and maximum number of instances to ensure that your application has enough capacity to handle the load and to control costs.

Here is a Pulumi program written in TypeScript that sets up a managed instance group with an autoscaler on GCP:

```typescript
import * as gcp from "@pulumi/gcp";

// Create a Google Compute Engine instance template, which defines the blueprint for our VM instances.
const instanceTemplate = new gcp.compute.InstanceTemplate("instanceTemplate", {
    machineType: "f1-micro", // Specify the type of machine. Adjust this to the appropriate type for your workload.
    tags: ["web"], // Optional tags for identifying your instances.
    networkInterfaces: [{
        network: "default", // Assuming the use of the default network; replace with your custom network if needed.
        accessConfigs: [{}], // This configuration requests an ephemeral public IP.
    }],
    disks: [{
        sourceImage: "projects/debian-cloud/global/images/family/debian-10", // The image from which to initialize the boot disk.
        autoDelete: true, // The boot disk will be deleted when the instance is deleted.
        boot: true,
    }],
});

// Create a managed instance group based on the instance template.
const instanceGroupManager = new gcp.compute.InstanceGroupManager("instanceGroupManager", {
    versions: [{
        instanceTemplate: instanceTemplate.selfLink,
    }],
    targetSize: 1, // Start with a single instance.
    zone: "us-central1-a", // Specify the zone where your instances should be created.
});

// Create an autoscaler for the managed instance group.
const autoscaler = new gcp.compute.RegionAutoscaler("autoscaler", {
    target: instanceGroupManager.instanceGroup,
    region: "us-central1",
    autoscalingPolicy: {
        minNumReplicas: 1, // The minimum number of instances to maintain.
        maxNumReplicas: 10, // The maximum number of instances to scale out to.
        cpuUtilization: {
            target: 0.8, // The target CPU utilization (80%) at which to scale. Adjust as needed for your use case.
        },
        cooldownPeriod: 45, // The number of seconds to wait after a new instance comes online before re-evaluating conditions.
    },
});

// Export the URL of the instance group to access it easily after deployment.
export const instanceGroupURL = instanceGroupManager.instanceGroup;
```

This code does the following:

1. Imports the `@pulumi/gcp` package to interact with GCP resources.
2. Defines an instance template (`gcp.compute.InstanceTemplate`) that specifies the configuration for VM instances in the managed instance group. It sets the machine type, network, and boot disk image.
3. Creates a managed instance group (`gcp.compute.InstanceGroupManager`) that manages the actual VM instances. It specifies the desired size and zone for the instances.
4. Defines an autoscaler (`gcp.compute.RegionAutoscaler`) that links to the managed instance group. The autoscaler uses the CPU utilization policy to determine when to scale the number of instances. The `minNumReplicas` and `maxNumReplicas` define the boundaries for the number of VMs in the instance group.
5. Sets the `target` CPU utilization to 80%, which means that if the average CPU utilization of the instances in the group goes above this threshold, the autoscaler will add more instances, up to a maximum of 10, as defined by `maxNumReplicas`.

When deploying this code with `pulumi up`, Pulumi will provision the resources as defined, and you'll have a scalable group of VM instances on GCP that adjust based on CPU usage. Remember to replace the network and image with the actual ones you intend to use in your project.