Esta página foi traduzida pela API Cloud Translation.

Reserve um endereço IP externo estático

Pode reservar endereços IP externos estáticos. Também pode listar e libertar os seus 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 o artigo Configurar endereços IP externos estáticos.

Os endereços IP externos podem ser estáticos ou efémeros. Se uma VM precisar de um endereço IP externo fixo que não se altere, pode obter um endereço IP externo estático. Pode reservar novos endereços IP externos ou promover endereços IP externos efémeros existentes.

Se precisar de um endereço IP interno estático, consulte o artigo Reserve um endereço IP interno estático em alternativa.

Antes de começar

Leia acerca dos endereços IP.
Leia acerca das quotas e dos limites para endereços IP externos estáticos.
Leia acerca dos preços dos endereços IP externos.
Se ainda não o fez, configure a autenticação. A autenticação é o processo através do qual a sua identidade é validada para acesso a Google Cloud serviços e APIs. Para executar código ou exemplos a partir de um ambiente de desenvolvimento local, pode fazer a autenticação da seguinte forma.
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

Instale a CLI Google Cloud. Após a instalação, inicialize a CLI gcloud executando o seguinte comando:
```
gcloud init
```
Se estiver a usar um fornecedor de identidade (IdP) externo, primeiro tem de iniciar sessão na CLI gcloud com a sua identidade federada.

Nota: se instalou a CLI gcloud anteriormente, certifique-se de que tem a versão mais recente executando gcloud components update.
Terraform

Para usar os exemplos do Terraform nesta página num ambiente de desenvolvimento local, instale e inicialize a CLI gcloud e, em seguida, configure as credenciais predefinidas da aplicação com as suas credenciais de utilizador.
Para mais informações, consulte Configure o ADC para um ambiente de desenvolvimento local na Google Cloud documentação de autenticação.
REST

Para usar os exemplos da API REST nesta página num ambiente de desenvolvimento local, usa as credenciais que fornece à CLI gcloud.
Para mais informações, consulte o artigo Autenticar para usar REST na Google Cloud documentação de autenticação.

Funções necessárias

Para receber as autorizações de que precisa para reservar e gerir endereços IP estáticos, peça ao seu administrador para lhe conceder a função do IAM Administrador da rede de computação (roles/compute.networkAdmin) no seu projeto. Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Esta função predefinida contém as autorizações necessárias para reservar e gerir endereços IP estáticos. Para ver as autorizações exatas que são necessárias, expanda a secção Autorizações necessárias:

Autorizações necessárias

São necessárias as seguintes autorizações para reservar e gerir 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

Também pode conseguir estas autorizações com funções personalizadas ou outras funções predefinidas.

Acerca dos endereços IP externos estáticos

Um endereço IP externo estático é o endereço IP reservado para o seu recurso até decidir libertá-lo. Se tiver um endereço IP no qual os seus clientes ou utilizadores confiam para aceder ao seu serviço, pode reservar esse endereço IP para que apenas o seu recurso o possa usar. Também pode promover um endereço IP externo efémero para um endereço IP externo estático.

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

A tabela seguinte indica os endereços IP externos estáticos suportados pelo 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`	Conjunto de endereços IP externos da Google	Projeto
Endereços IPv6 externos regionais	VMs e balanceadores de carga regionais suportados	`/96`	Intervalo de endereços IPv6 externos da sub-rede	Sub-rede
Endereços IPv4 externos globais	Balanceadores de carga globais	`/32`	Conjunto de endereços IP externos da Google	Projeto
Endereços IPv6 externos globais	Balanceadores de carga globais	`/64`	Conjunto de endereços IP externos da Google	Projeto

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

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

Limitações

Apenas um recurso de cada vez pode usar um endereço IP externo estático.
Não existe forma de verificar se um endereço IP é estático ou efémero depois de ter sido atribuído a um recurso. Pode 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 de acordo com o respetivo tipo de pilha:
- Interfaces apenas IPv4:
  - Um endereço IPv4 interno (obrigatório)
  - Um endereço IPv4 externo (opcional)
- Interfaces de pilha dupla (IPv4 e IPv6):
  - Um endereço IPv4 interno (obrigatório)
  - Um endereço IPv4 externo (opcional)
  - Um intervalo de endereços IPv6, interno ou externo, mas não ambos (obrigatório)/96
- Interfaces apenas IPv6:
  - Um intervalo de endereços IPv6, interno ou externo, mas não ambos (obrigatório)/96
Não pode anular a atribuição nem alterar o endereço IPv6 externo de uma VM com uma interface de rede apenas IPv6. No entanto, pode promover um endereço IP externo efémero de um recurso para um endereço IP externo estático, para que o endereço permaneça reservado mesmo após a eliminação do recurso.
Não pode alterar o nome de um endereço IP estático.

Nota: as interfaces de rede podem receber tráfego de várias regras de encaminhamento, que podem publicar outros endereços IP externos. Qualquer número de endereços IP externos pode fazer referência a uma interface de rede através destas regras de encaminhamento, mas só pode ser atribuído um endereço IPv4 externo e um intervalo de endereços IPv6 externos a cada interface de rede./96

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

Reserve um novo endereço IP externo estático

Depois de reservar o endereço, atribua-o a uma nova VM durante a criação ou a uma VM existente.

Consola

Na Google Cloud consola, aceda à página Endereços IP.
Aceda a Endereços IP
Clique em Reservar endereço IP estático externo.
No campo Nome, introduza um nome de endereço IP.
Especifique se o nível do serviço de rede é Premium ou Standard. A reserva de endereços estáticos IPv6 só é suportada no nível Premium.
Especifique se é um endereço IPv4 ou IPv6.
Especifique se este endereço IP é Regional ou Global.
- Se estiver a reservar um endereço IP estático para um balanceador de carga global, escolha Global e, de seguida, clique em Reservar.
- Se estiver a reservar um endereço IP estático para uma VM ou para um balanceador de carga regional, escolha Regional e, em seguida, selecione a região na qual quer criar o endereço.
Se estiver a reservar um endereço IPv6 externo regional, também deve escolher o seguinte:
- Rede: a rede da VPC
- Sub-rede: a sub-rede a partir da qual atribuir o endereço IPv6 regional estático
- Tipo de ponto final: escolha Instância de VM ou Balanceador de carga de rede
Opcional: se estiver a reservar o endereço IP externo estático para uma VM, na lista Anexado a, selecione uma VM à qual anexar o endereço IP.
Clique em Reservar para reservar o endereço IP.

gcloud

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

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

Endereço IP global

Para reservar um endereço IP global:

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

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=ENDPOINT_TYPE

Substitua o seguinte:

ADDRESS_NAME: o nome que quer associar a esta morada.
REGION: para endereços IP externos regionais, especifique uma região para o endereço IP.
SUBNET_NAME: para endereços IPv6 externos regionais, especifique a sub-rede a partir da qual atribuir o endereço IPv6 regional estático. A sub-rede tem de ter um intervalo de endereços IPv6 externos atribuídos.
IP_VERSION: para endereços IP globais, especifique a versão do IP, IPv4 ou IPv6.
ENDPOINT_TYPE: para endereços IPv6 externos regionais, especifique o tipo de ponto final, VM ou NETLB.

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

gcloud compute addresses describe ADDRESS_NAME

Terraform

Pode usar o recurso google_compute_address para criar um endereço IP externo regional.

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

O exemplo seguinte mostra 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 regional addresses.insert:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses
```
O corpo do pedido deve conter o seguinte:
```
{
  "name": "ADDRESS_NAME"
}
```
Substitua o seguinte:
- PROJECT_ID: o ID do projeto para este pedido
- REGION: o nome da região para este pedido
- ADDRESS_NAME: o nome que quer associar à morada
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 do pedido deve conter o seguinte:
```
{
  "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 do pedido deve conter o seguinte:
```
{
  "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étodoaddresses.insert:

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

O corpo do pedido deve conter o seguinte:

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

Substitua SUBNET pela sub-rede deste projeto.

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

Ir

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	"cloud.google.com/go/compute/apiv1/computepb"
)

// reserveNewRegionalExternal reserves a new regional external IP address in Google Cloud Platform.
func reserveNewRegionalExternal(w io.Writer, projectID, region, addressName string, isPremium bool) (*computepb.Address, error) {
	// projectID := "your_project_id"
	// region := "europe-central2"
	// addressName := "your_address_name"
	// isPremium := true
	ctx := context.Background()

	networkTier := computepb.AccessConfig_STANDARD.String()
	if isPremium {
		networkTier = computepb.AccessConfig_PREMIUM.String()
	}

	address := &computepb.Address{
		Name:        &addressName,
		NetworkTier: &networkTier,
	}

	client, err := compute.NewAddressesRESTClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewAddressesRESTClient: %w", err)
	}
	defer client.Close()

	req := &computepb.InsertAddressRequest{
		Project:         projectID,
		Region:          region,
		AddressResource: address,
	}

	op, err := client.Insert(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("unable to reserve regional address: %w", err)
	}

	err = op.Wait(ctx)
	if err != nil {
		return nil, fmt.Errorf("waiting for the regional address reservation operation to complete: %w", err)
	}

	addressResult, err := client.Get(ctx, &computepb.GetAddressRequest{
		Project: projectID,
		Region:  region,
		Address: addressName,
	})
	if err != nil {
		return nil, fmt.Errorf("unable to get reserved regional address: %w", err)
	}

	fmt.Fprintf(w, "Regional address %v reserved: %v", addressName, addressResult.GetAddress())

	return addressResult, err
}

// reserveNewGlobalExternal reserves a new global external IP address in Google Cloud Platform.
func reserveNewGlobalExternal(w io.Writer, projectID, addressName string, isV6 bool) (*computepb.Address, error) {
	// projectID := "your_project_id"
	// addressName := "your_address_name"
	// isV6 := false
	ctx := context.Background()
	ipVersion := computepb.Address_IPV4.String()
	if isV6 {
		ipVersion = computepb.Address_IPV6.String()
	}

	address := &computepb.Address{
		Name:      &addressName,
		IpVersion: &ipVersion,
	}

	client, err := compute.NewGlobalAddressesRESTClient(ctx)
	if err != nil {
		return nil, fmt.Errorf("NewGlobalAddressesRESTClient: %w", err)
	}
	defer client.Close()

	req := &computepb.InsertGlobalAddressRequest{
		Project:         projectID,
		AddressResource: address,
	}

	op, err := client.Insert(ctx, req)
	if err != nil {
		return nil, fmt.Errorf("unable to reserve global address: %w", err)
	}

	err = op.Wait(ctx)
	if err != nil {
		return nil, fmt.Errorf("waiting for the global address reservation operation to complete: %w", err)
	}

	addressResult, err := client.Get(ctx, &computepb.GetGlobalAddressRequest{
		Project: projectID,
		Address: addressName,
	})
	if err != nil {
		return nil, fmt.Errorf("unable to get reserved global address: %w", err)
	}

	fmt.Fprintf(w, "Global address %v reserved: %v", addressName, addressResult.GetAddress())

	return addressResult, nil
}

Java


import com.google.cloud.compute.v1.Address;
import com.google.cloud.compute.v1.Address.AddressType;
import com.google.cloud.compute.v1.Address.IpVersion;
import com.google.cloud.compute.v1.Address.NetworkTier;
import com.google.cloud.compute.v1.AddressesClient;
import com.google.cloud.compute.v1.GlobalAddressesClient;
import com.google.cloud.compute.v1.InsertAddressRequest;
import com.google.cloud.compute.v1.InsertGlobalAddressRequest;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ReserveNewExternalAddress {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Google Cloud project you want to use.
    String projectId = "your-project-id";
    // Address name you want to use.
    String addressName = "your-address-name";
    // 'IPV4' or 'IPV6' depending on the IP version. IPV6 if True.
    boolean ipV6 = false;
    // 'STANDARD' or 'PREMIUM' network tier. Standard option available only in regional ip.
    boolean isPremium = false;
    // region (Optional[str]): The region to reserve the IP address in, if regional.
    // Must be None if global.
    String region = null;

    reserveNewExternalIpAddress(projectId, addressName, ipV6, isPremium, region);
  }

  // Reserves a new external IP address in the specified project and region.
  public static List<Address> reserveNewExternalIpAddress(String projectId, String addressName,
                                                          boolean ipV6, boolean isPremium,
                                                          String region)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {

    String ipVersion = ipV6 ? IpVersion.IPV6.name() : IpVersion.IPV4.name();
    String networkTier = !isPremium && region != null
            ? NetworkTier.STANDARD.name() : NetworkTier.PREMIUM.name();

    Address.Builder address = Address.newBuilder()
            .setName(addressName)
            .setAddressType(AddressType.EXTERNAL.name())
            .setNetworkTier(networkTier);

    // Use global client if no region is specified
    if (region == null) {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      try (GlobalAddressesClient client = GlobalAddressesClient.create()) {
        address.setIpVersion(ipVersion);

        InsertGlobalAddressRequest addressRequest = InsertGlobalAddressRequest.newBuilder()
                .setProject(projectId)
                .setRequestId(UUID.randomUUID().toString())
                .setAddressResource(address.build())
                .build();

        client.insertCallable().futureCall(addressRequest).get(30, TimeUnit.SECONDS);

        return Lists.newArrayList(client.list(projectId).iterateAll());
      }
    } else {
      // Initialize client that will be used to send requests. This client only needs to be created
      // once, and can be reused for multiple requests.
      try (AddressesClient client = AddressesClient.create()) {
        address.setRegion(region);

        InsertAddressRequest addressRequest = InsertAddressRequest.newBuilder()
                .setProject(projectId)
                .setRequestId(UUID.randomUUID().toString())
                .setAddressResource(address.build())
                .setRegion(region)
                .build();

        client.insertCallable().futureCall(addressRequest).get(30, TimeUnit.SECONDS);

        return Lists.newArrayList(client.list(projectId, region).iterateAll());
      }
    }
  }
}

Python

from typing import Optional

from google.cloud.compute_v1.services.addresses.client import AddressesClient
from google.cloud.compute_v1.services.global_addresses import GlobalAddressesClient
from google.cloud.compute_v1.types import Address


def reserve_new_external_ip_address(
    project_id: str,
    address_name: str,
    is_v6: bool = False,
    is_premium: bool = False,
    region: Optional[str] = None,
):
    """
    Reserves a new external IP address in the specified project and region.

    Args:
    project_id (str): Your Google Cloud project ID.
    address_name (str): The name for the new IP address.
    is_v6 (bool): 'IPV4' or 'IPV6' depending on the IP version. IPV6 if True.
    is_premium (bool): 'STANDARD' or 'PREMIUM' network tier. Standard option available only in regional ip.
    region (Optional[str]): The region to reserve the IP address in, if regional. Must be None if global.

    Returns:
    None
    """

    ip_version = "IPV6" if is_v6 else "IPV4"
    network_tier = "STANDARD" if not is_premium and region else "PREMIUM"

    address = Address(
        name=address_name,
        address_type="EXTERNAL",
        network_tier=network_tier,
    )
    if not region:  # global IP address
        client = GlobalAddressesClient()
        address.ip_version = ip_version
        operation = client.insert(project=project_id, address_resource=address)
    else:  # regional IP address
        address.region = region
        client = AddressesClient()
        operation = client.insert(
            project=project_id, region=region, address_resource=address
        )

    operation.result()

    print(f"External IP address '{address_name}' reserved successfully.")

Promova um endereço IP externo efémero

Se a sua VM tiver um endereço IP externo efémero e quiser atribuir permanentemente o endereço IP ao seu projeto, promova o endereço IP externo efémero a um endereço IP externo estático. A promoção de um endereço IP externo efémero para reservado não faz com que Google Cloud sejam perdidos pacotes enviados para a VM. Isto inclui pacotes enviados diretamente para a VM ou através de um equilibrador de carga.

Consola

Aceda à página Endereços IP.
Aceda a Endereços IP
Clique em Endereços IP externos.
Opcional: no campo Filtrar, pesquise o endereço IP efémero que quer promover.
No menu Mais ações () do endereço IP que quer promover, selecione Promover para endereço IP estático.
Introduza um nome para o novo endereço IP estático e, de seguida, clique em Reservar.

gcloud

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

Para promover um endereço IPv4 externo efémero para um endereço IPv4 externo estático, forneça o endereço IP externo efémero através da flag --addresses com o comando compute addresses create. Use a flag region para promover um endereço IP regional efémero ou a flag global para promover um endereço IP global efémero.
```
gcloud compute addresses create ADDRESS_NAME --addresses=IP_ADDRESS \
    [--region=REGION | --global]
```
Substitua o seguinte:
- ADDRESS_NAME: o nome que quer associar a esta morada.
- IP_ADDRESS: o endereço IP que quer promover.
- REGION: a região à qual o endereço IP regional pertence.
Para promover um endereço IPv6 externo regional efémero para um endereço IPv6 externo regional estático, forneça o endereço IP externo efémero através da flag --addresses com o comando gcloud compute addresses create.
```
gcloud compute addresses create ADDRESS_NAME \
  --region=REGION \
  --addresses=IPV6_ADDRESS \
  --prefix-length=96
```
Substitua o seguinte:
- 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 está a promover.

API

Para promover um endereço IP regional efémero, 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 efémero, faça um pedido POST ao URI seguinte:

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

Especifique os valores dos campos obrigatórios do corpo do pedido:

Para endereços IPv4, o corpo do pedido deve conter os seguintes campos:

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

Para endereços IPv6, o corpo do pedido deve conter os seguintes campos:
```
{
  "name": "ADDRESS_NAME",
  "address": "IPV6_ADDRESS"
  "prefixLength": 96
  "addressType": "EXTERNAL"
}
```
Substitua o seguinte:
- ADDRESS_NAME: o nome que quer associar a esta morada
- IPV4_ADDRESS|IPV6_ADDRESS: o endereço IPv4 ou IPv6 que quer promover
- REGION: a região à qual o endereço IPv4 ou IPv6 pertence
- PROJECT_ID: o ID do projeto para este pedido

Ir

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 associado à VM, mesmo depois de ter sido promovido a um endereço IP externo estático. Se precisar de atribuir o endereço IP externo estático recém-promovido a outro recurso, desatribua o endereço IP externo estático da VM existente.

Liste endereços IP externos estáticos

Para listar os endereços IP externos estáticos que reservou para o seu projeto, siga estes passos.

Consola

Na Google Cloud consola, aceda à página Endereços IP.

Aceda a Endereços IP
Clique em Endereços IP externos.

gcloud

Use o comando gcloud compute addresses list:

Para apresentar uma lista de todos os endereços IP, use o seguinte comando:
```
gcloud compute addresses list
```
Para apresentar uma lista de todos os endereços IP globais, use o seguinte comando:
```
gcloud compute addresses list --global
```
Para apresentar uma lista de todos os endereços IP regionais numa determinada região, use o seguinte comando:
```
gcloud compute addresses list \
    --regions=REGION
```
Substitua REGION pela região para a qual quer apresentar uma lista de moradas. Pode 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 o seguinte:
- PROJECT_ID: o ID do projeto para este pedido
- REGION: o nome da região para este pedido
Para apresentar uma lista de todas as moradas 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 o seguinte:

PROJECT_ID: o ID do projeto para este pedido

Ir

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

Descreva um endereço IP externo estático

Para obter informações sobre um endereço IP externo estático, siga estes passos.

Consola

Na Google Cloud consola, aceda à página Endereços IP.

Aceda a Endereços IP
Clique em Endereços IP externos.
Clique no endereço IP sobre o qual quer obter mais informações.

gcloud

Use o comando gcloud compute addresses describe. Substitua ADDRESS_NAME pelo nome do endereço IP externo que 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 o seguinte:
- PROJECT_ID: o ID do projeto do pedido
- REGION: o nome da região para o pedido
- 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 o seguinte:
- PROJECT_ID: o ID do projeto do pedido
- ADDRESS_NAME: o nome do endereço IP

Ir

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

Libertar um endereço IP externo estático

Se já não precisar de um endereço IPv4 ou IPv6 externo estático, pode libertar o endereço IP eliminando o recurso de endereço IP.

Se estiver a usar a consola Google Cloud , só pode libertar um endereço IP estático se não estiver a ser usado por outro recurso.

Se estiver a usar a CLI gcloud ou a API, pode libertar um endereço IP, quer esteja ou não a ser usado por outro recurso.

Se o endereço IP não estiver a ser usado por um recurso, o endereço IP é devolvido ao conjunto de endereços IP externos disponíveis.
Se o endereço IP estiver a ser usado por um recurso, permanece associado ao recurso até que este seja eliminado.

Consola

Na Google Cloud consola, aceda à página Endereços IP.

Aceda a Endereços IP
Clique em Endereços IP externos.
Opcional: no campo Filtro, introduza static e, de seguida, selecione Estático : tipo na lista pendente.
Selecione o endereço IP externo estático que quer libertar.
Clique em Retirar endereço estático.

Se não vir esta opção, clique no menu Mais ações () na barra de menu superior e, de seguida, selecione Libertar endereço estático na lista.

gcloud

Use o comando compute addresses delete:

gcloud compute addresses delete ADDRESS_NAME

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

API

Para libertar 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 o seguinte:
- PROJECT_ID: o ID do projeto para este pedido
- REGION: o nome da região para este pedido
- ADDRESS_NAME: o nome do endereço IP
Para libertar 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 o seguinte:
- ADDRESS_NAME: o nome do endereço IP
- PROJECT_ID: o ID do projeto para este pedido

Ir

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

O que se segue?

Saiba como configurar endereços IP externos estáticos para uma VM nova ou existente.
Saiba mais sobre as especificações de endereços IP para regras de encaminhamento e como usar regras de encaminhamento na vista geral das regras de encaminhamento.
Saiba mais sobre endereços IP.

Reserve um endereço IP externo estático

Antes de começar

Console

gcloud

Terraform

REST

Funções necessárias

Autorizações necessárias

Acerca dos endereços IP externos estáticos

Limitações

Reserve um novo endereço IP externo estático

Consola

gcloud

Endereço IP global

Endereço IPv4 externo regional

Endereço IPv6 externo regional

Terraform

API

Ir

Java

Python

Promova um endereço IP externo efémero

Consola

gcloud

API

Ir

Java

Python

Liste endereços IP externos estáticos

Consola

gcloud

API

Ir

Java

Python

Descreva um endereço IP externo estático

Consola

gcloud

API

Ir

Java

Python

Libertar um endereço IP externo estático

Consola

gcloud

API

Ir

Java

Python

O que se segue?