Esta página se ha traducido con Cloud Translation API.

Reservar una dirección IP externa estática

Puedes reservar direcciones IP externas estáticas. También puedes enumerar y liberar tus direcciones IP externas estáticas reservadas. Para asignar una dirección IP externa estática a una instancia de máquina virtual, consulta Configurar 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 nuevas direcciones IP externas o promover direcciones IP externas efímeras.

Si necesitas una dirección IP interna estática, consulta el artículo Reservar una dirección IP interna estática.

Antes de empezar

Consulta información sobre las direcciones IP.
Consulta las cuotas y los límites de las direcciones IP externas estáticas.
Consulta los precios de las direcciones IP externas.
Si aún no lo has hecho, configura la autenticación. La autenticación es el proceso por el que se verifica tu identidad para acceder a los servicios y las APIs de Google Cloud . Para ejecutar código o ejemplos 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 la CLI de Google Cloud ejecutando el siguiente comando:
```
gcloud init
```
Si utilizas un proveedor de identidades (IdP) externo, primero debes iniciar sesión en la CLI de gcloud con tu identidad federada.

Nota: Si ya has instalado la CLI de gcloud, 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 la CLI de gcloud y, a continuación, configura las credenciales predeterminadas de la aplicación con tus credenciales de usuario.
Para obtener más información, consulta Configurar ADC en un entorno de desarrollo local en la documentación de autenticación Google Cloud .
REST

Para usar las muestras de la API REST de esta página en un entorno de desarrollo local, debes usar las credenciales que proporciones a la CLI de gcloud.
Para obtener más información, consulta el artículo Autenticarse para usar REST de la documentación sobre autenticación de Google Cloud .

Roles obligatorios

Para obtener los permisos que necesitas para reservar y gestionar direcciones IP estáticas, pide a tu administrador que te conceda el rol de gestión de identidades y accesos Administrador de red de Compute (roles/compute.networkAdmin) en tu proyecto. Para obtener más información sobre cómo conceder roles, consulta el artículo Gestionar el acceso a proyectos, carpetas y organizaciones.

Este rol predefinido contiene los permisos necesarios para reservar y gestionar direcciones IP estáticas. Para ver los permisos exactos que se necesitan, despliega la sección Permisos necesarios:

Permisos obligatorios

Para reservar y gestionar direcciones IP estáticas, se necesitan los siguientes permisos:

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 u otros roles predefinidos.

Acerca de las direcciones IP externas estáticas

Una dirección IP externa estática es la dirección IP reservada para tu recurso hasta que decidas liberarla. Si tienes una dirección IP que tus clientes o usuarios utilizan para acceder a tu servicio, puedes reservarla para que solo tu recurso pueda usarla. También puedes promocionar una dirección IP externa efímera a una dirección IP externa estática.

Para obtener más información, consulta el artículo Direcciones IP.

En la siguiente tabla se enumeran las direcciones IP externas estáticas admitidas porGoogle Cloud.

Tipo de dirección IP	Recurso	Intervalo de IP	Fuente	Asociado con
Direcciones IPv4 externas regionales	Máquinas virtuales y balanceadores de carga regionales	`/32`	Grupo de direcciones IP externas de Google	Proyecto
Direcciones IPv6 externas regionales	Máquinas virtuales y balanceadores de carga regionales admitidos	`/96`	Intervalo de direcciones IPv6 externas de la subred	Subred
Direcciones IPv4 externas globales	Balanceadores de carga globales	`/32`	Grupo de direcciones IP externas de Google	Proyecto
Direcciones IPv6 externas globales	Balanceadores de carga globales	`/64`	Grupo de direcciones IP externas de Google	Proyecto

Para ver una lista de los balanceadores de carga regionales y globales, consulta el resumen de los tipos de balanceadores de carga.

Las direcciones IP externas asignadas se encuentran en el mismo host físico que la VM y en la misma región que la VM para todos los fines, incluidos el enrutamiento, la latencia y los precios. Esto es así con independencia de la información de búsqueda de geolocalización de Internet.

Limitaciones

Solo un recurso a la vez puede usar una dirección IP externa estática.
No hay forma de comprobar si una dirección IP es estática o efímera después de que se haya asignado 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 para 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 asignadas las siguientes direcciones IP según su tipo de pila:
- Interfaces solo IPv4:
  - Una dirección IPv4 interna (obligatoria)
  - Una dirección IPv4 externa (opcional)
- Interfaces de doble pila (IPv4 e IPv6):
  - Una dirección IPv4 interna (obligatoria)
  - Una dirección IPv4 externa (opcional)
  - Un intervalo de direcciones IPv6, ya sea interno o externo, pero no ambos (obligatorio)/96
- Interfaces solo IPv6:
  - Un intervalo de direcciones IPv6, ya sea interno o externo, pero no ambos (obligatorio)/96
No puedes desasignar ni cambiar la dirección IPv6 externa de una VM con una interfaz de red solo IPv6. Sin embargo, puedes convertir una dirección IP externa efímera de un recurso en una dirección IP externa estática para que la dirección siga reservada incluso después de que se elimine 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 servir otras direcciones IP externas. Cualquier número de direcciones IP externas puede hacer referencia a una interfaz de red a través de estas reglas de reenvío, pero a cada interfaz de red solo se le puede asignar una dirección IPv4 externa y un intervalo de direcciones IPv6 externas /96.

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

Reservar una dirección IP externa estática nueva

Después de reservar la dirección, asígnala a una máquina virtual nueva al crearla o a una máquina virtual que ya tengas.

Consola

En la Google Cloud consola, ve a la página Direcciones IP.
Ir a direcciones IP
Haz clic en Reservar dirección IP estática externa.
En el campo Nombre, introduce un nombre para la dirección IP.
Especifica si el nivel de servicio de red es Premium o Standard. La reserva de direcciones estáticas IPv6 solo se admite en el nivel Premium.
Especifica si se trata de una dirección IPv4 o IPv6.
Especifica si esta dirección IP es Regional o Global.
- Si vas a reservar una dirección IP estática para un balanceador de carga global, elige Global y, a continuación, haz clic en Reservar.
- Si vas a reservar una dirección IP estática para una VM o para un balanceador de carga regional, elige Regional y, a continuación, selecciona la región en la que quieres crear la dirección.
Si vas a reservar una dirección IPv6 externa regional, elige también lo siguiente:
- Red: la red de VPC
- Subred: la subred de la que se asignará la dirección IPv6 regional estática
- Tipo de endpoint: elige Instancia de VM o Balanceador de carga de red.
Opcional: Si vas a reservar la dirección IP externa estática para una máquina virtual, selecciona una máquina virtual en la lista Asignado a para asignarle la dirección IP.
Haz clic en Reservar para reservar la dirección IP.

gcloud

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

Sigue estas 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

Haz los cambios siguientes:

ADDRESS_NAME: el nombre que quieras asociar a esta dirección.
REGION: en el caso de las direcciones IP externas regionales, especifica una región para la dirección IP.
SUBNET_NAME: en el caso de las direcciones IPv6 externas regionales, especifica la subred desde la que se asignará la dirección IPv6 regional estática. La subred debe tener un intervalo de direcciones IPv6 externas asignado.
IP_VERSION: para las direcciones IP globales, especifica la versión de IP, IPv4 o IPv6.
ENDPOINT_TYPE: en el caso de las direcciones IPv6 externas regionales, especifica el tipo de endpoint, 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, llama al método regional addresses.insert:
```
POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/addresses
```
El cuerpo de la solicitud debe contener lo siguiente:
```
{
  "name": "ADDRESS_NAME"
}
```
Haz los cambios siguientes:
- PROJECT_ID: el ID de proyecto de esta solicitud
- REGION: el nombre de la región de esta solicitud
- ADDRESS_NAME: el nombre que quieras asociar a la dirección
Para las 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 lo siguiente:
```
{
  "name": "ADDRESS_NAME"
}
```
Para las 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 lo siguiente:
```
{
  "name": "ADDRESS_NAME",
  "ipVersion": "IPV6"
}
```
Para ver el resultado, usa el método addresses.get.

Para las 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 lo siguiente:

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

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

Promocionar una dirección IP externa efímera

Si tu máquina virtual tiene una dirección IP externa efímera y quieres asignarla permanentemente a tu proyecto, conviértela en una dirección IP externa estática. Al promover una dirección IP externa efímera a reservada, no se pierden los paquetes enviados a la máquina virtual. Google Cloud Esto incluye los paquetes enviados a la máquina virtual directamente o mediante un balanceador de carga.

Consola

Ve a la página Direcciones IP.
Ir a direcciones IP
Haz clic en Direcciones IP externas.
Opcional: En el campo Filtrar, busca la dirección IP efímera que quieras promocionar.
En el menú Más acciones () de la dirección IP que quieras convertir en estática, selecciona Convertir en dirección IP estática.
Introduce un nombre para la nueva dirección IP estática y haz clic en Reservar.

gcloud

Sigue estas instrucciones para promover una dirección IPv4 o IPv6 externa estática:

Para convertir una dirección IPv4 externa efímera en una estática, proporciona la dirección IP externa efímera mediante la marca --addresses con el comando compute addresses create. Usa la marca region para promover una dirección IP regional efímera o la marca global para promover una dirección IP global efímera.
```
gcloud compute addresses create ADDRESS_NAME --addresses=IP_ADDRESS \
    [--region=REGION | --global]
```
Haz los cambios siguientes:
- ADDRESS_NAME: el nombre que quieras asociar a esta dirección.
- IP_ADDRESS: la dirección IP que quieras promocionar.
- REGION: la región a la que pertenece la dirección IP regional.
Para convertir una dirección IPv6 externa regional efímera en una dirección IPv6 externa regional estática, proporciona la dirección IP externa efímera mediante la marca --addresses con el comando gcloud compute addresses create.
```
gcloud compute addresses create ADDRESS_NAME \
  --region=REGION \
  --addresses=IPV6_ADDRESS \
  --prefix-length=96
```
Haz los cambios siguientes:
- ADDRESS_NAME: nombre del recurso de dirección IP.
- REGION: la región del recurso de dirección IPv6.
- IPV6_ADDRESS: la dirección IPv6 que quieres promocionar.

API

Para promover 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

Para promocionar una dirección IP global efímera, haz una solicitud POST al siguiente URI:

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

Especifique los valores de los campos obligatorios del cuerpo de la solicitud:

En el caso de las direcciones IPv4, el cuerpo de la solicitud debe contener los siguientes campos:
```
{
  "name": "ADDRESS_NAME",
  "address": "IPV4_ADDRESS"
  "addressType": "EXTERNAL"
}
```
En el caso de las direcciones IPv6, el cuerpo de la solicitud debe contener los siguientes campos:
```
{
  "name": "ADDRESS_NAME",
  "address": "IPV6_ADDRESS"
  "prefixLength": 96
  "addressType": "EXTERNAL"
}
```
Haz los cambios siguientes:
- ADDRESS_NAME: el nombre que quieras asociar a esta dirección
- IPV4_ADDRESS|IPV6_ADDRESS: la dirección IPv4 o IPv6 que quieras promocionar
- REGION: la región a la que pertenece la dirección IPv4 o IPv6
- PROJECT_ID: el ID de 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 asociada a la VM incluso después de que se haya convertido en una dirección IP externa estática. Si necesitas asignar la dirección IP externa estática recién promovida a otro recurso, desasigna la dirección IP externa estática de la máquina virtual.

Mostrar direcciones IP externas estáticas

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

Consola

En la Google Cloud consola, 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 obtener una lista de todas las direcciones IP, usa el siguiente comando:
```
gcloud compute addresses list
```
Para ver una lista con todas las direcciones IP globales, usa el siguiente comando:
```
gcloud compute addresses list --global
```
Para obtener una lista con todas las direcciones IP regionales de una región determinada, usa el siguiente comando:
```
gcloud compute addresses list \
    --regions=REGION
```
Sustituye REGION por la región de la que quieras obtener la lista de direcciones. Puede enumerar las direcciones de varias regiones especificando los nombres de las regiones 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
```
Haz los cambios siguientes:
- PROJECT_ID: el ID de proyecto de esta solicitud
- REGION: el nombre de la región de esta solicitud
Para obtener una lista de 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
```
Haz los cambios siguientes:

PROJECT_ID: el ID de 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.

Consola

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

Ir a direcciones IP
Haz clic en Direcciones IP externas.
Haz clic en la dirección IP sobre la que quieras obtener más información.

gcloud

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

Para obtener una dirección IPv4 o IPv6 global, usa el siguiente comando:
```
gcloud compute addresses describe ADDRESS_NAME --global
```
Para obtener 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
```
Haz los cambios siguientes:
- PROJECT_ID: el ID del proyecto de la solicitud
- REGION: el nombre de la región de la 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
```
Haz los cambios siguientes:
- PROJECT_ID: 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 liberar la dirección IP eliminando el recurso de dirección IP.

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

Si usas la CLI de gcloud o la API, puedes liberar una dirección IP independientemente de si la usa otro recurso.

Si la dirección IP no la utiliza ningún recurso, se devuelve al grupo de direcciones IP externas disponibles.
Si un recurso está usando la dirección IP, esta permanecerá asociada al recurso hasta que se elimine.

Consola

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

Ir a direcciones IP
Haz clic en Direcciones IP externas.
Opcional: En el campo Filtro, introduce static y, a continuación, selecciona Estático : tipo en la lista desplegable.
Selecciona la dirección IP externa estática que quieras liberar.
Haz clic en Liberar dirección estática.

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

gcloud

Usa el comando compute addresses delete:

gcloud compute addresses delete ADDRESS_NAME

Sustituye ADDRESS_NAME por el nombre de la dirección IPv4 o IPv6 que quieras 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
```
Haz los cambios siguientes:
- PROJECT_ID: el ID de proyecto de esta solicitud
- REGION: el nombre de la región de 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
```
Haz los cambios siguientes:
- ADDRESS_NAME: el nombre de la dirección IP
- PROJECT_ID: el ID de 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.")

Siguientes pasos

Consulta cómo configurar direcciones IP externas estáticas para una VM nueva o ya creada.
Consulta las especificaciones de las direcciones IP de las reglas de reenvío y cómo usar reglas de reenvío en la descripción general de las reglas de reenvío.
Más información sobre las direcciones IP

Reservar una dirección IP externa estática

Antes de empezar

Console

gcloud

Terraform

REST

Roles obligatorios

Permisos obligatorios

Acerca de las direcciones IP externas estáticas

Limitaciones

Reservar una dirección IP externa estática nueva

Consola

gcloud

Dirección IP global

Dirección IPv4 externa regional

Dirección IPv6 externa regional

Terraform

API

Go

Java

Python

Promocionar una dirección IP externa efímera

Consola

gcloud

API

Go

Java

Python

Mostrar direcciones IP externas estáticas

Consola

gcloud

API

Go

Java

Python

Describe una dirección IP externa estática

Consola

gcloud

API

Go

Java

Python

Liberar una dirección IP externa estática

Consola

gcloud

API

Go

Java

Python

Siguientes pasos