Create a reservation for a single project

This document explains how to create a single-project reservation, which can be consumed only by virtual machine (VM) instances in the same project. To learn more about reservations, see Reservations of Compute Engine zonal resources.

For other methods of creating reservations, see instead the following pages:

To create a reservation that can be used by multiple projects, see Create a shared reservation.
To create a reservation when purchasing a resource-based commitment, see Purchase commitments with attached reservations. Commitments provide discounts, known as committed use discounts (CUDs), on your on-demand resource costs in exchange for purchasing a minimum level of resources or for spending a minimum amount.

Before you begin

Review the requirements and restrictions for reservations.
If you haven't already, set up authentication. Authentication verifies your identity for access to Google Cloud services and APIs. To run code or samples from a local development environment, you can authenticate to Compute Engine by selecting one of the following options:
Select the tab for how you plan to use the samples on this page:
Console

When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.
gcloud
1. Install the Google Cloud CLI. After installation, initialize the Google Cloud CLI by running the following command:
```
gcloud init
```
  If you're using an external identity provider (IdP), you must first sign in to the gcloud CLI with your federated identity.
2. Set a default region and zone.
Terraform

To use the Terraform samples on this page in a local development environment, install and initialize the gcloud CLI, and then set up Application Default Credentials with your user credentials.
For more information, see Set up authentication for a local development environment.
REST

To use the REST API samples on this page in a local development environment, you use the credentials you provide to the gcloud CLI.
For more information, see Authenticate for using REST in the Google Cloud authentication documentation.

Required roles

To get the permissions that you need to create single-project reservations, ask your administrator to grant you the Compute Admin (roles/compute.admin) IAM role on the project. For more information about granting roles, see Manage access to projects, folders, and organizations.

This predefined role contains the permissions required to create single-project reservations. To see the exact permissions that are required, expand the Required permissions section:

Required permissions

The following permissions are required to create single-project reservations:

compute.reservations.create on the project
To specify an instance template: compute.instanceTemplates.useReadOnly on the instance template

You might also be able to get these permissions with custom roles or other predefined roles.

To consume a reservation, a VM must have properties that exactly match that reservation. To specify the properties of the VMs that you want to reserve, select one of the following sections in this document:

Recommended: Specify an instance template

This section explains how to use an instance template to define the properties of a reservation. By using an instance template, you can define the properties of a reservation and the VMs that can consume the reservation in the same place.
Specify an existing VM

This section explains how to use an existing VM to define the properties of a reservation. By using the properties of an existing VM, you can consume the reservation by creating VMs with properties that match the reference VM.
Specify properties directly

This section explains how to directly define the properties of a reservation. This method requires you to manually ensure that the properties of your VMs and reservations exactly match—any mismatched properties prevent consumption.

By default, a reservation can be automatically consumed by any VMs with properties that match it. If you want to control reservation consumption, do one or more of the following:

Create a reservation that can only be consumed by VMs that specifically target it, as explained in the following sections in this document. Then, configure VMs to consume that specific reservation.
Configure VMs to not consume reservations.

Additionally, you can specify a compact placement policy when creating a single-project specific reservation. A compact placement policy specifies that VMs are to be located as close to each other as possible to reduce network latency.

Specify an instance template

To avoid errors when creating a reservation by specifying an instance template, make sure of the following:

Create your reservation in the same region and zone as the resources within the instance template. Any regional or zonal resources specified in an instance template—such as a machine type or a Persistent Disk volume—restrict the use of the template to the locations where those resources exist. For example, if your instance template specifies an existing Persistent Disk volume in zone us-central1-a, then you can only create your reservation in the same zone. To check if an existing template specifies any resources that bind the template to a specific region or zone, view the details of the instance template and look for references to regional or zonal resources inside of it.
If the instance template specifies a compact placement policy, then make sure that the template specifies a supported machine type for compact placement policies. Otherwise, creating the reservation fails.

To create a single-project reservation by specifying an instance template, select one of the following options:

Console

In the Google Cloud console, go to the Reservations page.

Go to Reservations
Click Create reservation. The Create a reservation page appears.
In the Name field, enter a name for your reservation.
In the Region and Zone lists, select where you want to reserve resources.
Optional: To let custom training jobs or prediction jobs in Vertex AI consume a reservation of GPU VMs, in the Google Cloud services section, select Share reservation.
In the Use with VM instance section, select one of the following options:
- To allow matching VMs to automatically consume this reservation, select Use reservation automatically.
- To consume this reservation's resources only when you create matching VMs that specifically target the reservation by name, select Select specific reservation.
In the Resource details section, do the following:
- In the Number of VM instances field, enter the number of VMs that you want to reserve.
- To specify VM configurations by using an instance template, select Use instance template, and then, in the list that appears, select the instance template.
In the Auto-delete section, you can enable the auto-delete option to let Compute Engine automatically delete the reservation at a specific date and time. Automatically deleting reservations can be useful to avoid unnecessary charges when you stop consuming the reservation.
To create the reservation, click Create. The Reservations page appears. Creating the reservation can take up to a minute to complete. To verify when Compute Engine finishes creating it, view your reservations.

gcloud

To create a single-project reservation, use the gcloud compute reservations create command.

To create a single-project reservation by specifying an instance template and without including any optional flags, run the following command:

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Replace the following:

RESERVATION_NAME: the name of the reservation to create.
INSTANCE_TEMPLATE_URL: the URL of an existing instance template. Specify one of the following values:
- For a regional instance template: projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME
- For a global instance template: INSTANCE_TEMPLATE_NAME
NUMBER_OF_VMS: the number of VMs to reserve.
ZONE: the zone in which to reserve resources.

For example, to create a reservation for ten VMs in zone us-central1-a by specifying a global instance template, run the following command:

gcloud compute reservations create my-reservation \
    --source-instance-template=example-instance-template \
    --vm-count=10 \
    --zone=us-central1-a

Optionally, you can do one or more of the following:

To specify that only VMs that specifically target this reservation can consume it, include the --require-specific-reservation flag.

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

To allow a reservation of GPU VMs to be consumed by custom training jobs or prediction jobs in Vertex AI, include the --reservation-sharing-policy flag set to ALLOW_ALL.

gcloud compute reservations create RESERVATION_NAME \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --reservation-sharing-policy=ALLOW_ALL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

To enable Compute Engine to automatically delete the reservation, select one of the following methods:
- To delete the reservation at a specific date and time, use the gcloud beta compute reservations create command with the --delete-at-time flag.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Replace DELETE_AT_TIME with a date and time formatted as an RFC 3339 timestamp, which must be as follows: none YYYY-MM-DDTHH:MM:SSOFFSET
  
  Replace the following:
  - YYYY-MM-DD: a date formatted as a 4-digit year, 2-digit month, and a 2-digit day of the month, separated by hyphens (-).
  - HH:MM:SS: a time formatted as a 2-digit hour using a 24-hour time, 2-digit minutes, and 2-digit seconds, separated by colons (:).
  - OFFSET: the time zone formatted as an offset of Coordinated Universal Time (UTC). For example, to use the Pacific Standard Time (PST), specify -08:00. Alternatively, to use no offset, specify Z.
- To delete the reservation after a specific duration, use the gcloud beta compute reservations create command with the --delete-after-duration flag.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --source-instance-template=INSTANCE_TEMPLATE_URL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Replace DELETE_AFTER_DURATION with a duration in days, hours, minutes, or seconds. For example, specify 30m for 30 minutes, or 1d2h3m4s for 1 day, 2 hours, 3 minutes, and 4 seconds.

Go

Java

Node.js

Python

REST

To create a single-project reservation, make a POST request to the reservations.insert method.

To create a single-project reservation by specifying an instance template and without including any optional flags, make the following POST request:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

Replace the following:

PROJECT_ID: the ID of the project where you want to reserve resources and where the instance template exists.
ZONE: the zone in which to reserve resources.
RESERVATION_NAME: the name of the reservation to create.
NUMBER_OF_VMS: the number of VMs to reserve.
INSTANCE_TEMPLATE_URL: the URL of an existing instance template. Specify one of the following values:
- For a regional instance template: projects/PROJECT_ID/regions/REGION/instanceTemplates/INSTANCE_TEMPLATE_NAME
- For a global instance template: INSTANCE_TEMPLATE_NAME

For example, to create a reservation for ten VMs in zone us-central1-a by specifying a global instance template, make the following POST request:

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "specificReservation": {
    "count": "10",
    "sourceInstanceTemplate": "example-instance-template"
  }
}

Optionally, you can do one or more of the following:

To specify that only VMs that specifically target this reservation can consume it, include the specificReservationRequired field in the request body, and set the field to true.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  },
  "specificReservationRequired": true
}

To let custom training jobs or prediction jobs in Vertex AI consume a reservation of GPU VMs, include the serviceShareType field and set it to ALLOW_ALL.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}

To enable Compute Engine to automatically delete the reservation, select one of the following methods:
- To delete the reservation at a specific date and time, make a POST request to the beta.reservations.insert method. In the request body, include the deleteAtTime field.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}
```
  Replace DELETE_AT_TIME with a date and time formatted as an RFC 3339 timestamp, which must be as follows:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Replace the following:
  - YYYY-MM-DD: a date formatted as a 4-digit year, 2-digit month, and a 2-digit day of the month, separated by hyphens (-).
  - HH:MM:SS: a time formatted as a 2-digit hour using a 24-hour time, 2-digit minutes, and 2-digit seconds, separated by colons (:).
  - OFFSET: the time zone formatted as an offset of Coordinated Universal Time (UTC). For example, to use the Pacific Standard Time (PST), specify -08:00. Alternatively, to use no offset, specify Z.
- To delete the reservation after a specific duration, make a POST request to the beta.reservations.insert method. In the request body, include the deleteAfterDuration field.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "sourceInstanceTemplate": "INSTANCE_TEMPLATE_URL"
  }
}
```
  Replace DELETE_AFTER_DURATION with a duration in seconds. For example, specify 86400 for 86,400 seconds (1 day).

Specify an existing VM

You can only create a reservation based on an existing VM in the same zone as the VM.

After creating the reservation, you can consume it by creating VMs with properties that match the reference VM. You can do this by doing one of the following:

Create and use an instance template as follows:
1. Create an instance template based on the reference VM without overriding the reference VM's properties.
2. Create VMs using the newly-created template by doing one or both of the following:
  - Create a single VM
  - Create a zonal managed instance group (MIG)
Create a VM based on the reference VM while ensuring that the properties of the new VM and the reference VM exactly match.

To create a single-project reservation that uses the properties of an existing VM, do the following:

In the Google Cloud console, go to the Reservations page.

Go to Reservations
Click Create reservation. The Create a reservation page appears.
In the Name field, enter a name for your reservation.
In the Region and Zone lists, select where you want to reserve resources.
Optional: To let custom training jobs or prediction jobs in Vertex AI consume a reservation of GPU VMs, in the Google Cloud services section, select Share reservation.
In the Use with VM instance section, select one of the following options:
- To allow matching VMs to automatically consume this reservation, select Use reservation automatically.
- To consume this reservation's resources only when you create matching VMs that specifically target the reservation by name, select Select specific reservation.
In the Resource details section, do the following:
- In the Number of VM instances field, enter the number of VMs that you want to reserve.
- To specify VM configurations by using an instance template, select Use existing VM, and then, in the list that appears, select the VM.
Optional: To specify a compact placement policy for a reservation that meets the requirements, in the Group placement policy section, click the Select or create a group placement policy list, and then do one of the following:
- To create a compact placement policy to specify in this reservation, do the following:
  1. Click Create group placement policy. The Create a group placement policy pane appears.
  2. In the Policy name field, enter a name for your policy.
  3. Click Create. Creating the compact placement policy might take a few seconds to complete.
- Otherwise, select an existing compact placement policy.
In the Auto-delete section, you can enable the auto-delete option to let Compute Engine automatically delete the reservation at a specific date and time. Automatically deleting reservations can be useful to avoid unnecessary charges when you stop consuming the reservation.
To create the reservation, click Create. The Reservations page appears. Creating the reservation can take up to a minute to complete. To verify when Compute Engine finishes creating it, view your reservations.

Specify properties directly

To create a single-project reservation by specifying properties directly, select one of the following options:

Console

In the Google Cloud console, go to the Reservations page.

Go to Reservations
Click Create reservation. The Create a reservation page appears.
In the Name field, enter a name for your reservation.
In the Region and Zone lists, select where you want to reserve resources.
Optional: To let custom training jobs or prediction jobs in Vertex AI consume a reservation of GPU VMs, in the Google Cloud services section, select Share reservation.
In the Use with VM instance section, select one of the following options:
- To allow matching VMs to automatically consume this reservation, select Use reservation automatically.
- To consume this reservation's resources only when you create matching VMs that specifically target the reservation by name, select Select specific reservation.
In the Resource details section, do the following:
- In the Number of VM instances field, enter the number of VMs that you want to reserve.
- Specify the machine series and type that you want to reserve.
Optional: To specify a compact placement policy for a reservation that meets the reservation requirements, in the Group placement policy section, click the Select or create a group placement policy list, and then do one of the following:
- To create a compact placement policy to specify in this reservation, do the following:
  1. Click Create group placement policy. The Create a group placement policy pane appears.
  2. In the Policy name field, enter a name for your policy.
  3. Click Create. Creating the compact placement policy might take a few seconds to complete.
- Otherwise, select an existing compact placement policy.
In the Auto-delete section, you can enable the auto-delete option to let Compute Engine automatically delete the reservation at a specific date and time. Automatically deleting reservations can be useful to avoid unnecessary charges when you stop consuming the reservation.
To create the reservation, click Create. The Reservations page appears. Creating the reservation can take up to a minute to complete. To verify when Compute Engine finishes creating it, view your reservations.

gcloud

To create a single-project reservation, use the gcloud compute reservations create command.

To create a single-project reservation by specifying properties directly and without including any optional flags, run the following command:

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

Replace the following:

RESERVATION_NAME: the name of the reservation to create.
MACHINE_TYPE: a machine type to use for each VM.
NUMBER_OF_VMS: the number of VMs to reserve.
ZONE: the zone in which to reserve resources.

For example, to create a reservation in zone us-central1-a for ten VMs that each use an N2 predefined machine type with 4 vCPUs, run the following command:

gcloud compute reservations create my-reservation \
    --machine-type=n2-standard-4 \
    --vm-count=10 \
    --zone=us-central1-a

Optionally, you can do one or more of the following:

To attach GPUs to your reserved N1 VMs, include the --accelerator flag.
```
gcloud compute reservations create RESERVATION_NAME \
    --accelerator=count=NUMBER_OF_ACCELERATORS,type=ACCELERATOR_TYPE \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Replace the following:
- NUMBER_OF_ACCELERATORS: the number of GPUs to add per reserved VM.
- ACCELERATOR_TYPE: a supported GPU model for N1 VMs. Ensure that your chosen GPU model is available in the zone where you want to reserve resources. Otherwise, creating the reservation fails.
To attach Local SSD disks to a machine type that doesn't include Local SSD disks by default, include the --local-ssd flag. You can only attach Local SSD disks of 375 GB.
```
gcloud compute reservations create RESERVATION_NAME \
    --local-ssd=count=NUMBER_OF_LOCAL_SSD_DISKS,size=375,interface=INTERFACE_TYPE \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Replace the following:
- NUMBER_OF_LOCAL_SSD_DISKS: the number of Local SSD disks to attach.
- INTERFACE_TYPE: the type of disk interface that you want each Local SSD disk to use and that your specified machine type supports. Specify one of the following values:
  - For the NVME disk interface: nvme
  - For the SCSI disk interface: scsi
To have the reserved VMs use a specific minimum CPU platform instead of the zone's default CPU platform, include the --min-cpu-platform flag.
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --min-cpu-platform="MIN_CPU_PLATFORM" \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Replace MIN_CPU_PLATFORM with a minimum CPU platform. To make sure that a CPU platform is available in the zone where you're reserving resources, view the available CPU platforms by zone.

To specify that only VMs that specifically target this reservation can consume it, include the --require-specific-reservation flag.

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

To specify a compact placement policy for lower network latency among VMs, include the --resource-policies=policy flag.
```
gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --resource-policies=policy=COMPACT_PLACEMENT_POLICY_NAME \
    --require-specific-reservation \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
Replace COMPACT_PLACEMENT_POLICY_NAME with the name of an existing compact placement policy. Additionally, to avoid errors when creating a single-project reservation that specifies a compact placement policy, make sure to specify the following:
- A supported machine type and maximum number of VMs for compact placement policies.
- A zone within the region where the compact placement policy is located.
- The --require-specific-reservation flag. This indicates that only VMs that specifically target the reservation can consume it.

To let custom training jobs or prediction jobs in Vertex AI consume a reservation of GPU VMs, include the --reservation-sharing-policy flag set to ALLOW_ALL.

gcloud compute reservations create RESERVATION_NAME \
    --machine-type=MACHINE_TYPE \
    --reservation-sharing-policy=ALLOW_ALL \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE

To enable Compute Engine to automatically delete the reservation, select one of the following methods:
- To delete the reservation at a specific date and time, use the gcloud beta compute reservations create command with the --delete-at-time flag.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-at-time=DELETE_AT_TIME \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Replace DELETE_AT_TIME with a date and time formatted as an RFC 3339 timestamp, which must be as follows:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Replace the following:
  - YYYY-MM-DD: a date formatted as a 4-digit year, 2-digit month, and a 2-digit day of the month, separated by hyphens (-).
  - HH:MM:SS: a time formatted as a 2-digit hour using a 24-hour time, 2-digit minutes, and 2-digit seconds, separated by colons (:).
  - OFFSET: the time zone formatted as an offset of Coordinated Universal Time (UTC). For example, to use the Pacific Standard Time (PST), specify -08:00. Alternatively, to use no offset, specify Z.
- To delete the reservation after a specific duration, use the gcloud beta compute reservations create command with the --delete-after-duration flag.
```
gcloud beta compute reservations create RESERVATION_NAME \
    --delete-after-duration=DELETE_AFTER_DURATION \
    --machine-type=MACHINE_TYPE \
    --vm-count=NUMBER_OF_VMS \
    --zone=ZONE
```
  Replace DELETE_AFTER_DURATION with a duration in days, hours, minutes, or seconds. For example, specify 30m for 30 minutes, or 1d2h3m4s for 1 day, 2 hours, 3 minutes, and 4 seconds.

Go

Java

Node.js

Python

Terraform

To create a single-project reservation, use the google_compute_reservation Terraform resource.

For example, to create a single-project reservation for one N2 predefined machine type with 2 vCPUs, use the following resource:

For more information about how to use Terraform, see Using Terraform with Google Cloud.

REST

To create a single-project reservation, make a POST request to the reservations.insert method.

To create a single-project reservation by specifying properties directly and without any including any optional fields, make the following POST request:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

Replace the following:

PROJECT_ID: the ID of the project where you want to reserve resources.
ZONE: the zone in which to reserve resources.
RESERVATION_NAME: the name of the reservation to create.
NUMBER_OF_VMS: the number of VMs to reserve.
MACHINE_TYPE: a machine type to use for each VM.

For example, to create a reservation in zone us-central1-a for ten VMs that each use an N2 predefined machine type with 4 vCPUs, make the following POST request:

POST https://compute.googleapis.com/compute/v1/projects/example-project/zones/us-central1-a/reservations

{
  "name": "my-reservation",
  "specificReservation": {
    "count": "10",
    "instanceProperties": {
      "machineType": "n2-standard-4",
    }
  }
}

Optionally, you can do one or more of the following:

To attach GPUs to your reserved N1 VMs, include the guestAccelerators field in the request body.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "guestAccelerators": [
        {
          "acceleratorCount": NUMBER_OF_ACCELERATORS,
          "acceleratorType": "ACCELERATOR_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}

Replace the following:

NUMBER_OF_ACCELERATORS: the number of GPUs to add per reserved VM.
ACCELERATOR_TYPE: a supported GPU model for N1 VMs. Ensure that your chosen GPU model is available in the zone where you want to reserve resources. Otherwise, creating the reservation fails.

To attach Local SSD disks to a machine type that doesn't include Local SSD disks by default, include the localSsds field in the request body. You can only attach Local SSD disks of 375 GB.

For example, to attach two Local SSD disks to the machine type that you want to reserve, make a request as follows:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "localSsds": [
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        },
        {
          "diskSizeGb": "375",
          "interface": "INTERFACE_TYPE"
        }
      ],
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
Replace INTERFACE_TYPE with the type of disk interface that you want each Local SSD disk to use and that your specified machine type supports. Specify one of the following values:
- For the NVME disk interface: NVME
- For the SCSI disk interface: SCSI
To have the reserved VMs use a specific minimum CPU platform instead of the zone's default CPU platform, include the minCpuPlatform field in the request body.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE",
      "minCpuPlatform": "MIN_CPU_PLATFORM"
    }
  }
}
```
Replace MIN_CPU_PLATFORM with a minimum CPU platform. To make sure that a CPU platform is available in the zone where you're reserving resources, view the available CPU platforms by zone.
To specify a compact placement policy to reduce network latency among your reserved VMs, include the resourcePolicies field in the request body.
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "resourcePolicies": {
    "policy" : "projects/PROJECT_ID/regions/REGION/resourcePolicies/COMPACT_PLACEMENT_POLICY_NAME"
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}
```
Replace the following:
- REGION: the region where the compact placement policy is located. You can only create the reservation within the region of the placement policy.
- COMPACT_PLACEMENT_POLICY_NAME: the name of an existing compact placement policy.
Additionally, to avoid errors when creating a single-project reservation that specifies a compact placement policy, make sure to specify the following:
- A supported machine type for compact placement policies.
- The specificReservationRequired field set to true. This indicates that only VMs that specifically target this reservation can consume it.

To specify that only VMs that specifically target this reservation can consume it, include the specificReservationRequired field in the request body and set the field to true.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  },
  "specificReservationRequired": true
}

To allow a reservation of GPU VMs to be consumed by custom training jobs or prediction jobs in Vertex AI, include the serviceShareType field and set it to ALLOW_ALL.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/reservations

{
  "name": "RESERVATION_NAME",
  "reservationSharingPolicy": {
    "serviceShareType": "ALLOW_ALL"
  },
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}

To enable Compute Engine to automatically delete the reservation, select one of the following methods:
- To delete the reservation at a specific date and time, make a POST request to the beta.reservations.insert method. In the request body, include the deleteAtTime field.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAtTime": "DELETE_AT_TIME",
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Replace DELETE_AT_TIME with a date and time formatted as an RFC 3339 timestamp, which must be as follows:
```
YYYY-MM-DDTHH:MM:SSOFFSET
```
  Replace the following:
  - YYYY-MM-DD: a date formatted as a 4-digit year, 2-digit month, and a 2-digit day of the month, separated by hyphens (-).
  - HH:MM:SS: a time formatted as a 2-digit hour using a 24-hour time, 2-digit minutes, and 2-digit seconds, separated by colons (:).
  - OFFSET: the time zone formatted as an offset of Coordinated Universal Time (UTC). For example, to use the Pacific Standard Time (PST), specify -08:00. Alternatively, to use no offset, specify Z.
- To delete the reservation after a specific duration, make a POST request to the beta.reservations.insert method. In the request body, include the deleteAfterDuration field.
```
POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/reservations

{
  "deleteAfterDuration": {
    "seconds": "DELETE_AFTER_DURATION"
  },
  "name": "RESERVATION_NAME",
  "specificReservation": {
    "count": "NUMBER_OF_VMS",
    "instanceProperties": {
      "machineType": "MACHINE_TYPE"
    }
  }
}
```
  Replace DELETE_AFTER_DURATION with a duration in seconds. For example, specify 86400 for 86,400 seconds (1 day).

Troubleshooting

Learn how to troubleshoot reservation creation.

What's next

Learn how to view your reservations.
Learn how to attach reservations to commitments.
Learn how to consume reservations.
Learn how to monitor reservations consumption.

Except as otherwise noted, the content of this page is licensed under the Creative Commons Attribution 4.0 License, and code samples are licensed under the Apache 2.0 License. For details, see the Google Developers Site Policies. Java is a registered trademark of Oracle and/or its affiliates.

Last updated 2026-02-20 UTC.