Compute Engine offers predefined machine types that you can use when
you create a VM instance. A predefined machine type has a preset number of vCPUs
and amount of memory, and is charged at a set price.
If predefined VMs don't meet your needs, you can create
a VM instance with custom virtualized hardware settings. Specifically, you can
create a VM instance with a custom number of vCPUs and amount of memory,
effectively using a custom machine type. With custom machine types, you can
create VM instances with as little as 1 vCPU and up to 96 vCPUs, or any even
number of vCPUs in between. You can also configure up to 8 GB of memory per vCPU.
Custom machine types are available in the general-purpose machine family.
When you create a custom VM, you're deploying a custom VM from the E2, N2, N2D,
or N1 machine family.
Custom VMs are ideal in the following scenarios:
- Workloads that aren't a good fit for the predefined virtual machine types.
- Workloads that require more processing power or more memory but don't need
all upgrades that are provided by the next level machine type.
Before you begin
Required roles
To get the permissions that you need to create a VM with a custom machine type,
ask your administrator to grant you the
Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1
) IAM role on the project.
For more information about granting roles, see Manage access.
This predefined role contains
the permissions required to create a VM with a custom machine type. To see the exact permissions that are
required, expand the Required permissions section:
Required permissions
The following permissions are required to create a VM with a custom machine type:
-
To add extended memory to an existing VM:
compute.instances.setMachineType
on the VM
-
To create a VM with a custom machine type:
compute.instances.create
on the project - To use a custom image to create the VM:
compute.images.useReadOnly
on the image - To use a snapshot to create the VM:
compute.snapshots.useReadOnly
on the snapshot - To use an instance template to create the VM:
compute.instanceTemplates.useReadOnly
on the instance template - To assign a legacy network to the VM:
compute.networks.use
on the project - To specify a static IP address for the VM:
compute.addresses.use
on the project - To assign an external IP address to the VM when using a legacy network:
compute.networks.useExternalIp
on the project - To specify a subnet for the VM:
compute.subnetworks.use
on the project or on the chosen subnet - To assign an external IP address to the VM when using a VPC network:
compute.subnetworks.useExternalIp
on the project or on the chosen subnet - To set VM instance metadata for the VM:
compute.instances.setMetadata
on the project - To set tags for the VM:
compute.instances.setTags
on the VM - To set labels for the VM:
compute.instances.setLabels
on the VM - To set a service account for the VM to use:
compute.instances.setServiceAccount
on the VM - To create a new disk for the VM:
compute.disks.create
on the project - To attach an existing disk in read-only or read-write mode:
compute.disks.use
on the disk - To attach an existing disk in read-only mode:
compute.disks.useReadOnly
on the disk
You might also be able to get
these permissions
with custom roles or
other predefined roles.
Pricing
Google charges for custom VMs based on the number of vCPUs and memory
hours that the VM uses. This is different from how predefined machine
types are charged. The on-demand prices for custom machine types include a 5%
premium over the on-demand prices for standard machine types.
See VM instance pricing
for the pricing information of custom machine types from each machine family.
Custom VMs are subject to the same 1-minute minimum charge as any other
instance, but sustained use discounts for custom
machine types are calculated differently. For more information, see
sustained use discounts
for custom VMs.
Expressing memory in GB or MB
For Google Cloud tools and documentation, machine type memory is
calculated in gigabytes (GB), where 1 GB is 230 bytes. This unit of measurement is also known as a gibibyte (GiB) .
When converting memory from GB to MB, 1 GB = 1024 MB.
In the API, you must always provide memory in megabytes. If you use the
Google Cloud CLI, you can provide the total memory for a VM in gigabytes
or megabytes. However, the gcloud CLI expects the memory value to be
an integer, so you cannot provide a float value. For example, to express 5.75
GB, convert 5.75 GB into MB instead. In this case, 5.75 GB is 5888 MB.
Create a VM with a custom machine type
Before you create a VM instance, make sure you read and understand the
custom specifications
for creating this machine type.
Console
In the Google Cloud console, go to the Create an instance page.
Go to Create an instance
In the Zone list, select the zone where you want to host this VM.
The Series list is filtered to include only the machine type families
available in the selected zone.
In the Machine configuration section, select General-purpose.
- In the Series list, click N1 in First
Generation for
N1 custom machine types or E2, N2, or N2D for
Second Generation custom machine types.
- In the Machine type section, select Custom.
- To specify the number of vCPUs and the amount of
memory for the VM instance, drag the sliders or enter the values in
the text boxes. The console displays an estimated cost
for the VM as you change the number of vCPUs and memory.
Continue to create the VM.
gcloud
The gcloud
command for custom machine types differs slightly depending
on the machine type family.
For N1 machine types, use the
gcloud compute instances create
command
and include one of the following options:
- The
--custom-cpu
and --custom-memory
flags.
- The
--machine-type=custom-[NUMBER_OF_CPUS]-[NUMBER_OF_MB]
flag.
For example, the following command would create an instance running an N1
machine type with 4 vCPUs and 5 GB of total memory:
gcloud compute instances create example-instance \
--custom-cpu=4 --custom-memory=5
For N2 machine types, use the
gcloud compute instances create
command
and include one of the following options:
- The
--custom-cpu
, --custom-memory
, and --custom-vm-type
flags.
- The
--machine-type=n2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB
flag.
When using the --custom-memory
flag, specify the total amount of
memory in GB or in MB. The property must be an integer, so if you want to
specify increments of 0.25 GB for memory, convert that value to MB instead.
To specify an incremental value, such as 2.5 GB of memory, convert the value
to MB and supply the value followed by the MB suffix. The following example
creates an instance running an N2 machine type:
gcloud compute instances create example-instance \
--custom-cpu=6 --custom-memory=3072MB --custom-vm-type=n2
Alternatively, you can specify a custom machine type using the following
format:
gcloud compute instances create example-instance \
--machine-type n2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB
Replace the following:
NUMBER_OF_CPUS
: The number of CPUs you want.
NUMBER_OF_MB
: The amount of memory, in MB.
For example:
gcloud compute instances create example-instance --machine-type=n2-custom-6-3072
For N2D or E2 machine types, use the
gcloud compute instances create
command
and include one of the following options:
- The
--custom-cpu
, --custom-memory
, and --custom-vm-type
flags.
- The
--machine-type=n2d-custom-NUMBER_OF_CPUS-NUMBER_OF_MB
flag.
- The
--machine-type=e2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB
flag.
For E2 shared-core custom machine types, use the same
gcloud compute instances create
command
and include the shared-core machine size: micro
, small
, or medium
.
- The
--machine-type=e2-custom-SHARED_CORE_MACHINE_SIZE-NUMBER_OF_MB
flag.
For example:
gcloud compute instances create example-instance \
--machine-type=e2-custom-medium-NUMBER_OF_MB
When using the --custom-memory
flag, specify the total amount of
memory in GB or in MB. The property must be an integer. So, if you want to
specify increments of 0.25 GB for memory, convert the value to MB instead.
To specify an incremental value, such as 2.5 GB of memory, convert the value
to MB and supply the value followed by the MB suffix. The following example
creates an instance running an E2 machine type:
gcloud compute instances create example-instance \
--custom-cpu=6 --custom-memory=3072MB --custom-vm-type=e2
Alternatively, you can specify a custom machine type by using the following
format:
gcloud compute instances create example-instance \
--machine-type=e2-custom-NUMBER_OF_CPUS-NUMBER_OF_MB
Replace the following:
NUMBER_OF_CPUS
: The number of CPUs you want.
NUMBER_OF_MB
: The amount of memory, in MB.
For example:
gcloud compute instances create example-instance --machine-type=e2-custom-6-3072
To generate the Terraform code, you can use the Equivalent code component in the Google Cloud console.
- In the Google Cloud console, go to the VM instances page.
Go to VM Instances
- Click Create instance.
- Specify the parameters you want.
- At the top or bottom of the page, click Equivalent code, and then click
the Terraform tab to view the Terraform code.
Go
Before trying this sample, follow the Go setup instructions in the
Compute Engine quickstart using
client libraries.
For more information, see the
Compute Engine Go API
reference documentation.
To authenticate to Compute Engine, set up Application Default Credentials.
For more information, see
Set up authentication for a local development environment.
import (
"context"
"fmt"
"io"
compute "cloud.google.com/go/compute/apiv1"
computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
"google.golang.org/protobuf/proto"
)
func customMachineTypeURI(zone, cpuSeries string, coreCount, memory int) (string, error) {
const (
n1 = "custom"
n2 = "n2-custom"
n2d = "n2d-custom"
e2 = "e2-custom"
e2Micro = "e2-custom-micro"
e2Small = "e2-custom-small"
e2Medium = "e2-custom-medium"
)
type typeLimit struct {
allowedCores []int
minMemPerCore int
maxMemPerCore int
allowExtraMemory bool
extraMemoryLimit int
}
makeRange := func(start, end, step int) []int {
if step <= 0 || end < start {
return []int{}
}
s := make([]int, 0, 1+(end-start)/step)
for start <= end {
s = append(s, start)
start += step
}
return s
}
containsString := func(s []string, str string) bool {
for _, v := range s {
if v == str {
return true
}
}
return false
}
containsInt := func(nums []int, n int) bool {
for _, v := range nums {
if v == n {
return true
}
}
return false
}
var (
cpuSeriesE2Limit = typeLimit{
allowedCores: makeRange(2, 33, 2),
minMemPerCore: 512,
maxMemPerCore: 8192,
}
cpuSeriesE2MicroLimit = typeLimit{minMemPerCore: 1024, maxMemPerCore: 2048}
cpuSeriesE2SmallLimit = typeLimit{minMemPerCore: 2048, maxMemPerCore: 4096}
cpuSeriesE2MeidumLimit = typeLimit{minMemPerCore: 4096, maxMemPerCore: 8192}
cpuSeriesN2Limit = typeLimit{
allowedCores: append(makeRange(2, 33, 2), makeRange(36, 129, 4)...),
minMemPerCore: 512, maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
}
cpuSeriesN2DLimit = typeLimit{
allowedCores: []int{2, 4, 8, 16, 32, 48, 64, 80, 96},
minMemPerCore: 512, maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 768 << 10,
}
cpuSeriesN1Limit = typeLimit{
allowedCores: append([]int{1}, makeRange(2, 97, 2)...),
minMemPerCore: 922,
maxMemPerCore: 6656,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
}
)
typeLimitsMap := map[string]typeLimit{
n1: cpuSeriesN1Limit,
n2: cpuSeriesN2Limit,
n2d: cpuSeriesN2DLimit,
e2: cpuSeriesE2Limit,
e2Micro: cpuSeriesE2MicroLimit,
e2Small: cpuSeriesE2SmallLimit,
e2Medium: cpuSeriesE2MeidumLimit,
}
if !containsString([]string{e2, n1, n2, n2d}, cpuSeries) {
return "", fmt.Errorf("incorrect cpu type: %v", cpuSeries)
}
tl := typeLimitsMap[cpuSeries]
// Check whether the requested parameters are allowed.
// Find more information about limitations of custom machine types at:
// https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
// Check the number of cores
if len(tl.allowedCores) > 0 && !containsInt(tl.allowedCores, coreCount) {
return "", fmt.Errorf(
"invalid number of cores requested. Allowed number of cores for %v is: %v",
cpuSeries,
tl.allowedCores,
)
}
// Memory must be a multiple of 256 MB
if memory%256 != 0 {
return "", fmt.Errorf("requested memory must be a multiple of 256 MB")
}
// Check if the requested memory isn't too little
if memory < coreCount*tl.minMemPerCore {
return "", fmt.Errorf(
"requested memory is too low. Minimal memory for %v is %v MB per core",
cpuSeries,
tl.minMemPerCore,
)
}
// Check if the requested memory isn't too much
if memory > coreCount*tl.maxMemPerCore && !tl.allowExtraMemory {
return "", fmt.Errorf(
"requested memory is too large.. Maximum memory allowed for %v is %v MB per core",
cpuSeries,
tl.maxMemPerCore,
)
}
if memory > tl.extraMemoryLimit && tl.allowExtraMemory {
return "", fmt.Errorf(
"requested memory is too large.. Maximum memory allowed for %v is %v MB",
cpuSeries,
tl.extraMemoryLimit,
)
}
// Return the custom machine type in form of a string acceptable by Compute Engine API.
if containsString([]string{e2Small, e2Micro, e2Medium}, cpuSeries) {
return fmt.Sprintf("zones/%v/machineTypes/%v-%v", zone, cpuSeries, memory), nil
}
if memory > coreCount*tl.maxMemPerCore {
return fmt.Sprintf(
"zones/%v/machineTypes/%v-%v-%v-ext",
zone,
cpuSeries,
coreCount,
memory,
), nil
}
return fmt.Sprintf("zones/%v/machineTypes/%v-%v-%v", zone, cpuSeries, coreCount, memory), nil
}
// createInstanceWithCustomMachineTypeWithHelper creates a new VM instance with a custom machine type.
func createInstanceWithCustomMachineTypeWithHelper(
w io.Writer,
projectID, zone, instanceName, cpuSeries string,
coreCount, memory int,
) error {
// projectID := "your_project_id"
// zone := "europe-central2-b"
// instanceName := "your_instance_name"
// cpuSeries := "e2-custom-micro" // the type of CPU you want to use"
// coreCount := 2 // number of CPU cores you want to use.
// memory := 256 // the amount of memory for the VM instance, in megabytes.
machineType, err := customMachineTypeURI(zone, cpuSeries, coreCount, memory)
if err != nil {
return fmt.Errorf("unable to create custom machine type string: %w", err)
}
ctx := context.Background()
instancesClient, err := compute.NewInstancesRESTClient(ctx)
if err != nil {
return fmt.Errorf("NewInstancesRESTClient: %w", err)
}
defer instancesClient.Close()
req := &computepb.InsertInstanceRequest{
Project: projectID,
Zone: zone,
InstanceResource: &computepb.Instance{
Name: proto.String(instanceName),
Disks: []*computepb.AttachedDisk{
{
InitializeParams: &computepb.AttachedDiskInitializeParams{
DiskSizeGb: proto.Int64(10),
SourceImage: proto.String(
"projects/debian-cloud/global/images/family/debian-10",
),
},
AutoDelete: proto.Bool(true),
Boot: proto.Bool(true),
},
},
MachineType: proto.String(machineType),
NetworkInterfaces: []*computepb.NetworkInterface{
{
Name: proto.String("global/networks/default"),
},
},
},
}
op, err := instancesClient.Insert(ctx, req)
if err != nil {
return fmt.Errorf("unable to create instance: %w", err)
}
if err = op.Wait(ctx); err != nil {
return fmt.Errorf("unable to wait for the operation: %w", err)
}
fmt.Fprintf(w, "Instance created\n")
return nil
}
Java
Before trying this sample, follow the Java setup instructions in the
Compute Engine quickstart using
client libraries.
For more information, see the
Compute Engine Java API
reference documentation.
To authenticate to Compute Engine, set up Application Default Credentials.
For more information, see
Set up authentication for a local development environment.
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.InsertInstanceRequest;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import com.google.cloud.compute.v1.Operation;
import com.google.common.collect.ImmutableMap;
import java.io.IOException;
import java.util.Arrays;
import java.util.Collections;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.IntStream;
public class CreateWithHelper {
// This class defines the configurable parameters for a custom VM.
static final class TypeLimits {
int[] allowedCores;
int minMemPerCore;
int maxMemPerCore;
int extraMemoryLimit;
boolean allowExtraMemory;
TypeLimits(int[] allowedCores, int minMemPerCore, int maxMemPerCore, boolean allowExtraMemory,
int extraMemoryLimit) {
this.allowedCores = allowedCores;
this.minMemPerCore = minMemPerCore;
this.maxMemPerCore = maxMemPerCore;
this.allowExtraMemory = allowExtraMemory;
this.extraMemoryLimit = extraMemoryLimit;
}
}
public enum CpuSeries {
N1("custom"),
N2("n2-custom"),
N2D("n2d-custom"),
E2("e2-custom"),
E2_MICRO("e2-custom-micro"),
E2_SMALL("e2-custom-small"),
E2_MEDIUM("e2-custom-medium");
private static final Map<String, CpuSeries> ENUM_MAP;
static {
ENUM_MAP = init();
}
// Build an immutable map of String name to enum pairs.
public static Map<String, CpuSeries> init() {
Map<String, CpuSeries> map = new ConcurrentHashMap<>();
for (CpuSeries instance : CpuSeries.values()) {
map.put(instance.getCpuSeries(), instance);
}
return Collections.unmodifiableMap(map);
}
private final String cpuSeries;
CpuSeries(String cpuSeries) {
this.cpuSeries = cpuSeries;
}
public static CpuSeries get(String name) {
return ENUM_MAP.get(name);
}
public String getCpuSeries() {
return this.cpuSeries;
}
}
// This enum correlates a machine type with its limits.
// The limits for various CPU types are described in:
// https://cloud.google.com/compute/docs/general-purpose-machines
enum Limits {
CPUSeries_E2(new TypeLimits(getNumsInRangeWithStep(2, 33, 2), 512, 8192, false, 0)),
CPUSeries_E2MICRO(new TypeLimits(new int[]{}, 1024, 2048, false, 0)),
CPUSeries_E2SMALL(new TypeLimits(new int[]{}, 2048, 4096, false, 0)),
CPUSeries_E2MEDIUM(new TypeLimits(new int[]{}, 4096, 8192, false, 0)),
CPUSeries_N2(
new TypeLimits(concat(getNumsInRangeWithStep(2, 33, 2), getNumsInRangeWithStep(36, 129, 4)),
512, 8192, true, gbToMb(624))),
CPUSeries_N2D(
new TypeLimits(new int[]{2, 4, 8, 16, 32, 48, 64, 80, 96}, 512, 8192, true, gbToMb(768))),
CPUSeries_N1(
new TypeLimits(concat(new int[]{1}, getNumsInRangeWithStep(2, 97, 2)), 922, 6656, true,
gbToMb(624)));
private final TypeLimits typeLimits;
Limits(TypeLimits typeLimits) {
this.typeLimits = typeLimits;
}
public TypeLimits getTypeLimits() {
return typeLimits;
}
}
static ImmutableMap<String, Limits> typeLimitsMap = ImmutableMap.<String, Limits>builder()
.put("N1", Limits.CPUSeries_N1)
.put("N2", Limits.CPUSeries_N2)
.put("N2D", Limits.CPUSeries_N2D)
.put("E2", Limits.CPUSeries_E2)
.put("E2_MICRO", Limits.CPUSeries_E2MICRO)
.put("E2_SMALL", Limits.CPUSeries_E2SMALL)
.put("E2_MEDIUM", Limits.CPUSeries_E2SMALL)
.build();
// Returns the array of integers within the given range, incremented by the specified step.
// start (inclusive): starting number of the range
// stop (inclusive): ending number of the range
// step : increment value
static int[] getNumsInRangeWithStep(int start, int stop, int step) {
return IntStream.range(start, stop).filter(x -> (x - start) % step == 0).toArray();
}
static int gbToMb(int value) {
return value << 10;
}
static int[] concat(int[] a, int[] b) {
int[] result = new int[a.length + b.length];
System.arraycopy(a, 0, result, 0, a.length);
System.arraycopy(b, 0, result, a.length, b.length);
return result;
}
public static void main(String[] args)
throws IOException, ExecutionException, InterruptedException, TimeoutException {
// TODO(developer): Replace these variables before running the sample.
// Project ID or project number of the Cloud project you want to use.
String projectId = "your-google-cloud-project-id";
// Name of the zone to create the instance in. For example: "us-west3-b".
String zone = "google-cloud-zone";
// Name of the new virtual machine (VM) instance.
String instanceName = "instance-name";
String cpuSeries = "N1";
// Number of CPU cores you want to use.
int coreCount = 2;
// The amount of memory for the VM instance, in megabytes.
int memory = 256;
createInstanceWithCustomMachineTypeWithHelper(
projectId, zone, instanceName, cpuSeries, coreCount, memory);
}
// Create a VM instance with a custom machine type.
public static void createInstanceWithCustomMachineTypeWithHelper(
String project, String zone, String instanceName, String cpuSeries, int coreCount, int memory)
throws IOException, ExecutionException, InterruptedException, TimeoutException {
// Construct the URI string identifying the machine type.
String machineTypeUri = customMachineTypeUri(zone, cpuSeries, coreCount, memory);
// Initialize client that will be used to send requests. This client only needs to be created
// once, and can be reused for multiple requests. After completing all of your requests, call
// the `instancesClient.close()` method on the client to safely
// clean up any remaining background resources.
try (InstancesClient instancesClient = InstancesClient.create()) {
AttachedDisk attachedDisk = AttachedDisk.newBuilder()
.setInitializeParams(
// Describe the size and source image of the boot disk to attach to the instance.
// The list of public images available in Compute Engine can be found here:
// https://cloud.google.com/compute/docs/images#list_of_public_images_available_on
AttachedDiskInitializeParams.newBuilder()
.setSourceImage(
String.format("projects/%s/global/images/family/%s", "debian-cloud",
"debian-11"))
.setDiskSizeGb(10)
.build()
)
// Remember to set auto_delete to True if you want the disk to be deleted when you delete
// your VM instance.
.setAutoDelete(true)
.setBoot(true)
.build();
// Create the Instance object with the relevant information.
Instance instance = Instance.newBuilder()
.setName(instanceName)
.addDisks(attachedDisk)
.setMachineType(machineTypeUri)
.addNetworkInterfaces(
NetworkInterface.newBuilder().setName("global/networks/default").build())
.build();
// Create the insert instance request object.
InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder()
.setProject(project)
.setZone(zone)
.setInstanceResource(instance)
.build();
// Invoke the API with the request object and wait for the operation to complete.
Operation response = instancesClient.insertAsync(insertInstanceRequest)
.get(3, TimeUnit.MINUTES);
// Check for errors.
if (response.hasError()) {
throw new Error("Instance creation failed!!" + response);
}
System.out.printf("Instance created : %s", instanceName);
System.out.println("Operation Status: " + response.getStatus());
}
}
public static String customMachineTypeUri(String zone, String cpuSeries, int coreCount,
int memory) {
if (!Arrays.asList(CpuSeries.E2.cpuSeries, CpuSeries.N1.cpuSeries, CpuSeries.N2.cpuSeries,
CpuSeries.N2D.cpuSeries).contains(cpuSeries)) {
throw new Error(String.format("Incorrect cpu type: %s", cpuSeries));
}
TypeLimits typeLimit = Objects.requireNonNull(
typeLimitsMap.get(CpuSeries.get(cpuSeries).name())).typeLimits;
// Perform the following checks to verify if the requested parameters are allowed.
// Find more information about limitations of custom machine types at:
// https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
// 1. Check the number of cores and if the coreCount is present in allowedCores.
if (typeLimit.allowedCores.length > 0 && Arrays.stream(typeLimit.allowedCores)
.noneMatch(x -> x == coreCount)) {
throw new Error(String.format(
"Invalid number of cores requested. "
+ "Number of cores requested for CPU %s should be one of: %s",
cpuSeries,
Arrays.toString(typeLimit.allowedCores)));
}
// 2. Memory must be a multiple of 256 MB
if (memory % 256 != 0) {
throw new Error("Requested memory must be a multiple of 256 MB");
}
// 3. Check if the requested memory isn't too little
if (memory < coreCount * typeLimit.minMemPerCore) {
throw new Error(
String.format("Requested memory is too low. Minimum memory for %s is %s MB per core",
cpuSeries, typeLimit.minMemPerCore));
}
// 4. Check if the requested memory isn't too much
if (memory > coreCount * typeLimit.maxMemPerCore && !typeLimit.allowExtraMemory) {
throw new Error(String.format(
"Requested memory is too large.. Maximum memory allowed for %s is %s MB per core",
cpuSeries, typeLimit.extraMemoryLimit));
}
// 5. Check if the requested memory isn't too large
if (memory > typeLimit.extraMemoryLimit && typeLimit.allowExtraMemory) {
throw new Error(
String.format("Requested memory is too large.. Maximum memory allowed for %s is %s MB",
cpuSeries, typeLimit.extraMemoryLimit));
}
// Check if the CPU Series is E2 and return the custom machine type in the form of a string
// acceptable by Compute Engine API.
if (Arrays.asList(CpuSeries.E2_SMALL.cpuSeries, CpuSeries.E2_MICRO.cpuSeries,
CpuSeries.E2_MEDIUM.cpuSeries).contains(cpuSeries)) {
return String.format("zones/%s/machineTypes/%s-%s", zone, cpuSeries, memory);
}
// Check if extended memory was requested and return the extended custom machine type
// in the form of a string acceptable by Compute Engine API.
if (memory > coreCount * typeLimit.maxMemPerCore) {
return String.format("zones/%s/machineTypes/%s-%s-%s-ext", zone, cpuSeries, coreCount,
memory);
}
// Return the custom machine type in the form of a standard string
// acceptable by Compute Engine API.
return String.format("zones/%s/machineTypes/%s-%s-%s", zone, cpuSeries, coreCount, memory);
}
}
Node.js
Before trying this sample, follow the Node.js setup instructions in the
Compute Engine quickstart using
client libraries.
For more information, see the
Compute Engine Node.js API
reference documentation.
To authenticate to Compute Engine, set up Application Default Credentials.
For more information, see
Set up authentication for a local development environment.
/**
* TODO(developer): Uncomment and replace these variables before running the sample.
*/
// const projectId = 'YOUR_PROJECT_ID';
// const zone = 'europe-central2-b';
// const instanceName = 'YOUR_INSTANCE_NAME';
// const cpuSeries = 'N1';
// const coreCount = 2
// const memory = 256
const compute = require('@google-cloud/compute');
function range(from, to, step) {
return [...Array(Math.floor((to - from) / step) + 1)].map(
(_, i) => from + i * step
);
}
class CustomMachineType {
constructor(zone, cpuSeries, coreCount, memory) {
this.zone = zone;
this.cpuSeries = cpuSeries;
this.coreCount = coreCount;
this.memory = memory;
this.N1 = 'custom';
this.N2 = 'n2-custom';
this.N2D = 'n2d-custom';
this.E2 = 'e2-custom';
this.E2Micro = 'e2-custom-micro';
this.E2Small = 'e2-custom-small';
this.E2Medium = 'e2-custom-medium';
this.CpuSeriesE2Limit = {
allowedCores: range(2, 33, 2),
minMemPerCore: 512,
maxMemPerCore: 8192,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesE2MicroLimit = {
allowedCores: [],
minMemPerCore: 1024,
maxMemPerCore: 2048,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesE2SmallLimit = {
allowedCores: [],
minMemPerCore: 2048,
maxMemPerCore: 4096,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesE2MediumLimit = {
allowedCores: [],
minMemPerCore: 4096,
maxMemPerCore: 8192,
allowExtraMemory: false,
extraMemoryLimit: 0,
};
this.CpuSeriesN2Limit = {
allowedCores: [...range(2, 33, 2), ...range(36, 129, 4)],
minMemPerCore: 512,
maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
};
this.CpuSeriesN2DLimit = {
allowedCores: [2, 4, 8, 16, 32, 48, 64, 80, 96],
minMemPerCore: 512,
maxMemPerCore: 8192,
allowExtraMemory: true,
extraMemoryLimit: 768 << 10,
};
this.CpuSeriesN1Limit = {
allowedCores: [1, range(2, 97, 2)],
minMemPerCore: 922,
maxMemPerCore: 6656,
allowExtraMemory: true,
extraMemoryLimit: 624 << 10,
};
this.TYPE_LIMITS = {
[this.N1]: this.CpuSeriesN1Limit,
[this.N2]: this.CpuSeriesN2Limit,
[this.N2D]: this.CpuSeriesN2DLimit,
[this.E2]: this.CpuSeriesE2Limit,
[this.E2Micro]: this.CpuSeriesE2MicroLimit,
[this.E2Small]: this.CpuSeriesE2SmallLimit,
[this.E2Medium]: this.CpuSeriesE2MediumLimit,
};
if (![this.E2, this.N1, this.N2, this.N2D].includes(cpuSeries)) {
throw new Error(`Incorrect CPU type: ${this.cpuSeries}`);
}
this.typeLimit = this.TYPE_LIMITS[this.cpuSeries];
// Check whether the requested parameters are allowed.
// Find more information about limitations of custom machine types at:
// https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
// Check the number of cores
if (
this.typeLimit.allowedCores.length > 0 &&
!this.typeLimit.allowedCores.includes(coreCount)
) {
throw new Error(
`Invalid number of cores requested. Allowed number of cores for ${this.cpuSeries} is: ${this.typeLimit.allowedCores}`
);
}
// Memory must be a multiple of 256 MB
if (this.memory % 256 !== 0) {
throw new Error('Requested memory must be a multiple of 256 MB');
}
// Check if the requested memory isn't too little
if (this.memory < this.coreCount * this.typeLimit.minMemPerCore) {
throw new Error(
`Requested memory is too low. Minimal memory for ${this.cpuSeries} is ${this.typeLimit.minMemPerCore} MB per core`
);
}
// Check if the requested memory isn't too much
if (
this.memory > this.coreCount * this.typeLimit.maxMemPerCore &&
!this.typeLimit.allowExtraMemory
) {
throw new Error(
`Requested memory is too large.. Maximum memory allowed for ${this.cpuSeries} is ${this.typeLimit.maxMemPerCore} MB per core`
);
}
if (
this.memory > this.typeLimit.extraMemoryLimit &&
this.typeLimit.allowExtraMemory
) {
throw new Error(
`Requested memory is too large.. Maximum memory allowed for ${this.cpuSeries} is ${this.typeLimit.extraMemoryLimit} MB`
);
}
}
// Returns the custom machine type in form of a string acceptable by Compute Engine API.
getMachineTypeURI() {
if (
[this.E2Small, this.E2Micro, this.E2Medium].includes(this.cpuSeries)
) {
return `zones/${this.zone}/machineTypes/${this.cpuSeries}-${this.memory}`;
}
if (this.memory > this.coreCount * this.typeLimit.maxMemPerCore) {
return `zones/${this.zone}/machineTypes/${this.cpuSeries}-${this.coreCount}-${this.memory}-ext`;
}
return `zones/${zone}/machineTypes/${this.cpuSeries}-${this.coreCount}-${this.memory}`;
}
}
async function createInstanceWithCustomMachineTypeWithHelper() {
const instancesClient = new compute.InstancesClient();
const machineType = new CustomMachineType(
zone,
cpuSeries,
coreCount,
memory
).getMachineTypeURI();
const [response] = await instancesClient.insert({
instanceResource: {
name: instanceName,
disks: [
{
initializeParams: {
diskSizeGb: '64',
sourceImage:
'projects/debian-cloud/global/images/family/debian-11/',
},
autoDelete: true,
boot: true,
},
],
machineType,
networkInterfaces: [
{
name: 'global/networks/default',
},
],
},
project: projectId,
zone,
});
let operation = response.latestResponse;
const operationsClient = new compute.ZoneOperationsClient();
// Wait for the create operation to complete.
while (operation.status !== 'DONE') {
[operation] = await operationsClient.wait({
operation: operation.name,
project: projectId,
zone: operation.zone.split('/').pop(),
});
}
console.log('Instance created.');
}
createInstanceWithCustomMachineTypeWithHelper();
Python
Before trying this sample, follow the Python setup instructions in the
Compute Engine quickstart using
client libraries.
For more information, see the
Compute Engine Python API
reference documentation.
To authenticate to Compute Engine, set up Application Default Credentials.
For more information, see
Set up authentication for a local development environment.
from __future__ import annotations
from collections import namedtuple
from enum import Enum
from enum import unique
import re
import sys
from typing import Any
import warnings
from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1
def gb_to_mb(value: int) -> int:
return value << 10
class CustomMachineType:
"""
Allows to create custom machine types to be used with the VM instances.
"""
@unique
class CPUSeries(Enum):
N1 = "custom"
N2 = "n2-custom"
N2D = "n2d-custom"
E2 = "e2-custom"
E2_MICRO = "e2-custom-micro"
E2_SMALL = "e2-custom-small"
E2_MEDIUM = "e2-custom-medium"
TypeLimits = namedtuple(
"TypeLimits",
[
"allowed_cores",
"min_mem_per_core",
"max_mem_per_core",
"allow_extra_memory",
"extra_memory_limit",
],
)
# The limits for various CPU types are described on:
# https://cloud.google.com/compute/docs/general-purpose-machines
LIMITS = {
CPUSeries.E2: TypeLimits(frozenset(range(2, 33, 2)), 512, 8192, False, 0),
CPUSeries.E2_MICRO: TypeLimits(frozenset(), 1024, 2048, False, 0),
CPUSeries.E2_SMALL: TypeLimits(frozenset(), 2048, 4096, False, 0),
CPUSeries.E2_MEDIUM: TypeLimits(frozenset(), 4096, 8192, False, 0),
CPUSeries.N2: TypeLimits(
frozenset(range(2, 33, 2)).union(set(range(36, 129, 4))),
512,
8192,
True,
gb_to_mb(624),
),
CPUSeries.N2D: TypeLimits(
frozenset({2, 4, 8, 16, 32, 48, 64, 80, 96}), 512, 8192, True, gb_to_mb(768)
),
CPUSeries.N1: TypeLimits(
frozenset({1}.union(range(2, 97, 2))), 922, 6656, True, gb_to_mb(624)
),
}
def __init__(
self, zone: str, cpu_series: CPUSeries, memory_mb: int, core_count: int = 0
):
self.zone = zone
self.cpu_series = cpu_series
self.limits = self.LIMITS[self.cpu_series]
# Shared machine types (e2-small, e2-medium and e2-micro) always have
# 2 vCPUs: https://cloud.google.com/compute/docs/general-purpose-machines#e2_limitations
self.core_count = 2 if self.is_shared() else core_count
self.memory_mb = memory_mb
self._checked = False
self._check_parameters()
self.extra_memory_used = self._check_extra_memory()
def is_shared(self):
return self.cpu_series in (
CustomMachineType.CPUSeries.E2_SMALL,
CustomMachineType.CPUSeries.E2_MICRO,
CustomMachineType.CPUSeries.E2_MEDIUM,
)
def _check_extra_memory(self) -> bool:
if self._checked:
return self.memory_mb > self.core_count * self.limits.max_mem_per_core
else:
raise RuntimeError(
"You need to call _check_parameters() before calling _check_extra_memory()"
)
def _check_parameters(self):
"""
Check whether the requested parameters are allowed. Find more information about limitations of custom machine
types at: https://cloud.google.com/compute/docs/general-purpose-machines#custom_machine_types
"""
# Check the number of cores
if (
self.limits.allowed_cores
and self.core_count not in self.limits.allowed_cores
):
raise RuntimeError(
f"Invalid number of cores requested. Allowed number of cores for {self.cpu_series.name} is: {sorted(self.limits.allowed_cores)}"
)
# Memory must be a multiple of 256 MB
if self.memory_mb % 256 != 0:
raise RuntimeError("Requested memory must be a multiple of 256 MB.")
# Check if the requested memory isn't too little
if self.memory_mb < self.core_count * self.limits.min_mem_per_core:
raise RuntimeError(
f"Requested memory is too low. Minimal memory for {self.cpu_series.name} is {self.limits.min_mem_per_core} MB per core."
)
# Check if the requested memory isn't too much
if self.memory_mb > self.core_count * self.limits.max_mem_per_core:
if self.limits.allow_extra_memory:
if self.memory_mb > self.limits.extra_memory_limit:
raise RuntimeError(
f"Requested memory is too large.. Maximum memory allowed for {self.cpu_series.name} is {self.limits.extra_memory_limit} MB."
)
else:
raise RuntimeError(
f"Requested memory is too large.. Maximum memory allowed for {self.cpu_series.name} is {self.limits.max_mem_per_core} MB per core."
)
self._checked = True
def __str__(self) -> str:
"""
Return the custom machine type in form of a string acceptable by Compute Engine API.
"""
if self.cpu_series in {
self.CPUSeries.E2_SMALL,
self.CPUSeries.E2_MICRO,
self.CPUSeries.E2_MEDIUM,
}:
return f"zones/{self.zone}/machineTypes/{self.cpu_series.value}-{self.memory_mb}"
if self.extra_memory_used:
return f"zones/{self.zone}/machineTypes/{self.cpu_series.value}-{self.core_count}-{self.memory_mb}-ext"
return f"zones/{self.zone}/machineTypes/{self.cpu_series.value}-{self.core_count}-{self.memory_mb}"
def short_type_str(self) -> str:
"""
Return machine type in a format without the zone. For example, n2-custom-0-10240.
This format is used to create instance templates.
"""
return str(self).rsplit("/", maxsplit=1)[1]
@classmethod
def from_str(cls, machine_type: str):
"""
Construct a new object from a string. The string needs to be a valid custom machine type like:
- https://www.googleapis.com/compute/v1/projects/diregapic-mestiv/zones/us-central1-b/machineTypes/e2-custom-4-8192
- zones/us-central1-b/machineTypes/e2-custom-4-8192
- e2-custom-4-8192 (in this case, the zone parameter will not be set)
"""
zone = None
if machine_type.startswith("http"):
machine_type = machine_type[machine_type.find("zones/") :]
if machine_type.startswith("zones/"):
_, zone, _, machine_type = machine_type.split("/")
extra_mem = machine_type.endswith("-ext")
if machine_type.startswith("custom"):
cpu = cls.CPUSeries.N1
_, cores, memory = machine_type.rsplit("-", maxsplit=2)
else:
if extra_mem:
cpu_series, _, cores, memory, _ = machine_type.split("-")
else:
cpu_series, _, cores, memory = machine_type.split("-")
if cpu_series == "n2":
cpu = cls.CPUSeries.N2
elif cpu_series == "n2d":
cpu = cls.CPUSeries.N2D
elif cpu_series == "e2":
cpu = cls.CPUSeries.E2
if cores == "micro":
cpu = cls.CPUSeries.E2_MICRO
cores = 2
elif cores == "small":
cpu = cls.CPUSeries.E2_SMALL
cores = 2
elif cores == "medium":
cpu = cls.CPUSeries.E2_MEDIUM
cores = 2
else:
raise RuntimeError("Unknown CPU series.")
cores = int(cores)
memory = int(memory)
return cls(zone, cpu, memory, cores)
def get_image_from_family(project: str, family: str) -> compute_v1.Image:
"""
Retrieve the newest image that is part of a given family in a project.
Args:
project: project ID or project number of the Cloud project you want to get image from.
family: name of the image family you want to get image from.
Returns:
An Image object.
"""
image_client = compute_v1.ImagesClient()
# List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
newest_image = image_client.get_from_family(project=project, family=family)
return newest_image
def disk_from_image(
disk_type: str,
disk_size_gb: int,
boot: bool,
source_image: str,
auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
"""
Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
source for the new disk.
Args:
disk_type: the type of disk you want to create. This value uses the following format:
"zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
For example: "zones/us-west3-b/diskTypes/pd-ssd"
disk_size_gb: size of the new disk in gigabytes
boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
of the publicly available images or an image from one of your projects.
This value uses the following format: "projects/{project_name}/global/images/{image_name}"
auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it
Returns:
AttachedDisk object configured to be created using the specified image.
"""
boot_disk = compute_v1.AttachedDisk()
initialize_params = compute_v1.AttachedDiskInitializeParams()
initialize_params.source_image = source_image
initialize_params.disk_size_gb = disk_size_gb
initialize_params.disk_type = disk_type
boot_disk.initialize_params = initialize_params
# Remember to set auto_delete to True if you want the disk to be deleted when you delete
# your VM instance.
boot_disk.auto_delete = auto_delete
boot_disk.boot = boot
return boot_disk
def wait_for_extended_operation(
operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
"""
Waits for the extended (long-running) operation to complete.
If the operation is successful, it will return its result.
If the operation ends with an error, an exception will be raised.
If there were any warnings during the execution of the operation
they will be printed to sys.stderr.
Args:
operation: a long-running operation you want to wait on.
verbose_name: (optional) a more verbose name of the operation,
used only during error and warning reporting.
timeout: how long (in seconds) to wait for operation to finish.
If None, wait indefinitely.
Returns:
Whatever the operation.result() returns.
Raises:
This method will raise the exception received from `operation.exception()`
or RuntimeError if there is no exception set, but there is an `error_code`
set for the `operation`.
In case of an operation taking longer than `timeout` seconds to complete,
a `concurrent.futures.TimeoutError` will be raised.
"""
result = operation.result(timeout=timeout)
if operation.error_code:
print(
f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
file=sys.stderr,
flush=True,
)
print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
raise operation.exception() or RuntimeError(operation.error_message)
if operation.warnings:
print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
for warning in operation.warnings:
print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
return result
def create_instance(
project_id: str,
zone: str,
instance_name: str,
disks: list[compute_v1.AttachedDisk],
machine_type: str = "n1-standard-1",
network_link: str = "global/networks/default",
subnetwork_link: str = None,
internal_ip: str = None,
external_access: bool = False,
external_ipv4: str = None,
accelerators: list[compute_v1.AcceleratorConfig] = None,
preemptible: bool = False,
spot: bool = False,
instance_termination_action: str = "STOP",
custom_hostname: str = None,
delete_protection: bool = False,
) -> compute_v1.Instance:
"""
Send an instance creation request to the Compute Engine API and wait for it to complete.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
disks: a list of compute_v1.AttachedDisk objects describing the disks
you want to attach to your new instance.
machine_type: machine type of the VM being created. This value uses the
following format: "zones/{zone}/machineTypes/{type_name}".
For example: "zones/europe-west3-c/machineTypes/f1-micro"
network_link: name of the network you want the new instance to use.
For example: "global/networks/default" represents the network
named "default", which is created automatically for each project.
subnetwork_link: name of the subnetwork you want the new instance to use.
This value uses the following format:
"regions/{region}/subnetworks/{subnetwork_name}"
internal_ip: internal IP address you want to assign to the new instance.
By default, a free address from the pool of available internal IP addresses of
used subnet will be used.
external_access: boolean flag indicating if the instance should have an external IPv4
address assigned.
external_ipv4: external IPv4 address to be assigned to this instance. If you specify
an external IP address, it must live in the same region as the zone of the instance.
This setting requires `external_access` to be set to True to work.
accelerators: a list of AcceleratorConfig objects describing the accelerators that will
be attached to the new instance.
preemptible: boolean value indicating if the new instance should be preemptible
or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
spot: boolean value indicating if the new instance should be a Spot VM or not.
instance_termination_action: What action should be taken once a Spot VM is terminated.
Possible values: "STOP", "DELETE"
custom_hostname: Custom hostname of the new VM instance.
Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
delete_protection: boolean value indicating if the new virtual machine should be
protected against deletion or not.
Returns:
Instance object.
"""
instance_client = compute_v1.InstancesClient()
# Use the network interface provided in the network_link argument.
network_interface = compute_v1.NetworkInterface()
network_interface.network = network_link
if subnetwork_link:
network_interface.subnetwork = subnetwork_link
if internal_ip:
network_interface.network_i_p = internal_ip
if external_access:
access = compute_v1.AccessConfig()
access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
access.name = "External NAT"
access.network_tier = access.NetworkTier.PREMIUM.name
if external_ipv4:
access.nat_i_p = external_ipv4
network_interface.access_configs = [access]
# Collect information into the Instance object.
instance = compute_v1.Instance()
instance.network_interfaces = [network_interface]
instance.name = instance_name
instance.disks = disks
if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
instance.machine_type = machine_type
else:
instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
instance.scheduling = compute_v1.Scheduling()
if accelerators:
instance.guest_accelerators = accelerators
instance.scheduling.on_host_maintenance = (
compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
)
if preemptible:
# Set the preemptible setting
warnings.warn(
"Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
)
instance.scheduling = compute_v1.Scheduling()
instance.scheduling.preemptible = True
if spot:
# Set the Spot VM setting
instance.scheduling.provisioning_model = (
compute_v1.Scheduling.ProvisioningModel.SPOT.name
)
instance.scheduling.instance_termination_action = instance_termination_action
if custom_hostname is not None:
# Set the custom hostname for the instance
instance.hostname = custom_hostname
if delete_protection:
# Set the delete protection bit
instance.deletion_protection = True
# Prepare the request to insert an instance.
request = compute_v1.InsertInstanceRequest()
request.zone = zone
request.project = project_id
request.instance_resource = instance
# Wait for the create operation to complete.
print(f"Creating the {instance_name} instance in {zone}...")
operation = instance_client.insert(request=request)
wait_for_extended_operation(operation, "instance creation")
print(f"Instance {instance_name} created.")
return instance_client.get(project=project_id, zone=zone, instance=instance_name)
def create_custom_instance(
project_id: str,
zone: str,
instance_name: str,
cpu_series: CustomMachineType.CPUSeries,
core_count: int,
memory: int,
) -> compute_v1.Instance:
"""
Create a new VM instance with a custom machine type.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
cpu_series: the type of CPU you want to use. Select one value from the CustomMachineType.CPUSeries enum.
For example: CustomMachineType.CPUSeries.N2
core_count: number of CPU cores you want to use.
memory: the amount of memory for the VM instance, in megabytes.
Return:
Instance object.
"""
assert cpu_series in (
CustomMachineType.CPUSeries.E2,
CustomMachineType.CPUSeries.N1,
CustomMachineType.CPUSeries.N2,
CustomMachineType.CPUSeries.N2D,
)
custom_type = CustomMachineType(zone, cpu_series, memory, core_count)
newest_debian = get_image_from_family(project="debian-cloud", family="debian-10")
disk_type = f"zones/{zone}/diskTypes/pd-standard"
disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link)]
return create_instance(project_id, zone, instance_name, disks, str(custom_type))
REST
Using the instances.insert
method, construct your instance creation
request as you would normally would, but when specifying a
machineType
value,
use one of the following formats. Replace
NUMBER_OF_CPUS
with the
number of CPUs and AMOUNT_OF_MEMORY_MB
with the
amount of memory you want. Provide memory in MB units.
For N1 machine types, use:
zones/ZONE/machineTypes/custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
For N2 machine types, use:
zones/ZONE/machineTypes/n2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
For N2D machine types, use:
zones/ZONE/machineTypes/n2d-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
For E2 machine types, use:
zones/ZONE/machineTypes/e2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY_MB
For E2 shared-core custom machine types, use:
zones/ZONE/machineTypes/e2-custom-SHARED_CORE_MACHINE_SIZE-AMOUNT_OF_MEMORY_MB
For example, the following URL would create an instance with 4 vCPUs and 5
GB (5120 MB) of memory:
zones/us-central1-f/machineTypes/custom-4-5120
You can similarly create preemptible instances
and groups of instances with custom machine types.
Add extended memory to a machine type
Depending on the machine, each machine type has a specific
amount of memory by default. For example, if you create a custom N1 VM,
it can have up to 6.5 GB of memory per vCPU. For custom N2 VMs, this number
increases up to 8 GB of memory per vCPU.
For some workloads, this might not be enough memory. At an extra cost, you
can get more memory per vCPU beyond the default limit. This is referred to
as extended memory.
With extended memory, you can add memory to a machine type with
no limitations per vCPU. You can add extended memory up to certain limits based
on the machine type:
- For N1 machine types, you can add up to a total of 624 GB of memory per VM.
- For N2 machine types, you can add up to a total of 640 GB of memory per VM.
- For N2D machine types, you can add up to a total of 768 GB of memory per VM.
- Extended memory is not available for E2 machine types.
If you require more memory, you must use one of the memory-optimized machine
types, which let you create VMs with a total memory of up to 12 TB per VM.
For more information, see Memory-optimized machine family.
Determining whether you need extended memory
Certain workloads need more than the default amount of memory per vCPU to
deliver optimum results. Workloads that are based on in-memory high-
performance analytics databases, including relational and NoSQL databases such as MS SQL
Server, MongoDB, and MemcacheD/Redis, are in this category. The vCPU-based
licensing
of operating systems and software stacks also makes selecting an optimal VM
memory configuration more challenging with predefined machine types. By using
extended memory, you can add as much memory as your VMs need for the best price-
performance ratio.
Pricing
When using a custom machine type, any memory up to and including the default
amount per vCPU is charged at the N1 custom machine type pricing,
or the N2 custom machine type pricing.
E2 custom machine and E2 shared-core custom machine types
share the same pricing scheme.
For memory above the default, Compute Engine charges
for extended memory based on the N1 extended custom memory pricing
or the N2 extended custom memory pricing.
The price for extended memory is different from the price for memory
below the default threshold.
Extended memory prices differ depending on the region. Instances running with
extended memory are subject to the same 1-minute minimum charge as any other
instance. Extended memory also qualifies for sustained use discounts.
For more information, see
sustained use discounts for custom machine types
and extended custom memory pricing.
Limitations
- If your VM has Local SSD disks, you can't change the vCPU and memory configuration.
- You can add extended memory only to custom machine types. Predefined machine
types are not supported.
- There is a maximum amount of memory you can add to each VM instance. For N1
machine types, you can add up to 624 GB of memory. For N2 machine types, you
can add up to 640 GB of memory. For N2D machines types, you can add up to 768
GB of memory.
- N2D machine types are available only in select
regions and zones.
- You must specify memory in 256 MB increments.
- Extended memory does not qualify for
committed use discounts.
Add extended memory during instance creation
To create a VM instance with extended memory, complete the following steps.
Console
In the Google Cloud console, go to the Create an instance page.
Go to Create an instance
In the Zone list, select the zone where you want to host this VM. The
Series list is filtered to include only the machine type families
available in the selected zone.
In the Machine configuration section, select General-purpose.
- In the Series list, click N1 in First
Generation for N1 custom machine types or N2 or N2D for
Second Generation custom machine types.
- In the Machine type section, select Custom.
- To specify the number of vCPUs drag the Cores slider or enter the
value in the text box.
To add extended memory, select Extend memory, and do the
following:
- To specify the amount of memory for the VM instance, drag the
Memory slider or enter the value in the text box.
The console displays an estimated cost
for the VM as you change the number of vCPUs and memory.
Continue to create the VM.
gcloud
For N1 machine types, use the
gcloud compute instances create
command
with the --custom-extensions
flag to enable extended
memory. Specify the total memory that you want with the
--custom-memory
parameter.
gcloud compute instances create example-instance \
--custom-extensions --custom-cpu=2 --custom-memory=15
For N2 machine types, use the
gcloud compute instances create
command
with the --custom-extensions
, --custom-cpu
, and --custom-memory
flags, followed by the --custom-vm-type
flag, to specify the N2
machine type:
gcloud compute instances create example-instance \
--custom-extensions --custom-cpu=2 --custom-memory=16 \
--custom-vm-type=n2
For N2D machine types, use the
gcloud compute instances create
command
with the --custom-extensions
, --custom-cpu
, and --custom-memory
flags, followed by the --custom-vm-type
flag, to specify the N2D
machine type:
gcloud compute instances create example-instance \
--custom-extensions --custom-cpu=2 --custom-memory=16 \
--custom-vm-type=n2d
Python
Before trying this sample, follow the Python setup instructions in the
Compute Engine quickstart using
client libraries.
For more information, see the
Compute Engine Python API
reference documentation.
To authenticate to Compute Engine, set up Application Default Credentials.
For more information, see
Set up authentication for a local development environment.
from __future__ import annotations
import re
import sys
from typing import Any
import warnings
from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1
def get_image_from_family(project: str, family: str) -> compute_v1.Image:
"""
Retrieve the newest image that is part of a given family in a project.
Args:
project: project ID or project number of the Cloud project you want to get image from.
family: name of the image family you want to get image from.
Returns:
An Image object.
"""
image_client = compute_v1.ImagesClient()
# List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
newest_image = image_client.get_from_family(project=project, family=family)
return newest_image
def disk_from_image(
disk_type: str,
disk_size_gb: int,
boot: bool,
source_image: str,
auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
"""
Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
source for the new disk.
Args:
disk_type: the type of disk you want to create. This value uses the following format:
"zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
For example: "zones/us-west3-b/diskTypes/pd-ssd"
disk_size_gb: size of the new disk in gigabytes
boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
of the publicly available images or an image from one of your projects.
This value uses the following format: "projects/{project_name}/global/images/{image_name}"
auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it
Returns:
AttachedDisk object configured to be created using the specified image.
"""
boot_disk = compute_v1.AttachedDisk()
initialize_params = compute_v1.AttachedDiskInitializeParams()
initialize_params.source_image = source_image
initialize_params.disk_size_gb = disk_size_gb
initialize_params.disk_type = disk_type
boot_disk.initialize_params = initialize_params
# Remember to set auto_delete to True if you want the disk to be deleted when you delete
# your VM instance.
boot_disk.auto_delete = auto_delete
boot_disk.boot = boot
return boot_disk
def wait_for_extended_operation(
operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
"""
Waits for the extended (long-running) operation to complete.
If the operation is successful, it will return its result.
If the operation ends with an error, an exception will be raised.
If there were any warnings during the execution of the operation
they will be printed to sys.stderr.
Args:
operation: a long-running operation you want to wait on.
verbose_name: (optional) a more verbose name of the operation,
used only during error and warning reporting.
timeout: how long (in seconds) to wait for operation to finish.
If None, wait indefinitely.
Returns:
Whatever the operation.result() returns.
Raises:
This method will raise the exception received from `operation.exception()`
or RuntimeError if there is no exception set, but there is an `error_code`
set for the `operation`.
In case of an operation taking longer than `timeout` seconds to complete,
a `concurrent.futures.TimeoutError` will be raised.
"""
result = operation.result(timeout=timeout)
if operation.error_code:
print(
f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
file=sys.stderr,
flush=True,
)
print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
raise operation.exception() or RuntimeError(operation.error_message)
if operation.warnings:
print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
for warning in operation.warnings:
print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
return result
def create_instance(
project_id: str,
zone: str,
instance_name: str,
disks: list[compute_v1.AttachedDisk],
machine_type: str = "n1-standard-1",
network_link: str = "global/networks/default",
subnetwork_link: str = None,
internal_ip: str = None,
external_access: bool = False,
external_ipv4: str = None,
accelerators: list[compute_v1.AcceleratorConfig] = None,
preemptible: bool = False,
spot: bool = False,
instance_termination_action: str = "STOP",
custom_hostname: str = None,
delete_protection: bool = False,
) -> compute_v1.Instance:
"""
Send an instance creation request to the Compute Engine API and wait for it to complete.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
disks: a list of compute_v1.AttachedDisk objects describing the disks
you want to attach to your new instance.
machine_type: machine type of the VM being created. This value uses the
following format: "zones/{zone}/machineTypes/{type_name}".
For example: "zones/europe-west3-c/machineTypes/f1-micro"
network_link: name of the network you want the new instance to use.
For example: "global/networks/default" represents the network
named "default", which is created automatically for each project.
subnetwork_link: name of the subnetwork you want the new instance to use.
This value uses the following format:
"regions/{region}/subnetworks/{subnetwork_name}"
internal_ip: internal IP address you want to assign to the new instance.
By default, a free address from the pool of available internal IP addresses of
used subnet will be used.
external_access: boolean flag indicating if the instance should have an external IPv4
address assigned.
external_ipv4: external IPv4 address to be assigned to this instance. If you specify
an external IP address, it must live in the same region as the zone of the instance.
This setting requires `external_access` to be set to True to work.
accelerators: a list of AcceleratorConfig objects describing the accelerators that will
be attached to the new instance.
preemptible: boolean value indicating if the new instance should be preemptible
or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
spot: boolean value indicating if the new instance should be a Spot VM or not.
instance_termination_action: What action should be taken once a Spot VM is terminated.
Possible values: "STOP", "DELETE"
custom_hostname: Custom hostname of the new VM instance.
Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
delete_protection: boolean value indicating if the new virtual machine should be
protected against deletion or not.
Returns:
Instance object.
"""
instance_client = compute_v1.InstancesClient()
# Use the network interface provided in the network_link argument.
network_interface = compute_v1.NetworkInterface()
network_interface.network = network_link
if subnetwork_link:
network_interface.subnetwork = subnetwork_link
if internal_ip:
network_interface.network_i_p = internal_ip
if external_access:
access = compute_v1.AccessConfig()
access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
access.name = "External NAT"
access.network_tier = access.NetworkTier.PREMIUM.name
if external_ipv4:
access.nat_i_p = external_ipv4
network_interface.access_configs = [access]
# Collect information into the Instance object.
instance = compute_v1.Instance()
instance.network_interfaces = [network_interface]
instance.name = instance_name
instance.disks = disks
if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
instance.machine_type = machine_type
else:
instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"
instance.scheduling = compute_v1.Scheduling()
if accelerators:
instance.guest_accelerators = accelerators
instance.scheduling.on_host_maintenance = (
compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
)
if preemptible:
# Set the preemptible setting
warnings.warn(
"Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
)
instance.scheduling = compute_v1.Scheduling()
instance.scheduling.preemptible = True
if spot:
# Set the Spot VM setting
instance.scheduling.provisioning_model = (
compute_v1.Scheduling.ProvisioningModel.SPOT.name
)
instance.scheduling.instance_termination_action = instance_termination_action
if custom_hostname is not None:
# Set the custom hostname for the instance
instance.hostname = custom_hostname
if delete_protection:
# Set the delete protection bit
instance.deletion_protection = True
# Prepare the request to insert an instance.
request = compute_v1.InsertInstanceRequest()
request.zone = zone
request.project = project_id
request.instance_resource = instance
# Wait for the create operation to complete.
print(f"Creating the {instance_name} instance in {zone}...")
operation = instance_client.insert(request=request)
wait_for_extended_operation(operation, "instance creation")
print(f"Instance {instance_name} created.")
return instance_client.get(project=project_id, zone=zone, instance=instance_name)
def create_custom_instances_extra_mem(
project_id: str, zone: str, instance_name: str, core_count: int, memory: int
) -> list[compute_v1.Instance]:
"""
Create 3 new VM instances with extra memory without using a CustomMachineType helper class.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
core_count: number of CPU cores you want to use.
memory: the amount of memory for the VM instance, in megabytes.
Returns:
List of Instance objects.
"""
newest_debian = get_image_from_family(project="debian-cloud", family="debian-10")
disk_type = f"zones/{zone}/diskTypes/pd-standard"
disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link)]
# The core_count and memory values are not validated anywhere and can be rejected by the API.
instances = [
create_instance(
project_id,
zone,
f"{instance_name}_n1_extra_mem",
disks,
f"zones/{zone}/machineTypes/custom-{core_count}-{memory}-ext",
),
create_instance(
project_id,
zone,
f"{instance_name}_n2_extra_mem",
disks,
f"zones/{zone}/machineTypes/n2-custom-{core_count}-{memory}-ext",
),
create_instance(
project_id,
zone,
f"{instance_name}_n2d_extra_mem",
disks,
f"zones/{zone}/machineTypes/n2d-custom-{core_count}-{memory}-ext",
),
]
return instances
REST
Using the instances.insert
method,
construct your instance creation request as you would normally, but when
specifying a machineType
value, use one of the following formats:
For N1 machine types, use:
zones/ZONE/machineTypes/custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
For N2 machine types, use:
zones/ZONE/machineTypes/n2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
For N2D machine types, use:
zones/ZONE/machineTypes/n2d-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Replace the following:
NUMBER_OF_CPUS
: The number of vCPUs.
AMOUNT_OF_MEMORY
: The memory, in MB.
For example, the following specifies an N2 machine type with 2 vCPUs and
20 GB of memory:
zones/ZONE/machineTypes/n2-custom-2-20480-ext
Add extended memory to an existing VM instance
To add more memory to an existing instance, you must first
stop the instance.
After the instance stops, complete the following steps to add more memory to
the VM.
Console
In the Google Cloud console, go to the VM instances page.
Go to VM instances
Choose the stopped VM you want to modify from the VM list.
Click Edit at the top of the page.
In Machine configuration, select General-purpose.
In the Machine type section, select Custom.
Select the number of vCPUs you want.
To add extended memory, select
Extend memory and then specify the amount of memory you want.
Save your changes.
gcloud
Use the compute instances set-machine-type
command
with the --custom-memory
and --custom-extensions
flags.
For example, to add 2 GB memory to a VM instance named example-instance
,
which currently has an N1 machine type with 2 vCPU, 13 GB, in the
us-central1-b
zone, use the following command:
gcloud compute instances set-machine-type example-instance \
--zone=us-central1-b --custom-cpu=2 \
--custom-memory=15 --custom-extensions
Go
Before trying this sample, follow the Go setup instructions in the
Compute Engine quickstart using
client libraries.
For more information, see the
Compute Engine Go API
reference documentation.
To authenticate to Compute Engine, set up Application Default Credentials.
For more information, see
Set up authentication for a local development environment.
import (
"context"
"fmt"
"io"
"strings"
compute "cloud.google.com/go/compute/apiv1"
computepb "google.golang.org/genproto/googleapis/cloud/compute/v1"
"google.golang.org/protobuf/proto"
)
// modifyInstanceWithExtendedMemory sends an instance creation request
// to the Compute Engine API and waits for it to complete.
func modifyInstanceWithExtendedMemory(
w io.Writer,
projectID, zone, instanceName string,
newMemory int,
) error {
// projectID := "your_project_id"
// zone := "europe-central2-b"
// instanceName := "your_instance_name"
// newMemory := 256 // the amount of memory for the VM instance, in megabytes.
ctx := context.Background()
instancesClient, err := compute.NewInstancesRESTClient(ctx)
if err != nil {
return fmt.Errorf("NewInstancesRESTClient: %w", err)
}
defer instancesClient.Close()
reqInstance := &computepb.GetInstanceRequest{
Project: projectID,
Zone: zone,
Instance: instanceName,
}
instance, err := instancesClient.Get(ctx, reqInstance)
if err != nil {
return fmt.Errorf("unable to get instance: %w", err)
}
containsString := func(s []string, str string) bool {
for _, v := range s {
if v == str {
return true
}
}
return false
}
if !(strings.Contains(instance.GetMachineType(), "machineTypes/n1-") ||
strings.Contains(instance.GetMachineType(), "machineTypes/n2-") ||
strings.Contains(instance.GetMachineType(), "machineTypes/n2d-")) {
return fmt.Errorf("extra memory is available only for N1, N2 and N2D CPUs")
}
// Make sure that the machine is turned off
if !containsString([]string{"TERMINATED", "STOPPED"}, instance.GetStatus()) {
reqStop := &computepb.StopInstanceRequest{
Project: projectID,
Zone: zone,
Instance: instanceName,
}
op, err := instancesClient.Stop(ctx, reqStop)
if err != nil {
return fmt.Errorf("unable to stop instance: %w", err)
}
if err = op.Wait(ctx); err != nil {
return fmt.Errorf("unable to wait for the operation: %w", err)
}
}
// Modify the machine definition, remember that extended memory
// is available only for N1, N2 and N2D CPUs
machineType := instance.GetMachineType()
start := machineType[:strings.LastIndex(machineType, "-")]
updateReq := &computepb.SetMachineTypeInstanceRequest{
Project: projectID,
Zone: zone,
Instance: instanceName,
InstancesSetMachineTypeRequestResource: &computepb.InstancesSetMachineTypeRequest{
MachineType: proto.String(fmt.Sprintf("%s-%v-ext", start, newMemory)),
},
}
op, err := instancesClient.SetMachineType(ctx, updateReq)
if err != nil {
return fmt.Errorf("unable to update instance: %w", err)
}
if err = op.Wait(ctx); err != nil {
return fmt.Errorf("unable to wait for the operation: %w", err)
}
fmt.Fprintf(w, "Instance updated\n")
return nil
}
Python
Before trying this sample, follow the Python setup instructions in the
Compute Engine quickstart using
client libraries.
For more information, see the
Compute Engine Python API
reference documentation.
To authenticate to Compute Engine, set up Application Default Credentials.
For more information, see
Set up authentication for a local development environment.
from __future__ import annotations
import sys
import time
from typing import Any
from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1
def wait_for_extended_operation(
operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
"""
Waits for the extended (long-running) operation to complete.
If the operation is successful, it will return its result.
If the operation ends with an error, an exception will be raised.
If there were any warnings during the execution of the operation
they will be printed to sys.stderr.
Args:
operation: a long-running operation you want to wait on.
verbose_name: (optional) a more verbose name of the operation,
used only during error and warning reporting.
timeout: how long (in seconds) to wait for operation to finish.
If None, wait indefinitely.
Returns:
Whatever the operation.result() returns.
Raises:
This method will raise the exception received from `operation.exception()`
or RuntimeError if there is no exception set, but there is an `error_code`
set for the `operation`.
In case of an operation taking longer than `timeout` seconds to complete,
a `concurrent.futures.TimeoutError` will be raised.
"""
result = operation.result(timeout=timeout)
if operation.error_code:
print(
f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
file=sys.stderr,
flush=True,
)
print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
raise operation.exception() or RuntimeError(operation.error_message)
if operation.warnings:
print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
for warning in operation.warnings:
print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)
return result
def add_extended_memory_to_instance(
project_id: str, zone: str, instance_name: str, new_memory: int
):
"""
Modify an existing VM to use extended memory.
Args:
project_id: project ID or project number of the Cloud project you want to use.
zone: name of the zone to create the instance in. For example: "us-west3-b"
instance_name: name of the new virtual machine (VM) instance.
new_memory: the amount of memory for the VM instance, in megabytes.
Returns:
Instance object.
"""
instance_client = compute_v1.InstancesClient()
instance = instance_client.get(
project=project_id, zone=zone, instance=instance_name
)
if not (
"n1-" in instance.machine_type
or "n2-" in instance.machine_type
or "n2d-" in instance.machine_type
):
raise RuntimeError("Extra memory is available only for N1, N2 and N2D CPUs.")
# Make sure that the machine is turned off
if instance.status not in (
instance.Status.TERMINATED.name,
instance.Status.STOPPED.name,
):
operation = instance_client.stop(
project=project_id, zone=zone, instance=instance_name
)
wait_for_extended_operation(operation, "instance stopping")
start = time.time()
while instance.status not in (
instance.Status.TERMINATED.name,
instance.Status.STOPPED.name,
):
# Waiting for the instance to be turned off.
instance = instance_client.get(
project=project_id, zone=zone, instance=instance_name
)
time.sleep(2)
if time.time() - start >= 300: # 5 minutes
raise TimeoutError()
# Modify the machine definition, remember that extended memory is available only for N1, N2 and N2D CPUs
start, end = instance.machine_type.rsplit("-", maxsplit=1)
instance.machine_type = start + f"-{new_memory}-ext"
# TODO: If you prefer to use the CustomMachineType helper class, uncomment this code and comment the 2 lines above
# Using CustomMachineType helper
# cmt = CustomMachineType.from_str(instance.machine_type)
# cmt.memory_mb = new_memory
# cmt.extra_memory_used = True
# instance.machine_type = str(cmt)
operation = instance_client.update(
project=project_id,
zone=zone,
instance=instance_name,
instance_resource=instance,
)
wait_for_extended_operation(operation, "instance update")
return instance_client.get(project=project_id, zone=zone, instance=instance_name)
REST
Make a POST
request to the
instances.setMachineType
method
with the desired machine type in the request body. Use one of the following
formats:
For N1 machine types, use:
zones/ZONE/machineTypes/custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
For N2 machine types, use:
zones/ZONE/machineTypes/n2-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
For N2D machine types, use:
zones/ZONE/machineTypes/n2d-custom-NUMBER_OF_CPUS-AMOUNT_OF_MEMORY-ext
Replace the following:
NUMBER_OF_CPUS
: The number of vCPUs.
AMOUNT_OF_MEMORY
: The memory, in MB.
For example, the following request specifies an N1 machine type with
2 vCPUs and 15 GB of memory:
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME/setMachineType
{
machineType: "zones/us-central1-f/machineTypes/custom-2-15360-ext"
}
What's next