Configurare indirizzi IP esterni statici

---

Puoi assegnare indirizzi IP esterni statici alle tue istanze di macchine virtuali (VM). Puoi anche modificare, elencare e rilasciare indirizzi IP statici per le VM. Per prenotare un indirizzo IP esterno statico, consulta Prenotare un indirizzo IP esterno statico.

Gli indirizzi IP esterni possono essere statici o temporanei. Se una VM richiede un indirizzo IP esterno fisso che non cambia, svolgi quanto segue:

1. Ottieni un indirizzo IP esterno statico. Puoi prenotare nuovi indirizzi IP esterni o promuovere indirizzi IP esterni temporanei esistenti.
2. Assegna l'indirizzo IP riservato a una VM esistente o al momento della creazione di una nuova VM.

Se hai bisogno di un indirizzo IP statico sulla tua rete Compute Engine interna, consulta Prenotare un indirizzo IP interno statico.

Prima di iniziare

• Scopri di più sugli indirizzi IP.
• Scopri di più su quote e limiti per gli indirizzi IP esterni statici.
• Scopri di più sui prezzi degli indirizzi IP esterni.
• Se non l'hai ancora fatto, configura l'autenticazione. L'autenticazione è la procedura mediante la quale la tua identità viene verificata per l'accesso alle API e ai servizi Google Cloud. Per eseguire codice o esempi da un ambiente di sviluppo locale, puoi autenticarti su Compute Engine selezionando una delle seguenti opzioni:
  

  Select the tab for how you plan to use the samples on this page:

  Console

  When you use the Google Cloud console to access Google Cloud services and APIs, you don't need to set up authentication.

  gcloud

  1. Install the Google Cloud CLI, then initialize it by running the following command:

     gcloud init

     Note: If you installed the gcloud CLI previously, make sure you have the latest version by running gcloud components update.
  2. Set a default region and zone.

  Terraform

  Per utilizzare gli esempi di Terraform in questa pagina in un ambiente di sviluppo locale, installa e inizializza gcloud CLI, quindi configura le Credenziali predefinite dell'applicazione con le tue credenziali utente.

  1. Install the Google Cloud CLI.

  2. To initialize the gcloud CLI, run the following command:

     gcloud init

  3. If you're using a local shell, then create local authentication credentials for your user account:

     gcloud auth application-default login

     You don't need to do this if you're using Cloud Shell.

  Per ulteriori informazioni, consulta Set up authentication for a local development environment.

  REST

  Per utilizzare gli esempi dell'API REST in questa pagina in un ambiente di sviluppo locale, utilizza le credenziali fornite a gcloud CLI.

  Install the Google Cloud CLI, then initialize it by running the following command:

  gcloud init

  Per saperne di più, consulta Eseguire l'autenticazione per l'utilizzo di REST nella documentazione sull'autenticazione di Google Cloud.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per configurare e gestire gli indirizzi IP statici, chiedi all'amministratore di concederti i seguenti ruoli IAM nel progetto:

• Per creare e aggiornare le VM: Compute Instance Admin (v1) (roles/compute.instanceAdmin.v1)

Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per configurare e gestire gli indirizzi IP statici. Per visualizzare le autorizzazioni esatte richieste, espandi la sezione Autorizzazioni richieste:

Autorizzazioni obbligatorie

Per configurare e gestire gli indirizzi IP statici sono richieste le seguenti autorizzazioni:

• compute.instances.update nell'istanza VM
• compute.instances.updateNetworkInterface nell'istanza VM
• compute.instances.addAccessConfig nell'istanza VM
• compute.instances.deleteAccessConfig nell'istanza VM
• compute.networks.list sulla rete
• compute.subnetworks.use nella subnet
• compute.subnetworks.list nella subnet
• Per creare le VM:
  • compute.instances.create sul progetto
  • Per utilizzare un'immagine personalizzata per creare la VM: compute.images.useReadOnly sull'immagine
  • Per utilizzare uno snapshot per creare la VM: compute.snapshots.useReadOnly nello snapshot
  • Per utilizzare un modello di istanza per creare la VM: compute.instanceTemplates.useReadOnly nel modello di istanza
  • Per assegnare una rete legacy alla VM: compute.networks.use nel progetto
  • Per specificare un indirizzo IP statico per la VM: compute.addresses.use nel progetto
  • Per assegnare un indirizzo IP esterno alla VM quando nel progetto viene utilizzata una rete precedente: compute.networks.useExternalIp
  • Per specificare una subnet per la VM: compute.subnetworks.use nel progetto o nella subnet scelta
  • Per assegnare un indirizzo IP esterno alla VM quando utilizzi una rete VPC: compute.subnetworks.useExternalIp nel progetto o nella subnet scelta
  • Per impostare i metadati dell'istanza VM per la VM: compute.instances.setMetadata nel progetto
  • Per impostare i tag per la VM: compute.instances.setTags sulla VM
  • Per impostare le etichette per la VM: compute.instances.setLabels sulla VM
  • Per impostare un account di servizio per l'utilizzo di: compute.instances.setServiceAccount sulla VM
  • Per creare un nuovo disco per la VM: compute.disks.create nel progetto
  • Per collegare un disco esistente in modalità di sola lettura o di lettura e scrittura: compute.disks.use sul disco
  • Per collegare un disco esistente in modalità di sola lettura: compute.disks.useReadOnly sul disco

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Limitazioni

• Solo una risorsa alla volta può utilizzare un indirizzo IP esterno statico.

• Non è possibile verificare se un indirizzo IP è statico o temporaneo dopo che è stato assegnato a una risorsa. Puoi confrontare l'indirizzo IP con l'elenco di indirizzi IP esterni statici riservati al progetto. Utilizza il subcomando gcloud compute addresses list per visualizzare un elenco di indirizzi IP esterni statici disponibili per il progetto.

• Ogni VM può avere più interfacce di rete, e a ogni interfaccia possono essere assegnati i seguenti indirizzi IP:

  • Un indirizzo IPv4 interno (obbligatorio)
  • Un indirizzo IPv4 esterno
  • Un intervallo di indirizzi IPv6 /96, interno o esterno, ma non entrambi

• Non puoi modificare il nome di un indirizzo IP statico.

• Gli indirizzi IP esterni assegnati si trovano sullo stesso host fisico della VM e nella stessa regione della VM per tutti gli scopi, inclusi routing, latenza e prezzi. Ciò vale indipendentemente dalle informazioni di ricerca della geolocalizzazione internet.

Nota: le interfacce di rete possono ricevere traffico da più regole di inoltro, che potrebbero servire altri indirizzi IP esterni. Qualsiasi numero di indirizzi IP esterni può fare riferimento a un'interfaccia di rete tramite queste regole di inoltro, ma a ogni interfaccia di rete può essere assegnato un solo indirizzo IPv4 esterno e un solo intervallo di indirizzi IPv6 /96 esterni.

Per ulteriori informazioni sulle regole di bilanciamento del carico e di inoltro, consulta la documentazione sul bilanciamento del carico.

Visualizzare gli indirizzi IP esterni statici disponibili

Per elencare gli indirizzi IP esterni statici che hai prenotato per il tuo progetto:

Console

1. Nella console Google Cloud, vai alla pagina Indirizzi IP.

   Vai a indirizzi IP

2. Fai clic su Indirizzi IP esterni.

gcloud

Utilizza il comando gcloud compute addresses list:

• Per elencare tutti gli indirizzi IP, utilizza il seguente comando:

  gcloud compute addresses list

• Per elencare tutti gli indirizzi IP globali, utilizza il seguente comando:

  gcloud compute addresses list --global

• Per elencare tutti gli indirizzi IP regionali di una determinata regione, utilizza il seguente comando:

  gcloud compute addresses list \
      --regions=REGION
  

  Sostituisci REGION con la regione per cui vuoi elencare gli indirizzi. Puoi elencare gli indirizzi di più regioni specificando i nomi delle regioni separati da virgole:

  gcloud compute addresses list \
      --regions=REGION1,REGION2,..REGION_n_
  

API

• Per elencare gli indirizzi IPv4 o IPv6 regionali, chiama il metodo addresses.list:

  GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses
  

  Sostituisci quanto segue:

  • PROJECT_ID: l'ID progetto per questa richiesta
  • REGION: il nome della regione per questa richiesta

• Per elencare tutti gli indirizzi in tutte le regioni, chiama il metodo addresses.aggregatedList:

  GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/aggregated/addresses
  

• Per elencare gli indirizzi IPv4 o IPv6 globali, chiama il metodo globalAddresses.list:

  GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses
  

  Sostituisci quanto segue:

  PROJECT_ID: l'ID progetto per questa richiesta

Vai

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	"google.golang.org/api/iterator"

	"cloud.google.com/go/compute/apiv1/computepb"
)

// listRegionalExternal retrieves list external IP addresses in Google Cloud Platform region.
func listRegionalExternal(w io.Writer, projectID, region string) ([]*computepb.Address, error) {
	// projectID := "your_project_id"
	// region := "europe-west3"

	ctx := context.Background()
	// Create the service client.
	addressesClient, err := compute.NewAddressesRESTClient(ctx)
	if err != nil {
		return nil, err
	}
	defer addressesClient.Close()

	// Build the request.
	req := &computepb.ListAddressesRequest{
		Project: projectID,
		Region:  region,
	}

	// List the addresses.
	it := addressesClient.List(ctx, req)

	// Iterate over the results.
	var addresses []*computepb.Address
	for {
		address, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, err
		}
		addresses = append(addresses, address)
	}

	// Print the addresses.
	fmt.Fprint(w, "Fetched addresses: \n")
	for _, address := range addresses {
		fmt.Fprintf(w, "%s\n", *address.Name)
	}

	return addresses, nil
}

// listGlobalExternal retrieves list external global IP addresses in Google Cloud Platform.
func listGlobalExternal(w io.Writer, projectID string) ([]*computepb.Address, error) {
	// projectID := "your_project_id"

	ctx := context.Background()
	// Create the service client.
	addressesClient, err := compute.NewGlobalAddressesRESTClient(ctx)
	if err != nil {
		return nil, err
	}
	defer addressesClient.Close()

	// Build the request.
	req := &computepb.ListGlobalAddressesRequest{
		Project: projectID,
	}

	// List the addresses.
	it := addressesClient.List(ctx, req)

	// Iterate over the results.
	var addresses []*computepb.Address
	for {
		address, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return nil, err
		}
		addresses = append(addresses, address)
	}

	// Print the addresses.
	fmt.Fprint(w, "Fetched addresses: \n")
	for _, address := range addresses {
		fmt.Fprintf(w, "%s\n", *address.Name)
	}

	return addresses, nil
}

Java

import com.google.cloud.compute.v1.Address;
import com.google.cloud.compute.v1.AddressesClient;
import com.google.cloud.compute.v1.GlobalAddressesClient;
import com.google.cloud.compute.v1.ListAddressesRequest;
import com.google.cloud.compute.v1.ListGlobalAddressesRequest;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

public class ListStaticExternalIp {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "your-project-id";
    // Region where the VM and IP is located.
    String region = "your-region-id";

    listStaticExternalIp(projectId, region);
  }

  // Lists all static external IP addresses, either regional or global.
  public static List<Address> listStaticExternalIp(String projectId, String region)
          throws IOException {
    // Use regional client if a region is specified
    if (region != null) {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      try (AddressesClient client = AddressesClient.create()) {
        ListAddressesRequest request = ListAddressesRequest.newBuilder()
                .setProject(projectId)
                .setRegion(region)
                .build();

        return Lists.newArrayList(client.list(request).iterateAll());
      }
    } else {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      try (GlobalAddressesClient client = GlobalAddressesClient.create()) {
        ListGlobalAddressesRequest request = ListGlobalAddressesRequest.newBuilder()
                .setProject(projectId)
                .build();

        return Lists.newArrayList(client.list(request).iterateAll());
      }
    }
  }
}

Python

from typing import List, Optional

from google.cloud.compute_v1.services.addresses.client import AddressesClient
from google.cloud.compute_v1.services.global_addresses import GlobalAddressesClient
from google.cloud.compute_v1.types import Address


def list_static_ip_addresses(
    project_id: str, region: Optional[str] = None
) -> List[Address]:
    """
    Lists all static external IP addresses, either regional or global.

    Args:
    project_id (str): project ID.
    region (Optional[str]): The region of the IP addresses if regional. None if global.

    Returns:
    List[Address]: A list of Address objects containing details about the requested IPs.
    """
    if region:
        # Use regional client if a region is specified
        client = AddressesClient()
        addresses_iterator = client.list(project=project_id, region=region)
    else:
        # Use global client if no region is specified
        client = GlobalAddressesClient()
        addresses_iterator = client.list(project=project_id)

    return list(addresses_iterator)  # Convert the iterator to a list to return

Configurare indirizzi IP esterni statici

Le sezioni seguenti descrivono come configurare indirizzi IP esterni statici per le tue VM.

Creare una VM che utilizza un indirizzo IP esterno statico

Dopo aver prenotato un indirizzo IP esterno statico, puoi assegnarlo a una VM.

Console

1. Nella console Google Cloud, vai alla pagina Crea un'istanza.

   Vai a Crea un'istanza

2. Specifica i dettagli della VM.

3. Espandi la sezione Opzioni avanzate.

4. Espandi la sezione Networking.

5. Nella sezione Interfacce di rete, espandi un'interfaccia di rete per modificarla.

6. Per assegnare un indirizzo IPv4:

   1. Seleziona una rete.
   2. Seleziona l'indirizzo IP dall'elenco Indirizzo IPv4 esterno.

7. Per assegnare un indirizzo IPv6:

   1. Seleziona una rete che contenga una subnet IPv6.
   2. Seleziona una subnet dual-stack dall'elenco Subnet.
   3. Per Tipo di stack IP, seleziona IPv4 e IPv6 (stack doppio).
   4. Seleziona l'indirizzo IPv6 esterno appena prenotato dall'elenco Indirizzo IPv6 esterno. In alternativa, seleziona CREA INDIRIZZO IP e prenota un nuovo indirizzo IPv6 esterno statico.
   5. In Network Service Tier (Livello di servizio di rete), seleziona Premium.

8. Per completare la modifica dell'interfaccia di rete predefinita, fai clic su Fine.

9. Continua con la procedura di creazione della VM.

gcloud

Puoi creare una VM e assegnare un indirizzo IP esterno regionale statico che hai già prenotato.

• Per assegnare un indirizzo IPv4 esterno statico, procedi nel seguente modo:

  gcloud compute instances create VM_NAME --address=IP_ADDRESS
  

  Sostituisci quanto segue:

  • VM_NAME: il nome della VM.
  • IP_ADDRESS: l'indirizzo IP da assegnare alla VM. Utilizza l'indirizzo IP esterno statico prenotato, non il nome dell'indirizzo.

• Per assegnare un indirizzo IPv6 esterno statico, procedi nel seguente modo:

  gcloud compute instances create VM_NAME \
      --subnet=SUBNET \
      --stack-type=IPV4_IPV6 \
      --external-ipv6-address=IPV6_ADDRESS \
      --external-ipv6-prefix-length=96 \
      --ipv6-network-tier=PREMIUM \
      --zone=ZONE
  

Terraform

Puoi utilizzare la risorsa google_compute_instance per assegnare un indirizzo IP esterno.

resource "google_compute_instance" "default" {
  name         = "dns-proxy-nfs"
  machine_type = "n1-standard-1"
  zone         = "us-central1-a"

  boot_disk {
    initialize_params {
      image = "ubuntu-1404-trusty-v20160627"
    }
  }

  network_interface {
    network = "default"
    access_config {
      nat_ip = google_compute_address.default.address
    }
  }
}

REST

Per assegnare un indirizzo IPv4 esterno statico a una nuova VM, procedi nel seguente modo:

Nella richiesta di creazione di una nuova VM, fornisci esplicitamente la proprietà networkInterfaces[].accessConfigs[].natIP e l'indirizzo IPv4 esterno che vuoi utilizzare. Ad esempio:

{
  "name": "VM_NAME",
  "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
  "networkInterfaces": [{
    "accessConfigs": [{
      "type": "ONE_TO_ONE_NAT",
      "name": "External NAT",
      "natIP": "IPV4_ADDRESS"
     }],
    "network": "global/networks/default"
  }],
  "disks": [{
      "autoDelete": "true",
      "boot": "true",
      "type": "PERSISTENT",
      "initializeParams": {
          "sourceImage": "SOURCE_IMAGE"
      }
}]
}

Per assegnare un indirizzo IPv6 esterno statico a una nuova VM, procedi nel seguente modo:

Nella richiesta di creazione di una nuova VM, fornisci esplicitamente la proprietà networkInterfaces[].ipv6AccessConfigs[].externalIpv6 e l'indirizzo IPv6 esterno che vuoi utilizzare. Ad esempio:

{
  "name": "VM_NAME",
  "machineType": "zones/ZONE/machineTypes/MACHINE_TYPE",
  "networkInterfaces": [{
          "accessConfigs": [{
              "name": "external-nat",
              "type": "ONE_TO_ONE_NAT"
          }],
          "ipv6AccessConfigs": [{
        "externalIpv6": "IOV6_ADDRESS",
        "externalIpv6PrefixLength": 96,
        "name": "external-ipv6-access-config",
        "networkTier": "PREMIUM",
        "type": "DIRECT_IPV6"
          }],
      "stackType": "IPV4_IPV6",
      "subnetwork":"SUBNETWORK
  }],
  "disks": [{
    "autoDelete": "true",
    "boot": "true",
    "mode": "READ_WRITE",
    "type": "PERSISTENT",
    "initializeParams": {
        "sourceImage": "SOURCE_IMAGE"
    },
  }],
 }

Vai

// assignStaticExternalToNewVM creates a new VM instance and assigns a static external IP address to it.
// NOTE: ip address is expected to exist and be located in the same region as new VM
func assignStaticExternalToNewVM(w io.Writer, projectID, zone, instanceName, ipAddress string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// ipAddress := 301.222.11.123

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	imagesClient, err := compute.NewImagesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewImagesRESTClient: %w", 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-12",
	}
	newestDebian, err := imagesClient.GetFromFamily(ctx, newestDebianReq)
	if err != nil {
		return fmt.Errorf("unable to get image from family: %w", 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{
				{
					AccessConfigs: []*computepb.AccessConfig{
						{
							Type:        proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
							Name:        proto.String("External NAT"),
							NetworkTier: proto.String(computepb.AccessConfig_PREMIUM.String()),
							NatIP:       proto.String(ipAddress),
						},
					},
				},
			},
		},
	}

	op, err := instancesClient.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to create instance: %w", err)
	}

	if err = op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Static address %s assigned to new VM", ipAddress)

	return nil
}

Java

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AccessConfig.Type;
import com.google.cloud.compute.v1.Address.NetworkTier;
import com.google.cloud.compute.v1.AttachedDisk;
import com.google.cloud.compute.v1.AttachedDiskInitializeParams;
import com.google.cloud.compute.v1.GetInstanceRequest;
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 java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AssignStaticExternalNewVmAddress {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "your-project-id";
    // Instance ID of the Google Cloud project you want to use.
    String instanceId = "your-instance-id";
    // Name of the zone to create the instance in. For example: "us-west3-b"
    String zone = "your-zone-id";
    // 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"
    String machineType = String.format("zones/%s/machineTypes/{your-machineType-id}", zone);
    // boolean flag indicating if the instance should have an external IPv4 address assigned.
    boolean externalAccess = true;
    // 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.
    String externalIpv4 = "your-externalIpv4-id";

    assignStaticExternalNewVmAddress(projectId, instanceId, zone,
            externalAccess, machineType, externalIpv4);
  }

  // Create a new VM instance with assigned static external IP address.
  public static Instance assignStaticExternalNewVmAddress(String projectId, String instanceName,
                                                          String zone, boolean externalAccess,
                                                          String machineType, String externalIpv4)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    String sourceImage;
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (ImagesClient imagesClient = ImagesClient.create()) {
      sourceImage = imagesClient.getFromFamily("debian-cloud", "debian-11").getSelfLink();
    }
    AttachedDisk attachedDisk = buildAttachedDisk(sourceImage, zone);

    return createInstance(projectId, instanceName, zone,
            attachedDisk, machineType, externalAccess, externalIpv4);
  }

  private static AttachedDisk buildAttachedDisk(String sourceImage, String zone) {
    AttachedDiskInitializeParams initializeParams = AttachedDiskInitializeParams.newBuilder()
            .setSourceImage(sourceImage)
            .setDiskSizeGb(10)
            .setDiskType(String.format("zones/%s/diskTypes/pd-standard", zone))
            .build();

    return AttachedDisk.newBuilder()
            .setInitializeParams(initializeParams)
            // Remember to set auto_delete to True if you want the disk to be deleted
            // when you delete your VM instance.
            .setAutoDelete(true)
            .setBoot(true)
            .build();
  }

  // Send an instance creation request to the Compute Engine API and wait for it to complete.
  private static Instance createInstance(String projectId, String instanceName,
                                         String zone, AttachedDisk disks,
                                         String machineType, boolean externalAccess,
                                         String externalIpv4)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient client = InstancesClient.create()) {
      Instance instanceResource =
              buildInstanceResource(instanceName, disks, machineType, externalAccess, externalIpv4);

      InsertInstanceRequest build = InsertInstanceRequest.newBuilder()
              .setProject(projectId)
              .setRequestId(UUID.randomUUID().toString())
              .setZone(zone)
              .setInstanceResource(instanceResource)
              .build();
      client.insertCallable().futureCall(build).get(60, TimeUnit.SECONDS);

      GetInstanceRequest getInstanceRequest = GetInstanceRequest.newBuilder()
              .setInstance(instanceName)
              .setProject(projectId)
              .setZone(zone)
              .build();

      return client.get(getInstanceRequest);
    }
  }

  private static Instance buildInstanceResource(String instanceName, AttachedDisk disk,
                                                String machineType, boolean externalAccess,
                                                String externalIpv4) {
    NetworkInterface networkInterface =
            networkInterface(externalAccess, externalIpv4);

    return Instance.newBuilder()
            .setName(instanceName)
            .addDisks(disk)
            .setMachineType(machineType)
            .addNetworkInterfaces(networkInterface)
            .build();
  }

  private static NetworkInterface networkInterface(boolean externalAccess, String externalIpv4) {
    NetworkInterface.Builder build = NetworkInterface.newBuilder()
            .setNetwork("global/networks/default");
    if (externalAccess) {
      AccessConfig.Builder accessConfig = AccessConfig.newBuilder()
              .setType(Type.ONE_TO_ONE_NAT.name())
              .setName("External NAT")
              .setNetworkTier(NetworkTier.PREMIUM.name());
      if (externalIpv4 != null) {
        accessConfig.setNatIP(externalIpv4);
      }
      build.addAccessConfigs(accessConfig.build());
    }

    return build.build();
  }
}

Python

from __future__ import annotations

import re
import sys
from typing import Any
import warnings

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def get_image_from_family(project: str, family: str) -> compute_v1.Image:
    """
    Retrieve the newest image that is part of a given family in a project.

    Args:
        project: project ID or project number of the Cloud project you want to get image from.
        family: name of the image family you want to get image from.

    Returns:
        An Image object.
    """
    image_client = compute_v1.ImagesClient()
    # List of public operating system (OS) images: https://cloud.google.com/compute/docs/images/os-details
    newest_image = image_client.get_from_family(project=project, family=family)
    return newest_image


def disk_from_image(
    disk_type: str,
    disk_size_gb: int,
    boot: bool,
    source_image: str,
    auto_delete: bool = True,
) -> compute_v1.AttachedDisk:
    """
    Create an AttachedDisk object to be used in VM instance creation. Uses an image as the
    source for the new disk.

    Args:
         disk_type: the type of disk you want to create. This value uses the following format:
            "zones/{zone}/diskTypes/(pd-standard|pd-ssd|pd-balanced|pd-extreme)".
            For example: "zones/us-west3-b/diskTypes/pd-ssd"
        disk_size_gb: size of the new disk in gigabytes
        boot: boolean flag indicating whether this disk should be used as a boot disk of an instance
        source_image: source image to use when creating this disk. You must have read access to this disk. This can be one
            of the publicly available images or an image from one of your projects.
            This value uses the following format: "projects/{project_name}/global/images/{image_name}"
        auto_delete: boolean flag indicating whether this disk should be deleted with the VM that uses it

    Returns:
        AttachedDisk object configured to be created using the specified image.
    """
    boot_disk = compute_v1.AttachedDisk()
    initialize_params = compute_v1.AttachedDiskInitializeParams()
    initialize_params.source_image = source_image
    initialize_params.disk_size_gb = disk_size_gb
    initialize_params.disk_type = disk_type
    boot_disk.initialize_params = initialize_params
    # Remember to set auto_delete to True if you want the disk to be deleted when you delete
    # your VM instance.
    boot_disk.auto_delete = auto_delete
    boot_disk.boot = boot
    return boot_disk


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_instance(
    project_id: str,
    zone: str,
    instance_name: str,
    disks: list[compute_v1.AttachedDisk],
    machine_type: str = "n1-standard-1",
    network_link: str = "global/networks/default",
    subnetwork_link: str = None,
    internal_ip: str = None,
    external_access: bool = False,
    external_ipv4: str = None,
    accelerators: list[compute_v1.AcceleratorConfig] = None,
    preemptible: bool = False,
    spot: bool = False,
    instance_termination_action: str = "STOP",
    custom_hostname: str = None,
    delete_protection: bool = False,
) -> compute_v1.Instance:
    """
    Send an instance creation request to the Compute Engine API and wait for it to complete.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        zone: name of the zone to create the instance in. For example: "us-west3-b"
        instance_name: name of the new virtual machine (VM) instance.
        disks: a list of compute_v1.AttachedDisk objects describing the disks
            you want to attach to your new instance.
        machine_type: machine type of the VM being created. This value uses the
            following format: "zones/{zone}/machineTypes/{type_name}".
            For example: "zones/europe-west3-c/machineTypes/f1-micro"
        network_link: name of the network you want the new instance to use.
            For example: "global/networks/default" represents the network
            named "default", which is created automatically for each project.
        subnetwork_link: name of the subnetwork you want the new instance to use.
            This value uses the following format:
            "regions/{region}/subnetworks/{subnetwork_name}"
        internal_ip: internal IP address you want to assign to the new instance.
            By default, a free address from the pool of available internal IP addresses of
            used subnet will be used.
        external_access: boolean flag indicating if the instance should have an external IPv4
            address assigned.
        external_ipv4: external IPv4 address to be assigned to this instance. If you specify
            an external IP address, it must live in the same region as the zone of the instance.
            This setting requires `external_access` to be set to True to work.
        accelerators: a list of AcceleratorConfig objects describing the accelerators that will
            be attached to the new instance.
        preemptible: boolean value indicating if the new instance should be preemptible
            or not. Preemptible VMs have been deprecated and you should now use Spot VMs.
        spot: boolean value indicating if the new instance should be a Spot VM or not.
        instance_termination_action: What action should be taken once a Spot VM is terminated.
            Possible values: "STOP", "DELETE"
        custom_hostname: Custom hostname of the new VM instance.
            Custom hostnames must conform to RFC 1035 requirements for valid hostnames.
        delete_protection: boolean value indicating if the new virtual machine should be
            protected against deletion or not.
    Returns:
        Instance object.
    """
    instance_client = compute_v1.InstancesClient()

    # Use the network interface provided in the network_link argument.
    network_interface = compute_v1.NetworkInterface()
    network_interface.network = network_link
    if subnetwork_link:
        network_interface.subnetwork = subnetwork_link

    if internal_ip:
        network_interface.network_i_p = internal_ip

    if external_access:
        access = compute_v1.AccessConfig()
        access.type_ = compute_v1.AccessConfig.Type.ONE_TO_ONE_NAT.name
        access.name = "External NAT"
        access.network_tier = access.NetworkTier.PREMIUM.name
        if external_ipv4:
            access.nat_i_p = external_ipv4
        network_interface.access_configs = [access]

    # Collect information into the Instance object.
    instance = compute_v1.Instance()
    instance.network_interfaces = [network_interface]
    instance.name = instance_name
    instance.disks = disks
    if re.match(r"^zones/[a-z\d\-]+/machineTypes/[a-z\d\-]+$", machine_type):
        instance.machine_type = machine_type
    else:
        instance.machine_type = f"zones/{zone}/machineTypes/{machine_type}"

    instance.scheduling = compute_v1.Scheduling()
    if accelerators:
        instance.guest_accelerators = accelerators
        instance.scheduling.on_host_maintenance = (
            compute_v1.Scheduling.OnHostMaintenance.TERMINATE.name
        )

    if preemptible:
        # Set the preemptible setting
        warnings.warn(
            "Preemptible VMs are being replaced by Spot VMs.", DeprecationWarning
        )
        instance.scheduling = compute_v1.Scheduling()
        instance.scheduling.preemptible = True

    if spot:
        # Set the Spot VM setting
        instance.scheduling.provisioning_model = (
            compute_v1.Scheduling.ProvisioningModel.SPOT.name
        )
        instance.scheduling.instance_termination_action = instance_termination_action

    if custom_hostname is not None:
        # Set the custom hostname for the instance
        instance.hostname = custom_hostname

    if delete_protection:
        # Set the delete protection bit
        instance.deletion_protection = True

    # Prepare the request to insert an instance.
    request = compute_v1.InsertInstanceRequest()
    request.zone = zone
    request.project = project_id
    request.instance_resource = instance

    # Wait for the create operation to complete.
    print(f"Creating the {instance_name} instance in {zone}...")

    operation = instance_client.insert(request=request)

    wait_for_extended_operation(operation, "instance creation")

    print(f"Instance {instance_name} created.")
    return instance_client.get(project=project_id, zone=zone, instance=instance_name)


def assign_static_external_ip_to_new_vm(
    project_id: str, zone: str, instance_name: str, ip_address: str
) -> compute_v1.Instance:
    """
    Create a new VM instance with assigned static external IP address.

    Args:
        project_id (str): project ID or project number of the Cloud project you want to use.
        zone (str): name of the zone to create the instance in. For example: "us-west3-b"
        instance_name (str): name of the new virtual machine (VM) instance.
        ip_address(str): external address to be assigned to this instance. It must live in the same
        region as the zone of the instance and be precreated before function called.

    Returns:
        Instance object.
    """
    newest_debian = get_image_from_family(project="debian-cloud", family="debian-12")
    disk_type = f"zones/{zone}/diskTypes/pd-standard"
    disks = [disk_from_image(disk_type, 10, True, newest_debian.self_link, True)]
    instance = create_instance(
        project_id,
        zone,
        instance_name,
        disks,
        external_ipv4=ip_address,
        external_access=True,
    )
    return instance

Modificare o assegnare un indirizzo IP esterno a una VM esistente

Puoi modificare o assegnare un indirizzo IP esterno, temporaneo o statico, a una VM esistente.

Una VM può avere più interfacce e ogni interfaccia può avere un indirizzo IP esterno. Se la VM ha già un indirizzo IP esterno, devi prima rimuoverlo. Dopodiché puoi assegnare un nuovo indirizzo IP esterno alla VM esistente.

Nota: se devi aggiornare l'indirizzo IP di una regola di forwarding, consulta Modificare l'indirizzo IP di una regola di inoltro.

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic sul nome della VM a cui vuoi assegnare un indirizzo IP esterno. Viene visualizzata la pagina Dettagli istanza.

3. Nella pagina Dettagli istanza, completa i seguenti passaggi:

   1. Fai clic su Modifica.
   2. Espandi Interfacce di rete.
   3. Seleziona l'indirizzo IP esterno richiesto da assegnare alla VM:
      1. Per Indirizzo IPv4 esterno, seleziona Temporaneo o un indirizzo IPv4 esterno statico.
      2. Per Indirizzo IPv6 esterno, seleziona Temporaneo o un indirizzo IPv6 esterno statico.
   4. Fai clic su Fine.

4. Fai clic su Salva.

gcloud

1. (Facoltativo) Prenota un indirizzo IP esterno statico.

   Se vuoi assegnare un indirizzo IP esterno statico, devi prenotarne uno e assicurarti che non sia in uso da un'altra risorsa. Se necessario, segui le istruzioni per prenotare un nuovo indirizzo IP esterno statico o per annullare l'assegnazione di un indirizzo IP esterno statico.

   Se intendi utilizzare un indirizzo IP esterno temporaneo, puoi saltare questo passaggio e Compute Engine assegnerà in modo casuale un indirizzo IP esterno temporaneo.

2. Rimuovi eventuali assegnazioni di indirizzi IP esistenti, come descritto in Annullare l'assegnazione di un indirizzo IP esterno statico.

3. Assegna il nuovo indirizzo IP esterno.

   • Per assegnare un indirizzo IPv4, utilizza il subcomando instances add-access-config:

     Nota: non sostituireIP_ADDRESS con il nome dell'indirizzo IP statico. Devi utilizzare l'indirizzo IP effettivo.

     gcloud compute instances add-access-config VM_NAME \
       --access-config-name="ACCESS_CONFIG_NAME" --address=IP_ADDRESS
     

     Sostituisci quanto segue:

     • VM_NAME: il nome della VM.
     • ACCESS_CONFIG_NAME: il nome da assegnare a questa configurazione di accesso. Assicurati di includere il nome completo tra virgolette.
     • IP_ADDRESS: l'indirizzo IP da aggiungere.

     Se vuoi che Compute Engine assegni un indirizzo IP esterno temporaneo anziché utilizzare un indirizzo IP esterno statico, ometti la proprietà --address IP_ADDRESS:

     gcloud compute instances add-access-config VM_NAME \
       --access-config-name="ACCESS_CONFIG_NAME"
     

   • Per assegnare un intervallo di indirizzi IPv6, utilizza il subcomando instance network-interfaces update:

     gcloud compute instances network-interfaces update VM_NAME \
       --network-interface=NIC \
       --ipv6-network-tier=PREMIUM \
       --stack-type=IPV4_IPV6 \
       --external-ipv6-address=IPV6_ADDRESS \
       --external-ipv6-prefix-length=96 \
       --zone=ZONE
     

     Sostituisci quanto segue:

     • VM_NAME: il nome della VM.
     • NIC: il nome dell'interfaccia di rete.
     • IPV6_ADDRESS: l'indirizzo IPv6 da assegnare alla VM. Specifica il primo indirizzo IPv6 nell'intervallo/96.
     • ZONE: la zona della VM.

REST

Puoi modificare l'indirizzo IPv4 o IPv6 esterno di una VM aggiungendo una nuova configurazione di accesso per la VM.

1. Rimuovi eventuali assegnazioni di indirizzi IP esistenti, come descritto in Annullare l'assegnazione di un indirizzo IP esterno statico.

2. Elimina la configurazione di accesso esistente inviando una richiesta POST al metodo instances.deleteAccessConfig.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/deleteAccessConfig
   

3. Aggiungi una nuova configurazione di accesso all'interfaccia di rete della VM inviando una richiesta POST al metodo instances.addAccessConfig.

   • Per gli indirizzi IPv4, effettua la seguente richiesta:

     POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/addAccessConfig
     {
     "natIP": "IPV4_ADDRESS",
     "name": "ACCESS_CONFIG_NAME"
     }
     

   • Per gli indirizzi IPv6, aggiorna la proprietà networkInterfaces[].ipv6AccessConfigs[].externalIpv6 e l'indirizzo IPv6 esterno che vuoi utilizzare.

     Consulta Assegnare un indirizzo IP esterno statico a una nuova VM

Vai

import (
	"context"
	"fmt"
	"io"

	"google.golang.org/protobuf/proto"

	compute "cloud.google.com/go/compute/apiv1"
	"cloud.google.com/go/compute/apiv1/computepb"
)

// assignStaticAddressToExistingVM assigns a static external IP address to an existing VM instance.
// Note: VM and assigned IP must be in the same region.
func assignStaticAddressToExistingVM(w io.Writer, projectID, zone, instanceName, IPAddress, networkInterfaceName string) error {
	// projectID := "your_project_id"
	// zone := "europe-central2-b"
	// instanceName := "your_instance_name"
	// IPAddress := "34.111.222.333"
	// networkInterfaceName := "nic0"

	ctx := context.Background()
	instancesClient, err := compute.NewInstancesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewInstancesRESTClient: %w", err)
	}
	defer instancesClient.Close()

	reqGet := &computepb.GetInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
	}

	instance, err := instancesClient.Get(ctx, reqGet)
	if err != nil {
		return fmt.Errorf("could not get instance: %w", err)
	}

	var networkInterface *computepb.NetworkInterface
	for _, ni := range instance.NetworkInterfaces {
		if *ni.Name == networkInterfaceName {
			networkInterface = ni
			break
		}
	}

	if networkInterface == nil {
		return fmt.Errorf("No network interface named '%s' found on instance %s", networkInterfaceName, instanceName)
	}

	var accessConfig *computepb.AccessConfig
	for _, ac := range networkInterface.AccessConfigs {
		if *ac.Type == computepb.AccessConfig_ONE_TO_ONE_NAT.String() {
			accessConfig = ac
			break
		}
	}

	if accessConfig != nil {
		// network interface is immutable - deletion stage is required in case of any assigned ip (static or ephemeral).
		reqDelete := &computepb.DeleteAccessConfigInstanceRequest{
			Project:          projectID,
			Zone:             zone,
			Instance:         instanceName,
			AccessConfig:     *accessConfig.Name,
			NetworkInterface: networkInterfaceName,
		}

		opDelete, err := instancesClient.DeleteAccessConfig(ctx, reqDelete)
		if err != nil {
			return fmt.Errorf("unable to delete access config: %w", err)
		}

		if err = opDelete.Wait(ctx); err != nil {
			return fmt.Errorf("unable to wait for the operation: %w", err)
		}
	}

	reqAdd := &computepb.AddAccessConfigInstanceRequest{
		Project:  projectID,
		Zone:     zone,
		Instance: instanceName,
		AccessConfigResource: &computepb.AccessConfig{
			NatIP: &IPAddress,
			Type:  proto.String(computepb.AccessConfig_ONE_TO_ONE_NAT.String()),
		},
		NetworkInterface: networkInterfaceName,
	}

	opAdd, err := instancesClient.AddAccessConfig(ctx, reqAdd)
	if err != nil {
		return fmt.Errorf("unable to add access config: %w", err)
	}

	if err = opAdd.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Static address %s assigned to the instance %s\n", IPAddress, instanceName)

	return nil
}

Java

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AccessConfig.Type;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class AssignStaticExistingVm {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "your-project-id";
    // Instance ID of the Google Cloud project you want to use.
    String instanceId = "your-instance-id";
    // Name of the zone to create the instance in. For example: "us-west3-b"
    String zone = "your-zone-id";
    // Name of the network interface to assign.
    String netInterfaceName = "your-netInterfaceName-id";

    assignStaticExistingVmAddress(projectId, instanceId, zone, netInterfaceName);
  }

  // Updates or creates an access configuration for a VM instance to assign a static external IP.
  // As network interface is immutable - deletion stage is required
  // in case of any assigned ip (static or ephemeral).
  // VM and ip address must be created before calling this function.
  // IMPORTANT: VM and assigned IP must be in the same region.
  public static Instance assignStaticExistingVmAddress(String projectId, String instanceId,
                                                       String zone, String netInterfaceName)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient client = InstancesClient.create()) {
      Instance instance = client.get(projectId, zone, instanceId);

      NetworkInterface networkInterface = null;
      for (NetworkInterface netInterface : instance.getNetworkInterfacesList()) {
        if (netInterface.getName().equals(netInterfaceName)) {
          networkInterface = netInterface;
          break;
        }
      }

      if (networkInterface == null) {
        throw new IllegalArgumentException(
                String.format(
                        "No '{network_interface_name}' variable found on instance %s.",
                        instanceId)
        );
      }
      AccessConfig accessConfig = null;
      for (AccessConfig config : networkInterface.getAccessConfigsList()) {
        if (config.getType().equals(Type.ONE_TO_ONE_NAT.name())) {
          accessConfig = config;
          break;
        }
      }

      if (accessConfig != null) {
        // Delete the existing access configuration first
        client.deleteAccessConfigAsync(projectId, zone, instanceId,
                        accessConfig.getName(), netInterfaceName)
                .get(30, TimeUnit.SECONDS);
      }

      // Add a new access configuration with the new IP
      AccessConfig newAccessConfig = AccessConfig.newBuilder()
              // Leave this field undefined to use an IP from a shared ephemeral IP address pool
              // .setNatIP(ipAddress)
              .setType(Type.ONE_TO_ONE_NAT.name())
              .setName("external-nat")
              .build();

      client.addAccessConfigAsync(projectId, zone, instanceId, netInterfaceName, newAccessConfig)
              .get(30, TimeUnit.SECONDS);

      // return updated instance
      return client.get(projectId, zone, instanceId);
    }
  }
}

Python

import uuid

from google.cloud.compute_v1 import InstancesClient
from google.cloud.compute_v1.types import AccessConfig
from google.cloud.compute_v1.types import AddAccessConfigInstanceRequest
from google.cloud.compute_v1.types import DeleteAccessConfigInstanceRequest


def assign_static_ip_to_existing_vm(
    project_id: str,
    zone: str,
    instance_name: str,
    ip_address: str,
    network_interface_name: str = "nic0",
):
    """
    Updates or creates an access configuration for a VM instance to assign a static external IP.
    As network interface is immutable - deletion stage is required in case of any assigned ip (static or ephemeral).
    VM and ip address must be created before calling this function.
    IMPORTANT: VM and assigned IP must be in the same region.

    Args:
        project_id (str): Project ID.
        zone (str): Zone where the VM is located.
        instance_name (str): Name of the VM instance.
        ip_address (str): New static external IP address to assign to the VM.
        network_interface_name (str): Name of the network interface to assign.

    Returns:
        google.cloud.compute_v1.types.Instance: Updated instance object.
    """
    client = InstancesClient()
    instance = client.get(project=project_id, zone=zone, instance=instance_name)
    network_interface = next(
        (ni for ni in instance.network_interfaces if ni.name == network_interface_name),
        None,
    )

    if network_interface is None:
        raise ValueError(
            f"No network interface named '{network_interface_name}' found on instance {instance_name}."
        )

    access_config = next(
        (ac for ac in network_interface.access_configs if ac.type_ == "ONE_TO_ONE_NAT"),
        None,
    )

    if access_config:
        # Delete the existing access configuration first
        delete_request = DeleteAccessConfigInstanceRequest(
            project=project_id,
            zone=zone,
            instance=instance_name,
            access_config=access_config.name,
            network_interface=network_interface_name,
            request_id=str(uuid.uuid4()),
        )
        delete_operation = client.delete_access_config(delete_request)
        delete_operation.result()

    # Add a new access configuration with the new IP
    add_request = AddAccessConfigInstanceRequest(
        project=project_id,
        zone=zone,
        instance=instance_name,
        network_interface="nic0",
        access_config_resource=AccessConfig(
            nat_i_p=ip_address, type_="ONE_TO_ONE_NAT", name="external-nat"
        ),
        request_id=str(uuid.uuid4()),
    )
    add_operation = client.add_access_config(add_request)
    add_operation.result()

    updated_instance = client.get(project=project_id, zone=zone, instance=instance_name)
    return updated_instance

Limitare gli indirizzi IP esterni a VM specifiche

Per determinati carichi di lavoro, potresti avere requisiti essenziali che includono limitazioni di sicurezza e di rete. Ad esempio, potresti limitare gli indirizzi IP esterni in modo che solo VM specifiche possano utilizzarli. Questa opzione può contribuire a impedire l'esfiltrazione di dati o mantenere l'isolamento della rete. Con un criterio dell'organizzazione, puoi limitare gli indirizzi IP esterni a VM specifiche con limitazioni per controllare l'utilizzo degli indirizzi IP esterni per le tue VM all'interno di un' organizzazione o un progetto.

Attenzione: la limitazione degli IP esterni a VM specifiche può impedire ai cluster GKE e ai gruppi di istanze gestite esistenti di aggiungere nuove VM. Se un cluster GKE o un gruppo di istanze gestite è configurato per creare VM con indirizzi IP esterni, le azioni di riparazione automatica e scalabilità automatica non riescono.

Il vincolo per il controllo dell'indirizzo IP esterno sulle VM è:

constraints/compute.vmExternalIpAccess

Per utilizzare la limitazione, specifica un criterio con un allowedList di VM che possono avere indirizzi IP esterni. Se non specifichi un criterio, tutti gli indirizzi IP esterni sono consentiti per tutte le VM. Quando il criterio è attivo, solo alle VM elencate nell'elenco allowedValues può essere assegnato un indirizzo IP esterno, temporaneo o statico, mentre alle altre VM Compute Engine nell'organizzazione o nel progetto che non sono definite esplicitamente nel criterio è vietato utilizzare indirizzi IP esterni.

Le VM vengono identificate negli elenchi consentiti e vietati utilizzando l'URI della VM:

projects/PROJECT_ID/zones/ZONE/instances/VM_NAME

Specifiche per la limitazione degli indirizzi IP esterni

• Puoi applicare questo vincolo di elenco solo alle VM.
• Non puoi applicare il vincolo in modo retroattivo. Tutte le VM che hanno indirizzi IP esterni prima dell'attivazione del criterio mantengono i propri indirizzi IP esterni.
• Questo vincolo accetta un allowedList o un deniedList, ma non entrambi nella stessa norma.
• Spetta a te o a un amministratore con le autorizzazioni richieste gestire e mantenere l'integrità e il ciclo di vita della VM. Il vincolo verifica solo l'URI della VM e non impedisce alle VM nella lista consentita di essere modificate, eliminate o ricreate.

Autorizzazioni necessarie per limitare gli indirizzi IP esterni

Per impostare un vincolo a livello di progetto o di organizzazione, devi avere ricevuto il ruolo orgpolicy.policyAdmin nell'organizzazione.

Imposta il vincolo dei criteri a livello di organizzazione

Nota: la lunghezza di ogni stringa utilizzata per ogni URI VM non può superare i 200 caratteri.

Console

1. Vai alla pagina Criteri dell'organizzazione.

   Vai a Criteri dell'organizzazione

2. Se necessario, seleziona l'organizzazione richiesta dal menu a discesa del progetto.
3. Fai clic su Definisci IP esterni consentiti per le istanze VM.
4. Fai clic su Modifica per modificare il criterio IP esterno. Se non riesci ad accedere allo strumento Modifica, significa che non disponi delle autorizzazioni corrette.

5. Seleziona Personalizza per impostare il criterio dell'organizzazione per VM specifiche.

   

6. Seleziona Applicazione criterio e Tipo di criterio.

7. Per Valori criterio, seleziona Personalizzato.

8. Inserisci un URI per una VM e premi Invio. L'URI deve avere il seguente formato:

   projects/PROJECT_ID/zones/ZONE/instances/VM_NAME
   

9. Fai clic su Nuovo valore criterio e inserisci gli URI per le VM, se necessario.

10. Fai clic su Salva per applicare la limitazione.

gcloud

Per impostare una limitazione per l'accesso tramite IP esterno, devi prima avere l'ID della tua organizzazione. Puoi trovare l'ID organizzazione eseguendo il comando organizations list e cercando l'ID numerico nella risposta:

gcloud organizations list

Gcloud CLI restituisce un elenco di organizzazioni nel seguente formato:

DISPLAY_NAME               ID
example-organization1      29252605212
example-organization2      1234567890

Utilizza il comando gcloud resource-manager org-policies set-policy per impostare il criterio. Devi fornire i criteri come file JSON. Crea un file JSON nel seguente formato:

{
"constraint": "constraints/compute.vmExternalIpAccess",
"listPolicy": {
  "allowedValues": [
     "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME",
     "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME",
     "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME"
  ]
 }
}

Sostituisci quanto segue:

• PROJECT_ID: l'ID progetto per questa richiesta, ad esempio example-project. Tieni presente che questa operazione è diversa dalla configurazione dei criteri dell'organizzazione, che richiedono l'ID numerico dell'organizzazione.
• ZONE: la zona della VM
• VM_NAME: il nome della VM

In alternativa, puoi specificare un elenco deniedValues per indicare le VM per le quali vuoi vietare esplicitamente l'utilizzo di un indirizzo IP esterno. A qualsiasi VM non presente nell'elenco sarà implicitamente consentito avere un indirizzo IP esterno. Puoi specificare solo allowedValues o deniedValues, ma non entrambi.

Quindi, passa il file con la richiesta:

gcloud resource-manager org-policies set-policy MY_POLICY.JSON --organization=ORGANIZATION_ID

Sostituisci ORGANIZATION_ID con l'ID numerico dell'organizzazione.

Se non vuoi che nessuna VM abbia accesso all'IP esterno, puoi impostare un criterio con allValues impostato su DENY:

{
  "constraint": "constraints/compute.vmExternalIpAccess",
  "listPolicy": {
    "allValues": "DENY"
  }
}

REST

Utilizza l'API setOrgPolicy() per definire la limitazione. Le VM nell'elenco allowedValue specificato possono avere indirizzi IP esterni. In alternativa, puoi specificare un elenco deniedValues per indicare le VM a cui vuoi vietare esplicitamente di avere un indirizzo IP esterno. A qualsiasi VM non presente nell'elenco sarebbe implicitamente consentito avere un indirizzo IP esterno. Puoi specificare solo allowedValues o deniedValues, ma non entrambi.

Ad esempio, di seguito è riportata una richiesta di applicazione del vincolo compute.vmExternalIpAccess a un'organizzazione in cui le VM di determinati progetti all'interno dell'organizzazione possono avere indirizzi IP esterni:

POST https://cloudresourcemanager.googleapis.com/v1/organizations/ORGANIZATION_ID:setOrgPolicy

dove ORGANIZATION_ID è l'ID numerico dell'organizzazione.

Ora, nel corpo della richiesta, fornisci il criterio per questo vincolo:

{
  "policy": {
    "constraint": "constraints/compute.vmExternalIpAccess",
    "listPolicy": {
      "allowedValues": [
        "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME",
        "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME",
        "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME"
        ]
      }
    }
 }

Se non vuoi che nessuna VM abbia accesso all'IP esterno, puoi impostare un criterio con allValues impostato su DENY:

{
  "policy": {
    "constraint": "constraints/compute.vmExternalIpAccess",
    "listPolicy": {
      "allValues": "DENY"
      }
    }
 }

Imposta il criterio a livello di progetto

L'impostazione di un criterio a livello di progetto sostituisce il criterio a livello di organizzazione. Ad esempio, se a livello di organizzazione è presente example-vm-1 nell'elencoallowedValues, ma il criterio a livello di progetto ha la stessa VM nell'elencodeniedValues, alla VM non sarà consentito avere un indirizzo IP esterno.

Console

Segui la stessa procedura descritta in Impostare un vincolo dei criteri a livello di organizzazione, ma scegli il progetto dal selettore dei progetti anziché dall'organizzazione.

gcloud

Utilizza il comando gcloud resource-manager org-policies set-policy per impostare il criterio. Devi fornire i criteri come file JSON. Crea un file JSON nel seguente formato:

{
 "constraint": "constraints/compute.vmExternalIpAccess",
 "listPolicy": {
  "allowedValues": [
   "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME"
  ]
 }
}

Sostituisci quanto segue:

• PROJECT_ID: l'ID progetto per questa richiesta, ad esempio example-project. Tieni presente che questa operazione è diversa dalla configurazione dei criteri dell'organizzazione, che richiedono l'ID numerico dell'organizzazione.
• ZONE: la zona della VM.
• VM_NAME: il nome della VM.

In alternativa, puoi specificare un deniedValues elenco di VM per le quali vuoi vietare esplicitamente l'utilizzo di un indirizzo IP esterno. A qualsiasi VM non presente nell'elenco sarà implicitamente consentito avere un indirizzo IP esterno. Puoi specificare solo allowedValues o deniedValues, ma non entrambi.

Quindi, passa il file con la richiesta:

gcloud resource-manager org-policies set-policy MY_POLICY.JSON --project=example-project

REST

Utilizza l'API setOrgPolicy per definire la limitazione. Le VM nell'elenco allowedValue specificato sono autorizzate ad avere indirizzi IP esterni. In alternativa, puoi specificare un elencodeniedValues per indicare le VM a cui vuoi vietare esplicitamente di avere un indirizzo IP esterno. A qualsiasi VM non presente nell'elenco è implicitamente consentito avere un indirizzo IP esterno. Puoi specificare solo allowedValues o deniedValues, ma non entrambi.

Ad esempio, di seguito è riportata una richiesta per impostare il vincolo compute.vmExternalIpAccess su un progetto per consentire a VM specifiche di avere indirizzi IP esterni:

POST https://cloudresourcemanager.googleapis.com/v1/projects/PROJECT_ID:setOrgPolicy

Sostituisci PROJECT_ID con l'ID progetto per questa richiesta.

Il corpo della richiesta contiene il criterio per questo vincolo:

{
  "policy": {
    "constraint": "constraints/compute.vmExternalIpAccess",
    "listPolicy": {
      "allowedValues": [
        "projects/PROJECT_ID/zones/ZONE/instances/VM_NAME"
      ]
    }
  }
}

Best practice per limitare gli indirizzi IP esterni

• Evita di utilizzare l'elenco deniedValues con questo vincolo. Se definisci valori nell'elenco deniedValues, significa che solo le VM nell'elenco deniedValues non possono utilizzare indirizzi IP esterni. Questo potrebbe essere un problema di sicurezza se vuoi controllare esattamente quali VM possono avere indirizzi IP esterni. Se vuoi rimuovere determinate VM dall'elenco allowedValues, aggiorna il criterio esistente per rimuovere le VM dall'elenco allowedValues anziché inserirle nell'elenco deniedValues a un livello di gerarchia inferiore.allowedList

• Se vuoi impostare un criterio su gran parte della gerarchia delle risorse, ma esentare determinati progetti, ripristina il criterio predefinito utilizzando il metodo setOrgPolicy specificando l'oggetto restoreDefault per consentire l'associazione di tutte le VM dei progetti ad indirizzi IP esterni. I criteri attuali per i progetti non sono interessati dall'impostazione predefinita.

• Utilizza il criterio dell'organizzazione insieme ai ruoli IAM per controllare meglio il tuo ambiente. Questo criterio si applica solo alle VM, ma se vuoi controllare e limitare meglio gli indirizzi IP esterni sui dispositivi di rete, puoi concedere il ruolo compute.networkAdmin alle parti appropriate.

• Tutti i servizi e i prodotti in esecuzione su Compute Engine all'interno dell'organizzazione o del progetto con il criterio abilitato sono soggetti a queste norme dell'organizzazione. Nello specifico, questo criterio riguarda servizi come Google Kubernetes Engine, Dataflow, Dataproc e Cloud SQL. Se si tratta di un problema, Google consiglia di configurare altri servizi e prodotti in un progetto diverso a cui non sono stati applicati i criteri dell'organizzazione e di utilizzare VPC condiviso, se necessario.

Gestire gli indirizzi IP esterni statici

Le sezioni seguenti descrivono come gestire gli indirizzi IP esterni statici per le tue VM.

Determinare se un indirizzo IP interno è temporaneo o statico

Gli indirizzi IP interni statici e temporanei si comportano e appaiono allo stesso modo nella maggior parte dei contesti. Tuttavia, con gli indirizzi IP interni statici, puoi utilizzare lo stesso indirizzo IP per la stessa risorsa anche se la elimini e la ricrei. In genere, un indirizzo IP temporaneo viene rilasciato se interrompi o elimini la risorsa.

Per determinare se un indirizzo è statico o temporaneo:

1. Nella console Google Cloud, vai alla pagina Indirizzi IP.

   Vai a indirizzi IP

2. Individua l'indirizzo nell'elenco e controlla la colonna Tipo per conoscere il tipo di indirizzo IP.

Annullare l'assegnazione di un indirizzo IP esterno statico

L'annullamento dell'assegnazione di un indirizzo IP lo rimuove dalla risorsa, ma lo mantiene riservato. Una volta annullata l'assegnazione, puoi riassegnarlo a un'altra risorsa.

Nota: per gli indirizzi IP esterni statici non assegnati viene addebitata una tariffa superiore rispetto agli indirizzi IP esterni statici e temporanei in uso. Per ulteriori informazioni, consulta Prezzi per indirizzi IP esterni.

Puoi anche annullare l'assegnazione dell'indirizzo IPv4 o IPv6 eliminando la VM.

Console

1. Nella console Google Cloud, vai alla pagina Indirizzi IP.

   Vai a indirizzi IP

2. Fai clic su Indirizzi IP esterni.

3. Seleziona l'indirizzo IP statico di cui vuoi annullare l'assegnazione.

4. Fai clic su Modifica per aprire la finestra di dialogo Allega indirizzo IP.

5. Dall'elenco a discesa Allega a, seleziona Nessuno.

6. Fai clic su OK.

gcloud

1. Controlla se è in uso un indirizzo IP statico utilizzando il comando gcloud compute addresses list:

   gcloud compute addresses list
   

   L'output è simile al seguente:

   NAME                      REGION    ADDRESS                  STATUS
   example-address-ipv4      REGION    198.51.100.1             RESERVED
   example-address-new-ipv4  REGION    203.0.113.1              IN_USE
   example-address-ipv6      REGION    2001:db8:1:1:1:1:1:1     RESERVED
   example-address-new-ipv6  REGION    2001:db8:4:4:4:4:4:4     IN_USE
   

   • Se l'indirizzo IP non è in uso, lo stato è RESERVED.
   • Se l'indirizzo IP è in uso, lo stato è IN_USE.

2. Recupera il nome della VM che utilizza l'indirizzo IP:

   gcloud compute addresses describe ADDRESS_NAME \
     --region=REGION
   

   Sostituisci quanto segue:

   • ADDRESS_NAME: il nome della risorsa dell'indirizzo IPv6.
   • REGION: la regione della risorsa indirizzo IPv6.

   L'output è simile al seguente:

   address: IP_ADDRESS
   addressType: EXTERNAL
   ...
   region: https://www.googleapis.com/compute/v1/projects/PROJECT/regions/REGION
   selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT/regions/REGION/addresses/ADDRESS_NAME
   status: IN_USE
   subnetwork: https://www.googleapis.com/compute/v1/projects/PROJECT/regions/REGION/subnetworks/SUBNET
   users:
   - https://www.googleapis.com/compute/v1/projects/PROJECT/zones/ZONE/instances/VM_NAME
   

   Il campo users mostra il nome della VM che utilizza l'indirizzo IP.

3. Rimuovi l'assegnazione dell'indirizzo IP dalla VM.

   • Per annullare l'assegnazione di un indirizzo IPv4, elimina il file di configurazione dell'accesso della VM:

     1. Recupera il nome della configurazione di accesso da eliminare. Per ottenere il nome, utilizza il comando gcloud compute instances describe. Sostituisci VM_NAME con il nome della VM.

        gcloud compute instances describe VM_NAME
        

        La configurazione dell'accesso viene visualizzata nel seguente formato:

        networkInterfaces:
          - accessConfigs:
            - kind: compute#accessConfig
              name: external-nat
              natIP: 203.0.113.1
              type: ONE_TO_ONE_NAT
        

        Nota: il valore name della configurazione di accesso potrebbe essere diverso da external-nat; assicurati di controllare il nome della tua configurazione di accesso. In alcuni casi, potrebbe essere utilizzata una versione precedente del nome della configurazione di accesso,External NAT.

     2. Elimina la configurazione di accesso utilizzando il comando gcloud compute instances delete-access-config:

        gcloud compute instances delete-access-config VM_NAME \
          --access-config-name="ACCESS_CONFIG_NAME"
        

        Sostituisci quanto segue:

        • VM_NAME: il nome della VM.
        • ACCESS_CONFIG_NAME: il nome della configurazione di accesso da eliminare. Assicurati di includere il nome completo tra virgolette.

   • Per annullare l'assegnazione di un intervallo di indirizzi IPv6, utilizza il comando instance network-interfaces update:

     gcloud compute instances network-interfaces update VM_NAME \
       --network-interface=nic0 \
       --stack-type=IPV4_ONLY \
       --zone=ZONE
     

     Sostituisci quanto segue:

     • VM_NAME: il nome della VM che utilizza l'indirizzo IP.
     • ZONE: la zona della VM.

4. Verifica che l'indirizzo IP esterno statico sia ora disponibile e contrassegnato come RESERVED anziché IN_USE.

   gcloud compute addresses list \
     --filter="ADDRESS_NAME AND region=REGION"
   

   Sostituisci quanto segue:

   • ADDRESS_NAME: il nome della risorsa dell'indirizzo IP.
   • REGION: la regione della risorsa indirizzo IP.

Ora che l'indirizzo IP esterno statico è disponibile, puoi scegliere di assegnarlo a un'altra VM.

REST

Per annullare l'assegnazione di un indirizzo IPv4 o IPv6 esterno statico, svolgi i seguenti passaggi:

• Per gli indirizzi IPv4, elimina la configurazione di accesso associata alla VM che utilizza l'indirizzo.

  1. Per controllare i dettagli della configurazione di accesso di una VM, effettua una richiesta GET al metodo instances.get.

     GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME
     

  2. Elimina la configurazione di accesso esistente inviando una richiesta POST al metodo instances.deleteAccessConfig.

     POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/deleteAccessConfig
     

     Sostituisci quanto segue:

     • PROJECT_ID: l'ID progetto per questa richiesta
     • ZONE: la zona in cui si trova la VM
     • VM_NAME: il nome della VM

• Per gli indirizzi IPv6, aggiorna il tipo di stack dell'interfaccia di rete della VM a cui è collegato l'indirizzo IPv6.

  1. Invia una richiesta PATCH al metodo instances.updateNetworkInterface.

  2. Nel corpo della richiesta, aggiorna il valore del campo stackType in IPV4_ONLY.

     Ad esempio:

     PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/VM_NAME/updateNetworkInterface
     
     {
       "networkInterfaces": [{
         ...
         "stackType" : "IPV4_ONLY"
         ...
         }]
     }
     

Java

import com.google.cloud.compute.v1.AccessConfig;
import com.google.cloud.compute.v1.AccessConfig.Type;
import com.google.cloud.compute.v1.Instance;
import com.google.cloud.compute.v1.InstancesClient;
import com.google.cloud.compute.v1.NetworkInterface;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UnassignStaticIpAddress {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "your-project-id";
    // Instance ID of the Google Cloud project you want to use.
    String instanceId = "your-instance-id";
    // Name of the zone to create the instance in. For example: "us-west3-b"
    String zone = "your-zone";
    // Name of the network interface to assign.
    String netInterfaceName = "your-netInterfaceName";

    unassignStaticIpAddress(projectId, instanceId, zone, netInterfaceName);
  }

  public static Instance unassignStaticIpAddress(String projectId, String instanceId,
                                                 String zone, String netInterfaceName)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (InstancesClient client = InstancesClient.create()) {
      Instance instance = client.get(projectId, zone, instanceId);
      NetworkInterface networkInterface = null;
      for (NetworkInterface netIterface : instance.getNetworkInterfacesList()) {
        if (netIterface.getName().equals(netInterfaceName)) {
          networkInterface = netIterface;
          break;
        }
      }

      if (networkInterface == null) {
        throw new IllegalArgumentException(
                String.format(
                        "No '{network_interface_name}' variable found on instance %s.",
                        instanceId)
        );
      }

      AccessConfig accessConfig = null;
      for (AccessConfig config : networkInterface.getAccessConfigsList()) {
        if (config.getType().equals(Type.ONE_TO_ONE_NAT.name())) {
          accessConfig = config;
          break;
        }
      }

      if (accessConfig != null) {
        // Delete the existing access configuration first
        client.deleteAccessConfigAsync(projectId, zone, instanceId,
                        accessConfig.getName(), netInterfaceName).get(30, TimeUnit.SECONDS);
      }

      // return updated instance
      return client.get(projectId, zone, instanceId);
    }
  }
}

Python

import uuid

from google.cloud.compute_v1 import InstancesClient
from google.cloud.compute_v1.types import DeleteAccessConfigInstanceRequest


def unassign_static_ip_from_existing_vm(
    project_id: str,
    zone: str,
    instance_name: str,
    network_interface_name: str = "nic0",
):
    """
    Updates access configuration for a VM instance to unassign a static external IP.
    VM (and IP address in case of static IP assigned) must be created before calling this function.

    Args:
        project_id (str): Project ID.
        zone (str): Zone where the VM is located.
        instance_name (str): Name of the VM instance.
        network_interface_name (str): Name of the network interface to unassign.
    """
    client = InstancesClient()
    instance = client.get(project=project_id, zone=zone, instance=instance_name)
    network_interface = next(
        (ni for ni in instance.network_interfaces if ni.name == network_interface_name),
        None,
    )

    if network_interface is None:
        raise ValueError(
            f"No network interface named '{network_interface_name}' found on instance {instance_name}."
        )

    access_config = next(
        (ac for ac in network_interface.access_configs if ac.type_ == "ONE_TO_ONE_NAT"),
        None,
    )

    if access_config:
        # Delete the existing access configuration
        delete_request = DeleteAccessConfigInstanceRequest(
            project=project_id,
            zone=zone,
            instance=instance_name,
            access_config=access_config.name,
            network_interface=network_interface_name,
            request_id=str(uuid.uuid4()),
        )
        delete_operation = client.delete_access_config(delete_request)
        delete_operation.result()

    updated_instance = client.get(project=project_id, zone=zone, instance=instance_name)
    return updated_instance

Rilasciare un indirizzo IP esterno statico

Se non hai più bisogno di un indirizzo IPv4 o IPv6 esterno statico, puoi rilasciarlo eliminando la risorsa indirizzo IP. L'eliminazione di una VM non comporta il rilascio automatico di un indirizzo IP esterno statico. Devi rilasciare manualmente gli indirizzi IP esterni statici quando non li utilizzi più.

Per rilasciare un indirizzo IP esterno statico, consulta Rilasciare un indirizzo IP esterno statico nella documentazione di VPC.

Passaggi successivi

• Scopri di più sugli indirizzi IP.
• Scopri di più su reti e firewall.
• Scopri come indirizzare le VM utilizzando il DNS interno.
• Esamina i prezzi di VPC.