Se usó la API de Cloud Translation para traducir esta página.

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 Google Cloud servicios y las APIs. 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

Instala Google Cloud CLI. Después de la instalación, inicializa Google Cloud CLI ejecutando el siguiente comando:
```
gcloud init
```
Si usas un proveedor de identidad externo (IdP), primero debes acceder a gcloud CLI con tu identidad federada.

Nota: Si ya instalaste gcloud CLI, asegúrate de que tienes la versión más reciente ejecutando gcloud components update.
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.
Para obtener más información, consulta Configura ADC 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 proporciones a gcloud CLI.
Para obtener más información, consulta Autentícate para usar REST en la documentación de autenticación de Google Cloud .

Roles requeridos

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 de 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 conGoogle 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.

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.

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 según su tipo de pila:
- Interfaces solo IPv4:
  - Una dirección IPv4 interna (obligatoria)
  - Una dirección IPv4 externa (opcional)
- Interfaces de pila doble (IPv4 e IPv6):
  - Una dirección IPv4 interna (obligatoria)
  - Una dirección IPv4 externa (opcional)
  - Un rango de direcciones IPv6 /96, ya sean internas o externas, pero no ambas (obligatorio)
- Interfaces solo IPv6:
  - Un rango de direcciones IPv6 /96, ya sean internas o externas, pero no ambas (obligatorio)
No puedes anular la asignación ni cambiar la dirección IPv6 externa de una VM con una interfaz de red solo para IPv6. Sin embargo, puedes promover una dirección IP externa efímera de un recurso a una dirección IP externa estática para que la dirección permanezca reservada incluso después de que se borre el recurso.
No puedes cambiar el nombre de una dirección IP estática.

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

En la consola de Google Cloud , ve a la página Direcciones IP.
Ir a Direcciones IP
Haz clic en Reservar dirección IP externa estática.
En el campo Nombre, ingresa un nombre de dirección IP.
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.
Especifica si es una dirección IPv4 o IPv6.
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.
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
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.
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=IP_VERSION

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

Reemplaza lo siguiente:

ADDRESS_NAME: el nombre que deseas asociar a esta dirección.
REGION: Para direcciones IP externas regionales, especifica una región para 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.
IP_VERSION: Para direcciones IP globales, especifica la versión de IP, ya sea IPv4 o IPv6.
ENDPOINT_TYPE: Para direcciones IPv6 externas regionales, especifica el tipo de extremo, ya sea VM o NETLB.

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.
    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 a la VM. Esto incluye los paquetes que se enviaron a la VM directamente o mediante un balanceador de cargas.

Console

Ve a la página Direcciones IP.
Ir a Direcciones IP
Haz clic en Direcciones IP externas.
Opcional: En el campo Filtro, busca la dirección IP efímera que deseas ascender.
En el menú Más acciones () de la dirección IP que deseas ascender, elige Ascender a dirección IP estática.
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 gcloud 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

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

Ir a Direcciones IP
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

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

Ir a Direcciones IP
Haz clic en Direcciones IP externas.
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 Google Cloud consola, 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

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

Ir a Direcciones IP
Haz clic en Direcciones IP externas.
Opcional: En el campo Filtro, ingresa static y, luego, selecciona Estático: Tipo en la lista desplegable.
Elige la dirección IP externa estática que deseas liberar.
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?

Obtén información sobre cómo configurar direcciones IP externas estáticas para una VM nueva o existente.
Obtén información sobre las especificaciones de direcciones IP para las reglas de reenvío y cómo usar reglas de reenvío en la Descripción general de las reglas de reenvío.
Obtén más información acerca de las direcciones IP.