Mencadangkan alamat IP eksternal statis

Anda dapat mencadangkan alamat IP eksternal statis. Anda juga dapat mencantumkan dan merilis alamat IP eksternal statis yang Anda cadangkan. Untuk menetapkan IP eksternal statis ke instance virtual machine (VM), lihat Mengonfigurasi alamat IP eksternal statis.

Alamat IP eksternal dapat bersifat statis atau sementara. Jika VM memerlukan alamat IP eksternal tetap yang tidak berubah, Anda dapat mendapatkan alamat IP eksternal statis. Anda dapat mencadangkan alamat IP eksternal baru atau mempromosikan alamat IP eksternal sementara yang sudah ada.

Jika Anda memerlukan alamat IP internal statis, lihat Mencadangkan alamat IP internal statis sebagai gantinya.

Sebelum memulai

• Baca tentang alamat IP.
• Baca kuota dan batas untuk alamat IP eksternal statis.
• Baca harga alamat IP eksternal.
• Jika Anda belum melakukannya, siapkan autentikasi. Autentikasi adalah proses di mana identitas Anda telah diverifikasi untuk mendapatkan akses ke layanan dan API Google Cloud. Untuk menjalankan kode atau contoh dari lingkungan pengembangan lokal, Anda dapat mengautentikasi sebagai berikut.

  Pilih tab untuk melihat bagaimana Anda berencana menggunakan contoh di halaman ini:

  Konsol

  Saat menggunakan Konsol Google Cloud untuk mengakses API dan layanan Google Cloud, Anda tidak perlu menyiapkan autentikasi.

  gcloud

  Instal Google Cloud CLI, lalu initialize dengan menjalankan perintah berikut:

  gcloud init

  Catatan: Jika Anda telah menginstal gcloud CLI sebelumnya, pastikan Anda memiliki versi baru dengan menjalankan gcloud components update.

  Terraform

  Untuk menggunakan contoh Terraform di halaman ini dari lingkungan pengembangan lokal, instal dan lakukan inisialisasi gcloud CLI, lalu siapkan Kredensial Default Aplikasi dengan kredensial pengguna Anda.

  1. Menginstal Google Cloud CLI.

  2. Untuk initialize gcloud CLI, jalankan perintah berikut:

     gcloud init

  3. Buat kredensial autentikasi lokal untuk Akun Google Anda:

     gcloud auth application-default login

  Untuk informasi selengkapnya, lihat Menyiapkan autentikasi untuk lingkungan pengembangan lokal dalam dokumentasi autentikasi Google Cloud.

  REST

  Untuk menggunakan contoh REST API di halaman ini dalam lingkungan pengembangan lokal, gunakan kredensial yang Anda berikan ke gcloud CLI.

  Instal Google Cloud CLI, lalu initialize dengan menjalankan perintah berikut:

  gcloud init

Peran yang diperlukan

Untuk mendapatkan izin yang diperlukan untuk mencadangkan dan mengelola alamat IP statis, minta administrator untuk memberi Anda Peran IAM Compute Network Admin (roles/compute.networkAdmin) di project Anda. Untuk mengetahui informasi selengkapnya tentang cara memberikan peran, lihat Mengelola akses.

Peran bawaan ini berisi izin yang diperlukan untuk memesan dan mengelola alamat IP statis. Untuk melihat izin yang benar-benar diperlukan, luaskan bagian Izin yang diperlukan:

Izin yang diperlukan

Izin berikut diperlukan untuk mencadangkan dan mengelola alamat IP statis:

• compute.addresses.create di alamat IP
• compute.addresses.createInternal di alamat IP
• compute.networks.list di jaringan ini
• compute.subnetworks.use di subnet
• compute.subnetworks.list di subnet

Anda mungkin juga bisa mendapatkan izin ini dengan peran khusus atau peran bawaan lainnya.

Tentang alamat IP eksternal statis

Alamat IP eksternal statis adalah alamat IP yang dicadangkan untuk resource Anda sampai Anda memutuskan untuk merilisnya. Jika memiliki alamat IP yang diandalkan pelanggan atau pengguna untuk mengakses layanan Anda, Anda dapat mencadangkan alamat IP tersebut sehingga hanya resource Anda yang dapat menggunakannya. Anda juga dapat mempromosikan alamat IP eksternal sementara menjadi alamat IP eksternal statis.

Untuk mengetahui informasi selengkapnya, lihat Alamat IP.

Catatan: Alamat IP eksternal statis tidak diumumkan ke internet publik sampai Anda mengaitkannya dengan resource, seperti VM atau aturan penerusan.

Tabel berikut mencantumkan alamat IP eksternal statis yang didukung oleh Google Cloud.

Jenis alamat IP	Resource	Rentang IP	Asal	Dikaitkan dengan
Alamat IPv4 eksternal regional	VM dan load balancer regional	/32	Kumpulan alamat IP eksternal Google	Project
Alamat IPv6 eksternal regional	VM dan load balancer regional yang didukung	/96	Rentang alamat IPv6 eksternal subnet	Subnet
Alamat IPv4 eksternal global	Load balancer global	/32	Kumpulan alamat IP eksternal Google	Project
Alamat IPv6 eksternal global	Load balancer global	/64	Kumpulan alamat IP eksternal Google	Project

Untuk mengetahui daftar load balancer regional dan global, lihat Ringkasan jenis load balancer.

Batasan

• Hanya satu resource dalam satu waktu yang dapat menggunakan alamat IP eksternal statis.

• Tidak ada cara untuk memeriksa apakah alamat IP bersifat statis atau sementara setelah ditetapkan ke resource. Anda dapat membandingkan alamat IP dengan daftar alamat IP eksternal statis yang dicadangkan untuk project tersebut. Gunakan Sub-perintah gcloud compute addresses list untuk melihat daftar alamat IP eksternal statis yang tersedia bagi proyek.

• Setiap VM dapat memiliki beberapa antarmuka jaringan, dan setiap antarmuka dapat memiliki alamat IP berikut:

  • Alamat IPv4 internal (wajib)
  • Alamat IPv4 eksternal
  • Rentang alamat IPv6 /96, baik internal maupun eksternal, tetapi tidak keduanya

• Anda tidak dapat mengubah nama alamat IP statis.

• Alamat IP eksternal yang ditetapkan berada di host fisik yang sama dengan VM dan berada di region yang sama dengan VM untuk semua tujuan, termasuk {i>routing<i}, latensi, dan harga. Hal ini berlaku terlepas dari geolokasi internet pencarian informasi.

Catatan: Antarmuka jaringan dapat menerima traffic dari beberapa aturan penerusan, yang mungkin menyalurkan alamat IP eksternal lainnya. Apa saja jumlah alamat IP eksternal yang dapat mereferensikan antarmuka jaringan melalui aturan penerusan ini, tetapi setiap antarmuka jaringan hanya dapat ditetapkan satu alamat IPv4 eksternal dan satu rentang alamat IPv6 /96 eksternal.

Untuk mengetahui informasi selengkapnya tentang aturan penerusan dan load balancing, baca dokumentasi load balancing.

Mereservasi alamat IP eksternal statis baru

Setelah mereservasi alamat, tetapkan alamat tersebut ke VM baru saat membuatnya atau ke VM yang sudah ada.

Catatan: Jika Anda mencadangkan alamat IP eksternal statis, tetapi tidak menetapkannya ke resource seperti VM atau aturan penerusan, maka Anda akan dikenakan biaya tingkat yang lebih tinggi daripada alamat IP eksternal statis dan sementara yang sedang digunakan. Untuk informasi selengkapnya, lihat Harga alamat IP eksternal.

Konsol

1. Di Konsol Google Cloud, buka halaman IP addresses.

   Buka alamat IP

2. Klik Reserve external static IP address.
3. Di kolom Name, masukkan nama alamat IP.
4. Tentukan apakah tingkat layanan jaringan adalah Premium atau Standard. Pemesanan alamat statis IPv6 hanya didukung pada paket Premium.
5. Tentukan apakah alamat tersebut adalah alamat IPv4 atau IPv6.
6. Tentukan apakah alamat IP ini adalah Regional atau Global.
   • Jika Anda mencadangkan alamat IP statis untuk load balancer global, pilih Global lalu klik Reserve.
   • Jika Anda memesan alamat IP statis untuk VM atau load balancer regional, pilih Regional, lalu pilih region untuk membuat alamat.

7. Jika Anda mencadangkan alamat IPv6 eksternal regional, pilih juga hal berikut:

   • Network: jaringan VPC
   • Subnetwork: subnet tempat Anda menetapkan region statis Alamat IPv6
   • Endpoint type: pilih VM instance atau Network Load Balancer

8. Opsional: Jika Anda mencadangkan alamat IP eksternal statis untuk VM, lalu dalam daftar Attached to, pilih VM untuk pasang alamat IP.

9. Klik Reserve untuk mereservasi alamat IP.

gcloud

Untuk mencadangkan alamat IP eksternal statis, gunakan perintah gcloud compute addresses create.

Gunakan petunjuk berikut untuk memesan alamat IPv4 atau IPv6 eksternal statis:

Catatan: Alamat IP global hanya dapat digunakan dengan load balancer global.

Alamat IP global

Untuk mencadangkan alamat IP global:

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

Alamat IPv4 eksternal regional

Untuk memesan alamat IPv4 eksternal regional:

   gcloud compute addresses create ADDRESS_NAME \
       --region=REGION
   

Alamat IPv6 eksternal regional

Untuk memesan alamat IPv6 eksternal regional:

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

Ganti kode berikut:

• ADDRESS_NAME: nama yang Anda inginkan dikaitkan dengan alamat ini.
• REGION: untuk alamat IP eksternal regional, tentukan wilayah tempat Anda ingin memesan alamat ini. Wilayah ini harus berada di region yang sama dengan resource yang ingin Anda lampirkan ke alamat IP.
• SUBNET_NAME: untuk alamat IPv6 eksternal regional, menentukan subnet yang menjadi asal alamat IPv6 regional statis. Tujuan subnet harus memiliki rentang alamat IPv6 eksternal yang ditetapkan.
• [IPV4 | IPV6]: untuk alamat IP global, menentukan versi IP, yaitu IPv4 atau IPv6. Untuk eksternal regional Alamat IPv6, tentukan IPv6. Rentang IPv6 /96 ditetapkan dari subnet yang ditentukan.
• VM | NETLB: untuk alamat IPv6 eksternal regional, menentukan jenis endpoint; apakah itu VM atau load balancer jaringan.

Untuk melihat hasilnya, gunakan perintah gcloud compute addresses describe:

gcloud compute addresses describe ADDRESS_NAME

Terraform

Anda dapat menggunakan resource google_compute_address untuk membuat alamat IP eksternal regional.

Catatan: Anda tidak dapat menyertakan alamat IP tertentu selama reservasi data kecuali Anda Bawa alamat IP Anda sendiri.

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

Contoh berikut menunjukkan cara menggunakan resource google_compute_global_address untuk membuat alamat IPv6 eksternal global:

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

• Untuk membuat alamat IPv4 regional, panggil alamat IPv4 regional Metode addresses.insert:

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

  Isi permintaan Anda harus berisi informasi berikut:

  {
    "name": "ADDRESS_NAME"
  }
  

  Ganti kode berikut:

  • PROJECT_ID: project ID untuk permintaan ini
  • REGION: nama wilayah untuk ini minta
  • ADDRESS_NAME: nama yang Anda inginkan hubungkan dengan alamat

• Untuk alamat IPv4 statis global, panggil metode globalAddresses.insert:

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

  Isi permintaan Anda harus berisi informasi berikut:

  {
    "name": "ADDRESS_NAME"
  }
  

• Untuk alamat IPv6 statis global, panggil metode globalAddresses.insert:

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

  Isi permintaan Anda harus berisi informasi berikut:

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

  Untuk melihat hasilnya, gunakan metode addresses.get.

• Untuk alamat IPv6 statis regional, panggil metode addresses.insert:

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

  Isi permintaan Anda harus berisi informasi berikut:

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

  Ganti SUBNET dengan subnet untuk project ini.

  Untuk melihat hasilnya, gunakan metode 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.")

Mempromosikan alamat IP eksternal sementara

Jika VM Anda memiliki alamat IP eksternal sementara dan Anda ingin menetapkan alamat IP secara permanen ke project Anda, alamat IP eksternal sementara ke alamat IP eksternal statis. Mempromosikan ke dicadangkan untuk alamat IP eksternal sementara tidak menyebabkan Google Cloud meninggalkan paket yang dikirim ke VM. Ini termasuk paket yang dikirim ke VM secara langsung atau dengan load balancer.

Konsol

1. Buka halaman Alamat IP.

   Buka alamat IP

2. Klik Alamat IP eksternal.
3. Opsional: Di kolom Filter, telusuri alamat IP sementara yang ingin Anda promosikan.
4. Pada menu Tindakan lainnya () di alamat IP yang ingin dipromosikan, pilih Promosikan ke alamat IP statis.
5. Masukkan nama untuk alamat IP statis baru, lalu klik Cadangkan.

gcloud

Gunakan petunjuk berikut untuk mempromosikan IPv4 atau IPv6 eksternal statis alamat:

• Untuk mempromosikan alamat IPv4 eksternal efemeral ke IPv4 eksternal statis alamat IP eksternal, berikan alamat IP eksternal sementara dengan menggunakan flag --addresses dengan Perintah compute addresses create. Gunakan tanda region untuk mempromosikan alamat IP regional sementara atau flag global untuk mempromosikan alamat IP global sementara.

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

  Ganti kode berikut:

  • ADDRESS_NAME: nama yang Anda inginkan dikaitkan dengan alamat ini.
  • IP_ADDRESS: alamat IP yang Anda inginkan untuk dipromosikan.

  • REGION: region tempat IP regional alamat milik mereka.

  • Untuk mempromosikan alamat IPv6 eksternal regional efemeral menjadi alamat IPv6 statis alamat IPv6 eksternal regional, berikan IP eksternal sementara alamat IP dengan menggunakan flag --addresses dengan Perintah compute addresses create.

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

  Ganti kode berikut:

  • ADDRESS_NAME: nama untuk alamat IP resource Anda
  • REGION: region untuk alamat IPv6 resource Anda
  • IPV6_ADDRESS: alamat IPv6 yang Anda mempromosikan.

API

Untuk mempromosikan alamat IP regional sementara, panggil metode addresses.insert:

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

Untuk mempromosikan alamat IP global sementara, buat permintaan POST ke URI berikut:

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

Tentukan nilai untuk kolom yang wajib diisi dari isi permintaan:

• Untuk alamat IPv4, isi permintaan Anda harus berisi hal berikut bidang:

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

• Untuk alamat IPv6, isi permintaan Anda harus berisi hal berikut bidang:

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

  Ganti kode berikut:

  • ADDRESS_NAME: nama yang Anda inginkan hubungkan dengan alamat ini
  • IPV4_ADDRESS|IPV6_ADDRESS: IPv4 atau IPv6 yang ingin Anda promosikan
  • REGION: region tempat IPv4 atau IPv6 alamat milik
  • PROJECT_ID: project ID untuk permintaan ini

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

Alamat IP eksternal tetap terpasang pada VM bahkan setelah telah dipromosikan menjadi alamat IP eksternal statis. Jika Anda perlu menetapkan alamat IP eksternal statis yang baru dipromosikan ke sumber daya lain, batalkan penetapan alamat IP eksternal statis dari VM yang ada.

Mencantumkan alamat IP eksternal statis

Untuk mencantumkan alamat IP eksternal statis yang telah dicadangkan untuk project Anda, ikuti langkah-langkah berikut.

Konsol

1. Di Konsol Google Cloud, buka halaman IP addresses.

   Buka IP addresses

2. Klik Alamat IP eksternal.

gcloud

Gunakan perintah gcloud compute addresses list:

• Untuk menampilkan semua alamat IP, gunakan perintah berikut:

  gcloud compute addresses list

• Untuk menampilkan daftar semua alamat IP global, gunakan perintah berikut:

  gcloud compute addresses list --global

• Untuk menampilkan daftar semua alamat IP regional di region tertentu, gunakan perintah berikut berikut:

  gcloud compute addresses list \
      --regions=REGION
  

  Ganti REGION dengan wilayah yang ingin Anda daftar alamat. Anda dapat mencantumkan alamat beberapa region berdasarkan menentukan nama wilayah yang dipisahkan koma:

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

API

• Untuk mencantumkan alamat IPv4 atau IPv6 regional, panggil metode addresses.list:

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

  Ganti kode berikut:

  • PROJECT_ID: project ID untuk permintaan ini
  • REGION: nama wilayah untuk ini minta

• Untuk menampilkan daftar semua alamat di semua region, panggil metode addresses.aggregatedList:

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

• Untuk mencantumkan alamat IPv4 atau IPv6 global, panggil metode globalAddresses.list:

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

  Ganti kode berikut:

  PROJECT_ID: project ID untuk permintaan ini

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

Menjelaskan alamat IP eksternal statis

Untuk mendapatkan informasi tentang alamat IP eksternal statis, ikuti langkah-langkah berikut.

Konsol

1. Di Konsol Google Cloud, buka halaman IP addresses.

   Buka IP addresses

2. Klik Alamat IP eksternal.

3. Klik alamat IP yang ingin Anda dapatkan informasinya lebih lanjut.

gcloud

Gunakan perintah gcloud compute addresses describe. Ganti ADDRESS_NAME dengan nama alamat IP eksternal yang ingin Anda deskripsikan.

• Untuk alamat IPv4 atau IPv6 global, gunakan perintah berikut:

  gcloud compute addresses describe ADDRESS_NAME --global

• Untuk alamat IPv4 atau IPv6 regional, gunakan perintah berikut:

  gcloud compute addresses describe ADDRESS_NAME --region=REGION

API

• Untuk mendeskripsikan alamat IPv4 atau IPv6 regional, panggil metode addresses.get:

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

  Ganti kode berikut:

  • PROJECT_ID: project ID untuk permintaan
  • REGION: nama region untuk permintaan ini
  • ADDRESS_NAME: nama alamat IP

• Untuk mendeskripsikan alamat IPv4 atau IPv6 global, panggil metode globalAddresses.get:

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

  Ganti kode berikut:

  • PROJECT_ID: project ID untuk permintaan
  • ADDRESS_NAME: nama alamat 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

Merilis alamat IP eksternal statis

Jika tidak lagi memerlukan alamat IPv4 atau IPv6 eksternal statis, Anda dapat melepas alamat IP dengan menghapus resource alamat IP.

Jika menggunakan konsol Google Cloud, Anda dapat melepas alamat IP statis hanya jika tidak digunakan oleh resource lain.

Jika menggunakan gcloud CLI atau API, Anda dapat merilis alamat IP baik sedang digunakan oleh sumber daya lain atau tidak.

• Jika alamat IP tidak digunakan oleh suatu resource, alamat IP tersebut akan dikembalikan ke kumpulan alamat IP eksternal yang tersedia.

• Jika alamat IP digunakan oleh suatu resource, alamat IP tersebut akan tetap terpasang ke resource tersebut hingga resource dihapus.

Penting: Setelah alamat IP dirilis, Anda mungkin tidak dapat mencadangkan alamat IPv4 atau IPv6 statis yang sama karena beberapa pengguna lain mungkin sudah mencadangkannya.

Konsol

1. Di Konsol Google Cloud, buka halaman IP addresses.

   Buka IP addresses

2. Klik Alamat IP eksternal.

3. Opsional: Di kolom Filter, masukkan static, lalu pilih Static : Ketik dari menu drop-down.

4. Pilih alamat IP eksternal statis yang ingin dilepaskan.

5. Klik Release static address.

   Jika Anda tidak melihat opsi ini, klik menu Tindakan lainnya () di panel menu atas, lalu pilih Lepaskan alamat statis dari daftar.

gcloud

Gunakan perintah compute addresses delete:

gcloud compute addresses delete ADDRESS_NAME

Ganti ADDRESS_NAME dengan nama IPv4 atau Alamat IPv6 yang akan dirilis.

API

• Untuk merilis alamat IPv4 atau IPv6 regional, panggil metode addresses.delete:

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

  Ganti kode berikut:

  • PROJECT_ID: project ID untuk permintaan ini
  • REGION: nama wilayah untuk ini minta
  • ADDRESS_NAME: nama alamat IP

• Untuk merilis alamat IPv4 atau IPv6 global, panggil metode globalAddresses.delete:

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

  Ganti kode berikut:

  • ADDRESS_NAME: nama alamat IP
  • PROJECT_ID: project ID untuk permintaan ini

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

Langkah selanjutnya

• Pelajari cara Mengonfigurasi alamat IP eksternal statis untuk VM baru atau yang sudah ada.
• Pelajari spesifikasi alamat IP tentang aturan penerusan, dan cara menggunakan aturan penerusan, di Ringkasan aturan penerusan.
• Pelajari alamat IP lebih lanjut.
• Tinjau harga VPC.