Statische externe IP-Adressen konfigurieren

---

Sie können Ihren virtuellen Maschinen (VMs) und Bare-Metal-Instanzen statische externe IP-Adressen zuweisen. Sie können statische IP-Adressen für Ihre Instanzen auch ändern, auflisten und freigeben. Informationen zum Reservieren einer statischen externen IP-Adresse finden Sie unter Statische externe IP-Adresse reservieren.

Externe IP-Adressen können statisch oder sitzungsspezifisch sein. Wenn für eine Instanz eine feste externe IP-Adresse erforderlich ist, die sich nicht ändert, gehen Sie so vor:

1. Holen Sie sich eine statische externe IP-Adresse. Sie können neue externe IP-Adressen reservieren oder vorhandene sitzungsspezifische externe IP-Adressen umwandeln.
2. Weisen Sie die reservierte IP-Adresse einer vorhandenen Instanz zu oder weisen Sie sie beim Erstellen einer neuen Instanz zu.

Wenn Sie eine statische IP-Adresse für Ihr internes Compute Engine-Netzwerk benötigen, lesen Sie stattdessen den Artikel Statische interne IP-Adresse reservieren.

Informationen zum Reservieren einer statischen externen IP-Adresse oder zum Erstellen einer globalen externen IP-Adresse finden Sie unter Statische externe IP-Adresse reservieren.

Hinweise

• Weitere Informationen zu IP-Adressen
• Informationen zu Kontingenten und Limits für statische externe IP-Adressen.
• Informationen zu Preisen für externe IP-Adressen.
• Richten Sie die Authentifizierung ein, falls Sie dies noch nicht getan haben. Bei der Authentifizierung wird Ihre Identität für den Zugriff auf Google Cloud -Dienste und ‑APIs überprüft. Zur Ausführung von Code oder Beispielen aus einer lokalen Entwicklungsumgebung können Sie sich bei Compute Engine authentifizieren. Wählen Sie dazu eine der folgenden Optionen aus:
  

  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

  Wenn Sie die Terraform-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung verwenden möchten, installieren und initialisieren Sie die gcloud CLI und richten dann die Standardanmeldedaten für Anwendungen mit Ihren Nutzeranmeldedaten ein.

  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.

  Weitere Informationen unter Set up authentication for a local development environment.

  REST

  Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.

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

  gcloud init

  Weitere Informationen finden Sie unter Für die Verwendung von REST authentifizieren in der Dokumentation zur Google Cloud-Authentifizierung.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für Ihr Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Konfigurieren und Verwalten von statischen IP-Adressen benötigen:

• Zum Erstellen und Aktualisieren von Instanzen: Compute-Instanzadministrator (Version 1) (roles/compute.instanceAdmin.v1)

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Konfigurieren und Verwalten von statischen IP-Adressen erforderlich sind. Erweitern Sie den Abschnitt Erforderliche Berechtigungen, um die erforderlichen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um statische IP-Adressen zu reservieren und zu verwalten:

• compute.instances.update für die Instanz
• compute.instances.updateNetworkInterface für die Instanz
• compute.instances.addAccessConfig für die Instanz
• compute.instances.deleteAccessConfig für die Instanz
• compute.networks.list für das Netzwerk
• compute.subnetworks.use für das Subnetz
• compute.subnetworks.list für das Subnetz
• So erstellen Sie Instanzen:
  • compute.instances.create für das Projekt
  • Zur Erstellung der VM mit einem benutzerdefinierten Image: compute.images.useReadOnly für das Image
  • Zur Erstellung der VM mithilfe eines Snapshots: compute.snapshots.useReadOnly für den Snapshot
  • Zur Erstellung der VM mithilfe einer Instanzvorlage: compute.instanceTemplates.useReadOnly für die Instanzvorlage
  • Um der VM ein Legacy-Netzwerk zuzuweisen: compute.networks.use für das Projekt
  • Zum Festlegen einer statische IP-Adresse für die VM: compute.addresses.use für das Projekt
  • Zur Zuweisung einer externen IP-Adresse zur VM bei Verwendung eines Legacy-Netzwerks: compute.networks.useExternalIp für das Projekt
  • Um ein Subnetz für die VM anzugeben: compute.subnetworks.use für das Projekt oder für das ausgewählte Subnetz
  • Um der VM eine externe IP-Adresse zuzuweisen, wenn Sie ein VPC-Netzwerk verwenden: compute.subnetworks.useExternalIp für das Projekt oder für das ausgewählte Subnetz
  • Um die Metadaten der VM-Instanz für die VM festzulegen: compute.instances.setMetadata für das Projekt
  • Um Tags für die VM festzulegen: compute.instances.setTags für die VM
  • Um Labels für die VM festzulegen: compute.instances.setLabels für die VM
  • Um ein Dienstkonto festzulegen, das die VM verwenden soll: compute.instances.setServiceAccount für die VM
  • Um ein neues Laufwerk für die VM zu erstellen: compute.disks.create für das Projekt
  • Um ein vorhandenes Laufwerk im Lese- oder Lese‑/Schreibmodus anzuhängen: compute.disks.use für das Laufwerk
  • Um ein vorhandenes Laufwerk im Lesemodus anzuhängen: compute.disks.useReadOnly für das Laufwerk

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

Beschränkungen

• Eine statische externe IP-Adresse kann immer nur von einer einzigen Ressource verwendet werden.

• Ist eine IP-Adresse einmal einer Ressource zugewiesen, kann nicht überprüft werden, ob die IP-Adresse statisch oder sitzungsspezifisch ist. Sie können die IP-Adresse mit der Liste der für dieses Projekt reservierten statischen externen IP-Adressen vergleichen. Mit dem Unterbefehl gcloud compute addresses list können Sie eine Liste der für Ihr Projekt verfügbaren statischen externen IP-Adressen aufrufen.

• Jede VM kann mehrere Netzwerkschnittstellen haben und jeder Schnittstelle können je nach Stacktyp die folgenden IP-Adressen zugewiesen werden:

  • Nur IPv4-Schnittstellen:
    • Eine interne IPv4-Adresse (erforderlich)
    • Eine externe IPv4-Adresse (optional)
  • Dual-Stack-Schnittstellen (IPv4 und IPv6):
    • Eine interne IPv4-Adresse (erforderlich)
    • Eine externe IPv4-Adresse (optional)
    • Ein /96-IPv6-Adressbereich, entweder intern oder extern, aber nicht beides (erforderlich)
  • Nur-IPv6-Schnittstellen (Vorabversion):
    • Ein /96-IPv6-Adressbereich, entweder intern oder extern, aber nicht beides (erforderlich)

• Sie können die externe IPv6-Adresse einer VM mit einer reinen IPv6-Netzwerkschnittstelle nicht aufheben oder ändern. Sie können jedoch eine sitzungsspezifische externe IP-Adresse einer Ressource in eine statische externe IP-Adresse umwandeln, damit die Adresse auch nach dem Löschen der Ressource reserviert bleibt.

• Der Name einer statischen IP-Adresse kann nicht geändert werden.

Hinweis: Netzwerkschnittstellen können Traffic über mehrere Weiterleitungsregeln empfangen, die unter Umständen andere externe IP-Adressen bedienen. Beliebig viele externe IP-Adressen können eine Netzwerkschnittstelle über diese Weiterleitungsregeln referenzieren, aber jeder Netzwerkschnittstelle kann nur eine externe IPv4-Adresse und ein externer /96-IPv6-Adressbereich zugewiesen werden.

Weitere Informationen über Load-Balancing und Weiterleitungsregeln finden Sie in der Dokumentation zu Load-Balancing (nur auf Englisch verfügbar).

Verfügbare statische externe IP-Adressen ansehen

So listen Sie statische externe IP-Adressen auf, die Sie für Ihr Projekt reserviert haben.

Console

1. Rufen Sie in der Google Cloud Console die Seite IP-Adressen auf.

   "IP-Adressen" aufrufen

2. Klicken Sie auf Externe IP-Adressen.

gcloud

Führen Sie folgenden gcloud compute addresses list-Befehl aus:

• Verwenden Sie den folgenden Befehl, um alle globalen IP-Adressen aufzulisten:

  gcloud compute addresses list

• Verwenden Sie den folgenden Befehl, um alle globalen IP-Adressen aufzulisten:

  gcloud compute addresses list --global

• Verwenden Sie den folgenden Befehl, um alle regionalen IP-Adressen in einer bestimmten Region aufzulisten:

  gcloud compute addresses list \
      --regions=REGION
  

  Ersetzen Sie REGION durch die Region, für die Sie Adressen auflisten möchten. Sie können Adressen mehrerer Regionen auflisten, indem Sie durch Kommas getrennte Regionsnamen angeben:

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

API

• Rufen Sie die Methode addresses.list auf, um regionale IPv4- oder IPv6-Adressen aufzulisten:

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

  Ersetzen Sie Folgendes:

  • PROJECT_ID ist die Projekt-ID für diese Anfrage.
  • REGION ist der Name der Region für diese Anfrage.

• Rufen Sie die Methode addresses.aggregatedList auf, um eine Liste aller Adressen in allen Regionen zu erhalten.

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

• Rufen Sie die Methode globalAddresses.list auf, um globale IPv4- oder IPv6-Adressen aufzulisten:

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

  Ersetzen Sie Folgendes:

  PROJECT_ID ist die Projekt-ID für diese Anfrage.

Go

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

Statische externe IP-Adressen konfigurieren

In den folgenden Abschnitten wird beschrieben, wie Sie statische externe IP-Adressen für Ihre Instanzen konfigurieren.

Instanz mit statischer externer IP-Adresse erstellen

Nachdem Sie eine statische externe IP-Adresse reserviert haben, können Sie sie einer Instanz zuweisen.

Console

1. Rufen Sie in der Google Cloud -Konsole die Seite Instanz erstellen auf.

   Zur Seite „Instanz erstellen“

2. Geben Sie die Instanzdetails an.

3. Maximieren Sie den Bereich Erweiterte Optionen.

4. Maximieren Sie den Bereich Netzwerk.

5. Maximieren Sie im Bereich Netzwerkschnittstellen eine Netzwerkschnittstelle, um sie zu bearbeiten.

6. So weisen Sie eine IPv4-Adresse zu:

   1. Wählen Sie ein Netzwerk aus.
   2. Wählen Sie die IP-Adresse aus der Liste Externe IPv4-Adresse aus.

7. So weisen Sie eine IPv6-Adresse zu:

   1. Wählen Sie ein Netzwerk aus, das ein Subnetz mit einem externen IPv6-Adressbereich enthält.
   2. Wählen Sie das Subnetz aus der Liste Subnetzwerk aus.
   3. Wählen Sie für IP-Stack-Typ die Option IPv4 und IPv6 (Dual-Stack) oder IPv6 (einzelner Stack) aus.
   4. Wählen Sie die neu reservierte externe IPv6-Adresse aus der Liste Externe IPv6-Adresse aus. Alternativ können Sie Statische externe IPv6-Adresse reservieren auswählen und eine neue statische externe IPv6-Adresse reservieren.
   5. Wählen Sie für Netzwerkdienststufe die Option Premium aus.

8. Klicken Sie auf Fertig, um die Änderung der Standard-Netzwerkschnittstelle abzuschließen.

9. Fahren Sie mit der Erstellung der Instanz fort.

gcloud

Sie können eine Instanz erstellen und eine statische regionale, externe IP-Adresse zuweisen, die Sie bereits reserviert haben.

• So weisen Sie eine statische externe IPv4-Adresse zu:

  gcloud compute instances create INSTANCE_NAME \
      --zone=ZONE \
      --address=IPV4_ADDRESS
  

• So weisen Sie eine statische externe IPv6-Adresse zu:

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

  Ersetzen Sie Folgendes:

  • INSTANCE_NAME: Der Name der Compute-Instanz.
  • ZONE: die Zone, in der die Instanz erstellt wird.
  • IPV4_ADDRESS: die IPv4-Adresse, die der Instanz zugewiesen werden soll. Verwenden Sie die reservierte statische externe IP-Adresse, nicht den Adressnamen.
  • SUBNET: ein Subnetz mit externen IPv6-Adressen
  • STACK_TYPE: der Stacktyp für die Instanz, entweder IPV4_IPV6 (Dual-Stack) oder IPV6_ONLY
  • IPV6_ADDRESS: die IPv6-Adresse, die der Instanz zugewiesen werden soll. Verwenden Sie die reservierte statische externe IP-Adresse, nicht den Adressnamen.

Terraform

Sie können mit der Ressource google_compute_instance eine externe IP-Adresse zuweisen.

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

• So weisen Sie einer neuen Compute-Instanz eine statische externe IPv4-Adresse zu:

  Geben Sie in der Anfrage zum Erstellen einer neuen Instanz explizit das Attribut networkInterfaces[].accessConfigs[].natIP und die externe IPv4-Adresse an, die Sie verwenden möchten, z. B.:

  {
    "name": "INSTANCE_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"
           }
    }]
  }
  

  Ersetzen Sie Folgendes:

  • INSTANCE_NAME: der Name der Compute-Instanz
  • ZONE: die Zone, in der die Instanz erstellt wird.
  • MACHINE_TYPE (optional): Vollständige oder teilweise URL der Maschinentypressource, die beim Erstellen der Instanz verwendet werden soll, im Format: zones/ZONE/machineTypes/MACHINE_TYPE
  • IPV4_ADDRESS: die IPv4-Adresse, die der Instanz zugewiesen werden soll. Verwenden Sie die reservierte statische externe IP-Adresse, nicht den Adressnamen.
  • SOURCE_IMAGE: eine bestimmte Version eines öffentlichen Bildes, z. B. projects/debian-cloud/global/images/debian-10-buster-v20200309, oder einer Bildfamilie, z. B. projects/debian-cloud/global/images/family/debian-10

• So weisen Sie einer neuen Instanz eine statische externe IPv6-Adresse zu:

  Geben Sie in der Anfrage zum Erstellen einer neuen Instanz explizit das Attribut networkInterfaces[].ipv6AccessConfigs[].externalIpv6 und die externe IPv6-Adresse an, die Sie verwenden möchten, z. B.:

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

  Ersetzen Sie Folgendes:

  • INSTANCE_NAME: der Name der Compute-Instanz
  • ZONE: die Zone, in der die Instanz erstellt wird.
  • MACHINE_TYPE (optional): Vollständige oder teilweise URL der Maschinentypressource, die beim Erstellen der Instanz verwendet werden soll, im Format: zones/ZONE/machineTypes/MACHINE_TYPE
  • IPV6_ADDRESS: die IPv6-Adresse, die der Instanz zugewiesen werden soll. Verwenden Sie die reservierte statische externe IP-Adresse, nicht den Adressnamen.
  • STACK_TYPE: der Stacktyp für die Instanz, entweder IPV4_IPV6 (Dual-Stack) oder IPV6_ONLY
  • SUBNET: ein Subnetz mit externen IPv6-Adressen
  • SOURCE_IMAGE: eine bestimmte Version eines öffentlichen Bildes, z. B. "projects/debian-cloud/global/images/debian-10-buster-v20200309", oder einer Bildfamilie, z. B. "projects/debian-cloud/global/images/family/debian-10"

Go

// 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

Externe IP-Adresse ändern oder einer vorhandenen Instanz zuweisen

Sie können die sitzungsspezifische oder statische externe IP-Adresse für eine bestehende reine IPv4- oder Dual-Stack-Instanz ändern oder zuweisen. Dieser Vorgang wird für reine IPv6-Instanzen nicht unterstützt.

Eine Compute-Instanz kann mehrere Schnittstellen haben. Eine Single-Stack-Schnittstelle kann eine externe IP-Adresse haben. Eine Dual-Stack-Schnittstelle kann eine externe IPv4-Adresse und eine externe IPv6-Adresse haben. Wenn die Instanz bereits eine externe IP-Adresse hat, müssen Sie diese Adresse zuerst entfernen. Anschließend können Sie der vorhandenen Instanz eine neue externe IP-Adresse zuweisen.

Hinweis: Informationen zum Aktualisieren der IP-Adresse einer Weiterleitungsregel finden Sie unter IP-Adresse einer Weiterleitungsregel ändern.

Console

1. Rufen Sie in der Google Cloud Console die Seite VM-Instanzen auf.

   Zu „VM-Instanzen“

2. Klicken Sie auf den Namen der Instanz, der Sie eine externe IP-Adresse zuweisen möchten. Die Seite Instanzdetails wird angezeigt.

3. Führen Sie auf der Seite Instanzdetails folgende Schritte aus:

   1. Klicken Sie auf Bearbeiten.
   2. Maximieren Sie Netzwerkschnittstellen.
   3. Wählen Sie die erforderliche externe IP-Adresse aus, die der Instanz zugewiesen werden soll. Wenn die Instanz nur IPv4 unterstützt und Sie ihr eine IPv6-Adresse zuweisen möchten, müssen Sie zuerst den Stacktyp in „Dual-Stack“ ändern.
      1. Wählen Sie für Externe IPv4-Adresse entweder Sitzungsspezifisch oder eine statische externe IPv4-Adresse aus.
      2. Wählen Sie für Externe IPv6-Adresse entweder Sitzungsspezifisch oder eine statische externe IPv6-Adresse aus.
   4. Klicken Sie auf Fertig.

4. Klicken Sie auf Speichern.

gcloud

1. Optional: Reservieren Sie eine statische externe IP-Adresse.

   Wenn Sie eine statische externe IP-Adresse zuweisen, müssen Sie diese zuerst reservieren und prüfen, ob die Adresse nicht von einer anderen Ressource verwendet wird. Folgen Sie gegebenenfalls der Anleitung unter Neue statische externe IP-Adresse reservieren oder Zuweisung einer statischen externen IP-Adresse aufheben.

   Wenn Sie eine sitzungsspezifische externe IP-Adresse verwenden möchten, können Sie diesen Schritt überspringen. Compute Engine weist dann eine sitzungsspezifische externe IP-Adresse nach dem Zufallsprinzip zu.

2. Entfernen Sie alle vorhandenen IP-Adresszuweisungen. Weitere Informationen finden Sie unter Zuweisung einer statischen externen IP-Adresse aufheben.

3. Weisen Sie die neue externe IP-Adresse zu.

   • Verwenden Sie zum Zuweisen einer IPv4-Adresse den Unterbefehl instances add-access-config:

     Hinweis: Ersetzen Sie IP_ADDRESS nicht durch den Namen der statischen IP-Adresse, sondern geben Sie die tatsächliche IP-Adresse an.

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

     Ersetzen Sie Folgendes:

     • INSTANCE_NAME: der Name der Instanz.
     • ACCESS_CONFIG_NAME ist der Name dieser Zugriffskonfiguration. Achten Sie darauf, dass Sie vollständigen Namen in Anführungszeichen angeben.
     • IP_ADDRESS ist die IP-Adresse, die hinzugefügt werden soll.

     Wenn Sie möchten, dass Compute Engine eine sitzungsspezifische externe IP-Adresse statt einer statischen externen IP-Adresse zuweist, lassen Sie das Attribut --address IP_ADDRESS weg:

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

   • Verwenden Sie den Unterbefehl instance network-interfaces update, um eine Instanz in Dual-Stack umzuwandeln und ihr eine IPv6-Adresse zuzuweisen:

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

     Ersetzen Sie Folgendes:

     • INSTANCE_NAME: der Name der Instanz.
     • NIC: der Name der Netzwerkschnittstelle.
     • STACK_TYPE: der Stacktyp für die Instanz, der IPV4_IPV6 lauten muss. Sie können den Stacktyp nicht in IPV6_ONLY ändern.
     • IPV6_ADDRESS: die IPv6-Adresse, die der Instanz zugewiesen werden soll. Geben Sie die erste IPv6-Adresse im Bereich /96 an.
     • ZONE ist die Zone der Instanz.

REST

Sie können die externe IPv4- oder IPv6-Adresse einer Instanz ändern. Fügen Sie dazu eine neue Zugriffskonfiguration für diese Instanz hinzu.

1. Entfernen Sie alle vorhandenen IP-Adresszuweisungen. Weitere Informationen finden Sie unter Zuweisung einer statischen externen IP-Adresse aufheben.

2. Löschen Sie die vorhandene Zugriffskonfiguration. Senden Sie dazu eine POST-Anfrage an die Methode instances.deleteAccessConfig.

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

3. Fügen Sie der Netzwerkschnittstelle der Instanz eine neue Zugriffskonfiguration hinzu. Stellen Sie dazu eine POST-Anfrage an die Methode instances.addAccessConfig.

   • Stellen Sie für IPv4-Adressen die folgende Anfrage:

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

   • Aktualisieren Sie bei IPv6-Adressen die stackType der Netzwerkschnittstelle auf IPV4_IPV6 und aktualisieren Sie das Attribut networkInterfaces[].ipv6AccessConfigs[].externalIpv6 sowie die externe IPv6-Adresse, die Sie verwenden möchten.

     Weitere Informationen finden Sie unter Statische externe IP-Adresse einer neuen Instanz zuweisen.

Go

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

Externe IP-Adressen auf bestimmte Instanzen beschränken

Für bestimmte Arbeitslasten können grundlegende Anforderungen bestehen, zu denen Sicherheits- und Netzwerkeinschränkungen gehören. Sie haben beispielsweise die Möglichkeit, die externen IP-Adressen so zu beschränken, dass sie nur von bestimmten Compute-Instanzen verwendet werden können. Mit dieser Option können Sie die Daten-Exfiltration verhindern oder die Netzwerkisolation aufrechterhalten. Mithilfe einer Organisationsrichtlinie können Sie externe IP-Adressen auf bestimmte Instanzen beschränken, um die Verwendung externer IP-Adressen für Ihre Instanzen innerhalb einer Organisation oder eines Projekts zu steuern.

Achtung: Wenn Sie externe IP-Adressen auf bestimmte Instanzen beschränken, können vorhandene GKE-Cluster und verwaltete Instanzgruppen (Managed Instance Groups, MIGs) möglicherweise keine neuen Instanzen hinzufügen. Wenn ein GKE-Cluster oder eine MIG so konfiguriert ist, dass Instanzen mit externen IP-Adressen erstellt werden können, funktionieren die automatische Reparatur und das Autoscaling nicht.

Die Einschränkung zur Steuerung externer IP-Adressen auf Instanzen lautet:

constraints/compute.vmExternalIpAccess

Wenn Sie sie verwenden möchten, geben Sie eine Richtlinie mit einer allowedList-Aufstellung der Instanzen an, die externe IP-Adressen haben dürfen. Wenn Sie keine Richtlinie angeben, sind alle externen IP-Adressen für alle Instanzen zulässig. Ist dagegen eine Richtlinie vorhanden, kann nur den Instanzen, die in der allowedValues-Liste enthalten sind, eine sitzungsspezifische oder statische externe IP-Adresse zugewiesen werden. Andere Compute Engine-Instanzen in der Organisation oder dem Projekt, die nicht explizit in der Richtlinie definiert sind, dürfen keine externen IP-Adressen verwenden.

Instanzen werden in den Listen mit zugelassenen oder verbotenen Instanzen anhand ihres URI identifiziert:

projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME

Spezifikationen zum Beschränken externer IP-Adressen

• Sie können die Listeneinschränkung nur auf Instanzen anwenden.
• Die Einschränkung lässt sich nicht rückwirkend anwenden. Alle Instanzen, die externe IP-Adressen haben, bevor Sie die Richtlinie aktivieren, behalten diese.
• Diese Einschränkung akzeptiert entweder eine allowedList- oder eine deniedList-Aufstellung, aber nicht beide in derselben Richtlinie.
• Für die Verwaltung und Pflege des Lebenszyklus und der Integrität der Instanz sind Sie oder ein Administrator mit den entsprechenden Berechtigungen verantwortlich. Die Einschränkung überprüft nur den URI der Instanz und verhindert nicht, dass die Instanzen in der Zulassungsliste geändert, gelöscht oder neu erstellt werden.

Erforderliche Berechtigungen zum Beschränken externer IP-Adressen

Wenn Sie eine Einschränkung auf Projekt- oder Organisationsebene einrichten möchten, müssen Sie in Ihrer Organisation die Rolle orgpolicy.policyAdmin haben.

Richtlinieneinschränkung auf Organisationsebene festlegen

Hinweis: Strings für Instanz-URIs dürfen maximal 200 Zeichen lang sein.

Console

1. Öffnen Sie die Seite Organisationsrichtlinien.

   Zur Seite "Organisationsrichtlinien"

2. Wählen Sie gegebenenfalls die erforderliche Organisation aus dem Drop-down-Menü des Projekts aus.
3. Klicken Sie auf Zulässige externe IPs für VM-Instanzen definieren.
4. Klicken Sie auf Bearbeiten, um die externe IP-Richtlinie zu bearbeiten. Wenn Sie nicht auf Bearbeiten klicken können, fehlen Ihnen die erforderlichen Berechtigungen.

5. Wählen Sie Anpassen aus, um die Organisationsrichtlinie für bestimmte Instanzen festzulegen.

   

6. Wählen Sie die erforderlichen Richtlinienerzwingungen und den erforderlichen Richtlinientyp aus.

7. Wählen Sie für Richtlinienwerte die Option Benutzerdefiniert aus.

8. Geben Sie einen URI für eine Instanz ein. Der URI muss das folgende Format haben:

   projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME
   

9. Klicken Sie auf Neuer Richtlinienwert und geben Sie nach Bedarf URIs für Instanzen ein.

10. Klicken Sie auf Speichern, um die Einschränkung anzuwenden.

gcloud

Wenn Sie eine Einschränkung für den Zugriff auf externe IP-Adressen einrichten möchten, folgen Sie den Anweisungen unten. Sie können die Organisations-ID ermitteln, indem Sie den Befehl organizations list ausführen und in der Antwort nach der numerischen ID suchen:

gcloud organizations list

Die gcloud CLI gibt eine Liste der Organisationen im folgenden Format zurück:

DISPLAY_NAME               ID
example-organization1      29252605212
example-organization2      1234567890

Geben Sie die Richtlinie mit dem Befehl gcloud resource-manager org-policies set-policy an. Sie müssen die Richtlinie als JSON-Datei bereitstellen. Erstellen Sie eine JSON-Datei im folgenden Format:

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

Dabei gilt:

• PROJECT_ID ist die Projekt-ID für diese Anfrage, z. B. example-project. Beachten Sie, dass sich dieser Vorgang vom Einrichten der Organisationsrichtlinien unterscheidet. Hier ist die numerische ID der Organisation erforderlich.
• ZONE: Zone der Instanz
• INSTANCE_NAME ist der Name der Instanz.

Alternativ können Sie eine deniedValues-Liste mit Instanzen angeben, für die Sie externe IP-Adressen explizit ausschließen möchten. Alle Instanzen, die nicht auf der Liste stehen, dürfen dann eine externe IP-Adresse haben. Sie können nur eine der beiden Optionen allowedValues oder deniedValues angeben, aber nicht beide.

Übergeben Sie dann die Datei mit Ihrer Anfrage:

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

Ersetzen Sie ORGANIZATION_ID durch die numerische ID der Organisation.

Wenn keine der Instanzen auf externe IP-Adressen zugreifen können soll, legen Sie eine Richtlinie fest, in der allValues auf DENY gesetzt ist:

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

REST

Verwenden Sie die setOrgPolicy() API, um die Einschränkung zu definieren. Die von Ihnen in die allowedValue-Liste aufgenommenen Instanzen dürfen externe IP-Adressen haben. Alternativ können Sie eine deniedValues-Liste mit Instanzen angeben, für die Sie externe IP-Adressen explizit ausschließen möchten. Alle Instanzen, die nicht auf der Liste stehen, dürfen dann eine externe IP-Adresse haben. Sie können nur eine der beiden Optionen angeben, entweder allowedValues oder deniedValues, aber nicht beide.

Das folgende Beispiel zeigt eine Anfrage zum Anwenden der Einschränkung compute.vmExternalIpAccess für eine Organisation, in der Instanzen aus bestimmten Projekten innerhalb der Organisation externe IP-Adressen haben dürfen:

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

wobei ORGANIZATION_ID die numerische ID der Organisation ist.

Geben Sie nun im Anfragetext die Richtlinie für diese Einschränkung an:

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

Wenn keine der Instanzen auf externe IP-Adressen zugreifen können soll, legen Sie eine Richtlinie fest, in der allValues auf DENY gesetzt ist:

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

Richtlinie auf Projektebene einrichten

Eine auf Projektebene festgelegte Richtlinie überschreibt die Richtlinie auf der Organisationsebene. Wenn beispielsweise auf Organisationsebene die Instanz example-vm-1 auf der allowedValues-Liste steht, in der Richtlinie auf Projektebene dieselbe Instanz jedoch in der deniedValues-Liste enthalten ist, darf die Instanz keine externe IP-Adresse haben.

Console

Führen Sie den gleichen Vorgang aus, der unter Richtlinieneinschränkungen auf Organisationsebene einrichten erläutert wird, aber wählen Sie anstelle der Organisation das Projekt aus der Projektauswahl aus.

gcloud

Geben Sie die Richtlinie mit dem Befehl gcloud resource-manager org-policies set-policy an. Sie müssen die Richtlinie als JSON-Datei bereitstellen. Erstellen Sie eine JSON-Datei im folgenden Format:

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

Dabei gilt:

• PROJECT_ID ist die Projekt-ID für diese Anfrage, z. B. example-project. Beachten Sie, dass sich dieser Vorgang vom Einrichten der Organisationsrichtlinien unterscheidet. Hier ist die numerische ID der Organisation erforderlich.
• ZONE ist die Zone der Instanz.
• INSTANCE_NAME: der Name der Instanz.

Alternativ können Sie eine deniedValues-Liste mit Instanzen angeben, für die Sie externe IP-Adressen explizit ausschließen möchten. Alle Instanzen, die nicht auf der Liste stehen, dürfen dann eine externe IP-Adresse haben. Sie können nur eine der beiden Optionen angeben, entweder allowedValues oder deniedValues, aber nicht beide.

Übergeben Sie dann die Datei mit Ihrer Anfrage:

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

REST

Verwenden Sie die setOrgPolicy API, um die Einschränkung zu definieren. Die von Ihnen in die allowedValue-Liste aufgenommenen Instanzen dürfen externe IP-Adressen haben. Alternativ können Sie eine deniedValues-Liste mit Instanzen angeben, für die Sie externe IP-Adressen explizit ausschließen möchten. Alle Instanzen, die nicht auf der Liste stehen, dürfen eine externe IP-Adresse haben. Sie können nur allowedValues oder deniedValues angeben, aber nicht beide.

Das folgende Beispiel zeigt eine Anfrage zum Einrichten der Einschränkung compute.vmExternalIpAccess für ein Projekt, um für bestimmte Instanzen externe IP-Adressen zuzulassen:

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

Ersetzen Sie PROJECT_ID durch die Projekt-ID für diese Anfrage.

Der Anfragetext enthält die Richtlinie für diese Einschränkung:

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

Best Practices zum Beschränken externer IP-Adressen

• Vermeiden Sie die Verwendung der deniedValues-Liste mit dieser Einschränkung. Wenn Sie Werte in der Liste deniedValues definieren, bedeutet das, dass nur die Instanzen in der Liste deniedValues keine externen IP-Adressen haben dürfen. Dies könnte zu Sicherheitsproblemen führen, wenn Sie genau steuern möchten, welche Instanzen externe IP-Adressen haben dürfen. Wenn Sie bestimmte Instanzen aus der Liste allowedValues entfernen möchten, aktualisieren Sie die vorhandene Richtlinie, um die Instanzen aus der Aufstellung allowedList zu entfernen, statt die Instanzen in die Liste deniedValues mit einer niedrigeren Hierarchie aufzunehmen.

• Wenn Sie eine Richtlinie für einen großen Teil der Ressourcenhierarchie einrichten, aber bestimmte Projekte ausnehmen möchten, stellen Sie die Standardrichtlinie mit der Methode setOrgPolicy wieder her. Geben Sie dazu das Objekt restoreDefault an. Dadurch lassen Sie zu, dass alle Instanzen in den Projekten mit externen IP-Adressen verknüpft werden. Die aktuellen Richtlinien für Projekte sind von der Standardeinstellung nicht betroffen.

• Verwenden Sie die Organisationsrichtlinie zusammen mit IAM-Rollen, um die Umgebung besser zu steuern. Diese Richtlinie gilt nur für Instanzen. Wenn Sie externe IP-Adressen von Netzwerkgeräten jedoch besser kontrollieren und einschränken möchten, können Sie den entsprechenden Nutzern die Rolle compute.networkAdmin gewähren.

• Die Organisationsrichtlinie gilt für alle Dienste und Produkte, die innerhalb der Organisation oder des Projekts in Compute Engine ausgeführt werden und für die die Richtlinie aktiviert ist. Insbesondere sind Dienste wie Google Kubernetes Engine, Dataflow, Dataproc und Cloud SQL von dieser Richtlinie betroffen. Wenn dies ein Problem ist, sollten Sie weitere Dienste und Produkte in einem anderen Projekt einrichten, für das die Organisationsrichtlinie nicht gilt, und bei Bedarf freigegebene VPC verwenden.

Statische externe IP-Adressen verwalten

In den folgenden Abschnitten wird beschrieben, wie Sie statische externe IP-Adressen für Ihre Instanzen verwalten.

Ermitteln, ob eine interne IP-Adresse sitzungsspezifisch oder statisch ist

Statische und sitzungsspezifische interne IP-Adressen verhalten sich in den meisten Kontexten gleich und werden gleich angezeigt. Bei statischen internen IP-Adressen können Sie jedoch dieselbe IP-Adresse für dieselbe Ressource verwenden, auch wenn Sie die Ressource löschen und neu erstellen. Im Allgemeinen wird eine sitzungsspezifische IP-Adresse freigegeben, wenn Sie die Ressource beenden oder löschen.

So ermitteln Sie, ob eine Adresse statisch oder sitzungsspezifisch ist:

1. Rufen Sie in der Google Cloud Console die Seite IP-Adressen auf.

   "IP-Adressen" aufrufen

2. Suchen Sie die Adresse in der Liste und prüfen Sie die Spalte Typ auf den Typ der IP-Adresse.

Zuweisung einer statischen externen IP-Adresse aufheben

Durch das Aufheben der Zuweisung wird die IP-Adresse aus der Ressource entfernt, bleibt aber reserviert. Nachdem die Zuweisung der IP-Adresse aufgehoben wurde, können Sie sie einer anderen Ressource zuweisen. Dieses Verfahren wird für Dual-Stack-Instanzen unterstützt, aber nicht für reine IPv6-Instanzen.

Hinweis: Für nicht zugewiesene statische externe IP-Adressen werden Ihnen höhere Preise berechnet als für genutzte statische und sitzungsspezifische externe IP-Adressen. Weitere Informationen finden Sie unter Preise für externe IP-Adressen.

Sie können die Zuweisung der IPv4- oder IPv6-Adresse auch aufheben, indem Sie die Instanz löschen.

Console

1. Rufen Sie in der Google Cloud Console die Seite IP-Adressen auf.

   "IP-Adressen" aufrufen

2. Klicken Sie auf Externe IP-Adressen.

3. Wählen Sie die statische IP-Adresse aus, deren Zuweisung Sie aufheben möchten.

4. Klicken Sie auf Aktionen ansehen und wählen Sie die Option Auf eine andere Ressource neu zuweisen aus.

5. Wählen Sie aus der Drop-down-Liste Anhängen an die Option Keine aus.

6. Klicken Sie auf OK.

gcloud

1. Mit dem Befehl gcloud compute addresses list können Sie prüfen, ob eine statische IP-Adresse verwendet wird:

   gcloud compute addresses list
   

   Die Ausgabe sieht in etwa so aus:

   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
   

   • Wenn die IP-Adresse nicht verwendet wird, ist der Status RESERVED.
   • Wenn die IP-Adresse verwendet wird, ist der Status IN_USE.

2. Rufen Sie den Namen der Instanz ab, die die IP-Adresse verwendet:

   gcloud compute addresses describe ADDRESS_NAME \
     --region=REGION
   

   Ersetzen Sie Folgendes:

   • ADDRESS_NAME ist der Name der IPv6-Adressressource.
   • REGION ist die Region der IPv6-Adressressource.

   Die Ausgabe sieht in etwa so aus:

   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/INSTANCE_NAME
   

   Das Feld users zeigt den Namen der Instanz an, die die IP-Adresse verwendet.

3. Heben Sie die Zuweisung der IP-Adresse zur Instanz auf.

   • Löschen Sie die Zugriffskonfigurationsdatei der Instanz, um die Zuweisung einer IPv4-Adresse aufzuheben:

     1. Rufen Sie den Namen der Zugriffskonfiguration ab, die Sie löschen möchten. Verwenden Sie den Befehl gcloud compute instances describe, um den Namen abzurufen. Ersetzen Sie INSTANCE_NAME durch den Namen der Instanz.

        gcloud compute instances describe INSTANCE_NAME
        

        Die Zugriffskonfiguration wird im folgenden Format ausgegeben:

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

        Hinweis: Der name Ihrer Zugriffskonfiguration kann sich von external-nat unterscheiden: Achten Sie daher darauf, dass es sich um Ihren eigenen Zugriffskonfigurationsnamen handelt. In manchen Fällen wird eine ältere Version des Zugriffskonfigurationsnamens verwendet, etwa External NAT.

     2. Löschen Sie die Zugriffskonfiguration mit dem Befehl gcloud compute instances delete-access-config:

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

        Ersetzen Sie Folgendes:

        • INSTANCE_NAME: der Name der Instanz.
        • ACCESS_CONFIG_NAME ist der Name der Zugriffskonfiguration, die Sie löschen möchten. Der vollständige Name muss in Anführungszeichen angegeben werden.

   • Verwenden Sie den Befehl instance network-interfaces update, um die Zuweisung eines IPv6-Adressbereichs aufzuheben:

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

     Ersetzen Sie Folgendes:

     • INSTANCE_NAME ist der Name der Instanz, die die IP-Adresse verwendet.
     • ZONE ist die Zone der Instanz.

4. Überprüfen Sie, ob Ihre statische externe IP-Adresse nun verfügbar und anstelle von IN_USE als RESERVED gekennzeichnet ist.

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

   Ersetzen Sie Folgendes:

   • ADDRESS_NAME: der Name der IP-Adressressource.
   • REGION: die Region der IP-Adressressource.

Nachdem Ihre statische externe IP-Adresse jetzt verfügbar ist, können Sie sie einer anderen Instanz zuweisen.

REST

Führen Sie die folgenden Schritte aus, um die Zuweisung einer statischen externen IPv4- oder IPv6-Adresse aufzuheben:

• Löschen Sie bei IPv4-Adressen die Zugriffskonfiguration, die der Instanz zugeordnet ist, die die Adresse verwendet.

  1. Senden Sie eine GET-Anfrage an die Methode instances.get, um die Details der Zugriffskonfiguration einer Instanz zu prüfen.

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

  2. Löschen Sie die vorhandene Zugriffskonfiguration. Senden Sie dazu eine POST-Anfrage an die Methode instances.deleteAccessConfig.

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

     Ersetzen Sie Folgendes:

     • PROJECT_ID ist die Projekt-ID für diese Anfrage.
     • ZONE: Die Zone, in der sich die Instanz befindet.
     • INSTANCE_NAME ist der Name der Instanz.

• Aktualisieren Sie bei IPv6-Adressen den Stacktyp der Netzwerkschnittstelle für die Instanz, an die die IPv6-Adresse angehängt ist.

  1. Stellen Sie eine PATCH-Anfrage an die Methode instances.updateNetworkInterface.

  2. Aktualisieren Sie im Anfragetext den Wert des Felds stackType in IPV4_ONLY.

     Beispiel:

     PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_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

Statische externe IP-Adresse freigeben

Wenn Sie eine statische externe IPv4- oder IPv6-Adresse nicht mehr benötigen, können Sie die IP-Adresse freigeben. Löschen Sie dazu die IP-Adressressource. Durch das Löschen einer Instanz wird nicht automatisch eine statische externe IP-Adresse freigegeben. Sie müssen nicht mehr benötigte statische interne IP-Adressen manuell freigeben.

Informationen zum Freigeben einer statischen externen IP-Adresse finden Sie in der VPC-Dokumentation unter Statische externe IP-Adresse freigeben.

Nächste Schritte

• Weitere Informationen zu IP-Adressen
• Weitere Informationen zu Netzwerken und Firewalls
• Weitere Informationen zum Adressieren von Compute Engine-Instanzen mit internem DNS
• Preise für VPC