Diese Seite wurde von der Cloud Translation API übersetzt.

Statische externe IP-Adresse reservieren

Sie können statische externe IP-Adressen reservieren. Sie können auch Ihre reservierten statischen externen IP-Adressen auflisten und freigeben. Informationen zum Zuweisen einer statischen externen IP-Adresse zu einer VM-Instanz finden Sie unter Statische externe IP-Adressen konfigurieren.

Externe IP-Adressen können statisch oder sitzungsspezifisch sein. Wenn für eine VM eine feste externe IP-Adresse erforderlich ist, die sich nicht ändert, können Sie eine statische externe IP-Adresse abrufen. Sie können neue externe IP-Adressen reservieren oder vorhandene sitzungsspezifische externe IP-Adressen umwandeln.

Wenn Sie eine statische interne IP-Adresse benötigen, lesen Sie stattdessen den Artikel Statische interne 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 so authentifizieren.
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

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.
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 finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten in der Dokumentation zur Google Cloud-Authentifizierung.
REST

Verwenden Sie die von der gcloud CLI bereitgestellten Anmeldedaten, um die REST API-Beispiele auf dieser Seite in einer lokalen Entwicklungsumgebung zu verwenden.
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 den Compute-Netzwerkadministrator (roles/compute.networkAdmin) zu gewähren, um die Berechtigungen zu erhalten, die Sie zum Reservieren und Verwalten von statischen IP-Adressen benötigen. Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierte Rolle enthält die Berechtigungen, die zum Reservieren 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.addresses.create für die IP-Adresse
compute.addresses.createInternal für die IP-Adresse
compute.networks.list für das Netzwerk
compute.subnetworks.use für das Subnetz
compute.subnetworks.list für das Subnetz

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

Statische externe IP-Adressen

Eine statische externe IP-Adresse ist die IP-Adresse, die so lange für Ihre Ressource reserviert ist, bis Sie diese freigeben. Wenn Sie eine IP-Adresse haben, über die Ihre Kunden oder Nutzer regelmäßig auf Ihren Dienst zugreifen, können Sie diese reservieren, damit nur Ihre Ressource sie nutzen kann. Sie können auch eine sitzungsspezifische externe IP-Adresse in eine statische externe IP-Adresse umwandeln.

Weitere Informationen finden Sie unter IP-Adressen.

In der folgenden Tabelle sind die von Google Cloud unterstützten statischen externen IP-Adressen aufgeführt.

IP-Adresstyp	Ressource	IP-Bereich	Quelle	Verknüpft mit
Regionale externe IPv4-Adressen	VMs und regionale Load Balancer	`/32`	Pool externer IP-Adressen von Google	Projekt
Regionale externe IPv6-Adressen	VMs und unterstützte regionale Load Balancer	`/96`	Externer IPv6-Adressbereich des Subnetzes	Subnetz
Globale externe IPv4-Adressen	Globale Load Balancer	`/32`	Pool externer IP-Adressen von Google	Projekt
Globale externe IPv6-Adressen	Globale Load Balancer	`/64`	Pool externer IP-Adressen von Google	Projekt

Eine Liste der regionalen und globalen Load Balancer finden Sie unter Zusammenfassung der Load Balancer-Typen.

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 die folgenden IP-Adressen zugewiesen werden:
- Eine interne IPv4-Adresse (erforderlich)
- Eine externe IPv4-Adresse
- Ein /96-IPv6-Adressbereich, entweder intern oder extern, aber nicht beides
Der Name einer statischen IP-Adresse kann nicht geändert werden.
Zugewiesene externe IP-Adressen befinden sich für alle Zwecke auf dem gleichen physischen Host wie die VM und in derselben Region wie die VM, einschließlich Routing, Latenz und Preise. Dies gilt unabhängig von den Lookup-Informationen für die Internet-Standortbestimmung.

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).

Neue statische externe IP-Adresse reservieren

Nachdem Sie die Adresse reserviert haben, weisen Sie sie einer neuen VM zu, wenn Sie sie erstellen, oder einer vorhandenen VM.

Console

Rufen Sie in der Google Cloud Console die Seite IP-Adressen auf.
"IP-Adressen" aufrufen
Klicken Sie auf Externe statische IP-Adresse reservieren.
Geben Sie im Feld Name einen Namen für die IP-Adresse ein.
Geben Sie an, ob die Netzwerkdienststufe Premium oder Standard ist. Die Reservierung der statischen IPv6-Adresse wird nur in der Premium-Stufe unterstützt.
Geben Sie an, ob es sich um eine IPv4- oder IPv6-Adresse handelt.
Legen Sie fest, ob diese IP-Adresse regional oder global ist.
- Wenn Sie eine statische IP-Adresse für einen globalen Load Balancer reservieren, wählen Sie Global aus und klicken Sie dann auf Reservieren.
- Wenn Sie eine statische IP-Adresse für eine VM oder für einen regionalen Load Balancer reservieren, wählen Sie Regional und dann die Region aus, in der die Adresse erstellt werden soll.
Wenn Sie eine regionale externe IPv6-Adresse reservieren, wählen Sie außerdem Folgendes aus:
- Netzwerk: das VPC-Netzwerk
- Subnetzwerk: das Subnetz, aus dem die statische regionale IPv6-Adresse zugewiesen wird
- Endpunkttyp: Wählen Sie VM-Instanz oder Network Load Balancer aus.
Optional: Wenn Sie die statische externe IP-Adresse für eine VM reservieren, wählen Sie in der Liste Zugeordnet zu eine VM aus, an die die IP-Adresse angehängt werden soll.
Klicken Sie auf Reservieren, um die IP-Adresse zu reservieren.

gcloud

Verwenden Sie den Befehl gcloud compute addresses create, um eine statische externe IP-Adresse zu reservieren.

Verwenden Sie die folgende Anleitung, um eine statische externe IPv4- oder IPv6-Adresse zu reservieren:

Globale IP-Adresse

So reservieren Sie eine globale IP-Adresse:

  gcloud compute addresses create ADDRESS_NAME \
      --global \
      --ip-version [IPV4 | IPV6]

Regionale externe IPv4-Adresse

So reservieren Sie eine regionale externe IPv4-Adresse:

   gcloud compute addresses create ADDRESS_NAME \
       --region=REGION

Regionale externe IPv6-Adresse

So reservieren Sie eine regionale externe IPv6-Adresse:

   gcloud compute addresses create ADDRESS_NAME \
       --region=REGION \
       --subnet=SUBNET_NAME \
       --ip-version=IPV6 \
       --endpoint-type=[VM | NETLB]

Ersetzen Sie Folgendes:

ADDRESS_NAME ist der Name, den Sie mit dieser Adresse verknüpfen möchten.
REGION: Geben Sie für regionale externe IP-Adressen die Region an, in der Sie diese Adresse reservieren möchten. Die Region muss sich in derselben Region befinden wie die Ressource, der Sie die IP-Adresse zuweisen möchten.
SUBNET_NAME: Geben Sie für regionale externe IPv6-Adressen das Subnetz an, aus dem die statische regionale IPv6-Adresse zugewiesen werden soll. Das Subnetz muss einen zugewiesenen externen IPv6-Adressbereich haben.
[IPV4 | IPV6]: Geben Sie für globale IP-Adressen die IP-Version an, entweder IPv4 oder IPv6. Geben Sie für regionale externe IPv6-Adressen IPv6 an. Ein IPv6-Bereich /96 wird aus dem angegebenen Subnetz zugewiesen.
VM | NETLB: Geben Sie für regionale externe IPv6-Adressen den Endpunkttyp an. sei es eine VM oder ein Netzwerk-Load-Balancer.

Verwenden Sie den Befehl gcloud compute addresses describe, um das Ergebnis anzeigen zu lassen:

gcloud compute addresses describe ADDRESS_NAME

Terraform

Sie können mit der Ressource google_compute_address eine regionale externe IP-Adresse erstellen.

resource "google_compute_address" "default" {
  name   = "my-test-static-ip-address"
  region = "us-central1"
}

Das folgende Beispiel zeigt, wie Sie mit der Ressource google_compute_global_address eine globale externe IPv6-Adresse erstellen:

resource "google_compute_global_address" "default" {
  project      = var.project_id # Replace this with your service project ID in quotes
  name         = "ipv6-address"
  address_type = "EXTERNAL"
  ip_version   = "IPV6"
}

API

Rufen Sie zum Erstellen einer regionalen IPv4-Adresse die regionale Methode addresses.insert auf:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses
```
Ihre Anfrage sollte folgenden Text enthalten:
```
{
  "name": "ADDRESS_NAME"
}
```
Ersetzen Sie Folgendes:
- PROJECT_ID ist die Projekt-ID für diese Anfrage.
- REGION ist der Name der Region für diese Anfrage.
- ADDRESS_NAME ist der Name, den Sie mit der Adresse verknüpfen möchten.
Rufen Sie für globale statische IPv4-Adressen die Methode globalAddresses.insert auf:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses
```
Ihre Anfrage sollte folgenden Text enthalten:
```
{
  "name": "ADDRESS_NAME"
}
```
Rufen Sie für globale statische IPv6-Adressen die Methode globalAddresses.insert auf:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses
```
Ihre Anfrage sollte folgenden Text enthalten:
```
{
  "name": "ADDRESS_NAME",
  "ipVersion": "IPV6"
}
```
Verwenden Sie die Methode addresses.get, um das Ergebnis anzuzeigen.
Rufen Sie für globale statische IPv6-Adressen die Methode addresses.insert auf:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses
```
Ihre Anfrage sollte folgenden Text enthalten:
```
{
  "name": "ADDRESS_NAME",
  "ipVersion": "IPV6",
  "ipv6EndpointType": "VM|LB",
  "networkTier": "PREMIUM",
  "subnetwork": "SUBNET"
}
```
Ersetzen Sie SUBNET durch das Subnetz für dieses Projekt.

Verwenden Sie die Methode addresses.get, um das Ergebnis anzuzeigen.

Go

import (
	"context"
	"fmt"
	"io"

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

// reserveNewRegionalExternal reserves a new regional external IP address in Google Cloud Platform.
func reserveNewRegionalExternal(w io.Writer, projectID, region, addressName string, isPremium bool) (*computepb.Address, error) {
	// projectID := "your_project_id"
	// region := "europe-central2"
	// addressName := "your_address_name"
	// isPremium := true
	ctx := context.Background()

	networkTier := computepb.AccessConfig_STANDARD.String()
	if isPremium {
		networkTier = computepb.AccessConfig_PREMIUM.String()
	}

	address := &computepb.Address{
		Name:        &addressName,
		NetworkTier: &networkTier,
	}

	client, err := compute.NewAddressesRESTClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewAddressesRESTClient: %w", err)
	}
	defer client.Close()

	req := &computepb.InsertAddressRequest{
		Project:         projectID,
		Region:          region,
		AddressResource: address,
	}

	op, err := client.Insert(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("unable to reserve regional address: %w", err)
	}

	err = op.Wait(ctx)
	if err != nil {
		return nil, fmt.Errorf("waiting for the regional address reservation operation to complete: %w", err)
	}

	addressResult, err := client.Get(ctx, &computepb.GetAddressRequest{
		Project: projectID,
		Region:  region,
		Address: addressName,
	})
	if err != nil {
		return nil, fmt.Errorf("unable to get reserved regional address: %w", err)
	}

	fmt.Fprintf(w, "Regional address %v reserved: %v", addressName, addressResult.GetAddress())

	return addressResult, err
}

// reserveNewGlobalExternal reserves a new global external IP address in Google Cloud Platform.
func reserveNewGlobalExternal(w io.Writer, projectID, addressName string, isV6 bool) (*computepb.Address, error) {
	// projectID := "your_project_id"
	// addressName := "your_address_name"
	// isV6 := false
	ctx := context.Background()
	ipVersion := computepb.Address_IPV4.String()
	if isV6 {
		ipVersion = computepb.Address_IPV6.String()
	}

	address := &computepb.Address{
		Name:      &addressName,
		IpVersion: &ipVersion,
	}

	client, err := compute.NewGlobalAddressesRESTClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewGlobalAddressesRESTClient: %w", err)
	}
	defer client.Close()

	req := &computepb.InsertGlobalAddressRequest{
		Project:         projectID,
		AddressResource: address,
	}

	op, err := client.Insert(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("unable to reserve global address: %w", err)
	}

	err = op.Wait(ctx)
	if err != nil {
		return nil, fmt.Errorf("waiting for the global address reservation operation to complete: %w", err)
	}

	addressResult, err := client.Get(ctx, &computepb.GetGlobalAddressRequest{
		Project: projectID,
		Address: addressName,
	})
	if err != nil {
		return nil, fmt.Errorf("unable to get reserved global address: %w", err)
	}

	fmt.Fprintf(w, "Global address %v reserved: %v", addressName, addressResult.GetAddress())

	return addressResult, nil
}

Java


import com.google.cloud.compute.v1.Address;
import com.google.cloud.compute.v1.Address.AddressType;
import com.google.cloud.compute.v1.Address.IpVersion;
import com.google.cloud.compute.v1.Address.NetworkTier;
import com.google.cloud.compute.v1.AddressesClient;
import com.google.cloud.compute.v1.GlobalAddressesClient;
import com.google.cloud.compute.v1.InsertAddressRequest;
import com.google.cloud.compute.v1.InsertGlobalAddressRequest;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ReserveNewExternalAddress {

  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";
    // Address name you want to use.
    String addressName = "your-address-name";
    // 'IPV4' or 'IPV6' depending on the IP version. IPV6 if True. Option only for global regions.
    boolean ipV6 = false;
    // 'STANDARD' or 'PREMIUM' network tier. Standard option available only in regional ip.
    boolean isPremium = false;
    // region (Optional[str]): The region to reserve the IP address in, if regional.
    // Must be None if global.
    String region = null;

    reserveNewExternalIpAddress(projectId, addressName, ipV6, isPremium, region);
  }

  // Reserves a new external IP address in the specified project and region.
  public static List<Address> reserveNewExternalIpAddress(String projectId, String addressName,
                                                          boolean ipV6, boolean isPremium,
                                                          String region)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {

    String ipVersion = ipV6 ? IpVersion.IPV6.name() : IpVersion.IPV4.name();
    String networkTier = !isPremium && region != null
            ? NetworkTier.STANDARD.name() : NetworkTier.PREMIUM.name();

    Address.Builder address = Address.newBuilder()
            .setName(addressName)
            .setAddressType(AddressType.EXTERNAL.name())
            .setNetworkTier(networkTier);

    // Use global client if no 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 (GlobalAddressesClient client = GlobalAddressesClient.create()) {
        address.setIpVersion(ipVersion);

        InsertGlobalAddressRequest addressRequest = InsertGlobalAddressRequest.newBuilder()
                .setProject(projectId)
                .setRequestId(UUID.randomUUID().toString())
                .setAddressResource(address.build())
                .build();

        client.insertCallable().futureCall(addressRequest).get(30, TimeUnit.SECONDS);

        return Lists.newArrayList(client.list(projectId).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 (AddressesClient client = AddressesClient.create()) {
        address.setRegion(region);

        InsertAddressRequest addressRequest = InsertAddressRequest.newBuilder()
                .setProject(projectId)
                .setRequestId(UUID.randomUUID().toString())
                .setAddressResource(address.build())
                .setRegion(region)
                .build();

        client.insertCallable().futureCall(addressRequest).get(30, TimeUnit.SECONDS);

        return Lists.newArrayList(client.list(projectId, region).iterateAll());
      }
    }
  }
}

Python

from typing import 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 reserve_new_external_ip_address(
    project_id: str,
    address_name: str,
    is_v6: bool = False,
    is_premium: bool = False,
    region: Optional[str] = None,
):
    """
    Reserves a new external IP address in the specified project and region.

    Args:
    project_id (str): Your Google Cloud project ID.
    address_name (str): The name for the new IP address.
    is_v6 (bool): 'IPV4' or 'IPV6' depending on the IP version. IPV6 if True.
    is_premium (bool): 'STANDARD' or 'PREMIUM' network tier. Standard option available only in regional ip.
    region (Optional[str]): The region to reserve the IP address in, if regional. Must be None if global.

    Returns:
    None
    """

    ip_version = "IPV6" if is_v6 else "IPV4"
    network_tier = "STANDARD" if not is_premium and region else "PREMIUM"

    address = Address(
        name=address_name,
        address_type="EXTERNAL",
        network_tier=network_tier,
    )
    if not region:  # global IP address
        client = GlobalAddressesClient()
        address.ip_version = ip_version
        operation = client.insert(project=project_id, address_resource=address)
    else:  # regional IP address
        address.region = region
        client = AddressesClient()
        operation = client.insert(
            project=project_id, region=region, address_resource=address
        )

    operation.result()

    print(f"External IP address '{address_name}' reserved successfully.")

Sitzungsspezifische externe IP-Adresse umwandeln

Wenn Ihre VM eine sitzungsspezifische externe IP-Adresse hat und Sie diese dauerhaft Ihrem Projekt zuweisen möchten, wandeln Sie die sitzungsspezifische externe IP-Adresse in eine statische externe IP-Adresse um. Das Umwandeln einer sitzungsspezifischen externen IP-Adresse in eine reservierte führt nicht dazu, dass Google Cloud an die VM gesendete Pakete verwirft. Dies gilt auch für Pakete, die direkt oder über einen Load-Balancer an die VM gesendet werden.

Console

Wechseln Sie zur Seite IP-Adressen.
"IP-Adressen" aufrufen
Klicken Sie auf Externe IP-Adressen.
Optional: Suchen Sie im Feld Filter nach der sitzungsspezifischen IP-Adresse, die Sie hochstufen möchten.
Wählen Sie im Menü Weitere Aktionen () der IP-Adresse, die Sie hochstufen möchten, die Option In statische IP-Adresse umwandeln.
Geben Sie einen Namen für die neue statische IP-Adresse ein und klicken Sie auf Reservieren.

gcloud

Verwenden Sie die folgende Anleitung, um eine statische externe IPv4- oder IPv6-Adresse umzuwandeln:

Wenn Sie eine sitzungsspezifische externe IPv4-Adresse in eine statische externe IPv4-Adresse umwandeln möchten, geben Sie die sitzungsspezifische externe IP-Adresse mit dem Flag --addresses mit dem Befehl compute addresses create an. Mit dem Flag region können Sie eine sitzungsspezifische regionale IP-Adresse umwandeln und mit dem Flag global können Sie dies für eine sitzungsspezifische globale IP-Adresse tun.
```
gcloud compute addresses create ADDRESS_NAME --addresses=IP_ADDRESS \
    [--region=REGION | --global]
```
Ersetzen Sie Folgendes:
- ADDRESS_NAME ist der Name, den Sie mit dieser Adresse verknüpfen möchten.
- IP_ADDRESS: die IP-Adresse, die Sie umwandeln möchten.
- REGION: die Region, zu der die regionale IP-Adresse gehört.
Wenn Sie eine sitzungsspezifische regionale externe IPv6-Adresse in eine statische regionale externe IPv6-Adresse umwandeln möchten, geben Sie die sitzungsspezifische externe IP-Adresse mit dem Flag --addresses mit dem Befehl gcloud compute addresses create an.
```
gcloud compute addresses create ADDRESS_NAME \
  --region=REGION \
  --addresses=IPV6_ADDRESS \
  --prefix-length=96
```
Ersetzen Sie Folgendes:
- ADDRESS_NAME ist der Name der IP-Adressressource.
- REGION ist die Region für die IPv6-Adressressource.
- IPV6_ADDRESS ist die IPv6-Adresse, die Sie umwandeln.

API

Rufen Sie zum Umwandeln einer sitzungsspezifischen regionalen IP-Adresse die Methode addresses.insert auf:

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

Zum Umwandeln einer sitzungsspezifischen globalen IP-Adresse stellen Sie eine POST-Anfrage an den folgenden URI:

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

Geben Sie die Werte für die Pflichtfelder des Anfragetexts an:

Bei IPv4-Adressen sollte der Anfragetext die folgenden Felder enthalten:

{
  "name": "ADDRESS_NAME",
  "address": "IPV4_ADDRESS"
  "addressType": "EXTERNAL"
}

Bei IPv6-Adressen sollte der Anfragetext die folgenden Felder enthalten:
```
{
  "name": "ADDRESS_NAME",
  "address": "IPV6_ADDRESS"
  "prefixLength": 96
  "addressType": "EXTERNAL"
}
```
Ersetzen Sie Folgendes:
- ADDRESS_NAME ist der Name, den Sie mit dieser Adresse verknüpfen möchten.
- IPV4_ADDRESS|IPV6_ADDRESS: die IPv4- oder IPv6-Adresse, die Sie umwandeln möchten.
- REGION: die Region, zu der die IPv4- oder IPv6-Adresse gehört.
- PROJECT_ID ist die Projekt-ID für diese Anfrage.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

// promoteEphemeralAddress promotes an ephemeral IP address to a reserved static external IP address.
func promoteEphemeralAddress(w io.Writer, projectID, region, ephemeralIP, addressName string) error {
	// projectID := "your_project_id"
	// region := "europe-central2"
	// ephemeral_ip := "214.123.100.121"
	ctx := context.Background()

	client, err := compute.NewAddressesRESTClient(ctx)
	if err != nil {
		return fmt.Errorf("NewAddressesRESTClient: %w", err)
	}
	defer client.Close()

	addressResource := &computepb.Address{
		Name:        proto.String(addressName),
		AddressType: proto.String("EXTERNAL"),
		Address:     proto.String(ephemeralIP),
	}

	req := &computepb.InsertAddressRequest{
		Project:         projectID,
		Region:          region,
		AddressResource: addressResource,
	}

	op, err := client.Insert(ctx, req)
	if err != nil {
		return fmt.Errorf("failed to insert address promoted: %v", err)
	}

	// Wait for the operation to complete
	err = op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("failed to complete promotion operation: %v", err)
	}

	fmt.Fprintf(w, "Ephemeral IP %s address promoted successfully", ephemeralIP)
	return nil
}

Java


import com.google.cloud.compute.v1.Address;
import com.google.cloud.compute.v1.Address.AddressType;
import com.google.cloud.compute.v1.AddressesClient;
import com.google.cloud.compute.v1.InsertAddressRequest;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class PromoteEphemeralIp {

  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";
    // Ephemeral IP address to promote.
    String ephemeralIp = "your-ephemeralIp";
    // Name of the address to assign.
    String addressName = "your-addressName";

    promoteEphemeralIp(projectId, region, ephemeralIp, addressName);
  }

  // Promote ephemeral IP found on the instance to a static IP.
  public static List<Address> promoteEphemeralIp(String projectId, String region,
                                                 String ephemeralIp, String addressName)
          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 (AddressesClient client = AddressesClient.create()) {
      Address addressResource = Address.newBuilder()
              .setName(addressName)
              .setRegion(region)
              .setAddressType(AddressType.EXTERNAL.name())
              .setAddress(ephemeralIp)
              .build();

      InsertAddressRequest addressRequest = InsertAddressRequest.newBuilder()
              .setRegion(region)
              .setProject(projectId)
              .setAddressResource(addressResource)
              .setRequestId(UUID.randomUUID().toString())
              .build();

      client.insertCallable().futureCall(addressRequest).get(30, TimeUnit.SECONDS);

      return Lists.newArrayList(client.list(projectId, region).iterateAll());
    }
  }
}

Python

import uuid

from google.cloud.compute_v1 import AddressesClient
from google.cloud.compute_v1.types import Address


def promote_ephemeral_ip(project_id: str, ephemeral_ip: str, region: str):
    """
    Promote ephemeral IP found on the instance to a static IP.

    Args:
        project_id (str): Project ID.
        ephemeral_ip (str): Ephemeral IP address to promote.
        region (str): Region where the VM and IP is located.
    """
    addresses_client = AddressesClient()

    # Create a new static IP address using existing ephemeral IP
    address_resource = Address(
        name=f"ip-reserved-{uuid.uuid4()}",  # new name for promoted IP address
        region=region,
        address_type="EXTERNAL",
        address=ephemeral_ip,
    )
    operation = addresses_client.insert(
        project=project_id, region=region, address_resource=address_resource
    )
    operation.result()

    print(f"Ephemeral IP {ephemeral_ip} has been promoted to a static IP.")

Die externe IP-Adresse bleibt an die VM gebunden, auch wenn sie in eine statische externe IP-Adresse umgewandelt wurde. Wenn die kürzlich umgewandelte statische externe IP-Adresse einer anderen IP-Adresse zugewiesen werden soll, müssen Sie die Zuweisung der statischen IP-Adresse an eine bestehende VM aufheben.

Statische externe IP-Adressen auflisten

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

Console

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

"IP-Adressen" aufrufen
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-Adresse beschreiben

So rufen Sie Informationen zu einer statischen externen IP-Adresse ab:

Console

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

"IP-Adressen" aufrufen
Klicken Sie auf Externe IP-Adressen.
Klicken Sie auf die IP-Adresse, zu der Sie weitere Informationen erhalten möchten.

gcloud

Verwenden Sie den Befehl gcloud compute addresses describe und ersetzen Sie ADDRESS_NAME durch den Namen der externen IP-Adresse, die Sie beschreiben möchten.

Verwenden Sie für eine globale IPv4- oder IPv6-Adresse den folgenden Befehl:
```
gcloud compute addresses describe ADDRESS_NAME --global
```
Verwenden Sie für eine regionale IPv4- oder IPv6-Adresse den folgenden Befehl:
```
gcloud compute addresses describe ADDRESS_NAME --region=REGION
```

API

Rufen Sie zum Beschreiben einer regionalen IPv4- oder IPv6-Adresse die Methode addresses.get auf:
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses/ADDRESS_NAME
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die Projekt-ID für die Anfrage.
- REGION ist der Name der Region für diese Anfrage.
- ADDRESS_NAME ist der Name der IP-Adresse.
Rufen Sie zum Beschreiben einer globalen IPv4- oder IPv6-Adresse die Methode globalAddresses.get auf:
```
GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses/ADDRESS_NAME
```
Ersetzen Sie Folgendes:
- PROJECT_ID: die Projekt-ID für die Anfrage.
- ADDRESS_NAME ist der Name der IP-Adresse.

Go

import (
	"context"
	"fmt"
	"io"

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

// getExternalAddress retrieves the external IP address of the given address.
func getRegionalExternal(w io.Writer, projectID, region, addressName string) (*computepb.Address, error) {
	// projectID := "your_project_id"
	// region := "europe-west3"
	// addressName := "your_address_name"

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

	req := &computepb.GetAddressRequest{
		Project: projectID,
		Region:  region,
		Address: addressName,
	}

	address, err := addressesClient.Get(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("unable to get address: %w", err)
	}

	fmt.Fprintf(w, "Regional address %s has external IP address: %s\n", addressName, address.GetAddress())

	return address, nil
}

func getGlobalExternal(w io.Writer, projectID, addressName string) (*computepb.Address, error) {

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

	req := &computepb.GetGlobalAddressRequest{
		Project: projectID,
		Address: addressName,
	}

	address, err := globalAddressesClient.Get(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("unable to get address: %w", err)
	}

	fmt.Fprintf(w, "Global address %s has external IP address: %s\n", addressName, address.GetAddress())

	return address, nil
}

Java


import com.google.cloud.compute.v1.Address;
import com.google.cloud.compute.v1.AddressesClient;
import com.google.cloud.compute.v1.GetAddressRequest;
import com.google.cloud.compute.v1.GetGlobalAddressRequest;
import com.google.cloud.compute.v1.GlobalAddressesClient;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeoutException;

public class GetStaticIpAddress {

  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";
    // Name of the address to assign.
    String addressName = "your-addressName";

    getStaticIpAddress(projectId, region, addressName);
  }

  // Retrieves a static external IP address, either regional or global.
  public static Address getStaticIpAddress(String projectId, String region, String addressName)
          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()) {
        GetAddressRequest request = GetAddressRequest.newBuilder()
                .setProject(projectId)
                .setRegion(region)
                .setAddress(addressName)
                .build();

        return client.get(request);
      }
    } 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()) {
        GetGlobalAddressRequest request = GetGlobalAddressRequest.newBuilder()
                .setProject(projectId)
                .setAddress(addressName)
                .build();

        return client.get(request);
      }
    }
  }
}

Python

from typing import 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 get_static_ip_address(
    project_id: str, address_name: str, region: Optional[str] = None
) -> Address:
    """
    Retrieves a static external IP address, either regional or global.

    Args:
    project_id (str): project ID.
    address_name (str): The name of the IP address.
    region (Optional[str]): The region of the IP address if it's regional. None if it's global.

    Raises: google.api_core.exceptions.NotFound: in case of address not found

    Returns:
    Address: The Address object containing details about the requested IP.
    """
    if region:
        # Use regional client if a region is specified
        client = AddressesClient()
        address = client.get(project=project_id, region=region, address=address_name)
    else:
        # Use global client if no region is specified
        client = GlobalAddressesClient()
        address = client.get(project=project_id, address=address_name)

    return address

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.

Wenn Sie die Google Cloud Console verwenden, können Sie statische IP-Adressen nur freigeben, wenn sie nicht von anderen Ressourcen verwendet werden.

Wenn Sie die gcloud CLI oder API verwenden, können Sie eine IP-Adresse freigeben, unabhängig davon, ob sie von einer anderen Ressource verwendet wird oder nicht.

Wenn die IP-Adresse nicht von einer Ressource verwendet wird, wird sie an den Pool der verfügbaren externen IP-Adressen zurückgegeben.
Wenn die IP-Adresse von einer Ressource verwendet wird, bleibt sie an die Ressource gebunden, bis die Ressource gelöscht wird.

Console

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

"IP-Adressen" aufrufen
Klicken Sie auf Externe IP-Adressen.
Optional: Geben Sie im Feld Filter static ein und wählen Sie dann im Drop-down-Menü Statisch : Typ aus.
Wählen Sie die statische externe IP-Adresse aus, die Sie freigeben möchten.
Klicken Sie auf Statische Adresse freigeben.

Falls diese Option nicht angezeigt wird, klicken Sie in der oberen Menüleiste auf Weitere Aktionen () und wählen Sie anschließend Statische Adresse freigeben aus der Liste aus.

gcloud

Führen Sie den Befehl compute addresses delete aus:

gcloud compute addresses delete ADDRESS_NAME

Ersetzen Sie ADDRESS_NAME durch den Namen der freizugebenden IPv4- oder IPv6-Adresse.

API

Rufen Sie die Methode addresses.delete auf, um eine regionale IPv4- oder IPv6-Adresse freizugeben:
```
DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses/ADDRESS_NAME
```
Ersetzen Sie Folgendes:
- PROJECT_ID ist die Projekt-ID für diese Anfrage.
- REGION ist der Name der Region für diese Anfrage.
- ADDRESS_NAME ist der Name der IP-Adresse.
Rufen Sie die Methode globalAddresses.delete auf, um eine regionale IPv4- oder IPv6-Adresse freizugeben:
```
DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/addresses/ADDRESS_NAME
```
Ersetzen Sie Folgendes:
- ADDRESS_NAME ist der Name der IP-Adresse.
- PROJECT_ID ist die Projekt-ID für diese Anfrage.

Go

import (
	"context"
	"fmt"
	"io"

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

// releaseRegionalStaticExternal releases a static regional external IP address.
func releaseRegionalStaticExternal(w io.Writer, projectID, region, addressName string) error {
	// projectID := "your_project_id"
	// region := "us-central1"
	// addressName := "your_address_name"

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

	req := &computepb.DeleteAddressRequest{
		Project: projectID,
		Region:  region,
		Address: addressName,
	}

	op, err := addressesClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to release static external IP address: %w", err)
	}

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

	fmt.Fprintf(w, "Static external IP address released\n")

	return nil
}

// releaseGlobalStaticExternal releases a static global external IP address.
func releaseGlobalStaticExternal(w io.Writer, projectID, addressName string) error {
	// projectID := "your_project_id"
	// addressName := "your_address_name"

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

	req := &computepb.DeleteGlobalAddressRequest{
		Project: projectID,
		Address: addressName,
	}

	op, err := addressesClient.Delete(ctx, req)
	if err != nil {
		return fmt.Errorf("unable to release static external IP address: %w", err)
	}

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

	fmt.Fprintf(w, "Static external IP address released\n")

	return nil
}

Java


import com.google.cloud.compute.v1.AddressesClient;
import com.google.cloud.compute.v1.DeleteAddressRequest;
import com.google.cloud.compute.v1.DeleteGlobalAddressRequest;
import com.google.cloud.compute.v1.GlobalAddressesClient;
import com.google.cloud.compute.v1.Operation;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ReleaseStaticAddress {

  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";
    // The region to reserve the IP address in, if regional. Must be None if global
    String region = "your-region =";
    // Name of the address to release.
    String addressName = "your-addressName";

    releaseStaticAddress(projectId, addressName, region);
  }

  // Releases a static external IP address that is currently reserved.
  // This action requires that the address is not being used by any forwarding rule.
  public static void releaseStaticAddress(String projectId, String addressName, String region)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    Operation operation;
    // Use global client if no 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 (GlobalAddressesClient client = GlobalAddressesClient.create()) {
        DeleteGlobalAddressRequest request = DeleteGlobalAddressRequest.newBuilder()
                .setProject(projectId)
                .setAddress(addressName)
                .build();

        operation = client.deleteCallable().futureCall(request).get(30, TimeUnit.SECONDS);
      }
    } 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 (AddressesClient client = AddressesClient.create()) {
        DeleteAddressRequest request = DeleteAddressRequest.newBuilder()
                .setProject(projectId)
                .setRegion(region)
                .setAddress(addressName)
                .build();

        operation = client.deleteCallable().futureCall(request).get(30, TimeUnit.SECONDS);
      }
    }
    if (operation.hasError()) {
      System.out.printf("Can't release external IP address '%s'. Caused by : %s",
              addressName, operation.getError());
    }
    System.out.printf("External IP address '%s' released successfully.", addressName);
  }
}

Python

from typing import Optional

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


def release_external_ip_address(
    project_id: str,
    address_name: str,
    region: Optional[str] = None,
) -> None:
    """
    Releases a static external IP address that is currently reserved.
    This action requires that the address is not being used by any forwarding rule.

    Args:
        project_id (str): project ID.
        address_name (str): name of the address to release.
        region (Optional[str]): The region to reserve the IP address in, if regional. Must be None if global.


    """
    if not region:  # global IP address
        client = GlobalAddressesClient()
        operation = client.delete(project=project_id, address=address_name)
    else:  # regional IP address
        client = AddressesClient()
        operation = client.delete(
            project=project_id, region=region, address=address_name
        )

    operation.result()
    print(f"External IP address '{address_name}' released successfully.")

Nächste Schritte

Statische externe IP-Adressen für eine neue oder vorhandene VM konfigurieren
Mehr zu den IP-Adressspezifikationen für Weiterleitungsregeln und zur Verwendung von Weiterleitungsregeln finden Sie in der Übersicht über Weiterleitungsregeln.
Weitere Informationen zu IP-Adressen
Preise für VPC