고정 외부 IP 주소 예약

고정 외부 IP 주소를 예약할 수 있습니다. 예약된 고정 외부 IP 주소를 나열하고 해제할 수도 있습니다. 고정 외부 IP 주소를 가상 머신(VM) 인스턴스에 할당하려면 고정 외부 IP 주소 구성을 참조하세요.

외부 IP 주소는 고정 또는 임시 주소일 수 있습니다. VM에 변경되지 않는 고정 외부 IP 주소가 필요한 경우 고정 외부 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 주소의 목록을 확인하려면 gcloud compute addresses list 하위 명령어를 사용합니다.

• 각 VM에는 네트워크 인터페이스가 여러 개 있을 수 있으며 각 인터페이스에는 다음 IP 주소가 할당될 수 있습니다.

  • 내부 IPv4 주소(필수)
  • 외부 IPv4 주소
  • /96 IPv6 주소 범위(내부 또는 외부 중 하나)

• 고정 IP 주소 이름을 변경할 수 없습니다.

• 할당된 외부 IP 주소는 VM과 동일한 물리적 호스트에 존재하고, 라우팅, 지연 시간, 가격 책정을 포함한 모든 목적을 위해 VM과 동일한 리전에 존재합니다. 이는 인터넷 위치정보 조회 정보에 관계없이 적용됩니다.

참고: 네트워크 인터페이스는 여러 전달 규칙으로부터 트래픽을 수신하며 이 전달 규칙은 다른 외부 IP 주소에도 적용될 수 있습니다. 여러 외부 IP 주소에서 이러한 전달 규칙을 통해 네트워크 인터페이스를 참조할 수 있지만 각 네트워크 인터페이스에는 외부 IPv4 주소 하나와 외부 /96 IPv6 주소 범위 하나만 할당될 수 있습니다.

부하 분산 및 전달 규칙에 대한 자세한 내용은 부하 분산 문서를 읽어보세요.

새로운 고정 외부 IP 주소 예약

주소를 예약한 다음에는 새로 만드는 새 VM에 할당하거나 기존 VM에 할당할 수 있습니다.

참고: 고정 외부 IP 주소를 예약하지만 VM 또는 전달 규칙과 같은 리소스에 할당하지 않으면 사용 중인 고정 및 임시 외부 IP 주소보다 높은 요금이 청구됩니다. 자세한 내용은 외부 IP 주소 가격 책정을 참조하세요.

콘솔

1. Google Cloud 콘솔에서 IP 주소 페이지로 이동합니다.

   IP 주소로 이동

2. 외부 고정 IP 주소 예약을 클릭합니다.
3. 이름 필드에 IP 주소 이름을 입력합니다.
4. 네트워크 서비스 등급이 프리미엄 또는 표준인지 지정합니다. IPv6 고정 주소 예약은 프리미엄 등급에서만 지원됩니다.
5. IPv4 또는 IPv4 주소 여부를 지정합니다.
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
}

자바

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 주소로 승격하려면 --addresses 플래그를 compute addresses create 명령어와 함께 사용하여 임시 외부 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 주소로 승격하려면 --addresses 플래그를 compute addresses create 명령어와 함께 사용하여 임시 외부 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
}

자바

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
}

자바

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
}

자바

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 주소는 리소스가 삭제될 때까지 리소스에 연결되어 있습니다.

중요: 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
}

자바

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 가격 책정 살펴보기