Bulk create HPC-optimized instances that use RDMA

Reserve blocks of capacity for your deployment

This document explains how to reserve blocks of capacity by asking your account team to create a future reservation request for you. Use this reservation type to obtain capacity for dense deployment of VM instances. For an overview of all consumption options, see:

• For non-dense deployments: Compute Engine instances provisioning models
• For dense deployments: Choose a consumption option and obtain capacity

This action lets you reserve blocks of capacity for a defined duration, starting on a specific date and time that you choose. Based on your request, Google creates a draft future reservation request. After you review and submit this draft request, and Google Cloud approves it, Compute Engine automatically creates (auto-creates) an empty reservation. Then, at your chosen start time, Compute Engine provisions your requested capacity into the auto-created reservation. You can then use the reservation to create virtual machine (VM) instances until the reservation period ends.

As part of the future reservation request process, Google manages quota for your reserved resources. You don't need to request quota. At the start time of your approved future reservation, Google increases your quota if you lack it for the reserved resources.

To reserve blocks of capacity, complete the following steps:

1. Contact your account team and provide the following information for Google to create a draft future reservation request:

   • Project number: the number of the project where your account team creates the request and Compute Engine provisions the capacity. For information about how to find your project number, see Find the project name, number, and ID in the Resource Manager documentation.

   • Machine type: one of the H4D HPC-optimized machine types

   • Total count: the total number of VMs to reserve. You can only reserve multiples of two VMs. Block sizes and VM count per block vary based on machine type and availability. Your account team can provide more details for your request.

   • Zone: the zone where you want to reserve capacity. To review the available regions and zones for the H4D machine series, see Available regions and zones and select H4D in the Select a machine series list.

   • Start time: the start time of the reservation period. Format the start time as an RFC 3339 timestamp:

     YYYY-MM-DDTHH:MM:SSOFFSET
     

     Replace the following:

     • YYYY-MM-DD: a date formatted as a four-digit year, two-digit month, and a two-digit day of the month, separated by hyphens (-).

     • HH:MM:SS: a time formatted as a two-digit hour by using a 24-hour time, two-digit minutes, and two-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. To use no offset, specify Z.

   • End time: the end time of the reservation period. Format it as an RFC 3339 timestamp.

   • Share type: whether only your project can use the auto-created reservation (LOCAL), or other projects can use the reservation (SPECIFIC_PROJECTS).

     To share reserved capacity with other projects in your organization, do the following:

     1. If you haven't already, then verify that the project where Google creates the request is allowed to create shared reservations.

     2. Provide the numbers of the projects to share the reserved capacity with. You can specify up to 100 projects in your organization.

   • Reservation name: the name of the reservation that Compute Engine automatically creates to deliver your reserved capacity. Compute Engine only creates specifically targeted reservations.

   • Commitment name: if your reservation period is one year or longer, then you must purchase and attach a resource-based commitment to your reserved resources. You can purchase a commitment with a 1-year or 3-year plan. If you share the reserved capacity with other projects, then those projects get discounts only if they use the same Cloud Billing account as the project where you reserve capacity. For details, see Enable CUD sharing for resource-based commitments.

2. Google creates a draft future reservation request and your account team contacts you.

3. Review the draft request. Take note of the following when reviewing the reservation request:

   • You can start using the reserved capacity only after the specified start date and time.

   • When the specified end time is reached, Compute Engine does the following:

     • Deletes the auto-created reservation.
     • Stops or deletes any VMs that use the reservation. The action taken is based on the termination action that you specify when creating the VMs.

   • You can't change whether the reserved capacity is shared after you submit the reservation request.

   To review a draft future reservation request, select one of the following options:

   Console

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

      Go to Reservations

   2. Click the Future reservations tab. The Future Reservations table lists each future reservation request in your project, and each table column describes a property.

   3. In the Name column, click the name of the draft request that Google created for you. A page that gives the details of the future reservation request opens.

   4. In the Basic information section, verify that the request details, such as Dates and Share type, are correct. Also, if you requested a commitment, verify that it's specified.

   5. If any of these details are incorrect, then contact your account team.

   gcloud

   1. To view a list of future reservation requests in your project, use the gcloud beta compute future-reservations list command with the --filter flag set to PROCUREMENT_STATUS=DRAFTING:

      gcloud beta compute future-reservations list --filter=PROCUREMENT_STATUS=DRAFTING
      

   2. In the command output, look for the reservation request that has the name that you provided to your account team.

   3. To view the details of the draft request, use the gcloud beta compute future-reservations describe command:

      gcloud beta compute future-reservations describe FUTURE_RESERVATION_NAME \
          --zone=ZONE
      

      Replace the following:

      • FUTURE_RESERVATION_NAME: the name of the draft future reservation request.
      • ZONE: the zone where Google created the request.

      The output is similar to the following:

      autoCreatedReservationsDeleteTime: '2026-02-10T19:20:00Z'
      creationTimestamp: '2025-11-27T11:14:58.305-08:00'
      deploymentType: DENSE
      id: '7979651787097007552'
      kind: compute#futureReservation
      name: example-draft-request
      planningStatus: DRAFT
      reservationName: example-reservation
      schedulingType: INDEPENDENT
      selfLink: https://www.googleapis.com/compute/beta/projects/example-project/zones/europe-west4-b/futureReservations/example-draft-request
      selfLinkWithId: https://www.googleapis.com/compute/beta/projects/example-project/zones/europe-west4-b/futureReservations/7979651787097007552
      specificReservationRequired: true
      specificSkuProperties:
        instanceProperties:
          localSsds:
          - diskSizeGb: '375'
            interface: NVME
          ...
        machineType: h4d-highmem-192-lssd
      totalCount: '2'
      status:
        autoCreatedReservations:
        - https://www.googleapis.com/compute/beta/projects/example-project/zones/europe-west4-b/reservations/example-reservation
        fulfilledCount: '2'
        lockTime: '2026-01-27T19:15:00Z'
        procurementStatus: DRAFTING
      timeWindow:
        endTime: '2026-02-10T19:20:00Z'
        startTime: '2026-01-27T19:20:00Z'
      zone: https://www.googleapis.com/compute/beta/projects/example-project/zones/europe-west4-b
      

   4. In the command output, verify that the request details, such as the reservation period and share type, are correct. Additionally, if you purchased a commitment, verify that it's specified.

   5. If the details are incorrect, then contact your account team.

   REST

   1. To view a list of future reservation requests in your project, make a GET request to the beta futureReservations.list method. In the request URL, include the filter query parameter and set it to status.procurementStatus=DRAFTING:

      GET https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/futureReservations?filter=status.procurementStatus=DRAFTING
      

      Replace the following:

      • PROJECT_ID: the ID of the project where Google created the draft future reservation request.
      • ZONE: the zone where request exists.

   2. In the request output, look for the reservation request that has the name that you provided to your account team.

   3. To view the details of the draft request, make a GET request to the beta futureReservations.get method:

      GET https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/futureReservations/FUTURE_RESERVATION_NAME
      

      Replace FUTURE_RESERVATION_NAME with the name of the draft future reservation request.

      The output is similar to the following:

      {
        "specificSkuProperties": {
          "instanceProperties": {
            "machineType": "h4d-highmem-192-lssd",
            "localSsds": [
              {
                "diskSizeGb": "375",
                "interface": "NVME"
              },
              ...
            ]
          },
          "totalCount": "2"
        },
        "kind": "compute#futureReservation",
        "id": "7979651787097007552",
        "creationTimestamp": "2025-11-27T11:14:58.305-08:00",
        "selfLink": "https://www.googleapis.com/compute/beta/projects/example-project/zones/europe-west4-b/futureReservations/example-draft-request",
        "selfLinkWithId": "https://www.googleapis.com/compute/beta/projects/example-project/zones/europe-west4-b/futureReservations/7979651787097007552",
        "zone": "https://www.googleapis.com/compute/beta/projects/example-project/zones/europe-west4-b",
        "name": "example-draft-request",
        "timeWindow": {
          "startTime": "2026-01-27T19:20:00Z",
          "endTime": "2026-02-10T19:20:00Z"
        },
        "status": {
          "procurementStatus": "DRAFTING",
          "lockTime": "2026-01-27T19:15:00Z"
        },
        "planningStatus": "DRAFT",
        "specificReservationRequired": true,
        "reservationName": "example-reservation",
        "deploymentType": "DENSE",
        "schedulingType": "INDEPENDENT",
        "autoCreatedReservationsDeleteTime": "2026-02-10T19:20:00Z"
      }
      

   4. In the output, verify that the request details, such as the reservation period and share type, are correct. Additionally, if you requested a commitment, verify that it's specified.

   5. If the details are incorrect, then contact your account team.

4. If everything looks correct, then submit the reservation request. You must submit the request before the request start time.

   To submit a draft future reservation request, select one of the following options:

   Console

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

      Go to Reservations

   2. Click the Future reservations tab.

   3. In the Name column, click the name of the draft request that Google created for you.

   4. Click Submit.

   gcloud

   To submit the draft request for review, use the gcloud beta compute future-reservations update command with the --planning-status flag set to SUBMITTED:

   gcloud beta compute future-reservations update FUTURE_RESERVATION_NAME \
       --planning-status=SUBMITTED \
       --zone=ZONE
   

   REST

   To submit the draft request for review, make a PATCH request to the beta futureReservations.update method. In the request URL, include the updateMask query parameter and set it to planningStatus:

   PATCH https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/futureReservations/FUTURE_RESERVATION_NAME?updateMask=planningStatus
   
   {
     "name": "FUTURE_RESERVATION_NAME",
     "planningStatus": "SUBMITTED"
   }
   

5. Google Cloud immediately approves your submitted request.

6. Compute Engine creates an empty reservation with your requested resources.

7. To view the reservation, see View reserved capacity in the AI Hypercomputer documentation.

Optional: Create a placement policy

Use a placement policy if you want your VMs to be placed as close to each other as possible. However, if you want your VMs to be on a specific block, skip this step and provide the name of the required block during bulk creation of VMs.

Instances that communicate using Cloud RDMA must be located in a single zone, and, more stringently, within a single cluster fabric. You can create a compact placement policy and specify a max distance value to set the minimum compactness within a zone. There is a limit to the number of instances you can assign the compact placement policy to when you specify a max distance value, and the limit changes depending on what value you choose.

To create a compact placement policy, select one of the following options:

gcloud beta compute resource-policies create group-placement POLICY_NAME \
--collocation=collocated \
--max-distance=MAX_DISTANCE \
--region=REGION

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/regions/REGION/resourcePolicies
{
    "name": "POLICY_NAME",
    "groupPlacementPolicy": {
        "collocation": "COLLOCATED",
        "maxDistance": "MAX_DISTANCE"
    }
}

Create Virtual Private Cloud networks

RDMA-enabled instances require a minimum of two network interfaces (NICs):

• NIC type GVNIC: uses the gve driver for TCP/IP and Internet traffic for normal VM-VM and VM-Internet communication
• NIC type IRDMA: uses IDPF/iRDMA drivers for RDMA network communication between instances

Instances that use Cloud RDMA can have only one IRDMA interface. You can add up to eight additional GVNIC network interfaces for a total of 10 NICs per instance.

Review the following rules for configuring a network interface for an instance:

• Each network interface must connect to a different Virtual Private Cloud network.
• To configure an IRDMA network interface, you must first create a VPC network with the Falcon RDMA network profile in the same region and zone as the instance.
• For the GVNIC network interface, if you don't specify a network or subnet, Compute Engine uses the default VPC network and the auto subnet that's in the same region as the instance.
• If you specify a subnet but don't specify a network, Compute Engine infers the network from the subnet specified.
• If you specify a network, then you must specify a subnet and it must belong to the same network. Otherwise, instance creation fails.

To set up the Falcon Virtual Private Cloud (VPC) networks to use with your instances, you can either follow the documented instructions or use the provided script.

#!/bin/bash

# Create standard VPC (networks and subnets) for the two GVNIC interfaces
  for N in $(seq 0 1); do
    gcloud compute networks create GVNIC_NAME_PREFIX-net-$N \
        --subnet-mode=custom

    gcloud compute networks subnets create GVNIC_NAME_PREFIX-sub-$N \
        --network=GVNIC_NAME_PREFIX-net-$N \
        --region=<var>REGION</var> \
        --range=10.$N.0.0/16

    gcloud compute firewall-rules create GVNIC_NAME_PREFIX-internal-$N \
        --network=GVNIC_NAME_PREFIX-net-$N \
        --action=ALLOW \
        --rules=tcp:0-65535,udp:0-65535,icmp \
        --source-ranges=10.0.0.0/8
done

# Create SSH firewall rules
gcloud compute firewall-rules create GVNIC_NAME_PREFIX-ssh \
  --network=GVNIC_NAME_PREFIX-net-0 \
  --action=ALLOW \
  --rules=tcp:22 \
  --source-ranges=IP_RANGE

# Optional: Create a firewall rule for the external IP address for the
#  first GVNIC network interface
gcloud compute firewall-rules create GVNIC_NAME_PREFIX-allow-ping-net-0 \
  --network=GVNIC_NAME_PREFIX-net-0 \
  --action=ALLOW \
  --rules=icmp \
  --source-ranges=IP_RANGE

# Create a network for the RDMA over Falcon network interface
gcloud beta compute networks create RDMA_NAME_PREFIX-irdma \
  --network-profile=ZONE-vpc-falcon \
  --subnet-mode custom

# Create a subnet for the RDMA network
gcloud beta compute networks subnets create RDMA_NAME_PREFIX-irdma-sub \
    --network=RDMA_NAME_PREFIX-irdma \
    --region=REGION \
    --range=10.2.0.0/16
# offset to avoid overlap with GVNIC subnet ranges

Create RDMA-enabled instances in bulk

Review the following limitations before creating H4D instances with Cloud RDMA:

• You can't use Live migration during host maintenance events with instances that have a Cloud RDMA network interface. You must configure the instance to terminate during maintenance events.
• You can use only IPv4 addresses with RDMA network interfaces and VPC networks with a Falcon RDMA network profile.
• You can use only the H4D machine series to create HPC-optimized instances with Cloud RDMA.

The following steps show how to create RDMA-enabled instances in bulk with the first two network interfaces configured as GVNIC interfaces, and the third network interface configured as an IRDMA network interface:

gcloud compute instances bulk create \
    --name-pattern=NAME_PATTERN \
    --count=COUNT \
    --machine-type=MACHINE_TYPE \
    --image-family=IMAGE_FAMILY \
    --image=project= IMAGE_PROJECT \
    --reservation-affinity=specific \
    --reservation=RESERVATION \
    --provisioning-model=RESERVATION_BOUND \
    --instance-termination=action=DELETE \
    --maintenance-policy=TERMINATE \
    --region=REGION \
    --boot-disk-type=hyperdisk-balanced \
    --boot-disk-size=DISK_SIZE \
    --scopes=cloud-platform \
    --network-interface=nic-type=GVNIC, \
        network=GVNIC_NAME_PREFIX-net-0, \
        subnet=GVNIC_NAME_PREFIX-sub-0, \
        stack-type=STACK_TYPE, \
        address=EXTERNAL_IPV4_ADDRESS \
    --network-interface=nic-type=GVNIC, \
        network=GVNIC_NAME_PREFIX-net-1, \
        subnet=GVNIC_NAME_PREFIX-sub-1, no-address \
    --network-interface=nic-type=IRDMA, \
        network=RDMA_NAME_PREFIX-irdma, \
        subnet=RDMA_NAME_PREFIX-irdma-sub, \
        stack-type=IPV4_ONLY, no-address

POST https://compute.googleapis.com/compute/beta/projects/PROJECT_ID/zones/ZONE/instances/bulkInsert
{
  "namePattern":"NAME_PATTERN",
  "count":"COUNT",
  "instanceProperties":{
    "machineType":"MACHINE_TYPE",
    "disks":[
      {
        "boot":true,
        "initializeParams":{
          "diskSizeGb":"DISK_SIZE",
          "diskType":"hyperdisk-balanced",
          "sourceImage":"projects/IMAGE_PROJECT/global/images/family/IMAGE_FAMILY"
        },
        "mode":"READ_WRITE",
        "type":"PERSISTENT"
      }
    ],
    "networkInterfaces": [
      {
          "network": "GVNIC_NAME_PREFIX-net-0",
          "subnetwork": "GVNIC_NAME_PREFIX-sub-0",
          "accessConfigs": [
            {
                "type": "ONE_TO_ONE_NAT",
                "name": "External IP",
                "natIP": "EXTERNAL_IPV4_ADDRESS"
            }
          ],
          "stackType": "IPV4_ONLY",
          "nicType": "GVNIC",
      },
      {
          "network": "GVNIC_NAME_PREFIX-net-1",
          "subnetwork": "GVNIC_NAME_PREFIX-sub-1",
          "stackType": "IPV4_ONLY",
          "nicType": "GVNIC",
      },
      {
          "network": "RDMA_NAME_PREFIX-irdma",
          "subnetwork": "RDMA_NAME_PREFIX-irdma-sub",
          "stackType": "IPV4_ONLY",
          "nicType": "IRDMA",
      }
    ],
    "reservationAffinity":{
        "consumeReservationType":"SPECIFIC_RESERVATION",
        "key":"compute.googleapis.com/reservation-name",
        "values":[
            "RESERVATION"
        ],
        "scheduling":{
            "provisioningModel":"RESERVATION_BOUND",
            "instanceTerminationAction":"DELETE",
            "onHostMaintenance": "TERMINATE",
            "automaticRestart":true
        }
    },
    ...
  }
}