The easiest method for monitoring free space by mounted filesystems is to use the ___

This document explains how to create a virtual machine (VM) instance by using a boot disk image, a boot disk snapshot, or a container image. Some images support Shielded VM features, which offer security features such as UEFI-compliant firmware, Secure Boot, and vTPM-protected Measured Boot. On Shielded VMs, vTPM and integrity monitoring are enabled by default.

Índice Show

Before you begin
Create a VM instance from an image
View a list of public images available on Compute Engine
Create a VM from a snapshot
Create a VM instance from a container image
What's next?

While creating your VM, you can create one or more disks for it. You can also add more disks to the VM after it's created. Compute Engine automatically starts the VM instance after you create it.

While creating a VM, you can also add multiple network interfaces. To mitigate your VM's exposure to threats on the internet, you can omit the external IP address when you add a network interface to the instance. In such cases, the VM is accessible only from other VMs in the same VPC network or a linked network unless you configure Cloud NAT.

If you are creating a VM for the first time, see Quickstart using a Linux VM or Quickstart using a Windows Server VM.

For more specific or complicated VM creation, see the following resources:

If you are bringing an existing license, see Bringing your own license with sole-tenant nodes.

Before you begin

If you want to use the command-line examples in this guide, do the following:
If you want to use the API examples in this guide, set up API access.
When creating VMs from images or disks by using the Google Cloud CLI or the Compute Engine API, there's a limit of 20 VM instances per second. If you need to create a higher number of VMs per second, request a higher quota limit for the Images resource.

Create a VM instance from an image

This section explains how to create a VM from a public OS image or a custom image. A VM contains a bootloader, a boot file system, and an OS image.

View a list of public images available on Compute Engine

Before you create a VM by using a public image, review the list of public images that are available on Compute Engine.

For more information about the features available with each public image, see Feature support by operating system.

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

Go to Images

Run the following command:
gcloud compute images list
Make a note of the name of the image or image family and the name of the project containing the image.
Optional: To determine whether the image supports Shielded VM features, run the following command:
gcloud compute images describe IMAGE_NAME \ --project=IMAGE_PROJECT
Replace the following:
- IMAGE_NAME: name of the image to check for support of Shielded VM features
- IMAGE_PROJECT: project containing the image
If the image supports Shielded VM features, the following line appears in the output: type: UEFI_COMPATIBLE.

Run the following command:
GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/
Make a note of the name of the image or image family and the name of the project containing the image.
Optional: To determine whether the image supports Shielded VM features, run the following command:
GET https://compute.googleapis.com/compute/v1/projects/IMAGE_PROJECT/global/images/IMAGE_NAME
Replace the following:
- IMAGE_PROJECT: project containing the image
- IMAGE_NAME: name of the image to check for support of Shielded VM features
If the image supports Shielded VM features, the following line appears in the output: type: UEFI_COMPATIBLE.

Google, open source communities, and third-party vendors provide and maintain public OS images. By default, all Google Cloud projects can create VMs from public OS images. However, if your Cloud project has a defined list of trusted images, you can use only the images on that list to create a VM.

If you create a Shielded VM image with a local SSD, you can't shield data with integrity monitoring or the virtual platform trusted module (vTPM).

To perform this task, you must have the following permissions:

compute.instances.create on the project
compute.instances.updateShieldedVmConfig if you plan to create a Shielded VM instance and you want to be able to change any of the Shielded VM settings
compute.networks.use on the project if using a legacy network
compute.subnetworks.use either on the whole project or on the chosen subnet (VPC networks)
compute.networks.useExternalIp on the project if you need to assign an external IP address (either ephemeral or static) to the instance using a legacy network
compute.subnetworks.useExternalIp either on the whole project or on the chosen subnet if you need to assign an external IP address (either ephemeral or static) to the instance using a VPC network
compute.addresses.use on the project if specifying a static address in the project
compute.instances.setMetadata if setting metadata
compute.instances.setTags on the instance if setting tags
compute.instances.setLabels on the instance if setting labels
compute.images.useReadOnly on the image if creating a new root persistent disk
compute.disks.create on the project if creating a new root persistent disk with this instance
compute.disks.useReadOnly on the disk if attaching an existing persistent disk in read-only mode
compute.disks.use on the disk if attaching an existing disk in read/write mode
compute.disks.setLabels on the disk if setting labels
compute.snapshots.create on the project to create a new snapshot if creating an instance from a snapshot
compute.snapshots.useReadOnly on the snapshot if creating an instance from a snapshot

In the Google Cloud console, go to the VM instances page.

Go to VM instances
Select your project and click Continue.
Click Create instance.
Specify a Name for your VM. For more information, see Resource naming convention.
Optional: Change the Zone for this VM. Compute Engine randomizes the list of zones within each region to encourage use across multiple zones.
Select a Machine configuration for your VM.
In the Boot disk section, click Change, and then do the following:
1. On the Public images tab, choose the following:
  - Operating system
  - OS version
  - Boot disk type
  - Boot disk size
2. Optional: For advanced configuration options, click Show advanced configuration.
3. To confirm your boot disk options, click Select.
Note: Unless you explicitly choose a different boot disk, if the name of the new VM matches the name of an existing persistent disk, then the existing persistent disk automatically attaches to the new VM as the boot disk.
In the Firewall section, to permit HTTP or HTTPS traffic to the VM, select Allow HTTP traffic or Allow HTTPS traffic. When you select one of these, Compute Engine adds a network tag to your VM, which associates the firewall rule with the VM. Then, Compute Engine creates the corresponding ingress firewall rule that allows all incoming traffic on tcp:80 (HTTP) or tcp:443 (HTTPS).
Optional: If you chose an OS image that supports Shielded VM features, you can modify the Shielded VM settings. To modify shielded VM settings, expand the Security section in the Networking, disks, security, management, sole tenancy section and do the following, as required:
To create and start the VM, click Create.

Select a public image. Make a note of the name of the image or image family and the name of the project containing the image.
Use the gcloud compute instances create command to create a VM from an image family or from a specific version of an OS image.

If you specify the optional --shielded-secure-boot flag, Compute Engine creates a VM with all three of the Shielded VM features enabled:
- Virtual trusted platform module (vTPM)
- Integrity monitoring
- Secure Boot
After Compute Engine starts your VM, you must stop the VM to modify Shielded VM options.
gcloud compute instances create VM_NAME \ [--image=IMAGE | --image-family=IMAGE_FAMILY] \ --image-project=IMAGE_PROJECT --machine-type=MACHINE_TYPE
Replace the following:
- VM_NAME: name of the new VM
- IMAGE or IMAGE_FAMILY: specify one of the following:
  - IMAGE: a specific version of a public image
    
    For example, --image=debian-10-buster-v20200309.
  - IMAGE_FAMILY: an image family.
    
    This creates the VM from the most recent, non-deprecated OS image. For example, if you specify --image-family=debian-10, Compute Engine creates a VM from the latest version of the OS image in the Debian 10 image family.
- IMAGE_PROJECT: project containing the image
- MACHINE_TYPE: machine type, predefined or custom, for the new VM
  
  To get a list of the machine types available in a zone, use the gcloud compute machine-types list command with the --zones flag.
Verify that Compute Engine created the VM:
gcloud compute instances describe VM_NAME
Replace VM_NAME with the name of the VM.

Select a public image. Make a note of the name of the image or image family and the name of the project containing the image.
Use the instances.insert method to create a VM from an image family or from a specific version of an OS image:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances { "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE", "name":"VM_NAME", "disks":[ { "initializeParams":{ "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE" }, "boot":true } ], "networkInterfaces":[ { "network":"global/networks/NETWORK_NAME" } ], "shieldedInstanceConfig":{ "enableSecureBoot":"ENABLE_SECURE_BOOT" } }
Replace the following:
- PROJECT_ID: ID of the project to create the VM in
- ZONE: zone to create the VM in
- MACHINE_TYPE_ZONE: zone containing the machine type to use for the new VM
- MACHINE_TYPE: machine type, predefined or custom, for the new VM
- VM_NAME: name of the new VM
- IMAGE_PROJECT: project containing the image
  For example, if you specify debian-10 as the image family, specify debian-cloud as the image project.
- IMAGE or IMAGE_FAMILY: specify one of the following:
  - IMAGE: a specific version of a public image
    For example, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"
  - IMAGE_FAMILY: an image family
    This creates the VM from the most recent, non-deprecated OS image. For example, if you specify "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine creates a VM from the latest version of the OS image in the Debian 10 image family.
- NETWORK_NAME: the VPC network that you want to use for the VM. You can specify default to use your default network.
- ENABLE_SECURE_BOOT: Optional: If you chose an image that supports Shielded VM features, Compute Engine, by default, enables the virtual trusted platform module (vTPM) and integrity monitoring. Compute Engine does not enable Secure Boot by default.
  If you specify true for enableSecureBoot, Compute Engine creates a VM with all three Shielded VM features enabled. After Compute Engine starts your VM, to modify Shielded VM options, you must stop the VM.

using Google.Cloud.Compute.V1; using System.Threading.Tasks; public class CreateInstanceAsyncSample { public async Task CreateInstanceAsync( // TODO(developer): Set your own default values for these parameters or pass different values when calling this method. string projectId = "your-project-id", string zone = "us-central1-a", string machineName = "test-machine", string machineType = "n1-standard-1", string diskImage = "projects/debian-cloud/global/images/family/debian-10", long diskSizeGb = 10, string networkName = "default") { Instance instance = new Instance { Name = machineName, // See https://cloud.google.com/compute/docs/machine-types for more information on machine types. MachineType = $"zones/{zone}/machineTypes/{machineType}", // Instance creation requires at least one persistent disk. Disks = { new AttachedDisk { AutoDelete = true, Boot = true, Type = ComputeEnumConstants.AttachedDisk.Type.Persistent, InitializeParams = new AttachedDiskInitializeParams { // See https://cloud.google.com/compute/docs/images for more information on available images. SourceImage = diskImage, DiskSizeGb = diskSizeGb } } }, NetworkInterfaces = { new NetworkInterface { Name = networkName } } }; // Initialize client that will be used to send requests. This client only needs to be created // once, and can be reused for multiple requests. InstancesClient client = await InstancesClient.CreateAsync(); // Insert the instance in the specified project and zone. var instanceCreation = await client.InsertAsync(projectId, zone, instance); // Wait for the operation to complete using client-side polling. // The server-side operation is not affected by polling, // and might finish successfully even if polling times out. await instanceCreation.PollUntilCompletedAsync(); } }

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" ) // createInstance sends an instance creation request to the Compute Engine API and waits for it to complete. func createInstance(w io.Writer, projectID, zone, instanceName, machineType, sourceImage, networkName string) error { // projectID := "your_project_id" // zone := "europe-central2-b" // instanceName := "your_instance_name" // machineType := "n1-standard-1" // sourceImage := "projects/debian-cloud/global/images/family/debian-10" // networkName := "global/networks/default" ctx := context.Background() instancesClient, err := compute.NewInstancesRESTClient(ctx) if err != nil { return fmt.Errorf("NewInstancesRESTClient: %v", 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(sourceImage), }, AutoDelete: proto.Bool(true), Boot: proto.Bool(true), Type: proto.String(computepb.AttachedDisk_PERSISTENT.String()), }, }, MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/%s", zone, machineType)), NetworkInterfaces: []*computepb.NetworkInterface{ { Name: proto.String(networkName), }, }, }, } op, err := instancesClient.Insert(ctx, req) if err != nil { return fmt.Errorf("unable to create instance: %v", err) } if err = op.Wait(ctx); err != nil { return fmt.Errorf("unable to wait for the operation: %v", err) } fmt.Fprintf(w, "Instance created\n") return nil }

/** * 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 machineType = 'n1-standard-1'; // const sourceImage = 'projects/debian-cloud/global/images/family/debian-10'; // const networkName = 'global/networks/default'; const compute = require('@google-cloud/compute'); // Create a new instance with the values provided above in the specified project and zone. async function createInstance() { const instancesClient = new compute.InstancesClient(); console.log(`Creating the ${instanceName} instance in ${zone}...`); const [response] = await instancesClient.insert({ instanceResource: { name: instanceName, disks: [ { // Describe the size and source image of the boot disk to attach to the instance. initializeParams: { diskSizeGb: '10', sourceImage, }, autoDelete: true, boot: true, type: 'PERSISTENT', }, ], machineType: `zones/${zone}/machineTypes/${machineType}`, networkInterfaces: [ { // Use the network interface provided in the networkName argument. name: networkName, }, ], }, 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.'); } createInstance();

import re import sys from typing import Any, List 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: """ This method will wait 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.name = 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}" if accelerators: instance.guest_accelerators = accelerators 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 = compute_v1.Scheduling() 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)

require "google/cloud/compute/v1" # Sends an instance creation request to the Compute Engine API and waits for it to complete. # # @param [String] project project ID or project number of the Cloud project you want to use. # @param [String] zone name of the zone you want to use. For example: "us-west3-b" # @param [String] instance_name name of the new virtual machine. # @param [String] machine_type machine type of the VM being created. For example: "e2-standard-2" # See https://cloud.google.com/compute/docs/machine-types for more information # on machine types. # @param [String] source_image path to the operating system image to mount on your boot # disk. This can be one of the public images # (like "projects/debian-cloud/global/images/family/debian-10") # or a private image you have access to. # See https://cloud.google.com/compute/docs/images for more information on available images. # @param [String] network_name name of the network you want the new instance to use. # For example: "global/networks/default" represents the `default` # network interface, which is created automatically for each project. def create_instance project:, zone:, instance_name:, machine_type: "n2-standard-2", source_image: "projects/debian-cloud/global/images/family/debian-10", network_name: "global/networks/default" # Initialize client that will be used to send requests. This client only needs to be created # once, and can be reused for multiple requests. client = ::Google::Cloud::Compute::V1::Instances::Rest::Client.new # Construct the instance object. # It can be either a hash or ::Google::Cloud::Compute::V1::Instance instance. instance = { name: instance_name, machine_type: "zones/#{zone}/machineTypes/#{machine_type}", # Instance creation requires at least one persistent disk. disks: [{ auto_delete: true, boot: true, type: :PERSISTENT, initialize_params: { source_image: source_image, disk_size_gb: 10 } }], network_interfaces: [{ name: network_name }] } # Prepare a request to create the instance in the specified project and zone. request = { project: project, zone: zone, instance_resource: instance } puts "Creating the #{instance_name} instance in #{zone}..." begin # Send the insert request. operation = client.insert request # Wait for the create operation to complete. operation = wait_until_done operation: operation if operation.error? warn "Error during creation:", operation.error else compute_operation = operation.operation warn "Warning during creation:", compute_operation.warnings unless compute_operation.warnings.empty? puts "Instance #{instance_name} created." end rescue ::Google::Cloud::Error => e warn "Exception during creation:", e end end

A custom image belongs only to your project. To create a VM with a custom image, you must first create a custom image if you don't already have one.

Note: You must have access to the custom image to use it when you create a VM. By default, you have access to all custom images in your project. However, if your project has a defined list of trusted images, you can use only the images on that list to create a VM.

To perform this task, you must have the following permissions:

compute.instances.create on the project
compute.instances.updateShieldedVmConfig if you plan to create a Shielded VM instance and you want to be able to change any of the Shielded VM settings
compute.networks.use on the project if using a legacy network
compute.subnetworks.use either on the whole project or on the chosen subnet (VPC networks)
compute.networks.useExternalIp on the project if you need to assign an external IP address (either ephemeral or static) to the instance using a legacy network
compute.subnetworks.useExternalIp either on the whole project or on the chosen subnet if you need to assign an external IP address (either ephemeral or static) to the instance using a VPC network
compute.addresses.use on the project if specifying a static address in the project
compute.instances.setMetadata if setting metadata
compute.instances.setTags on the instance if setting tags
compute.instances.setLabels on the instance if setting labels
compute.images.useReadOnly on the image if creating a new root persistent disk
compute.disks.create on the project if creating a new root persistent disk with this instance
compute.disks.useReadOnly on the disk if attaching an existing persistent disk in read-only mode
compute.disks.use on the disk if attaching an existing disk in read/write mode
compute.disks.setLabels on the disk if setting labels
compute.snapshots.create on the project to create a new snapshot if creating an instance from a snapshot
compute.snapshots.useReadOnly on the snapshot if creating an instance from a snapshot

In the Google Cloud console, go to the VM instances page.

Go to VM instances
Select your project and click Continue.
Click Create instance.
Specify a Name for your VM. For more information, see Resource naming convention.
Optional: Change the Zone for this VM. Compute Engine randomizes the list of zones within each region to encourage use across multiple zones.
Select a Machine configuration for your VM.
In the Boot disk section, click Change, and then do the following:
1. Select the Custom Images tab.
2. To select the image project, click Select a project, and then do the following:
  1. Select the project that contains the image.
  2. Click Open.
3. In the Image list, click the image that you want to import.
4. Select the type and size of your boot disk.
5. Optional: For advanced configuration options, click Show advanced configuration.
6. To confirm your boot disk options, click Select.
In the Firewall section, to permit HTTP or HTTPS traffic to the VM, select Allow HTTP traffic or Allow HTTPS traffic.

The Google Cloud console adds a network tag to your VM and creates the corresponding ingress firewall rule that allows all incoming traffic on tcp:80 (HTTP) or tcp:443 (HTTPS). The network tag associates the firewall rule with the VM. For more information, see Firewall rules overview in the Virtual Private Cloud documentation.
To create and start the VM, click Create.

Run the gcloud compute instances create command to create a VM with a custom image:

gcloud compute instances create VM_NAME \ --image-project IMAGE_PROJECT \ [--image IMAGE | --image-family IMAGE_FAMILY] --subnet SUBNET

Replace the following:

VM_NAME: name of the VM
IMAGE_PROJECT: name of the project that contains the image
IMAGE or IMAGE_FAMILY: specify one of the following:
- IMAGE: name of your custom image
  For example, --image=my-debian-image-v2.
- IMAGE_FAMILY: if you created your custom images as part of a custom image family, specify that custom image family.
  This creates the VM from the most recent, non-deprecated OS image and OS version in your custom image family. For example, if you specify --image-family=my-debian-family, Compute Engine creates a VM from the latest OS image in your custom my-debian-family image family.
Note: Compute Engine uses the default image family and project if you don't specify an image. The default image family and project are debian-10 and debian-cloud, respectively.
SUBNET: If the subnet and instance are in the same project, replace SUBNET with the name of a subnet that is in the same region as the instance.

The process for creating a VM with a custom image in the API is the same as if you were creating a VM with a publicly available image.

To create the VM from a custom image, use the instances.insert method.

Replace the following:

PROJECT_ID: ID of the project to create the VM in
ZONE: zone to create the VM in
MACHINE_TYPE_ZONE: zone containing the machine type to use for the new VM
MACHINE_TYPE: machine type, predefined or custom, for the new VM
VM_NAME: name of the new VM
IMAGE_PROJECT: name of the project that contains the custom image
IMAGE or IMAGE_FAMILY: specify one of the following:
- IMAGE: name of your custom image. For example, "sourceImage": "projects/my-project-1234/global/images/my-debian-image-v2".
- IMAGE_FAMILY: if you created your custom images as part of a custom image family, specify that custom image family.
  This creates the VM from the most recent, non-deprecated OS image in your custom image family. For example, if you specify "sourceImage": "projects/my-project-1234/global/images/family/my-debian-family", Compute Engine creates a VM from the latest version of the OS image in the custom my-debian-family image family.
NETWORK_NAME: the VPC network that you want to use for the VM. You can specify default to use your default network.
ENABLE_SECURE_BOOT: Optional: If you chose an image that supports Shielded VM features, Compute Engine, by default, enables the virtual trusted platform module (vTPM) and integrity monitoring. Compute Engine does not enable Secure Boot by default.
If you specify true for enableSecureBoot, Compute Engine creates a VM with all three Shielded VM features enabled. After Compute Engine starts your VM, to modify Shielded VM options, you must stop the VM.

import com.google.api.gax.longrunning.OperationFuture; import com.google.cloud.compute.v1.AttachedDisk; import com.google.cloud.compute.v1.AttachedDisk.Type; import com.google.cloud.compute.v1.AttachedDiskInitializeParams; import com.google.cloud.compute.v1.Image; import com.google.cloud.compute.v1.ImagesClient; 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 java.io.IOException; import java.util.Vector; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class CreateInstancesAdvanced { /** * Create an AttachedDisk object to be used in VM instance creation. Uses an image as the source * for the new disk. * * @param diskType 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" * @param diskSizeGb size of the new disk in gigabytes * @param boot boolean flag indicating whether this disk should be used as a boot disk of an * instance * @param sourceImage 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}" * @return AttachedDisk object configured to be created using the specified image. */ private static AttachedDisk diskFromImage(String diskType, int diskSizeGb, boolean boot, String sourceImage) { AttachedDisk disk = AttachedDisk.newBuilder() .setBoot(boot) // Remember to set auto_delete to True if you want the disk to be deleted when // you delete your VM instance. .setAutoDelete(true) .setType(Type.PERSISTENT.toString()) .setInitializeParams( AttachedDiskInitializeParams.newBuilder() .setSourceImage(sourceImage) .setDiskSizeGb(diskSizeGb) .setDiskType(diskType) .build()) .build(); return disk; } /** * Send an instance creation request to the Compute Engine API and wait for it to complete. * * @param project project ID or project number of the Cloud project you want to use. * @param zone name of the zone to create the instance in. For example: "us-west3-b" * @param instanceName name of the new virtual machine (VM) instance. * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach * to your new instance. * @param machineType 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" * @param network 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. * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the * following format: "regions/{region}/subnetworks/{subnetwork_name}" * @return Instance object. */ private static Instance createWithDisks(String project, String zone, String instanceName, Vector<AttachedDisk> disks, String machineType, String network, String subnetwork) throws IOException, InterruptedException, ExecutionException, TimeoutException { try (InstancesClient instancesClient = InstancesClient.create()) { // Use the network interface provided in the networkName argument. NetworkInterface networkInterface; if (subnetwork != null) { networkInterface = NetworkInterface.newBuilder() .setName(network).setSubnetwork(subnetwork) .build(); } else { networkInterface = NetworkInterface.newBuilder() .setName(network).build(); } machineType = String.format("zones/%s/machineTypes/%s", zone, machineType); // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance. Instance instanceResource = Instance.newBuilder() .setName(instanceName) .setMachineType(machineType) .addAllDisks(disks) .addNetworkInterfaces(networkInterface) .build(); System.out.printf("Creating instance: %s at %s ", instanceName, zone); // Insert the instance in the specified project and zone. InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder() .setProject(project) .setZone(zone) .setInstanceResource(instanceResource).build(); OperationFuture<Operation, Operation> operation = instancesClient.insertAsync( insertInstanceRequest); // Wait for the operation to complete. Operation response = operation.get(3, TimeUnit.MINUTES); if (response.hasError()) { System.out.println("Instance creation failed ! ! " + response); return null; } System.out.println("Operation Status: " + response.getStatus()); return instancesClient.get(project, zone, instanceName); } } /** * Create a new VM instance with custom image used as its boot disk. * * @param project project ID or project number of the Cloud project you want to use. * @param zone name of the zone to create the instance in. For example: "us-west3-b" * @param instanceName name of the new virtual machine (VM) instance. * @param customImage link to the custom image you want to use in the form of: * "projects/{project_name}/global/images/{image_name}" * @return Instance object. */ public static Instance createFromCustomImage(String project, String zone, String instanceName, String customImage) throws IOException, InterruptedException, ExecutionException, TimeoutException { String diskType = String.format("zones/%s/diskTypes/pd-standard", zone); Vector<AttachedDisk> disks = new Vector<>(); disks.add(diskFromImage(diskType, 10, true, customImage)); return createWithDisks(project, zone, instanceName, disks, "n1-standard-1", "global/networks/default", null); }

/** * 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 customImageLink = 'projects/YOUR_PROJECT/global/images/YOUR_IMAGE_NAME'; const compute = require('@google-cloud/compute'); // Creates a new VM instance with custom image used as its boot disk. async function createInstanceFromCustomImage() { const instancesClient = new compute.InstancesClient(); const [response] = await instancesClient.insert({ project: projectId, zone, instanceResource: { name: instanceName, disks: [ { initializeParams: { diskSizeGb: '10', sourceImage: customImageLink, diskType: `zones/${zone}/diskTypes/pd-standard`, }, autoDelete: true, boot: true, type: 'PERSISTENT', }, ], machineType: `zones/${zone}/machineTypes/n1-standard-1`, networkInterfaces: [ { name: 'global/networks/default', }, ], }, }); 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.'); } createInstanceFromCustomImage();

In the Google Cloud console, go to the VM instances page.

Go to VM instances
Select your project and click Continue.
Click Create instance.
Specify a Name for your VM. For more information, see Resource naming convention.
Optional: Change the Zone for this VM. Compute Engine randomizes the list of zones within each region to encourage use across multiple zones.
Select a Machine configuration for your VM.
In the Boot disk section, click Change, and then do the following:
1. In the Public images tab, choose the following:
  - Operating system
  - OS version
  - Boot disk type
  - Boot disk size
2. Optional: For advanced configuration options, click Show advanced configuration.
3. To confirm your boot disk options, click Select.
Note: Unless you explicitly choose a different boot disk, if the name of the new VM matches the name of an existing persistent disk, then the existing persistent disk automatically attaches to the new VM as the boot disk.
In the Firewall section, to permit HTTP or HTTPS traffic to the VM, select Allow HTTP traffic or Allow HTTPS traffic. When you select one of these, Compute Engine adds a network tag to your VM, which associates the firewall rule with the VM. Then, Compute Engine creates the corresponding ingress firewall rule that allows all incoming traffic on tcp:80 (HTTP) or tcp:443 (HTTPS).
To add non-boot disks to your VM, expand the Networking, disks, security, management, sole tenancy section, and then do the following:
1. Expand the Disks section.
2. Click Add new disk, and then do the following:
  1. Specify a disk Name, Type, Source type, and Size.
  2. In the Attachment settings section, select disk's attachment Mode and the Deletion rule. For more information about adding new disks, see Add a persistent disk to your VM.
  3. Click Save.
To create and start the VM, click Create.

Run the gcloud compute instances create command to create a VM with additional non-boot disks.

You can add up to 128 non-boot disks while you're creating your VM. Specify the --create-disk flag for each non-boot disk you create.

To create non-boot disks from a public or stock image, specify the image or image-family and image-project properties with the --create-disk flag. To create a blank disk, don't include these properties. You can optionally include properties for the disk size and type.

gcloud compute instances create VM_NAME \ [--image=IMAGE | --image-family=IMAGE_FAMILY] \ --image-project=IMAGE_PROJECT \ --create-disk [image=DISK_IMAGE | image-family=DISK_IMAGE_FAMILY ],image-project=DISK_IMAGE_PROJECT,size=SIZE_GB,type=DISK_TYPE

Replace the following:

VM_NAME: name of the new VM
IMAGE or IMAGE_FAMILY. Specify one of the following:
- IMAGE: a specific version of a public image
  
  For example, --image=debian-10-buster-v20200309.
- IMAGE_FAMILY: an image family
  
  This creates the VM from the most recent, non-deprecated OS image. For example, if you specify --image-family=debian-10, Compute Engine creates a VM from the latest version of the OS image in the Debian 10 image family.
IMAGE_PROJECT: project containing the image
For additional disks, replace the following:
- DISK_IMAGE or DISK_IMAGE_FAMILY: Specify one of the following:
  - DISK_IMAGE: name of the image that you want to use as a non-boot disk
  - DISK_IMAGE_FAMILY: an image family to use as a non-boot disk
- DISK_IMAGE_PROJECT: an image project to which the disk image belongs
- SIZE_GB: Optional: size of the non-boot disk
- DISK_TYPE: Optional: full or partial URL for the type of the persistent disk
  
  For example, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd. To view the available disk types, run the gcloud compute disk-types list command.
For blank disks, don't specify the DISK_IMAGE, DISK_IMAGE_FAMILY, or DISK_IMAGE_PROJECT parameters.

You can create up to 128 non-boot disks at the time you create a VM by using the initializeParams property for each additional disk. Create additional disks with a public or private image. To add a blank disk, define the initializeParams entry with no sourceImage value.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances { "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE", "name":"VM_NAME", "disks":[ { "initializeParams":{ "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE" }, "boot":true }, { "initializeParams":{ "diskSizeGb":"SIZE_GB", "sourceImage":"projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE", "diskType":"DISK_TYPE" } }, { "initializeParams":{ "diskSizeGb":"SIZE_GB", "diskType":"DISK_TYPE" } } ], "networkInterfaces":[ { "network":"global/networks/NETWORK_NAME" } ], "shieldedInstanceConfig":{ "enableSecureBoot":"ENABLE_SECURE_BOOT" } }

Replace the following:

PROJECT_ID: ID of the project to create the VM in
ZONE: zone to create the VM in
MACHINE_TYPE_ZONE: zone containing the machine type to use for the new VM
MACHINE_TYPE: machine type, predefined or custom, for the new VM
VM_NAME: name of the new VM
IMAGE_PROJECT: project containing the image
For example, if you specify debian-10 as the image family, specify debian-cloud as the image project.
IMAGE or IMAGE_FAMILY: specify one of the following:
- IMAGE: a specific version of a public image
  For example, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"
- IMAGE_FAMILY: an image family
  This creates the VM from the most recent, non-deprecated OS image. For example, if you specify "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine creates a VM from the latest version of the OS image in the Debian 10 image family.
For additional disks, replace the following:
- SIZE_GB: disk size
- DISK_IMAGE or
- DISK_IMAGE_FAMILY: Specify either a source image or image family for the non-boot disk:
  - DISK_IMAGE: name of the image that you want to use as a non-boot disk For example, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/DISK_IMAGE".
  - DISK_IMAGE_FAMILY: an image family to use as a non-boot disk For example, "sourceImage": "projects/DISK_IMAGE_PROJECT/global/images/family/DISK_IMAGE_FAMILY".
- DISK_TYPE: full or partial URL for the type of the persistent disk. For example, https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/diskTypes/pd-ssd.
NETWORK_NAME: the VPC network that you want to use for the VM. You can specify default to use your default network.
ENABLE_SECURE_BOOT: Optional: If you chose an image that supports Shielded VM features, Compute Engine, by default, enables the virtual trusted platform module (vTPM) and integrity monitoring. Compute Engine does not enable Secure Boot by default.
If you specify true for enableSecureBoot, Compute Engine creates a VM with all three Shielded VM features enabled. After Compute Engine starts your VM, to modify Shielded VM options, you must stop the VM.

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" ) // createWithAdditionalDisk create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk. func createWithAdditionalDisk(w io.Writer, projectID, zone, instanceName string) error { // projectID := "your_project_id" // zone := "europe-central2-b" // instanceName := "your_instance_name" ctx := context.Background() instancesClient, err := compute.NewInstancesRESTClient(ctx) if err != nil { return fmt.Errorf("NewInstancesRESTClient: %v", err) } defer instancesClient.Close() imagesClient, err := compute.NewImagesRESTClient(ctx) if err != nil { return fmt.Errorf("NewImagesRESTClient: %v", err) } defer imagesClient.Close() // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details. newestDebianReq := &computepb.GetFromFamilyImageRequest{ Project: "debian-cloud", Family: "debian-10", } newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq) if err != nil { return fmt.Errorf("unable to get image from family: %v", err) } 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: newestDebian.SelfLink, DiskType: proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)), }, AutoDelete: proto.Bool(true), Boot: proto.Bool(true), Type: proto.String(computepb.AttachedDisk_PERSISTENT.String()), }, { InitializeParams: &computepb.AttachedDiskInitializeParams{ DiskSizeGb: proto.Int64(11), DiskType: proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)), }, AutoDelete: proto.Bool(true), Boot: proto.Bool(false), Type: proto.String(computepb.AttachedDisk_PERSISTENT.String()), }, }, MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)), 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: %v", err) } if err = op.Wait(ctx); err != nil { return fmt.Errorf("unable to wait for the operation: %v", err) } fmt.Fprintf(w, "Instance created\n") return nil }

import com.google.api.gax.longrunning.OperationFuture; import com.google.cloud.compute.v1.AttachedDisk; import com.google.cloud.compute.v1.AttachedDisk.Type; import com.google.cloud.compute.v1.AttachedDiskInitializeParams; import com.google.cloud.compute.v1.Image; import com.google.cloud.compute.v1.ImagesClient; 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 java.io.IOException; import java.util.Vector; import java.util.concurrent.ExecutionException; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; public class CreateInstancesAdvanced { /** * Create an AttachedDisk object to be used in VM instance creation. Uses an image as the source * for the new disk. * * @param diskType 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" * @param diskSizeGb size of the new disk in gigabytes * @param boot boolean flag indicating whether this disk should be used as a boot disk of an * instance * @param sourceImage 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}" * @return AttachedDisk object configured to be created using the specified image. */ private static AttachedDisk diskFromImage(String diskType, int diskSizeGb, boolean boot, String sourceImage) { AttachedDisk disk = AttachedDisk.newBuilder() .setBoot(boot) // Remember to set auto_delete to True if you want the disk to be deleted when // you delete your VM instance. .setAutoDelete(true) .setType(Type.PERSISTENT.toString()) .setInitializeParams( AttachedDiskInitializeParams.newBuilder() .setSourceImage(sourceImage) .setDiskSizeGb(diskSizeGb) .setDiskType(diskType) .build()) .build(); return disk; } /** * Create an AttachedDisk object to be used in VM instance creation. The created disk contains no * data and requires formatting before it can be used. * * @param diskType 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" * @param diskSizeGb size of the new disk in gigabytes * @return AttachedDisk object configured to be created as an empty disk. */ private static AttachedDisk emptyDisk(String diskType, int diskSizeGb) { AttachedDisk disk = AttachedDisk.newBuilder() .setBoot(false) // Remember to set auto_delete to True if you want the disk to be deleted when // you delete your VM instance. .setAutoDelete(true) .setType(Type.PERSISTENT.toString()) .setInitializeParams( AttachedDiskInitializeParams.newBuilder() .setDiskSizeGb(diskSizeGb) .setDiskType(diskType) .build()) .build(); return disk; } /** * Send an instance creation request to the Compute Engine API and wait for it to complete. * * @param project project ID or project number of the Cloud project you want to use. * @param zone name of the zone to create the instance in. For example: "us-west3-b" * @param instanceName name of the new virtual machine (VM) instance. * @param disks a list of compute_v1.AttachedDisk objects describing the disks you want to attach * to your new instance. * @param machineType 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" * @param network 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. * @param subnetwork name of the subnetwork you want the new instance to use. This value uses the * following format: "regions/{region}/subnetworks/{subnetwork_name}" * @return Instance object. */ private static Instance createWithDisks(String project, String zone, String instanceName, Vector<AttachedDisk> disks, String machineType, String network, String subnetwork) throws IOException, InterruptedException, ExecutionException, TimeoutException { try (InstancesClient instancesClient = InstancesClient.create()) { // Use the network interface provided in the networkName argument. NetworkInterface networkInterface; if (subnetwork != null) { networkInterface = NetworkInterface.newBuilder() .setName(network).setSubnetwork(subnetwork) .build(); } else { networkInterface = NetworkInterface.newBuilder() .setName(network).build(); } machineType = String.format("zones/%s/machineTypes/%s", zone, machineType); // Bind `instanceName`, `machineType`, `disk`, and `networkInterface` to an instance. Instance instanceResource = Instance.newBuilder() .setName(instanceName) .setMachineType(machineType) .addAllDisks(disks) .addNetworkInterfaces(networkInterface) .build(); System.out.printf("Creating instance: %s at %s ", instanceName, zone); // Insert the instance in the specified project and zone. InsertInstanceRequest insertInstanceRequest = InsertInstanceRequest.newBuilder() .setProject(project) .setZone(zone) .setInstanceResource(instanceResource).build(); OperationFuture<Operation, Operation> operation = instancesClient.insertAsync( insertInstanceRequest); // Wait for the operation to complete. Operation response = operation.get(3, TimeUnit.MINUTES); if (response.hasError()) { System.out.println("Instance creation failed ! ! " + response); return null; } System.out.println("Operation Status: " + response.getStatus()); return instancesClient.get(project, zone, instanceName); } } /** * Create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk. * * @param project project ID or project number of the Cloud project you want to use. * @param zone name of the zone to create the instance in. For example: "us-west3-b" * @param instanceName name of the new virtual machine (VM) instance. * @return Instance object. */ public static Instance createWithAdditionalDisk(String project, String zone, String instanceName) throws IOException, InterruptedException, ExecutionException, TimeoutException { try (ImagesClient imagesClient = ImagesClient.create()) { // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details Image image = imagesClient.getFromFamily("debian-cloud", "debian-10"); String diskType = String.format("zones/%s/diskTypes/pd-standard", zone); Vector<AttachedDisk> disks = new Vector<>(); disks.add(diskFromImage(diskType, 10, true, image.getSelfLink())); disks.add(emptyDisk(diskType, 11)); return createWithDisks(project, zone, instanceName, disks, "n1-standard-1", "global/networks/default", null); } }

/** * 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 compute = require('@google-cloud/compute'); // Create a new VM instance with Debian 10 operating system and a 11 GB additional empty disk. async function createWithAdditionalDisk() { const instancesClient = new compute.InstancesClient(); const imagesClient = new compute.ImagesClient(); // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details. const [newestDebian] = await imagesClient.getFromFamily({ project: 'debian-cloud', family: 'debian-10', }); const [response] = await instancesClient.insert({ project: projectId, zone, instanceResource: { name: instanceName, disks: [ { initializeParams: { diskSizeGb: '10', sourceImage: newestDebian.selfLink, diskType: `zones/${zone}/diskTypes/pd-standard`, }, autoDelete: true, boot: true, type: 'PERSISTENT', }, { initializeParams: { diskSizeGb: '11', diskType: `zones/${zone}/diskTypes/pd-standard`, }, autoDelete: true, boot: false, type: 'PERSISTENT', }, ], machineType: `zones/${zone}/machineTypes/n1-standard-1`, networkInterfaces: [ { name: 'global/networks/default', }, ], }, }); 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.'); } createWithAdditionalDisk();

import re import sys from typing import Any, List 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 empty_disk( disk_type: str, disk_size_gb: int, boot: bool = False, auto_delete: bool = True ) -> compute_v1.AttachedDisk(): """ Create an AttachedDisk object to be used in VM instance creation. The created disk contains no data and requires formatting before it can be used. 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 auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it Returns: AttachedDisk object configured to be created as an empty disk. """ disk = compute_v1.AttachedDisk() initialize_params = compute_v1.AttachedDiskInitializeParams() initialize_params.disk_type = disk_type initialize_params.disk_size_gb = disk_size_gb 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. disk.auto_delete = auto_delete disk.boot = boot return disk def wait_for_extended_operation( operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300 ) -> Any: """ This method will wait 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.name = 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}" if accelerators: instance.guest_accelerators = accelerators 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 = compute_v1.Scheduling() 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_with_additional_disk( project_id: str, zone: str, instance_name: str ) -> compute_v1.Instance: """ Create a new VM instance with Debian 10 operating system on a 20 GB disk and a 25 GB additional empty disk. 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. Returns: Instance object. """ 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, 20, True, newest_debian.self_link), empty_disk(disk_type, 25), ] instance = create_instance(project_id, zone, instance_name, disks) return instance

Format and mount the disks before using them.

If another user has shared an image with you, you can use the image to create a VM.

To perform this task, you must have the following permissions:

compute.instances.create on the project
compute.instances.updateShieldedVmConfig if you plan to create a Shielded VM instance and you want to be able to change any of the Shielded VM settings
compute.networks.use on the project if using a legacy network
compute.subnetworks.use either on the whole project or on the chosen subnet (VPC networks)
compute.networks.useExternalIp on the project if you need to assign an external IP address (either ephemeral or static) to the instance using a legacy network
compute.subnetworks.useExternalIp either on the whole project or on the chosen subnet if you need to assign an external IP address (either ephemeral or static) to the instance using a VPC network
compute.addresses.use on the project if specifying a static address in the project
compute.instances.setMetadata if setting metadata
compute.instances.setTags on the instance if setting tags
compute.instances.setLabels on the instance if setting labels
compute.images.useReadOnly on the image if creating a new root persistent disk
compute.disks.create on the project if creating a new root persistent disk with this instance
compute.disks.useReadOnly on the disk if attaching an existing persistent disk in read-only mode
compute.disks.use on the disk if attaching an existing disk in read/write mode
compute.disks.setLabels on the disk if setting labels
compute.snapshots.create on the project to create a new snapshot if creating an instance from a snapshot
compute.snapshots.useReadOnly on the snapshot if creating an instance from a snapshot

In the Google Cloud console, go to the Create an instance page.

Go to Create an instance
Specify a Name for your VM. For more information, see Resource naming convention.
Optional: Change the Zone for this VM. Compute Engine randomizes the list of zones within each region to encourage use across multiple zones.
Select a Machine configuration for your VM.
In the Boot disk section, click Change to configure your boot disk, and then do the following:

Select the Custom Images tab.
To select the image project, click Select a project, and then do the following:
1. Select the project that contains the image.
2. Click Open.
In the Image list, click the image that you want to import.
Select the type and size of your boot disk.
To confirm your boot disk options, click Select.

To permit HTTP or HTTPS traffic to the VM, in the Firewall section, select Allow HTTP traffic or Allow HTTPS traffic.

The Google Cloud console adds a network tag to your VM and creates the corresponding ingress firewall rule that allows all incoming traffic on tcp:80 (HTTP) or tcp:443 (HTTPS). The network tag associates the firewall rule with the VM. For more information, see Firewall rules overview in the Virtual Private Cloud documentation.
To start and create a VM, click Create.

Create a VM by using the gcloud compute instances create command, and use the --image and --image-project flags to specify the image name and the project where the image resides:

gcloud compute instances create VM_NAME \ --image=IMAGE \ --image-project=IMAGE_PROJECT

Replace the following:

VM_NAME: name for the new VM
IMAGE: name of the image
IMAGE_PROJECT: project to which the image belongs

If the command is successful, gcloud responds with the properties of the new VM:

Created [https://compute.googleapis.com/compute/v1/projects/myproject/zones/us-central1-b/instances/example-instance]. NAME ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS example-instance us-central1-b e2-standard-2 10.240.0.4 104.198.53.60 RUNNING

Follow the API instructions to create a VM from a public image, but specify the image field in the request body. To add blank disks, don't specify an image source. You can optionally specify the diskSizeGb, diskType, and labels properties.

[... image: "projects/PROJECT_ID/global/images/IMAGE_NAME { "initializeParams": { "diskSizeGb": "SIZE_GB", "sourceImage": "IMAGE" } } ...]

Replace the following:

PROJECT_ID: project containing the image
IMAGE_NAME: source image
SIZE_GB: disk size
IMAGE: source image for the non-boot disk

For blank disks, don't specify an image source.

Create a VM from a snapshot

You can create a new VM from a snapshot in the following ways:

To quickly create more than one VM with the same boot disk, create a custom image, then create VMs from that image instead of using a snapshot.

Create a VM instance from a container image

To deploy and launch a container on a Compute Engine VM, specify a container image name and optional configuration parameters when you create the VM. Compute Engine creates the VM by using the latest version of the Container-optimized OS public image, which has Docker installed. Then, Compute Engine launches the container when the VM starts. For more information, see Deploying containers on VMs.

To create a VM from a container image, you must use the Google Cloud console or gcloud.

To perform this task, you must have the following permissions:

compute.instances.create on the project
compute.instances.updateShieldedVmConfig if you plan to create a Shielded VM instance and you want to be able to change any of the Shielded VM settings
compute.networks.use on the project if using a legacy network
compute.subnetworks.use either on the whole project or on the chosen subnet (VPC networks)
compute.networks.useExternalIp on the project if you need to assign an external IP address (either ephemeral or static) to the instance using a legacy network
compute.subnetworks.useExternalIp either on the whole project or on the chosen subnet if you need to assign an external IP address (either ephemeral or static) to the instance using a VPC network
compute.addresses.use on the project if specifying a static address in the project
compute.instances.setMetadata if setting metadata
compute.instances.setTags on the instance if setting tags
compute.instances.setLabels on the instance if setting labels
compute.images.useReadOnly on the image if creating a new root persistent disk
compute.disks.create on the project if creating a new root persistent disk with this instance
compute.disks.useReadOnly on the disk if attaching an existing persistent disk in read-only mode
compute.disks.use on the disk if attaching an existing disk in read/write mode
compute.disks.setLabels on the disk if setting labels
compute.snapshots.create on the project to create a new snapshot if creating an instance from a snapshot
compute.snapshots.useReadOnly on the snapshot if creating an instance from a snapshot

In the Google Cloud console, go to the VM instances page.

Go to VM instances
Select your project and click Continue.
Click Create instance.
Specify a Name for your VM. For more information, see Resource naming convention.
In the Container section, click Deploy container.
1. Specify the Container image to use. For example:
  - To select an NGINX 1.12 container image from Cloud Launcher:
    
    gcr.io/cloud-marketplace/google/nginx1:1.12
  - To deploy an Apache container image from Docker Hub, always specify the full Docker image name:
    
    docker.io/httpd:2.4
2. Optional: Click Advanced container options. For more information, see Configuring options to run your container.
To create the VM, boot the VM, and launch the container, click Create.

Run the gcloud compute instances create-with-container command:

gcloud compute instances create-with-container VM_NAME \ --container-image=CONTAINER_IMAGE

Replace the following:

VM_NAME: name for the new VM.
CONTAINER_IMAGE: name of the container image.

For example, the following command creates a VM named nginx-vm, which launches and runs the container image:

gcr.io/cloud-marketplace/google/nginx1:1.12

gcloud compute instances create-with-container nginx-vm \ --container-image=gcr.io/cloud-marketplace/google/nginx1:1.12

To deploy an Apache container image from Docker Hub, always specify the full Docker image name:

docker.io/httpd:2.4.

If you plan to run an application on your VM that needs access to other Google Cloud services, create a service account before creating the VM, and then set up the VM to run as a service account. A service account is a special account whose credentials you can use in your application code to access other Google Cloud services.

For more information, see Service accounts.

To perform this task, you must have the following permissions:

compute.instances.create on the project
compute.instances.updateShieldedVmConfig if you plan to create a Shielded VM instance and you want to be able to change any of the Shielded VM settings
compute.networks.use on the project if using a legacy network
compute.subnetworks.use either on the whole project or on the chosen subnet (VPC networks)
compute.networks.useExternalIp on the project if you need to assign an external IP address (either ephemeral or static) to the instance using a legacy network
compute.subnetworks.useExternalIp either on the whole project or on the chosen subnet if you need to assign an external IP address (either ephemeral or static) to the instance using a VPC network
compute.addresses.use on the project if specifying a static address in the project
compute.instances.setMetadata if setting metadata
compute.instances.setTags on the instance if setting tags
compute.instances.setLabels on the instance if setting labels
compute.images.useReadOnly on the image if creating a new root persistent disk
compute.disks.create on the project if creating a new root persistent disk with this instance
compute.disks.useReadOnly on the disk if attaching an existing persistent disk in read-only mode
compute.disks.use on the disk if attaching an existing disk in read/write mode
compute.disks.setLabels on the disk if setting labels
compute.snapshots.create on the project to create a new snapshot if creating an instance from a snapshot
compute.snapshots.useReadOnly on the snapshot if creating an instance from a snapshot

By default, Google Cloud creates an auto mode VPC network called default for each project. To use a different network or a subnet that you manually created in an auto mode or custom mode VPC network, you must specify the subnet when you create the VM.

While creating a VM in a subnet, consider these rules:

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 VM.
If you don't specify a network, Compute Engine infers the network from the subnet specified.
If you specify a network, you must specify a subnet and it must belong to the same network. Otherwise, VM creation fails.

Note: You must create the subnet that you want to use before you create the VM. For more information, see Adding a new subnet to an existing VPC network.

In the Google Cloud console, go to the VM instances page.

Go to VM instances
Select your project and click Continue.
Click Create instance.
Specify a Name for your VM. For more information, see Resource naming convention.
Optional: Change the Zone for this VM. Compute Engine randomizes the list of zones within each region to encourage use across multiple zones.
In the Firewall section, to permit HTTP or HTTPS traffic to the VM, select Allow HTTP traffic or Allow HTTPS traffic.

The Google Cloud console adds a network tag to your VM and creates the corresponding ingress firewall rule that allows all incoming traffic on tcp:80 (HTTP) or tcp:443 (HTTPS). The network tag associates the firewall rule with the VM. For more information, see Firewall rules overview in the Virtual Private Cloud documentation.
Expand the Networking, disks, security, management, sole tenancy section.
1. Expand the Networking section.
2. For Network interfaces, specify the network details:
  1. In the Network field, select the VPC network that contains the subnet you created.
  2. In the Subnet field, select the subnet for the VM to use.
  3. Click Done.
To create and start the VM, click Create.

Using the Google Cloud CLI, follow the same instructions to create a VM from an image or a snapshot, and add the --subnet=SUBNET_NAME and --zone=ZONE flags when you run the gcloud compute instances create command:

gcloud compute instances create VM_NAME \ --network=NETWORK_NAME \ --subnet=SUBNET_NAME \ --zone=ZONE

Replace the following:

VM_NAME: name of the VM
NETWORK_NAME: Optional: name of the network
SUBNET_NAME: name of the subnet

To view a list of subnets in the network, use the gcloud compute networks subnets list command.
ZONE: zone where the VM is created, such as europe-west1-b

The VM's region is inferred from the zone.

Follow the API instructions to create a VM from an image or a snapshot, but specify the subnet field in the request body. To add blank disks, do not add a source image. You can optionally specify the diskSizeGb, diskType, and labels properties.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances { "machineType":"zones/MACHINE_TYPE_ZONE/machineTypes/MACHINE_TYPE", "name":"VM_NAME", "disks":[ { "initializeParams":{ "sourceImage":"projects/IMAGE_PROJECT/global/images/IMAGE" }, "boot":true } ], "networkInterfaces":[ { "network":"global/networks/NETWORK_NAME", "subnetwork":"regions/REGION/subnetworks/SUBNET_NAME", "accessConfigs":{ "name":"External NAT", "type":"ONE_TO_ONE_NAT" } } ], "shieldedInstanceConfig":{ "enableSecureBoot":"ENABLE_SECURE_BOOT" } }

Replace the following:

PROJECT_ID: ID of the project to create the VM in
ZONE: zone to create the VM in
MACHINE_TYPE_ZONE: zone containing the machine type to use for the new VM
MACHINE_TYPE: machine type, predefined or custom, for the new VM
VM_NAME: name of the new VM
IMAGE_PROJECT: project containing the image
For example, if you specify debian-10 as the image family, specify debian-cloud as the image project.
IMAGE or IMAGE_FAMILY: specify one of the following:
- IMAGE: a specific version of a public image
  For example, "sourceImage": "projects/debian-cloud/global/images/debian-10-buster-v20200309"
- IMAGE_FAMILY: an image family
  This creates the VM from the most recent, non-deprecated OS image. For example, if you specify "sourceImage": "projects/debian-cloud/global/images/family/debian-10", Compute Engine creates a VM from the latest version of the OS image in the Debian 10 image family.
NETWORK_NAME: the VPC network that you want to use for the VM. You can specify default to use your default network.
REGION: region where the specified subnet exists
SUBNET_NAME: name of the subnet
ENABLE_SECURE_BOOT: Optional: If you chose an image that supports Shielded VM features, Compute Engine, by default, enables the virtual trusted platform module (vTPM) and integrity monitoring. Compute Engine does not enable Secure Boot by default.
If you specify true for enableSecureBoot, Compute Engine creates a VM with all three Shielded VM features enabled. After Compute Engine starts your VM, to modify Shielded VM options, you must stop the VM.

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" ) // createInstanceWithSubnet creates a new VM instance with Debian 10 operating system in specified network and subnetwork. func createInstanceWithSubnet(w io.Writer, projectID, zone, instanceName, networkLink, subnetworkLink string) error { // projectID := "your_project_id" // zone := "europe-central2-b" // instanceName := "your_instance_name" // networkLink := "global/networks/default" // subnetworkLink := "regions/region/subnetworks/subnetwork_name" ctx := context.Background() instancesClient, err := compute.NewInstancesRESTClient(ctx) if err != nil { return fmt.Errorf("NewInstancesRESTClient: %v", err) } defer instancesClient.Close() imagesClient, err := compute.NewImagesRESTClient(ctx) if err != nil { return fmt.Errorf("NewImagesRESTClient: %v", err) } defer imagesClient.Close() // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details. newestDebianReq := &computepb.GetFromFamilyImageRequest{ Project: "debian-cloud", Family: "debian-10", } newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq) if err != nil { return fmt.Errorf("unable to get image from family: %v", err) } 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: newestDebian.SelfLink, DiskType: proto.String(fmt.Sprintf("zones/%s/diskTypes/pd-standard", zone)), }, AutoDelete: proto.Bool(true), Boot: proto.Bool(true), Type: proto.String(computepb.AttachedDisk_PERSISTENT.String()), }, }, MachineType: proto.String(fmt.Sprintf("zones/%s/machineTypes/n1-standard-1", zone)), NetworkInterfaces: []*computepb.NetworkInterface{ { Name: proto.String(networkLink), Subnetwork: proto.String(subnetworkLink), }, }, }, } op, err := instancesClient.Insert(ctx, req) if err != nil { return fmt.Errorf("unable to create instance: %v", err) } if err = op.Wait(ctx); err != nil { return fmt.Errorf("unable to wait for the operation: %v", err) } fmt.Fprintf(w, "Instance created\n") return nil }

/** * 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 networkLink = 'global/networks/default'; // const subnetworkLink = 'regions/europe-central2/subnetworks/default'; const compute = require('@google-cloud/compute'); // Creates a new VM instance with Debian 10 operating system in specified network and subnetwork. async function createInstanceWithSubnet() { const instancesClient = new compute.InstancesClient(); const imagesClient = new compute.ImagesClient(); // List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details. const [newestDebian] = await imagesClient.getFromFamily({ project: 'debian-cloud', family: 'debian-10', }); const [response] = await instancesClient.insert({ project: projectId, zone, instanceResource: { name: instanceName, disks: [ { initializeParams: { diskSizeGb: '10', sourceImage: newestDebian.selfLink, diskType: `zones/${zone}/diskTypes/pd-standard`, }, autoDelete: true, boot: true, type: 'PERSISTENT', }, ], machineType: `zones/${zone}/machineTypes/n1-standard-1`, networkInterfaces: [ { name: networkLink, subnetwork: subnetworkLink, }, ], }, }); 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.'); } createInstanceWithSubnet();

To find methods for resolving common VM creation errors, see Troubleshooting VM creation.

What's next?

If you're new to Google Cloud, create an account to evaluate how Compute Engine performs in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

Try Compute Engine free