保留靜態外部 IP 位址

您可以預留靜態外部 IP 位址。您也可以列出及釋出預留的靜態外部 IP 位址。如要將靜態外部 IP 位址指派給虛擬機器 (VM) 執行個體，請參閱「設定靜態外部 IP 位址」。

外部 IP 位址可以是靜態或臨時。如果 VM 需要固定的外部 IP 位址，您可以取得靜態外部 IP 位址。您可以預留新的外部 IP 位址，或將現有的臨時外部 IP 位址升級。

如需靜態內部 IP 位址，請改為參閱「預留靜態內部 IP 位址」。

本頁面說明如何從 Google 的外部 IP 位址集區保留靜態外部 IP 位址。如要瞭解如何保留透過自備 IP (BYOIP) 位址匯入的靜態外部 IP 位址，請參閱「自備 IP 位址」。

事前準備

• 瞭解 IP 位址。
• 瞭解靜態外部 IP 位址的配額和限制。
• 瞭解外部 IP 位址定價。
• 如果尚未設定驗證，請先完成設定。驗證是驗證身分的程序，可讓您存取 Google Cloud 服務和 API。如要從本機開發環境執行程式碼或範例，可以按照下列步驟進行驗證。

  請根據您打算如何使用本頁範例，選取對應的分頁標籤：

  控制台

  使用 Google Cloud 控制台存取 Google Cloud 服務和 API 時，不需要設定驗證機制。

  gcloud

  安裝 Google Cloud CLI。 安裝完成後，請執行下列指令，初始化 Google Cloud CLI：

  gcloud init

  如果採用外部識別資訊提供者 (IdP)，必須先 使用聯合身分登入 gcloud CLI。

  注意：如果您已經安裝 gcloud CLI，請務必執行 gcloud components update，確認您安裝的是最新版本。

  Terraform

  如要在本機開發環境中使用本頁的 Terraform 範例，請安裝並初始化 gcloud CLI，然後使用使用者憑證設定應用程式預設憑證。

  1. 安裝 Google Cloud CLI。

  2. 若您採用的是外部識別資訊提供者 (IdP)，請先 使用聯合身分登入 gcloud CLI。

  3. 如果您使用的是本機殼層，請為使用者帳戶建立本機驗證憑證：

     gcloud auth application-default login

     如果您使用的是 Cloud Shell，則不必執行這項操作。

     如果系統傳回驗證錯誤，且您使用的是外部識別資訊提供者 (IdP)，請確認您已 使用聯合身分登入 gcloud CLI。

  詳情請參閱 Google Cloud 驗證說明文件中的「 為本機開發環境設定 ADC」。

  REST

  如要在本機開發環境中使用本頁的 REST API 範例，請使用您提供給 gcloud CLI 的憑證。

  安裝 Google Cloud CLI。

  如果採用外部識別資訊提供者 (IdP)，必須先 使用聯合身分登入 gcloud CLI。

  詳情請參閱 Google Cloud 驗證說明文件中的「使用 REST 進行驗證」一節。

必要的角色

如要取得保留及管理靜態 IP 位址所需的權限，請要求管理員授予您專案的 Compute 網路管理員 (roles/compute.networkAdmin) IAM 角色。如要進一步瞭解如何授予角色，請參閱「管理專案、資料夾和組織的存取權」。

這個預先定義的角色具備預留及管理靜態 IP 位址所需的權限。如要查看確切的必要權限，請展開「Required permissions」(必要權限) 部分：

所需權限

必須具備下列權限，才能預留及管理靜態 IP 位址：

• compute.addresses.create IP 位址
• compute.addresses.createInternal IP 位址
• compute.networks.list 網路
• compute.subnetworks.use 子網路
• compute.subnetworks.list 子網路

您或許還可透過自訂角色或其他預先定義的角色取得這些權限。

關於靜態外部 IP 位址

靜態外部 IP 位址是一種資源，可保留 IP 位址供專案中的其他資源使用。保留的位址會維持固定，並可供客戶和服務使用，直到您決定釋出為止。您也可以將臨時外部 IP 位址升級為靜態外部 IP 位址。

詳情請參閱「IP 位址」。

注意： Google 提供的靜態外部 IP 位址不會向公開網際網路公告，除非您將這些位址與資源建立關聯，例如 VM 或外部轉送規則。

下表列出Google Cloud支援的靜態外部 IP 位址。

IP 位址類型	資源	IP 範圍	來源	關聯資源數
區域性外部 IPv4 位址	VM 和區域性負載平衡器	/32	Google 的外部 IP 位址集區，或透過 BYOIP 匯入	專案
區域性外部 IPv6 位址	VM 和支援的區域性負載平衡器	/96	子網路的外部 IPv6 位址範圍，可來自 Google 的外部 IP 位址集區，或透過 BYOIP 匯入	子網路
全域外部 IPv4 位址	全域負載平衡器	/32	Google 的外部 IP 位址集區，或透過 BYOIP 匯入	專案
全域外部 IPv6 位址	全域負載平衡器	/64	Google 的外部 IP 位址集區	專案

如需區域性和全域負載平衡器清單，請參閱「負載平衡器類型摘要」。

指派的外部 IP 位址與 VM 位於相同的實體主機，且與 VM 位於相同的區域，適用於所有用途，包括轉送、延遲和定價。無論網際網路地理位置查詢資訊為何，都是如此。

限制

• 一次只有一個資源可使用靜態外部 IP 位址。

• 每個運算執行個體可以有多個網路介面，每個介面可以根據其堆疊類型指派下列 IP 位址：

  • 僅限 IPv4 的介面：
    • 內部 IPv4 位址 (必要)
    • 外部 IPv4 位址 (選用)
  • 雙重堆疊 (IPv4 和 IPv6) 介面：
    • 內部 IPv4 位址 (必要)
    • 外部 IPv4 位址 (選用)
    • /96 IPv6 位址範圍，內部或外部，但不能兩者皆有 (必要)
  • 僅限 IPv6 的介面：
    • /96 IPv6 位址範圍，可以是內部或外部，但不能兩者皆是 (必要)

• 如果運算執行個體具有僅限 IPv6 的網路介面，您就無法取消指派或變更外部 IPv6 位址。不過，您可以將資源的臨時外部 IP 位址升級為靜態外部 IP 位址，這樣即使資源刪除後，位址仍會保留。

• 靜態 IP 位址的名稱無法變更。

附註：網路介面可接收來自多個轉送規則的流量，這些規則可能適用於其他外部 IP 位址。任意數量的外部 IP 位址都可以透過這些轉送規則參照網路介面，但每個網路介面只能指派一個外部 IPv4 位址和一個外部 /96 IPv6 位址範圍。

如要進一步瞭解負載平衡和轉送規則，請參閱負載平衡文件。

預留新的靜態外部 IP 位址

保留位址後，請在建立新 VM 時指派位址，或指派給現有 VM。

注意： 如果您保留了靜態外部 IP 位址，卻未將該位址指派給任一資源 (例如 VM 或轉送規則)，該位址的費用則高於使用中的靜態和臨時外部 IP 位址。詳情請參閱「外部 IP 位址定價」。

注意： Google Cloud 控制台不支援選取 IPv6 網路級別。如要明確將外部 IPv6 位址設為標準級 (預先發布版)，請使用 gcloud CLI 或 API。

控制台

1. 前往 Google Cloud 控制台的「IP addresses」(IP 位址) 頁面。

   前往「IP addresses」(IP 位址) 頁面

2. 按一下「保留外部」。
3. 在「Name」(名稱) 欄位中，輸入 IP 位址名稱。
4. 指定網路服務級別為「Premium」或「Standard」。
5. 指定 IPv4 或 IPv6 位址。
6. 指定這個 IP 位址是「區域性」還是「全域」。
   • 如要為全域負載平衡器保留靜態 IP 位址，請選擇「Global」(全域)，然後按一下「Reserve」(保留)。
   • 如要為 VM 或區域性負載平衡器保留靜態 IP 位址，請選擇「Regional」(區域性)，然後選取要建立位址的區域。

7. 如要保留區域性外部 IPv6 位址，請一併選擇下列項目：

   • 網路：虛擬私有雲網路
   • 子網路：要從中指派靜態區域 IPv6 位址的子網路

   • 「Static IPv6 range」(靜態 IPv6 範圍)：如要指定要保留的靜態外部 IPv6 位址範圍，請選取「Let me choose」(讓我選擇)，然後從子網路的 /64 外部 IPv6 位址範圍輸入自訂 /96 IPv6 位址範圍。否則，系統會自動在子網路中為您指派靜態外部 IPv6 位址範圍。

     如果是 Google 提供的外部 IPv6 子網路範圍，VM 的 IP 位址必須來自子網路 /64 外部 IPv6 位址範圍的前半部 (/65)，負載平衡的 IP 位址則必須來自後半部 (/65)。詳情請參閱「外部 IPv6 規格」。

   • 「端點類型」：選擇「VM 執行個體」或「外部直通式網路負載平衡器」

8. 選用：如要為 VM 保留靜態外部 IP 位址，請在「Attached to」(連結至) 清單中，選取要連結 IP 位址的 VM。

9. 按一下「Reserve」(保留)，保留 IP 位址。

gcloud

如要保留靜態外部 IP 位址，請使用 gcloud compute addresses create 指令。

請按照下列操作說明，保留靜態外部 IPv4 或 IPv6 位址：

注意： 全域 IP 位址只能與全域負載平衡器搭配使用。

• 如要保留全域外部 IP 位址，請使用 --global 旗標：

  gcloud compute addresses create ADDRESS_NAME \
    --global \
    --ip-version=IP_VERSION
  

  更改下列內容：

  • ADDRESS_NAME：要與這個位址建立關聯的名稱。
  • IP_VERSION：IP 版本，可以是 IPv4 或 IPv6。

• 如要保留區域性外部 IPv4 位址，請使用 --region 旗標指定區域：

  gcloud compute addresses create ADDRESS_NAME \
     --region=REGION
  

  更改下列內容：

  • ADDRESS_NAME：要與這個位址建立關聯的名稱。
  • REGION：IP 位址的區域。

• 如要保留區域性外部 IPv6 位址，請執行下列任一操作：

  • 如要從子網路自動分配區域性外部 IPv6 位址，請為 --ip-version 旗標指定 IPV6：

  gcloud compute addresses create ADDRESS_NAME \
      --region=REGION \
      --subnet=SUBNET_NAME \
      --ip-version=IPV6 \
      --endpoint-type=ENDPOINT_TYPE
  

  • 如要從子網路保留特定區域性外部 IPv6 位址，請指定 --addresses 旗標。請勿加入 --ip-version 旗標：

  gcloud compute addresses create ADDRESS_NAME \
      --region=REGION \
      --subnet=SUBNET_NAME \
      --endpoint-type=ENDPOINT_TYPE \
      --addresses=IPV6_ADDRESS
  

  更改下列內容：

  • ADDRESS_NAME：要與這個位址建立關聯的名稱。
  • REGION：IP 位址的區域。
  • SUBNET_NAME：要從中指派靜態區域 IPv6 位址的子網路。子網路必須指派外部 IPv6 位址範圍。
  • ENDPOINT_TYPE：如果是區域性外部 IPv6 位址，請指定端點類型，VM 或 NETLB。

  • IPV6_ADDRESS：要保留的 IPv6 位址，必須是子網路中的 /96 IPv6 位址範圍。

    如果是 Google 提供的外部 IPv6 子網路範圍，VM 的 IP 位址必須來自子網路 /64 外部 IPv6 位址範圍的前半部 (/65)，負載平衡的 IP 位址則必須來自後半部 (/65)。詳情請參閱「外部 IPv6 規格」。

如要查看結果，請使用 gcloud compute addresses describe 指令：

gcloud compute addresses describe ADDRESS_NAME

Terraform

您可以使用 google_compute_address 資源建立區域性外部 IP 位址。

注意： 除非您自備 IP 位址，否則無法在預留程序中加入特定 IP 位址。

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

下列範例說明如何使用 google_compute_global_address 資源建立全域外部 IPv6 位址：

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

• 如要建立區域性 IPv4 位址，請呼叫區域性 addresses.insert 方法：

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

  要求內容應包含以下程式碼：

  {
    "name": "ADDRESS_NAME"
  }
  

  更改下列內容：

  • PROJECT_ID：這項要求的專案 ID
  • REGION：這項要求的區域名稱
  • ADDRESS_NAME：要與位址建立關聯的名稱

• 如為全域靜態 IPv4 位址，請呼叫 globalAddresses.insert 方法：

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

  要求內容應包含以下程式碼：

  {
    "name": "ADDRESS_NAME"
  }
  

• 如為全域靜態 IPv6 位址，請呼叫 globalAddresses.insert 方法：

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

  要求內容應包含以下程式碼：

  {
    "name": "ADDRESS_NAME",
    "ipVersion": "IPV6"
  }
  

  如要查看結果，請使用 addresses.get 方法。

• 如為區域靜態 IPv6 位址，請呼叫 addresses.insert 方法：

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

  要求內容應包含以下程式碼：

  {
    "name": "ADDRESS_NAME",
    "ipVersion": "IPV6",
    "ipv6EndpointType": "VM|LB",
    "networkTier": "IPV6_NETWORK_TIER",
    "subnetwork": "SUBNET"
    "address": "IPV6_ADDRESS"
  }
  

  更改下列內容：

  • IPV6_NETWORK_TIER：子網路的網路服務級別。可以是 STANDARD (預先發布版) 或 PREMIUM。
  • SUBNET：這項專案的子網路。

  • IPV6_ADDRESS：要保留的 IPv6 位址，必須是子網路中的 /96 IPv6 位址範圍。如未指定，系統會自動分配 IP 位址。

    如果是 Google 提供的外部 IPv6 子網路範圍，VM 的 IP 位址必須來自子網路 /64 外部 IPv6 位址範圍的前半部 (/65)，負載平衡的 IP 位址則必須來自後半部 (/65)。詳情請參閱「外部 IPv6 規格」。

  如要查看結果，請使用 addresses.get 方法。

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

升級暫時外部 IP 位址

如果 VM 具有臨時外部 IP 位址，且您想將該 IP 位址永久指派給專案，請將臨時外部 IP 位址升級為靜態外部 IP 位址。將臨時外部 IP 位址升級為保留位址，不會導致 Google Cloud 捨棄傳送至 VM 的封包。包括直接傳送至 VM 或透過負載平衡器傳送的封包。

控制台

1. 前往「IP addresses」(IP 位址) 頁面。

   前往「IP addresses」(IP 位址) 頁面

2. 按一下「外部 IP 位址」。
3. 選用：在「Filter」(篩選器) 欄位中，搜尋要升級的臨時 IP 位址。
4. 在要升級的 IP 位址「More actions」(更多動作) 選單 () 中，選取「Promote to static IP address」(升級為靜態 IP 位址)。
5. 輸入新的靜態 IP 位址名稱，然後按一下「Reserve」(預留)。

gcloud

請按照下列操作說明，將靜態外部 IPv4 或 IPv6 位址升級：

• 如要將臨時外部 IPv4 位址升級為靜態外部 IPv4 位址，請使用 compute addresses create 指令搭配 --addresses 旗標，提供臨時外部 IP 位址。使用 region 旗標升級臨時區域性 IP 位址，或使用 global 旗標升級臨時全域 IP 位址。

  gcloud compute addresses create ADDRESS_NAME --addresses=IP_ADDRESS \
      [--region=REGION | --global]
  

  更改下列內容：

  • ADDRESS_NAME：要與這個位址建立關聯的名稱。
  • IP_ADDRESS：要升級的 IP 位址。
  • REGION：區域性 IP 位址所屬的區域。

• 如要將臨時區域性外部 IPv6 位址升級為靜態區域性外部 IPv6 位址，請使用 gcloud compute addresses create 指令搭配 --addresses 旗標，提供臨時外部 IP 位址。

  gcloud compute addresses create ADDRESS_NAME \
    --region=REGION \
    --addresses=IPV6_ADDRESS \
    --prefix-length=96
  

  更改下列內容：

  • ADDRESS_NAME：IP 位址資源的名稱。
  • REGION：IPv6 位址資源的區域。
  • IPV6_ADDRESS：要升級的 IPv6 位址。

API

如要升級臨時區域性 IP 位址，請呼叫 addresses.insert 方法：

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

如要推送臨時通用 IP 位址，請對以下 URI 發出 POST 要求：

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

指定要求主體必填欄位的值：

• 如果是 IPv4 位址，要求主體應包含下列欄位：

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

• 如果是 IPv6 位址，要求主體應包含下列欄位：

  {
    "name": "ADDRESS_NAME",
    "address": "IPV6_ADDRESS"
    "prefixLength": 96
    "addressType": "EXTERNAL"
  }
  

  更改下列內容：

  • ADDRESS_NAME：要與這個位址建立關聯的名稱
  • IPV4_ADDRESS|IPV6_ADDRESS：要升級的 IPv4 或 IPv6 位址
  • REGION：IPv4 或 IPv6 位址所屬的區域
  • PROJECT_ID：這項要求的專案 ID

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

即使外部 IP 位址已升級為靜態外部 IP 位址，仍會保持附加至 VM。如要將新升級的靜態外部 IP 位址指派給其他資源，請取消指派現有 VM 的靜態外部 IP 位址。

列出靜態外部 IP 位址

如要列出您為專案保留的靜態外部 IP 位址，請按照下列步驟操作。

控制台

1. 前往 Google Cloud 控制台的「IP addresses」(IP 位址) 頁面。

   前往「IP addresses」(IP 位址) 頁面

2. 按一下「外部 IP 位址」。

gcloud

使用 gcloud compute addresses list 指令：

• 如要列出所有 IP 位址，請使用下列指令：

  gcloud compute addresses list

• 如要列出所有全域 IP 位址，請使用下列指令：

  gcloud compute addresses list --global

• 如要列出指定區域中的所有區域性 IP 位址，請使用下列指令：

  gcloud compute addresses list \
      --regions=REGION
  

  將 REGION 替換為要列出位址的區域。如要列出多個區域的位址，請指定以半形逗號分隔的區域名稱：

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

API

• 如要列出區域 IPv4 或 IPv6 位址，請呼叫 addresses.list 方法：

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

  更改下列內容：

  • PROJECT_ID：這項要求的專案 ID
  • REGION：這項要求的區域名稱

• 如要列出所有區域中的所有位址，請呼叫 addresses.aggregatedList 方法：

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

• 如要列出全域 IPv4 或 IPv6 位址，請呼叫 globalAddresses.list 方法：

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

  更改下列內容：

  PROJECT_ID：這項要求的專案 ID

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

描述靜態外部 IP 位址

如要取得靜態外部 IP 位址的相關資訊，請按照下列步驟操作。

控制台

1. 前往 Google Cloud 控制台的「IP addresses」(IP 位址) 頁面。

   前往「IP addresses」(IP 位址) 頁面

2. 按一下「外部 IP 位址」。

3. 按一下要進一步瞭解的 IP 位址。

gcloud

使用 gcloud compute addresses describe 指令。將 ADDRESS_NAME 替換成要說明的外部 IP 位址名稱。

• 如要取得全域 IPv4 或 IPv6 位址，請使用下列指令：

  gcloud compute addresses describe ADDRESS_NAME --global

• 如要取得區域性 IPv4 或 IPv6 位址，請使用下列指令：

  gcloud compute addresses describe ADDRESS_NAME --region=REGION

API

• 如要描述區域 IPv4 或 IPv6 位址，請呼叫 addresses.get 方法：

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

  更改下列內容：

  • PROJECT_ID：要求的專案 ID
  • REGION：要求的區域名稱
  • ADDRESS_NAME：IP 位址的名稱

• 如要描述全域 IPv4 或 IPv6 位址，請呼叫 globalAddresses.get 方法：

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

  更改下列內容：

  • PROJECT_ID：要求的專案 ID
  • ADDRESS_NAME：IP 位址的名稱

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

釋出靜態外部 IP 位址

如果不再需要靜態外部 IPv4 或 IPv6 位址，可以刪除 IP 位址資源，釋出 IP 位址。

如果使用 Google Cloud 控制台，只有在其他資源未使用靜態 IP 位址時，才能釋出該位址。

如果使用 gcloud CLI 或 API，無論 IP 位址是否由其他資源使用，您都可以釋出該位址。

• 如果資源未使用該 IP 位址，系統會將該 IP 位址傳回可用的外部 IP 位址集區。

• 如果 IP 位址正由資源使用，則會保持附加至資源，直到資源刪除為止。

重要事項： 釋出 IP 位址後，您可能無法保留相同的靜態 IPv4 或 IPv6 位址，因為其他使用者可能已保留該位址。

控制台

1. 前往 Google Cloud 控制台的「IP addresses」(IP 位址) 頁面。

   前往「IP addresses」(IP 位址) 頁面

2. 按一下「外部 IP 位址」。

3. 選用：在「Filter」(篩選器) 欄位中輸入 static，然後從下拉式選單中選取「Static : Type」(靜態：類型)。

4. 選取要釋出的靜態外部 IP 位址。

5. 按一下「釋出靜態位址」。

   如果沒有看到這個選項，請按一下頂端選單列中的「More actions」(更多動作) 選單 ()，然後從清單中選取「Release static address」(釋出靜態位址)。

gcloud

使用 compute addresses delete 指令：

gcloud compute addresses delete ADDRESS_NAME

將 ADDRESS_NAME 替換為要釋出的 IPv4 或 IPv6 位址名稱。

API

• 如要釋出區域 IPv4 或 IPv6 位址，請呼叫 addresses.delete 方法：

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

  更改下列內容：

  • PROJECT_ID：這項要求的專案 ID
  • REGION：這項要求的區域名稱
  • ADDRESS_NAME：IP 位址的名稱

• 如要釋出全域 IPv4 或 IPv6 位址，請呼叫 globalAddresses.delete 方法：

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

  更改下列內容：

  • ADDRESS_NAME：IP 位址的名稱
  • PROJECT_ID：這項要求的專案 ID

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

後續步驟

• 瞭解如何為新的或現有的 VM 設定靜態外部 IP 位址。
• 如要瞭解轉送規則的 IP 位址規格，以及如何使用轉送規則，請參閱「轉送規則總覽」。
• 進一步瞭解 IP 位址。