Reserva una dirección IP externa estática

Puedes reservar direcciones IP externas estáticas. También puedes enumerar y liberar las direcciones IP externas estáticas reservadas. Para asignar una dirección IP externa estática a una instancia de máquina virtual (VM), consulta Configura direcciones IP externas estáticas.

Las direcciones IP externas pueden ser estáticas o efímeras. Si una VM requiere una dirección IP externa fija que no cambie, puedes obtener una dirección IP externa estática. Puedes reservar direcciones IP externas nuevas o ascender direcciones IP externas efímeras existentes.

Si necesitas una dirección IP interna estática, consulta Reserva una dirección IP interna estática, en su lugar.

Antes de comenzar

  • Lee sobre las direcciones IP.
  • Lee sobre cuotas y límites para direcciones IP externas estáticas.
  • Lee sobre los precios de las direcciones IP externas.
  • Configura la autenticación si aún no lo hiciste. La autenticación es el proceso mediante el cual se verifica tu identidad para acceder a los servicios y las API de Google Cloud. Para ejecutar código o muestras desde un entorno de desarrollo local, puedes autenticarte de la siguiente manera.

    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

    Terraform

    Para usar las muestras de Terraform de esta página en un entorno de desarrollo local, instala e inicializa gcloud CLI y, luego, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.

    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.

    Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local en la documentación de autenticación de Google Cloud.

    REST

    Para usar las muestras de la API de REST en esta página en un entorno de desarrollo local, debes usar las credenciales que proporcionas a la CLI de gcloud.

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

      gcloud init

    Si deseas obtener más información, consulta Autentica para usar REST en la documentación de autenticación de Google Cloud.

Roles obligatorios

Para obtener los permisos que necesitas para reservar y administrar direcciones IP estáticas, pídele a tu administrador que te otorgue el rol de IAM Administrador de Compute Network (roles/compute.networkAdmin) en tu proyecto. Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para reservar y administrar direcciones IP estáticas. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para reservar y administrar direcciones IP estáticas:

  • compute.addresses.create en la dirección IP
  • compute.addresses.createInternal en la dirección IP
  • compute.networks.list en la red
  • compute.subnetworks.use en la subred
  • compute.subnetworks.list en la subred

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos

Acerca de las direcciones IP externas estáticas

Una dirección IP externa estática es una dirección IP que se reserva para tu recurso hasta que decidas liberarla. Si tienes una dirección IP en la que tus clientes o usuarios confíen a fin de acceder a tu servicio, puedes reservarla para que solo tu recurso pueda usarla. También puedes subir la categoría de una dirección IP externa efímera a una dirección IP externa estática.

Para obtener más información, consulta Direcciones IP.

En la siguiente tabla, se enumeran las direcciones IP externas estáticas compatibles con Google Cloud.

Tipo de dirección IP Recurso Rango de IP Fuente Asociada con
Direcciones IPv4 externas regionales VMs y balanceadores de cargas regionales /32 Grupo de direcciones IP externas de Google Proyecto
Direcciones IPv6 externas regionales VMs y balanceadores de cargas regionales admitidos /96 Rango de direcciones IPv6 externas de la subred Subred
Direcciones IPv4 externas globales Balanceadores de cargas globales /32 Grupo de direcciones IP externas de Google Proyecto
Direcciones IPv6 externas globales Balanceadores de cargas globales /64 Grupo de direcciones IP externas de Google Proyecto

Para obtener una lista de los balanceadores de cargas regionales y globales, consulta Resumen de los tipos de balanceadores de cargas.

Limitaciones

  • Solo un recurso a la vez puede usar una dirección IP externa estática.

  • No hay forma de verificar si una dirección IP es estática o efímera después de que se asigna a un recurso. Puedes comparar la dirección IP con la lista de direcciones IP externas estáticas reservadas para ese proyecto. Usa el subcomando gcloud compute addresses list a fin de ver una lista de direcciones IP externas estáticas disponibles para el proyecto.

  • Cada VM puede tener varias interfaces de red y cada interfaz puede tener las siguientes direcciones IP asignadas:

    • Una dirección IPv4 interna (obligatoria)
    • Una dirección IPv4 externa
    • Un rango de direcciones IPv6 /96, ya sean internas o externas, pero no ambas

  • No puedes cambiar el nombre de una dirección IP estática.

  • Las direcciones IP externas asignadas existen en el mismo host físico que la instancia de VM y existen en la misma región que la VM para todos los fines, incluidos el enrutamiento, la latencia y los precios. Esto sucede sin importar la información de búsqueda de la ubicación geográfica de Internet.

Nota: Las interfaces de red pueden recibir tráfico de varias reglas de reenvío, que pueden entregar a otras direcciones IP externas. Cualquier cantidad de direcciones IP externas puede hacer referencia a una interfaz de red a través de estas reglas de reenvío, sin embargo, a cada interfaz de red se le puede asignar solo una dirección IPv4 externa y un rango de direcciones IPv6 /96 externas.

Para obtener más información sobre el balanceo de cargas y las reglas de reenvío, consulta la documentación de balanceo de cargas.

Reserva una dirección IP externa estática nueva

Después de reservar la dirección, asígnala a una VM nueva mientras la creas o a una VM existente.

Console

  1. En la consola de Google Cloud, ve a la página Direcciones IP.

    Ir a Direcciones IP

  2. Haz clic en Reservar dirección IP externa estática.
  3. En el campo Nombre, ingresa un nombre de dirección IP.
  4. Especifica si el nivel de servicio de red será Premium o Estándar. La reserva de direcciones estáticas IPv6 solo es compatible con el nivel Premium.
  5. Especifica si es una dirección IPv4 o IPv4.
  6. Elige si esta dirección IP será regional o global.
    • Si reservas una dirección IP estática para un balanceador de cargas global, elige Global y, luego, haz clic en Reservar.
    • Si reservas una dirección IP estática para una VM o un balanceador de cargas de red, elige Regional y, luego, elige la región en la que deseas crear la dirección.

  7. Si reservas una dirección IPv6 externa regional, también elige lo siguiente:

    • Red: la red de VPC
    • Subred: la subred desde la que se asigna la dirección IPv6 regional estática
    • Tipo de extremo: elige Instancia de VM o Balanceador de cargas de red

  8. Opcional: Si reservas la dirección IP externa estática de una VM, en la lista Adjuntar, elige una VM a la que deseas conectar la dirección IP.

  9. Haz clic en Reservar si deseas reservar la dirección IP.

gcloud

Para reservar una dirección IP externa estática, usa el comando gcloud compute addresses create.

Usa las siguientes instrucciones para reservar una dirección IPv4 o IPv6 externa estática:

Dirección IP global

Para reservar una dirección IP global, sigue estos pasos: 
  gcloud compute addresses create ADDRESS_NAME \
      --global \
      --ip-version [IPV4 | IPV6]

Dirección IPv4 externa regional

Para reservar una dirección IPv4 externa regional, sigue estos pasos: 
   gcloud compute addresses create ADDRESS_NAME \
       --region=REGION

Dirección IPv6 externa regional

Para reservar una dirección IPv6 externa regional, sigue estos pasos: 
   gcloud compute addresses create ADDRESS_NAME \
       --region=REGION \
       --subnet=SUBNET_NAME \
       --ip-version=IPV6 \
       --endpoint-type=[VM | NETLB]

Reemplaza lo siguiente:

  • ADDRESS_NAME: el nombre que deseas asociar a esta dirección.
  • REGION: para direcciones IP externas regionales, especifica la región en la que deseas reservar esta dirección. Esta región debe ser la misma que el recurso al que deseas conectar la dirección IP.
  • SUBNET_NAME: para direcciones IPv6 externas regionales, especifica la subred a la que se asignará la dirección IPv6 regional estática. La subred debe tener un rango de direcciones IPv6 externas asignado.
  • [IPV4 | IPV6]: para direcciones IP globales, especifica la versión de IP, ya sea IPv4 o IPv6. Para direcciones IPv6 externas regionales, especifica IPv6. Se asigna un rango de IPv6 /96 desde la subred especificada.
  • VM | NETLB: para direcciones IPv6 externas regionales, especifica el tipo de extremo; ya sea una VM o un balanceador de cargas de red.

Para ver el resultado, usa el comando gcloud compute addresses describe:

gcloud compute addresses describe ADDRESS_NAME

Terraform

Puedes usar el recurso google_compute_address para crear una dirección IP externa regional.

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

En el siguiente ejemplo, se muestra cómo usar el recurso google_compute_global_address para crear una dirección IPv6 externa 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 crear una dirección IPv4 regional, invoca el método addresses.insert regional:

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

    El cuerpo de la solicitud debe contener la siguiente información:

    {
  "name": "ADDRESS_NAME"
}

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto de esta solicitud.
    • REGION: el nombre de la región para esta solicitud
    • ADDRESS_NAME: Es el nombre que deseas asociar a la dirección

  • Para direcciones IPv4 estáticas globales, llama al método globalAddresses.insert:

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

    El cuerpo de la solicitud debe contener la siguiente información:

    {
  "name": "ADDRESS_NAME"
}

  • Para direcciones IPv6 estáticas globales, llama al método globalAddresses.insert:

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

    El cuerpo de la solicitud debe contener la siguiente información:

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

    Para ver el resultado, usa el método addresses.get.

  • Para direcciones IPv6 estáticas regionales, llama al método addresses.insert:

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

    El cuerpo de la solicitud debe contener la siguiente información:

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

    Reemplaza SUBNET por la subred de este proyecto.

    Para ver el resultado, usa el 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.")

Promueve una dirección IP externa efímera

Si tu instancia tiene una dirección IP externa efímera y deseas asignar la dirección IP a tu proyecto de manera permanente, debes promover la dirección IP externa efímera a una dirección IP externa estática. Promover una dirección IP externa efímera a una reservada no implica que Google Cloud descarte los paquetes enviados al VM. Esto incluye los paquetes que se enviaron a la VM directamente o mediante un balanceador de cargas.

Console

  1. Ve a la página Direcciones IP.

    Ir a Direcciones IP

  2. Haz clic en Direcciones IP externas.
  3. Opcional: En el campo Filtro, busca la dirección IP efímera que deseas ascender.
  4. En el menú Más acciones () de la dirección IP que deseas ascender, elige Ascender a dirección IP estática.
  5. Proporciona un nombre para la dirección IP estática nueva y haz clic en Reservar.

gcloud

Usa las siguientes instrucciones para ascender una dirección IPv4 o IPv6 externa estática:

  • Si quieres promover una dirección IPv4 externa efímera a una dirección IPv4 externa estática, debes proporcionar la dirección IP externa efímera mediante el uso de la siguiente información: --addresses marca con el compute addresses createcomando. Usa la marca region a fin de ascender una dirección IP regional efímera o la marca global a fin de ascender una dirección IP global efímera.

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

    Reemplaza lo siguiente:

    • ADDRESS_NAME: Es el nombre que deseas asociar a esta dirección.
    • IP_ADDRESS: la dirección IP que deseas ascender.

    • REGION: la región a la que pertenece la dirección IP regional.

    • Si quieres promover una dirección IPv6 externa regional efímera a una dirección IPv6 externa regional estática, debes proporcionar la dirección IP externa efímera mediante el uso de la marca --addresses con el comando compute addresses create.

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

    Reemplaza lo siguiente:

    • ADDRESS_NAME: un nombre para el recurso de dirección IP.
    • REGION: la región para el recurso de dirección IPv6.
    • IPV6_ADDRESS: la dirección IPv6 que estás promoviendo.

API

Para ascender una dirección IP regional efímera, llama al método addresses.insert:

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

Si quieres promover una dirección IP global efímera, debes realizar una solicitud POST al siguiente URI:

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

Especifica los valores para los campos obligatorios del cuerpo de la solicitud:

  • Para las direcciones IPv4, el cuerpo de la solicitud debe contener los siguientes campos:

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

  • Para las direcciones IPv6, el cuerpo de la solicitud debe contener los siguientes campos:

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

    Reemplaza lo siguiente:

    • ADDRESS_NAME: Es el nombre que deseas asociar a esta dirección
    • IPV4_ADDRESS|IPV6_ADDRESS: la dirección IPv4 o IPv6 que deseas ascender
    • REGION: la región a la que pertenece la dirección IPv4 o IPv6
    • PROJECT_ID: Es el ID del proyecto de esta solicitud.

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

La dirección IP externa permanece adjunta a la instancia incluso después de que se haya asignado a una dirección IP externa estática. Si necesitas asignar la dirección IP externa estática nueva a otro recurso, anula la asignación de la dirección IP externa estática de la VM existente.

Enumera direcciones IP externas estáticas

Para crear una lista de las direcciones IP externas estáticas que reservaste para tu proyecto, sigue estos pasos.

Console

  1. En la consola de Google Cloud, ve a la página Direcciones IP.

    Ir a Direcciones IP

  2. Haz clic en Direcciones IP externas.

gcloud

Usa el comando gcloud compute addresses list:

  • Para enumerar todas las direcciones IP, usa el siguiente comando:

    gcloud compute addresses list

  • Para enumerar todas las direcciones IP globales, usa el siguiente comando:

    gcloud compute addresses list --global

  • Para enumerar todas las direcciones IP regionales en una región determinada, usa el siguiente comando:

    gcloud compute addresses list \
    --regions=REGION

    Reemplaza REGION por la región de la que deseas enumerar las direcciones. Puedes enumerar direcciones de varias regiones si especificas nombres de región separados por comas:

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

API

  • Para enumerar las direcciones IPv4 o IPv6 regionales, llama al método addresses.list:

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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto de esta solicitud.
    • REGION: El nombre de la región para esta solicitud

  • Para enumerar todas las direcciones de todas las regiones, llama al método addresses.aggregatedList:

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

  • Para enumerar las direcciones IPv4 o IPv6 globales, llama al método globalAddresses.list:

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

    Reemplaza lo siguiente:

    PROJECT_ID: Es el ID del proyecto de esta solicitud.

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

Describe una dirección IP externa estática

Para obtener información sobre una dirección IP externa estática, sigue estos pasos.

Console

  1. En la consola de Google Cloud, ve a la página Direcciones IP.

    Ir a Direcciones IP

  2. Haz clic en Direcciones IP externas.

  3. Haz clic en la dirección IP que la que quieres obtener más información.

gcloud

Usa el comando gcloud compute addresses describe y reemplaza ADDRESS_NAME por el nombre de la dirección IP externa que deseas describir.

  • Para una dirección IPv4 o IPv6 global, usa el siguiente comando:

    gcloud compute addresses describe ADDRESS_NAME --global

  • Para una dirección IPv4 o IPv6 regional, usa el siguiente comando:

    gcloud compute addresses describe ADDRESS_NAME --region=REGION

API

  • Para describir una dirección IPv4 o IPv6 regional, llama al método addresses.get:

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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto de la solicitud.
    • REGION: El nombre de la región para esta solicitud
    • ADDRESS_NAME: El nombre de la dirección IP.

  • Para describir una dirección IPv4 o IPv6 global, llama al método globalAddresses.get:

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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto de la solicitud.
    • ADDRESS_NAME: El nombre de la dirección 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 una dirección IP externa estática

Si ya no necesitas una dirección IPv4 o IPv6 externa estática, puedes borrar el recurso de dirección IP para liberarla.

Si usas la consola de Google Cloud, puedes liberar una dirección IP estática solo si no la usa otro recurso.

Si usas gcloud CLI o la API, puedes liberar una dirección IP, ya sea que la use otro recurso o no.

  • Si un recurso no usa la dirección IP, esta se muestra al grupo de direcciones IP externas disponibles.

  • Si un recurso usa la dirección IP, permanece adjunta al recurso hasta que este se borra.

Console

  1. En la consola de Google Cloud, ve a la página Direcciones IP.

    Ir a Direcciones IP

  2. Haz clic en Direcciones IP externas.

  3. Opcional: En el campo Filtro, ingresa static y, luego, selecciona Estático: Tipo en la lista desplegable.

  4. Elige la dirección IP externa estática que deseas liberar.

  5. Haz clic en Liberar dirección estática.

    Si no ves esta opción, haz clic en el menú Más acciones () en la barra de menú superior y, luego, selecciona Liberar dirección estática en la lista.

gcloud

Usa el comando compute addresses delete:

gcloud compute addresses delete ADDRESS_NAME

Reemplaza ADDRESS_NAME por el nombre de la dirección IPv4 o IPv6 que deseas liberar.

API

  • Para liberar una dirección IPv4 o IPv6 regional, llama al método addresses.delete:

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

    Reemplaza lo siguiente:

    • PROJECT_ID: Es el ID del proyecto de esta solicitud.
    • REGION: El nombre de la región para esta solicitud
    • ADDRESS_NAME: El nombre de la dirección IP.

  • Para liberar una dirección IPv4 o IPv6 global, llama al método globalAddresses.delete:

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

    Reemplaza lo siguiente:

    • ADDRESS_NAME: El nombre de la dirección IP.
    • PROJECT_ID: Es el ID del proyecto de esta solicitud.

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

¿Qué sigue?