静的外部 IP アドレスの予約

静的外部 IP アドレスを予約できます。予約した静的外部 IP アドレスを一覧取得して解放することもできます。仮想マシン（VM）インスタンスに静的外部 IP アドレスを割り当てるには、静的外部 IP アドレスを構成するをご覧ください。

外部 IP アドレスには、静的なものとエフェメラルなものがあります。変更されない固定外部 IP アドレスが VM に必要な場合、静的外部 IP アドレスを取得できます。新しい外部 IP アドレスを予約することも、既存のエフェメラル外部 IP アドレスを昇格させることもできます。

静的内部 IP アドレスが必要な場合は、静的内部 IP アドレスを予約するをご覧ください。

始める前に

• IP アドレスの詳細をご覧ください。
• 静的外部 IP アドレスの割り当てと上限をご覧ください。
• 外部 IP アドレスの料金をご覧ください。
• まだ設定していない場合は、認証を設定します。認証とは、Google Cloud サービスと API にアクセスするために ID を確認するプロセスです。ローカル開発環境からコードまたはサンプルを実行するには、次のように認証を行います。

  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

  ローカル開発環境でこのページの Terraform サンプルを使用するには、gcloud CLI をインストールして初期化し、ユーザー認証情報を使用してアプリケーションのデフォルト認証情報を設定します。

  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.

  詳細については、Google Cloud の認証に関するドキュメントのローカル開発環境の認証の設定をご覧ください。

  REST

  このページの REST API サンプルをローカル開発環境で使用するには、gcloud CLI に指定した認証情報を使用します。

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

  gcloud init

  詳細については、Google Cloud 認証ドキュメントの REST を使用して認証するをご覧ください。

必要なロール

静的 IP アドレスの予約と管理に必要な権限を取得するには、プロジェクトに対する Compute ネットワーク管理者（roles/compute.networkAdmin）の IAM ロールを付与するよう管理者に依頼してください。ロールの付与については、プロジェクト、フォルダ、組織へのアクセス権の管理をご覧ください。

この事前定義ロールには、静的 IP アドレスの予約と管理に必要な権限が含まれています。必要とされる正確な権限については、「必要な権限」セクションを開いてご確認ください。

必要な権限

静的 IP アドレスの予約と管理には、次の権限が必要です。

• IP アドレスに対する compute.addresses.create
• IP アドレスに対する compute.addresses.createInternal
• ネットワークに対する compute.networks.list
• サブネットに対する compute.subnetworks.use
• サブネットに対する compute.subnetworks.list

カスタムロールや他の事前定義ロールを使用して、これらの権限を取得することもできます。

静的外部 IP アドレスについて

静的外部 IP アドレスはプロジェクト用に予約される IP アドレスであり、解放するまで予約されたままになります。お客様やユーザーがサービスにアクセスする際に利用する IP アドレスがある場合、該当リソースでのみ使用できるようにその IP アドレスを予約できます。また、エフェメラル外部 IP アドレスを静的外部 IP アドレスに昇格させることもできます。

詳細については、IP アドレスをご覧ください。

注: 静的外部 IP アドレスは、VM や外部転送ルールなどのリソースに関連付けるまで、公共のインターネットに公開されません。

次の表に、Google Cloud でサポートされている静的外部 IP アドレスを示します。

IP アドレスの種類	リソース	IP 範囲	ソース	関連付け
リージョン外部 IPv4 アドレス	VM とリージョン ロードバランサ	/32	Google の外部 IP アドレスのプール	プロジェクト
リージョン外部 IPv6 アドレス	VM とサポートされているリージョン ロードバランサ	/96	サブネットの外部 IPv6 アドレス範囲	サブネット
グローバル外部 IPv4 アドレス	グローバル ロードバランサ	/32	Google の外部 IP アドレスのプール	プロジェクト
グローバル外部 IPv6 アドレス	グローバル ロードバランサ	/64	Google の外部 IP アドレスのプール	プロジェクト

リージョン ロードバランサとグローバル ロードバランサの一覧については、ロードバランサ タイプのサマリーをご覧ください。

制限事項

• 一度に複数のリソースが同じ静的外部 IP アドレスを使用することはできません。

• IP アドレスをリソースに割り当てた後に、その IP アドレスが静的であるかエフェメラルであるかを確認する方法はありません。IP アドレスと、そのプロジェクトに予約されている静的外部 IP アドレスのリストを比較することは可能です。プロジェクトで使用可能な静的外部 IP アドレスのリストを表示するには、gcloud compute addresses list サブコマンドを使用します。

• 各 VM は複数のネットワーク インターフェースを持つことができ、各インターフェースには次の IP アドレスを割り振ることができます。

  • 内部 IPv4 アドレス（必須）
  • 外部 IPv4 アドレス
  • /96 IPv6 アドレス範囲（内部または外部のどちらか一方）

• 静的 IP アドレスの名前は変更できません。

• 割り当てられた外部 IP アドレスは、VM と同じ物理ホストに存在し、すべての用途（ルーティング、レイテンシ、料金設定など）の VM と同じリージョンに存在します。これは、インターネットの位置情報に関する検索情報に関係なく当てはまります。

注: ネットワーク インターフェースは複数の転送ルールからトラフィックを受信できますが、ルールの中には他の外部 IP アドレスを対象とするものもあります。これらの転送ルールによって任意の数の外部 IP アドレスがネットワーク インターフェースを参照できますが、各ネットワーク インターフェースには、外部 IPv4 アドレスを 1 つと、外部の /96 IPv6 アドレス範囲を 1 つだけ割り振ることができます。

ロード バランシングと転送ルールの詳細については、ロード バランシングのドキュメントをご覧ください。

新しい静的外部 IP アドレスを予約する

アドレスを予約した後、予約したアドレスを作成中の新しい VM または既存の VM に割り当てます。

注: 静的外部 IP アドレスを予約しても、VM や転送ルールなどのリソースに割り当てない場合は、使用中の静的外部 IP アドレスやエフェメラル外部 IP アドレスよりも高い料金が課金されます。詳細については、外部 IP アドレスの料金をご覧ください。

コンソール

1. Google Cloud コンソールで、[IP アドレス] ページに移動します。

   [IP アドレス] に移動

2. [静的外部 IP アドレスを予約] をクリックします。
3. [名前] フィールドに IP アドレス名を入力します。
4. ネットワーク サービス ティアがプレミアムかスタンダードかを指定します。IPv6 静的アドレス予約は、プレミアム ティアでのみサポートされます。
5. IPv4 アドレスか IPv6 アドレスかを指定します。
6. この IP アドレスがリージョン アドレスかグローバル アドレスかを指定します。
   • グローバル ロードバランサに静的 IP アドレスを予約する場合は、[グローバル] を選択して [予約] をクリックします。
   • VM またはリージョン ロードバランサ用に静的 IP アドレスを予約する場合は、[リージョン] を選択し、アドレスを作成するリージョンを選択します。

7. リージョン外部 IPv6 アドレスを予約する場合は、以下も選択します。

   • ネットワーク: VPC ネットワーク
   • サブネットワーク: 静的リージョン IPv6 アドレスを割り当てるサブネット
   • エンドポイントのタイプ: [VM インスタンス] または [ネットワーク ロードバランサ] を選択します

8. （省略可）VM インスタンス用の静的外部 IP アドレスを予約する場合は、[割り当て先] リストで IP アドレスを割り当てる VM インスタンスを選択します。

9. [予約] をクリックして IP アドレスを予約します。

gcloud

静的外部 IP アドレスを予約するには、gcloud compute addresses create コマンドを使用します。

静的外部 IPv4 アドレスまたは静的外部 IPv6 アドレスを予約するには、次の手順を使用します。

注: グローバル IP アドレスは、グローバル ロードバランサでのみ使用できます。

グローバル IP アドレス

グローバル IP アドレスを予約するには:

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

リージョン外部 IPv4 アドレス

リージョン外部 IPv4 アドレスを予約するには:

   gcloud compute addresses create ADDRESS_NAME \
       --region=REGION
   

リージョン外部 IPv6 アドレス

リージョン外部 IPv6 アドレスを予約するには:

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

次のように置き換えます。

• ADDRESS_NAME: このアドレスに関連付ける名前。
• REGION: リージョン外部 IP アドレスの場合は、このアドレスを予約するリージョンを指定します。これは、IP アドレスを割り振るリソースと同じリージョンにする必要があります。
• SUBNET_NAME: リージョン外部 IPv6 アドレスの場合は、静的リージョン IPv6 アドレスの割り振り元のサブネットを指定します。サブネットには、割り当てられた外部 IPv6 アドレス範囲が必要です。
• [IPV4 | IPV6]: グローバル IP アドレスの場合は、IP バージョン（IPv4 または IPv6）を指定します。リージョン外部 IPv6 アドレスの場合は、IPv6 を指定します。/96 IPv6 範囲は、指定されたサブネットから割り当てられます。
• VM | NETLB: リージョン外部 IPv6 アドレスの場合は、エンドポイント タイプ（VM またはネットワーク ロードバランサ）を指定します。

結果を表示するには、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": "PREMIUM",
    "subnetwork": "SUBNET"
  }
  

  SUBNET は、このプロジェクトのサブネットに置き換えます。

  結果を表示するには、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. 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.")

エフェメラル外部 IP アドレスを昇格させる

VM にエフェメラル外部 IP アドレスがあり、その IP アドレスを永続的にプロジェクトに割り当てる必要がある場合は、エフェメラル外部 IP アドレスを静的外部 IP アドレスに昇格させます。エフェメラル外部 IP アドレスを予約済みに昇格しても、Google Cloud では VM に送信されたパケットは破棄されません。これは、VM に直接送信されたパケットとロードバランサによって送信されたパケットの両方について該当します。

コンソール

1. [IP アドレス] ページに移動します。

   [IP アドレス] に移動

2. [外部 IP アドレス] をクリックします。
3. （省略可）[フィルタ] フィールドで、昇格するエフェメラル IP アドレスを検索します。
4. 昇格させる IP アドレスの [その他の操作] メニュー（）で、[静的 IP アドレスに昇格] を選択します。
5. 新しい静的 IP アドレスの名前を入力し、[予約] をクリックします。

gcloud

静的外部 IPv4 アドレスまたは静的外部 IPv6 アドレスを昇格させるには、次の手順を使用します。

• エフェメラル外部 IPv4 アドレスを静的外部 IPv4 アドレスに昇格させるには、compute addresses create コマンドで --addresses フラグを使用してエフェメラル外部 IP アドレスを指定します。エフェメラル リージョン IP アドレスを昇格させる場合は region フラグ、エフェメラル グローバル IP アドレスを昇格させる場合は global フラグを使用します。

  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 アドレス] ページに移動します。

   [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 アドレス] ページに移動します。

   [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 アドレス] ページに移動します。

   [IP アドレス] に移動

2. [外部 IP アドレス] をクリックします。

3. 省略可: [フィルタ] フィールドに「static」と入力し、プルダウン リストから [静的: タイプ] を選択します。

4. 解放する静的外部 IP アドレスを選択します。

5. [静的アドレスを解放] をクリックします。

   このオプションが表示されない場合は、上部のメニューバーにある [その他の操作] メニュー（）をクリックし、リストから [静的アドレスを解放] を選択します。

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 または既存の VM の静的外部 IP アドレスを構成する方法を学習する。
• 転送ルールの IP アドレスの仕様と転送ルールを使用する方法については、「転送ルールの概要」をご覧ください。
• IP アドレスについて学習する。
• VPC の料金を確認する