Reservar endereço IP externo estático

É possível reservar endereços IP externos estáticos. Também é possível listar e liberar os endereços IP externos estáticos reservados. Para atribuir um endereço IP externo estático a uma instância de máquina virtual (VM), consulte Configurar endereços IP externos estáticos.

Os endereços IP externos podem ser estáticos ou temporários. Se uma VM exige um endereço IP externo fixo que não muda, é possível conseguir um endereço IP externo estático. É possível reservar novos endereços IP externos ou promover endereços IP externos temporários já existentes.

Se você precisar de um endereço IP interno estático, consulte Reservar um endereço IP interno estático.

Antes de começar

• Leia sobre endereços IP.
• Leia sobre cotas e limites de endereços IP externos estáticos.
• Leia sobre preços de endereço IP externo.
• Configure a autenticação, caso ainda não tenha feito isso. A autenticação é o processo de verificação da sua identidade para acesso a serviços e APIs do Google Cloud. Para executar código ou amostras em um ambiente de desenvolvimento local, faça a autenticação da maneira a seguir.

  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

  Para usar os exemplos do Terraform nesta página em um ambiente de desenvolvimento local, instale e inicialize a gcloud CLI e, em seguida, configure o Application Default Credentials com suas credenciais de usuário.

  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.

  Para mais informações, consulte Configurar a autenticação para um ambiente de desenvolvimento local na documentação de autenticação do Google Cloud.

  REST

  Para usar as amostras da API REST nesta página em um ambiente de desenvolvimento local, use as credenciais fornecidas para gcloud CLI.

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

  gcloud init

  Para mais informações, consulte Autenticar para usar REST na documentação de autenticação do Google Cloud.

Funções exigidas

Para ter as permissões necessárias para reservar e gerenciar endereços IP estáticos, peça ao administrador para conceder a você o Administrador de rede do Compute (roles/compute.networkAdmin) do IAM no projeto. Para mais informações sobre a concessão de papéis, consulte Gerenciar o acesso a projetos, pastas e organizações.

Esse papel predefinido contém as permissões necessárias para reservar e gerenciar endereços IP estáticos. Para conferir as permissões exatas necessárias, expanda a seção Permissões necessárias:

Permissões necessárias

As permissões a seguir são necessárias para reservar e gerenciar endereços IP estáticos:

• compute.addresses.create no endereço IP
• compute.addresses.createInternal no endereço IP
• compute.networks.list na rede
• compute.subnetworks.use na sub-rede
• compute.subnetworks.list na sub-rede

Essas permissões também podem ser concedidas com funções personalizadas ou outros papéis predefinidos.

Sobre endereços IP externos estáticos

Um endereço IP externo estático é o endereço reservado para seu recurso até que você decida liberá-lo. Se você tiver um endereço IP que os clientes ou usuários usam para acessar seu serviço, reserve-o para que apenas seu recurso possa usá-lo. Também é possível promover um endereço IP externo temporário para um endereço IP externo estático.

Para mais informações, consulte Endereços IP.

Observação: os endereços IP externo estáticos não são anunciados para a Internet pública até que você os associe a um recurso, como uma VM ou uma regra de encaminhamento externo.

A tabela a seguir lista os endereços IP externos estáticos compatíveis com o Google Cloud.

Tipo de endereço IP	Recurso	Intervalo de IP	Origem	Associado a
Endereços IPv4 externos regionais	VMs e balanceadores de carga regionais	/32	Pool de endereços IP externos do Google	Projeto
Endereços IPv6 externos regionais	VMs e balanceadores de carga regionais compatíveis	/96	Intervalo de endereços IPv6 externo da sub-rede	Sub-rede
Endereços IPv4 externos globais	Balanceadores de carga globais	/32	Pool de endereços IP externos do Google	Projeto
Endereços IPv6 externos globais	Balanceadores de carga globais	/64	Pool de endereços IP externos do Google	Projeto

Para ver uma lista de balanceadores de carga regionais e globais, consulte o Resumo dos tipos de balanceador de carga.

Limitações

• Apenas um recurso por vez usa um endereço IP externo estático.

• Não há como verificar se um endereço IP é estático ou efêmero depois que ele é atribuído a um recurso. É possível comparar o endereço IP com a lista de endereços IP externos estáticos reservados para esse projeto. Use o subcomando gcloud compute addresses list para ver uma lista de endereços IP externos estáticos disponíveis para o projeto.

• Cada VM pode ter várias interfaces de rede e cada interface pode ter os seguintes endereços IP atribuídos:

  • Um endereço IPv4 interno (obrigatório)
  • Um endereço IPv4 externo
  • Um intervalo de endereços IPv6 /96, interno ou externo, mas não ambos

• Não é possível alterar o nome de um endereço IP estático.

• Os endereços IP externos atribuídos existem no mesmo host físico que a VM e existem na mesma região que a VM para todos os fins, incluindo roteamento, latência e preços. Isso ocorre independentemente das informações de pesquisa de geolocalização na Internet.

Observação: as interfaces de rede podem receber tráfego de várias regras de encaminhamento, que também disponibilizam outros endereços IP externos. Qualquer número de endereços IP externos pode se referir a uma interface de rede por meio dessas regras de encaminhamento, mas cada interface de rede pode receber apenas um endereço IPv4 externo e um intervalo de endereços IPv6 /96 externo.

Para mais informações sobre balanceamento de carga e regras de encaminhamento, leia a documentação sobre o balanceamento de carga.

Reservar um novo endereço IP externo estático.

Depois de reservar o endereço, atribua-o a uma nova VM ao criá-lo ou a uma VM existente.

Observação: se você reservar um endereço IP externo estático, mas não o atribuir a um recurso, como uma VM ou uma regra de encaminhamento, você receberá uma cobrança maior do que a dos endereços IP externos estáticos e temporários que estão em uso. Para mais informações, consulte Preços de endereços IP externos.

Console

1. No console do Google Cloud, acesse a página Endereços IP.

   Acessar endereços IP

2. Selecione Reservar endereço IP estático externo.
3. No campo Nome, digite um nome de endereço IP.
4. Especifique se o nível de serviço da rede é Premium ou Standard. A reserva de endereços estáticos IPv6 é suportada apenas no nível Premium.
5. Especifique se o endereço é IPv4 ou IPv6.
6. Especifique se esse endereço IP é regional ou global.
   • Se você estiver reservando um endereço IP estático para um balanceador de carga global, escolha Global e clique em Reservar.
   • Se você estiver reservando um endereço IP estático para uma VM ou para um balanceador de carga regional, escolha Regional e selecione a região para criar o endereço.

7. Se você estiver reservando um endereço IPv6 externo regional, escolha também o seguinte:

   • Rede: a rede VPC.
   • Sub-rede: a sub-rede da qual o endereço IPv6 regional será atribuído.
   • Tipo de endpoint: escolha VM instance ou Network Load Balancer

8. Opcional: se você estiver reservando o endereço IP externo estático de uma VM, selecione uma VM na lista Anexada a para anexar o endereço IP.

9. Clique em Reservar para reservar o IP.

gcloud

Para reservar um endereço IP externo estático, use o comando gcloud compute addresses create.

Use as instruções a seguir para reservar um endereço IPv4 ou IPv6 estático externo:

Observação: os endereços IP globais só podem ser usados com balanceadores de carga globais.

Endereço IP global

Para reservar um endereço IP global:

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

Endereço IPv4 externo regional

Para reservar um endereço IPv4 externo regional:

   gcloud compute addresses create ADDRESS_NAME \
       --region=REGION
   

Endereço IPv6 externo regional

Para reservar um endereço IPv6 externo regional:

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

Substitua:

• ADDRESS_NAME: o nome que você quer associar a esse endereço.
• REGION: para endereços IP externos regionais, especifique a região em que você quer reservar esse endereço. Ela precisa ser a mesma região do recurso ao qual o endereço IP será anexado.
• SUBNET_NAME: para endereços IPv6 externos regionais, especifique a sub-rede da qual o endereço IPv6 regional estático será atribuído. A sub-rede precisa ter um intervalo de endereços IPv6 externo atribuído.
• [IPV4 | IPV6]: para endereços IP globais, especifique a versão do IP, IPv4 ou IPv6. Para endereços IPv6 externos regionais, especifique IPv6. Um intervalo IPv6 /96 é atribuído a partir da sub-rede especificada.
• VM | NETLB: para endereços IPv6 externos regionais, especifique o tipo de endpoint. seja uma VM ou um balanceador de carga de rede.

Para ver o resultado, use o comando gcloud compute addresses describe:

gcloud compute addresses describe ADDRESS_NAME

Terraform

You can use the google_compute_address resource to create a regional external IP address.

Observação: Não é possível incluir um endereço IP específico durante o processo de reserva, a menos que vocêTraga seus próprios endereços IP ,

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

Veja na amostra a seguir como usar o recurso google_compute_global_address para criar um endereço IPv6 externo 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

• Para criar um endereço IPv4 regional, chame o método addresses.insert regional:

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

  O corpo da sua solicitação precisa ter:

  {
    "name": "ADDRESS_NAME"
  }
  

  Substitua:

  • PROJECT_ID: o ID do projeto desta solicitação
  • REGION: o nome da região para essa solicitação.
  • ADDRESS_NAME: o nome que você quer associar ao endereço.

• Para endereços IPv4 estáticos globais, chame o método globalAddresses.insert:

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

  O corpo da sua solicitação precisa ter:

  {
    "name": "ADDRESS_NAME"
  }
  

• Para endereços IPv6 estáticos globais, chame o método globalAddresses.insert:

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

  O corpo da sua solicitação precisa ter:

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

  Para ver o resultado, use o método addresses.get.

• Para endereços IPv6 estáticos regionais, chame o método addresses.insert:

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

  O corpo da sua solicitação precisa ter:

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

  Substitua SUBNET pela sub-rede do projeto.

  Para ver o resultado, use o método 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.")

Promover um endereço IP externo temporário

Se a VM tiver um endereço IP externo temporário e você quiser atribuir o endereço IP permanentemente ao projeto, promova o endereço IP externo temporário a um endereço IP externo estático. Promover um endereço IP externo temporário a reservado não faz com que o Google Cloud ignore pacotes enviados para a VM. Isso inclui pacotes enviados para a VM diretamente ou por meio de um balanceador de carga.

Console

1. Acesse a página Endereços IP.

   Acessar endereços IP

2. Clique em Endereços IP externos.
3. Opcional: no campo Filtro, procure o endereço IP temporário que você quer promover.
4. No menu Mais ações () do endereço IP que você quer promover, selecione Promover a endereço IP estático.
5. Insira um nome para o novo endereço IP estático e clique em Reservar.

gcloud

Use as seguintes instruções para promover um endereço IPv4 ou IPv6 externo estático:

• Para promover um endereço IPv4 externo temporário a um endereço IPv4 externo estático, forneça o endereço IP externo temporário usando a sinalização --addresses com o comando compute addresses create. Use a flag region para promover um endereço IP regional temporário ou a sinalização global para promover um endereço IP global temporário.

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

  Substitua:

  • ADDRESS_NAME: o nome que você quer associar a esse endereço.
  • IP_ADDRESS: o endereço IP que você quer promover.
  • REGION: a região a que o endereço IP regional pertence.

• Para promover um endereço IPv6 externo regional temporário a um endereço IPv6 externo estático, forneça o endereço IP externo temporário usando a sinalização --addresses com o comando gcloud compute addresses create.

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

  Substitua:

  • ADDRESS_NAME: um nome para o recurso de endereço IP.
  • REGION: a região do recurso de endereço IPv6.
  • IPV6_ADDRESS: o endereço IPv6 que você está promovendo.

API

Para promover um endereço IP regional temporário, chame o método addresses.insert:

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

Para promover um endereço IP global temporário, faça uma solicitação POST para o URI a seguir:

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

Especifique os valores dos campos obrigatórios do corpo da solicitação:

• Para endereços IPv4, o corpo da solicitação deve conter os seguintes campos:

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

• Para endereços IPv6, o corpo da solicitação precisa conter os seguintes campos:

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

  Substitua:

  • ADDRESS_NAME: o nome que você quer associar a esse endereço.
  • IPV4_ADDRESS|IPV6_ADDRESS: o endereço IPv4 ou IPv6 que você quer promover.
  • REGION: a região a que o endereço IPv4 ou IPv6 pertence.
  • PROJECT_ID: o ID do projeto desta solicitação

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

O endereço IP externo permanece anexado à VM, mesmo depois de ser sido promovido para um endereço IP externo estático. Se você precisar atribuir o endereço estático recém-promovido a outro recurso, cancele a atribuição do endereço IP externo estático da VM.

Listar endereços IP externos estáticos

Para listar endereços IP externos estáticos que você reservou para o projeto, siga estas etapas.

Console

1. No console do Google Cloud, acesse a página Endereços IP.

   Acessar endereços IP

2. Clique em Endereços IP externos.

gcloud

Use o comando gcloud compute addresses list:

• Para listar todos os endereços IP, use o seguinte comando:

  gcloud compute addresses list

• Para listar todos os endereços IP globais, use o seguinte comando:

  gcloud compute addresses list --global

• Para listar todos os endereços IP regionais em uma determinada região, use o seguinte comando:

  gcloud compute addresses list \
      --regions=REGION
  

  Substitua REGION pela região em que você quer listar os endereços. É possível listar endereços de várias regiões especificando nomes de regiões separados por vírgulas:

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

API

• Para listar endereços IPv4 ou IPv6 regionais, chame o método addresses.list:

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

  Substitua:

  • PROJECT_ID: o ID do projeto desta solicitação
  • REGION: o nome da região para essa solicitação;

• Para listar todos os endereços em todas as regiões, chame o método addresses.aggregatedList:

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

• Para listar endereços IPv4 ou IPv6 globais, chame o método globalAddresses.list:

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

  Substitua:

  PROJECT_ID: o ID do projeto desta solicitação

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

Descrever um endereço IP externo estático

Para informações sobre um endereço IP externo estático, siga estas etapas.

Console

1. No console do Google Cloud, acesse a página Endereços IP.

   Acessar endereços IP

2. Clique em Endereços IP externos.

3. Clique em um endereço IP para ver mais informações sobre ele.

gcloud

Use o comando gcloud compute addresses describe. Substitua ADDRESS_NAME pelo nome do endereço IP externo que você quer descrever.

• Para um endereço IPv4 ou IPv6 global, use o seguinte comando:

  gcloud compute addresses describe ADDRESS_NAME --global

• Para um endereço IPv4 ou IPv6 regional, use o seguinte comando:

  gcloud compute addresses describe ADDRESS_NAME --region=REGION

API

• Para descrever um endereço IPv4 ou IPv6 regional, chame o método addresses.get:

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

  Substitua:

  • PROJECT_ID: o ID do projeto para a solicitação.
  • REGION: o nome da região para essa solicitação
  • ADDRESS_NAME: o nome do endereço IP

• Para descrever um endereço IPv4 ou IPv6 global, chame o método globalAddresses.get:

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

  Substitua:

  • PROJECT_ID: o ID do projeto para a solicitação.
  • ADDRESS_NAME: o nome do endereço 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

Liberar um endereço IP externo estático

Se você não precisar mais de um endereço IPv4 ou IPv6 externo estático, libere o endereço IP excluindo o recurso de endereço IP.

Se você estiver usando o console do Google Cloud, só poderá liberar um endereço IP estático se ele não estiver sendo usado por outro recurso.

Se você estiver usando a CLI gcloud ou API, poderá liberar um endereço IP, esteja ele sendo usado ou não por outro recurso.

• Se o endereço IP não estiver sendo usado por um recurso, ele será retornado ao pool de endereços IP externos disponíveis.

• Se o endereço IP estiver sendo usado por um recurso, ele permanecerá anexado ao recurso até o recurso ser excluído.

Importante: depois que o endereço IP for liberado, talvez você não consiga reservar o mesmo endereço IPv4 ou IPv6 estático, porque algum outro usuário pode já ter reservado.

Console

1. No console do Google Cloud, acesse a página Endereços IP.

   Acessar endereços IP

2. Clique em Endereços IP externos.

3. Opcional: no campo Filtro, digite static e selecione Estático : Tipo na lista suspensa.

4. Selecione o endereço IP externo estático que você quer liberar.

5. Clique em Liberar endereço estático.

   Se essa opção não estiver disponível, clique no menu Mais ações () na barra de menus superior e selecione Liberar endereço estático da lista.

gcloud

Use o comando compute addresses delete (em inglês).

gcloud compute addresses delete ADDRESS_NAME

Substitua ADDRESS_NAME pelo nome do endereço IPv4 ou IPv6 a ser liberado.

API

• Para liberar um endereço IPv4 ou IPv6 regional, chame o método addresses.delete:

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

  Substitua:

  • PROJECT_ID: o ID do projeto desta solicitação
  • REGION: o nome da região para essa solicitação;
  • ADDRESS_NAME: o nome do endereço IP

• Para liberar um endereço IPv4 ou IPv6 global, chame o método globalAddresses.delete:

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

  Substitua:

  • ADDRESS_NAME: o nome do endereço IP
  • PROJECT_ID: o ID do projeto desta solicitação

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

A seguir

• Saiba como Configurar endereços IP externos estáticos para uma VM nova ou existente.
• Saiba mais sobre especificações de endereço IP para regras de encaminhamento e como usar regras de encaminhamento na Visão geral das regras de encaminhamento.
• Saiba mais sobre endereços IP.
• Revise os preços da VPC.