Usa rutas

En esta página, se describe cómo crear y administrar rutas para redes de nube privada virtual (VPC) en Google Cloud. También, se da por hecho que estás familiarizado con los diferentes tipos de rutas de Google Cloud y sus características, como se describe en la Descripción general de rutas.

En cada red nueva hay dos tipos de rutas que genera el sistema: una ruta predeterminada, la cual se puede quitar o reemplazar, y una ruta de subred para cada una de las subredes. No puedes quitar una ruta de subred, a menos que borres la subred correspondiente.

Además de las rutas generadas por el sistema, puedes crear otras rutas estáticas personalizadas.

Enumera las rutas para una red de VPC

Puedes usar Google Cloud CLI o la API para enumerar y ver detalles de los siguientes tipos de rutas:

• Rutas predeterminadas
• Rutas de subred
• Rutas de subred de intercambio de tráfico
• Rutas estáticas

Ni los comandos de gcloud CLI ni los métodos de la API muestran los siguientes tipos de rutas:

• Rutas basadas en políticas
• Rutas dinámicas
• Intercambio de tráfico de rutas estáticas y dinámicas

Para ver la vista completa de rutas, usa la consola de Google Cloud. Para enumerar y describir rutas basadas en políticas, consulta Usa rutas basadas en políticas.

Console

1. En la consola de Google Cloud, ve a la página Supervisión.

   Ir a Rutas

2. En la pestaña Effective routes, haz lo siguiente:

   • Elige una red de VPC.
   • Elige una región.

3. Haz clic en Ver.

4. Puedes filtrar propiedades, como el tipo de ruta, el rango de IP de destino y el tipo de siguiente salto.

5. Opcional: Haz clic en el botón de activación Mostrar rutas suprimidas a la posición activada para ver las rutas que se suprimen. Para ver el motivo por el que se suprimió una ruta, coloca el cursor sobre el ícono en la columna Estado.

gcloud

Para enumerar y ver los detalles de las rutas, usa los comandos gcloud compute routes. Se muestran las rutas de subred y las rutas estáticas de la red de VPC local y cualquier red de VPC con intercambio de tráfico. No se muestran otros tipos de ruta. Para ver todas las rutas, usa la consola de Google Cloud.

Para enumerar las rutas, haz lo siguiente:

gcloud compute routes list \
    --filter="network=NETWORK_NAME" \
    --project=PROJECT_ID

Para obtener detalles de una ruta, haz lo siguiente:

gcloud compute routes describe ROUTE_NAME \
    --format="flattened()" \
    --project=PROJECT_ID

Reemplaza lo siguiente:

• NETWORK_NAME: Es el nombre de la red de VPC.
• PROJECT_ID: el ID del proyecto que contiene tu red de VPC.
• ROUTE_NAME: el nombre de la ruta.

API

Para enumerar y ver los detalles de las rutas, usa los métodos routes.list y routes.get. Se muestran las rutas de subred y las rutas estáticas de la red de VPC local y cualquier red de VPC de intercambio de tráfico. No se muestran otros tipos de ruta. Para ver todas las rutas, usa la consola de Google Cloud.

Para enumerar las rutas, haz lo siguiente:

GET https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/routes?filter=network="NETWORK_URL

Para obtener detalles de una ruta, haz lo siguiente:

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

Reemplaza lo siguiente:

• PROJECT_ID: el ID del proyecto que contiene tu red de VPC.
• NETWORK_URL: la URL de la red de VPC.
• ROUTE_NAME: el nombre de la ruta.

Enumera las rutas aplicables a una interfaz de red de VM

Puedes usar la consola de Google Cloud a fin de ver las rutas aplicables para la interfaz de red de una VM. En esta vista, se acota la lista de rutas que puedes usar para el tráfico de salida.

Para ver las rutas aplicables a una interfaz de red específica de una VM, sigue estos pasos.

Console

1. En la consola de Google Cloud, ve a la página Instancias de VM.

   Ir a Instancias de VM

2. Ubica la instancia de VM en la lista. En el menú Más acciones al final de la fila, selecciona Ver detalles de red.

3. Si una instancia tiene varias interfaces de red, en la sección Detalles de la interfaz de red, selecciona la interfaz de red que deseas ver.

4. En la sección Detalles de firewall y rutas, haz clic en la pestaña Rutas para ver todas las rutas que aplican a la interfaz de red, ordenadas por nombre de ruta.

Agrega y quita rutas estáticas

Puedes agregar o quitar rutas estáticas y rutas basadas en políticas que sean locales para tu red de VPC. En esta sección, se describe cómo agregar y borrar rutas estáticas locales. Para obtener más información sobre cómo agregar y quitar rutas basadas en políticas, consulta Usa rutas basadas en políticas.

Las rutas de subred se agregan y borran de forma automática cuando agregas o borras una subred. Para obtener más información sobre cómo agregar y quitar subredes, consulta Trabaja con subredes.

Todas las rutas en una red de VPC que están conectadas mediante el intercambio de tráfico entre redes de VPC deben manipularse en la red de VPC que exporta esas rutas. Para obtener más información, consulta Opciones de intercambio de rutas.

Importante: Las rutas estáticas no se pueden modificar después de su creación. En su lugar, borra la ruta y crea una ruta de reemplazo.

Antes de agregar una ruta estática

Antes de agregar una ruta estática, considera lo siguiente:

• Asegúrate de comprender los diferentes tipos de siguientes saltos que pueden usar las rutas estáticas. Para obtener información sobre los diferentes tipos de próximos saltos de rutas estáticas, incluidos los que admiten destinos de IPv6, consulta Siguientes saltos y características.
• A menos que uses subredes híbridas, una ruta estática no puede tener un rango de destino que coincida con el rango de destino de una subred o una ruta de subred de intercambio de tráfico o sea más específico que dicho rango. Para obtener más información, consulta Interacciones con rutas estáticas personalizadas en Descripción general de la ruta y, además, Interacciones de la ruta estática y la subred en la documentación de intercambio de tráfico entre redes de VPC.
• Para evitar conflictos cuando usas una red de VPC de modo automático, no crees rutas estáticas cuyos destinos se ajusten a 10.128.0.0/9. Revisa los rangos IPv4 del modo automático para obtener más detalles.
• Los destinos de las rutas estáticas personalizadas no se pueden superponer con ningún rango asignado interno.
• Asegúrate de estar familiarizado con las instancias como siguientes saltos antes de crear una ruta estática personalizada que use una VM como su siguiente salto. Google Cloud solo valida que exista una VM en el momento en que creas la ruta si eliges una instancia de siguiente salto.
• Si creas una ruta con una etiqueta de red, solo las VM con esa etiqueta reciben esa ruta. Sin embargo, las VM etiquetadas aún recibirán todas las rutas que no tengan una etiqueta de red.

Nota: Para los siguientes saltos que usan Cloud Router, puedes usar rutas aprendidas personalizadas como alternativa a las rutas estáticas. A diferencia de las rutas estáticas, las rutas aprendidas personalizadas se suprimen de forma automática si su sesión de BGP asociada se interrumpe. Este comportamiento permite que se usen rutas alternativas en caso de una interrupción de red y puede evitar que el tráfico se descarte. Además, a diferencia de las rutas estáticas, las rutas aprendidas personalizadas se pueden usar a través de adjuntos de VLAN de Cloud Interconnect y túneles VPN con alta disponibilidad. Para obtener más información, consulta Rutas de aprendizaje personalizadas. Esta función está en vista previa.

Agrega una ruta estática

Agrega una ruta estática a una red. Para obtener más información sobre los diferentes tipos de siguientes saltos de rutas estáticas, incluidos los que admiten destinos de IPv6, consulta Siguientes saltos y características.

Console

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

   Ir a Rutas

2. Haz clic en la pestaña Administración de rutas.

3. Haz clic en Crear ruta.

4. Especifica un Nombre y una Descripción para la ruta.

5. En la lista Red, selecciona una red existente para la ruta.

6. En la lista Tipo de ruta, selecciona Ruta estática.

7. En la lista Versión de IP, selecciona la versión de IP requerida:

   • Para crear una ruta estática IPv4, selecciona IPv4.
   • Para crear una ruta estática IPv6, selecciona IPv6.

8. Especifica un rango de IP de destino. El destino más amplio posible es 0.0.0.0/0 para IPv4 o ::/0 para IPv6.

9. Especifica una prioridad para la ruta. La prioridad puede ser de 0 (la prioridad más alta) a 65535 (la prioridad más baja).

10. Para que la ruta sea aplicable solo a instancias seleccionadas con etiquetas de red que coincidan, especifícalas en el campo Etiquetas de instancia. Para que la ruta sea aplicable a todas las instancias de la red, deja el campo en blanco.

11. Selecciona un próximo salto para la ruta:

    • Puerta de enlace de Internet predeterminada: entrega paquetes a Internet y a los servicios y las APIs de Google
    • Especifica una instancia: entrega paquetes a la interfaz de red de una instancia de VM. Especifica la instancia de VM por nombre y zona. Si el destino de la ruta es una dirección IPv6, la instancia de VM debe ser pila doble.
    • Especifica la dirección IP de una instancia: Especifica la dirección IP de una instancia existente en la red de VPC. Para las rutas estáticas IPv6 (vista previa), la instancia debe ser de pila doble. Para conocer las restricciones importantes de direcciones IP de siguiente salto válidas, consulta Siguientes saltos de rutas estáticas.
    • Especifica el túnel VPN: entrega paquetes a un túnel de VPN clásica existente mediante el enrutamiento estático.
    • Especifica una regla de reenvío de un balanceador de cargas de red de transferencia interno: entrega paquetes a un balanceador de cargas de red de transferencia interno, que se especifica por su nombre y región de regla de reenvío interno.

12. Haz clic en Crear.

gcloud

Crea una ruta estática personalizada nueva con el siguiente comando de gcloud CLI:

gcloud compute routes create ROUTE_NAME \
    --network=NETWORK \
    --destination-range=DESTINATION_RANGE \
    --priority=PRIORITY \
    NEXT_HOP_SPECIFICATION

Reemplaza lo siguiente:

• ROUTE_NAME: el nombre de la ruta
• NETWORK: es el nombre de la red de VPC que contiene la ruta
• DESTINATION_RANGE: las direcciones IPv4 o IPv6 de destino a las que se aplica esta ruta. El destino más amplio posible es 0.0.0.0/0 para IPv4 o ::/0 para IPv6.
• PRIORITY: La prioridad de ruta, que puede ser de 0 (la prioridad más alta) a 65535 (la prioridad más baja)

• NEXT_HOP_SPECIFICATION: el próximo salto de la ruta estática. Usa uno de los siguientes parámetros o una combinación de parámetros:

  • --next-hop-gateway=default-internet-gateway: Entrega paquetes en Internet, a las APIs y a los servicios de Google.
  • --next-hop-instance=INSTANCE_NAME y --next-hop-instance-zone=ZONE: entregan paquetes a la interfaz de red de una instancia de VM existente. Especifica la instancia de VM por nombre y zona. Si el destino de la ruta es una dirección IPv6, la instancia de VM debe ser pila doble.
  • --next-hop-address=ADDRESS: especifica una IP de una instancia existente en la red de VPC. Para las rutas estáticas IPv6 (vista previa), la instancia debe ser de pila doble. Para conocer las restricciones importantes de direcciones IP de siguiente salto válidas, consulta Próximos saltos y funciones.
  • --next-hop-vpn-tunnel=VPN_TUNNEL_NAME y --next-hop-vpn-tunnel-region=REGION: entregan paquetes a un túnel de VPN clásica existente mediante el enrutamiento estático.
  • --next-hop-ilb=FORWARDING_RULE y --next-hop-ilb-region=REGION: entregan paquetes a un balanceador de cargas de red de transferencia interno. Especifica la instancia de VM mediante el nombre (o la dirección IPv4) y la región de la regla de reenvío interno.

  Para que la ruta estática personalizada solo se aplique a ciertas VM por etiqueta de red, agrega la marca --tags y especifica una o más etiquetas de red. Para obtener más información sobre cómo trabajan las etiquetas de red en conjunto con las rutas estáticas personalizadas, consulta Rutas aplicables en la descripción general de rutas. Puedes usar etiquetas con cualquier ruta estática personalizada.

Para obtener más información sobre la sintaxis de gcloud CLI, consulta la documentación del SDK.

API

Crea una nueva ruta estática personalizada.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/routes
{
  "name": "ROUTE_NAME",
  "network": "NETWORK_NAME",
  "destRange": "DESTINATION_RANGE",
  "priority": PRIORITY,
  "NEXT_HOP_SPECIFICATION"
}

Reemplaza lo siguiente:

• PROJECT_ID: el ID del proyecto en el que se crea tu ruta.
• ROUTE_NAME: el nombre de la ruta
• NETWORK: es el nombre de la red de VPC que contiene la ruta.
• DESTINATION_RANGE: el rango de direcciones IPv4 o IPv6 de destino al que se aplica esta ruta. El destino más amplio posible es 0.0.0.0/0 para IPv4 o ::/0 para IPv6.
• PRIORITY: La prioridad de ruta, que puede ser de 0 (la prioridad más alta) a 65535 (la prioridad más baja)
• NEXT_HOP_SPECIFICATION: el próximo salto de la ruta estática. Usa uno de los siguientes parámetros o una combinación de parámetros:
  • nextHopGateway: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/gateways/default-internet-gateway: entrega paquetes a Internet, a las APIs y a los servicios de Google
  • nextHopInstance: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME: entrega paquetes en la interfaz de red de una instancia de VM. Especifica la instancia de VM por nombre y zona. Si el destino de la ruta es una dirección IPv6, la instancia de VM debe ser pila doble.
  • nextHopIp: ADDRESS: especifica una IP de una instancia existente en la red de VPC. Para las rutas estáticas IPv6 (vista previa), la instancia debe ser de pila doble. Para conocer las restricciones importantes de direcciones IP de siguiente salto válidas, consulta Próximos saltos y funciones.
  • nextHopVpnTunnel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/vpnTunnels/VPN_TUNNEL_NAME: entrega paquetes a un túnel de VPN clásica existente mediante el enrutamiento estático.
  • nextHopIlb: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/forwardingRules/FORWARDING_RULE: entrega paquetes a un balanceador de cargas de red de transferencia interno. Especifica la instancia de VM mediante el nombre (o la dirección IPv4) y la región de la regla de reenvío interno.

Para que la ruta estática personalizada se aplique solo a algunas VM por etiqueta de red, agrega el campo tags y especifica una o más etiquetas de red. Para obtener más información sobre cómo trabajan las etiquetas de red en conjunto con las rutas estáticas personalizadas, consulta Rutas aplicables en la descripción general de rutas. Puedes usar etiquetas con cualquier ruta estática personalizada.

Para obtener más información, consulta el método routes.insert.

Terraform

Puedes crear una ruta estática mediante un módulo de Terraform.

Esta ruta estática crea una ruta predeterminada a Internet.

module "google_compute_route" {
  source       = "terraform-google-modules/network/google//modules/routes"
  version      = "~> 9.0"
  project_id   = var.project_id # Replace this with your project ID in quotes
  network_name = "default"

  routes = [
    {
      name              = "egress-internet"
      description       = "route through IGW to access internet"
      destination_range = "0.0.0.0/0"
      tags              = "egress-inet"
      next_hop_internet = "true"
    }
  ]
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

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

// createRoute creates a route with given name inside given project.
func createRoute(w io.Writer, projectID, name string) error {
	// projectID := "your_project_id"
	// name := "testname"

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

	route := &computepb.Route{
		Name:           proto.String(name),
		Network:        proto.String("global/networks/default"),
		DestRange:      proto.String("0.0.0.0/0"),
		NextHopGateway: proto.String("global/gateways/default-internet-gateway"),
	}

	req := &computepb.InsertRouteRequest{
		Project:       projectID,
		RouteResource: route,
	}
	op, err := client.Insert(ctx, req)

	if err != nil {
		return fmt.Errorf("unable to insert a route: %w", err)
	}

	if err := op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Route created\n")

	return nil
}

Java

import com.google.cloud.compute.v1.InsertRouteRequest;
import com.google.cloud.compute.v1.Operation;
import com.google.cloud.compute.v1.Route;
import com.google.cloud.compute.v1.RoutesClient;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateRoute {

  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 Cloud project you want to use.
    String projectId = "your-project-id";
    // Route name you want to use.
    String routeName = "your-route-name";
    createRoute(projectId, routeName);
  }

  // Create route for a project.
  public static Operation.Status createRoute(String projectId, String routeName)
          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 (RoutesClient routesClient = RoutesClient.create()) {
      String nextHopGateway =
              String.format("projects/%s/global/gateways/default-internet-gateway", projectId);

      Route route = Route.newBuilder()
              .setName(routeName)
              .setDestRange("10.0.0.0/16")
              .setNetwork("global/networks/default")
              .setNextHopGateway(nextHopGateway)
              .build();

      InsertRouteRequest request = InsertRouteRequest.newBuilder()
              .setProject(projectId)
              .setRequestId(UUID.randomUUID().toString())
              .setRouteResource(route)
              .build();

      return routesClient.insertCallable().futureCall(request)
              .get(30, TimeUnit.SECONDS).getStatus();
    }
  }
}

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def create_route(
    project_id: str,
    network: str,
    route_name: str,
    destination_range: str,
    *,
    next_hop_gateway: str | None = None,
    next_hop_ip: str | None = None,
    next_hop_instance: str | None = None,
    next_hop_vpn_tunnel: str | None = None,
    next_hop_ilb: str | None = None,
) -> compute_v1.Route:
    """
    Create a new route in selected network by providing a destination and next hop name.

    Note: The set of {next_hop_gateway, next_hop_ip, next_hop_instance, next_hop_vpn_tunnel,
        next_hop_ilb} is exclusive, you and only specify one of those parameters.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        network: name of the network the route will be created in. Available name formats:
            * https://www.googleapis.com/compute/v1/projects/{project_id}/global/networks/{network}
            * projects/{project_id}/global/networks/{network}
            * global/networks/{network}
        route_name: name of the new route.
        destination_range: range of destination IPs this route should be applied to. E.g. 10.0.0.0/16.
        next_hop_gateway: name of the gateway the traffic should be directed to.
        next_hop_ip: IP address the traffic should be directed to.
        next_hop_instance: name of the instance the traffic should be directed to. Name format:
            "projects/{project}/zones/{zone}/instances/{instance_name}"
        next_hop_vpn_tunnel: name of the VPN tunnel the traffic should be directed to. Name format:
            "projects/{project}/regions/{region}/vpnTunnels/{vpn_tunnel_name}"
        next_hop_ilb: name of a forwarding rule of the Internal Load Balancer the traffic
            should be directed to. Name format:
            "projects/{project}/regions/{region}/forwardingRules/{forwarding_rule_region}"

    Returns:
        A new compute_v1.Route object.
    """
    excl_args = {
        next_hop_instance,
        next_hop_ilb,
        next_hop_vpn_tunnel,
        next_hop_gateway,
        next_hop_ip,
    }
    args_set = sum(1 if arg is not None else 0 for arg in excl_args)

    if args_set != 1:
        raise RuntimeError("You must specify exactly one next_hop_* parameter.")

    route = compute_v1.Route()
    route.name = route_name
    route.network = network
    route.dest_range = destination_range

    if next_hop_gateway:
        route.next_hop_gateway = next_hop_gateway
    elif next_hop_ip:
        route.next_hop_ip = next_hop_ip
    elif next_hop_instance:
        route.next_hop_instance = next_hop_instance
    elif next_hop_vpn_tunnel:
        route.next_hop_vpn_tunnel = next_hop_vpn_tunnel
    elif next_hop_ilb:
        route.next_hop_ilb = next_hop_ilb

    route_client = compute_v1.RoutesClient()
    operation = route_client.insert(project=project_id, route_resource=route)

    wait_for_extended_operation(operation, "route creation")

    return route_client.get(project=project_id, route=route_name)

Agrega una ruta predeterminada IPv4

La ruta estática predeterminada IPv4 (0.0.0.0/0) con next-hop-gateway configurado como default-internet-gateway se configura de forma automática para cada red de VPC. Sigue estos pasos para volver a crear esta ruta si es necesario.

Console

1. En la consola de Google Cloud, ve a la página Supervisión.

   Ir a Rutas

2. Haz clic en la pestaña Administración de rutas.

3. Haz clic en Crear ruta.

4. Especifica un Nombre y una Descripción para la ruta.

5. Selecciona una red existente para la ruta.

6. En Rango de IP de destino, ingresa 0.0.0.0/0.

7. Especifica una Prioridad para la ruta. La prioridad puede ser de 0 (la prioridad más alta) a 65535 (la prioridad más baja).

8. En Siguiente salto, selecciona Puerta de enlace de Internet predeterminada.

9. Haz clic en Crear.

gcloud

Vuelve a crear la ruta IPv4 predeterminada de una red.

gcloud compute routes create ROUTE_NAME \
    --destination-range=0.0.0.0/0 \
    --network=NETWORK \
    --next-hop-gateway=default-internet-gateway

Reemplaza lo siguiente:

• ROUTE_NAME: un nombre para la ruta
• NETWORK: es el nombre de la red de VPC que contiene la ruta

API

Vuelve a crear la ruta IPv4 predeterminada de una red.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/routes
{
  "destRange": "0.0.0.0/0",
  "name": "ROUTE_NAME",
  "network": "NETWORK_NAME",
  "nextHopGateway": "projects/PROJECT_ID/global/gateways/default-internet-gateway"
}

Reemplaza lo siguiente:

• PROJECT_ID: el ID del proyecto en el que se crea tu ruta.
• ROUTE_NAME: un nombre para la ruta
• NETWORK_NAME: es el nombre de la red de VPC que contiene la ruta

Agrega una ruta predeterminada IPv6

La ruta estática predeterminada IPv6 (::/0) con next-hop-gateway configurado como default-internet-gateway se configura de forma automática para la red de VPC cuando creas una subred de doble pila con el externo. Tipo de acceso de IP. Puedes borrar la ruta para bloquear todo el tráfico de IPv6 desde las VMs hacia Internet. También puedes volver a crear la ruta si es necesario.

Console

1. En la consola de Google Cloud, ve a la página Supervisión.

   Ir a Rutas

2. Haz clic en la pestaña Administración de rutas.

3. Haz clic en Crear ruta.

4. Especifica un Nombre y una Descripción para la ruta.

5. Selecciona una red existente para la ruta.

6. En Rango de IP de destino, ingresa ::/0.

7. Especifica una prioridad para la ruta. La prioridad puede ser de 0 (la prioridad más alta) a 65535 (la prioridad más baja).

8. En Siguiente salto, selecciona Puerta de enlace de Internet predeterminada.

9. Haz clic en Crear.

gcloud

Vuelve a crear la ruta IPv6 predeterminada de una red.

gcloud compute routes create ROUTE_NAME \
    --destination-range=::/0 \
    --network=NETWORK \
    --next-hop-gateway=default-internet-gateway

Reemplaza lo siguiente:

• ROUTE_NAME: un nombre para la ruta.
• NETWORK: es el nombre de la red de VPC que contiene la ruta.

API

Vuelve a crear la ruta IPv6 predeterminada de una red.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/routes
{
  "destRange": "::/0",
  "name": "ROUTE_NAME",
  "network": "NETWORK_NAME",
  "nextHopGateway": "projects/PROJECT_ID/global/gateways/default-internet-gateway"
}

Reemplaza lo siguiente:

• PROJECT_ID: el ID del proyecto en el que se crea tu ruta.
• ROUTE_NAME: un nombre para la ruta
• NETWORK_NAME: es el nombre de la red de VPC que contiene la ruta

Modifica una ruta estática

No puedes editar ni actualizar una ruta estática después de crearla. Para modificar una ruta estática, debes borrarla y crear un reemplazo.

Borra una ruta estática

Para borrar un modelo, haz lo siguiente:

Console

1. En la consola de Google Cloud, ve a la página Supervisión.

   Ir a Rutas

2. Haz clic en la pestaña Administración de rutas.

3. Selecciona la casilla de verificación junto a la regla que deseas borrar.

4. Haz clic en Borrar.

5. Haz clic en Borrar nuevamente para confirmar.

gcloud

Borra una ruta estática personalizada mediante el siguiente comando de gcloud CLI:

gcloud compute routes delete ROUTE_NAME

Reemplaza ROUTE_NAME por el nombre de la ruta que deseas borrar.

API

Borra una ruta estática personalizada para quitarla de tu red de VPC mediante el método routes.delete:

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/routes/ROUTE_NAME

Reemplaza lo siguiente:

• PROJECT_ID: el ID del proyecto en el que se encuentra tu ruta.
• ROUTE_NAME: el nombre de la ruta que se borrará.

Go

import (
	"context"
	"fmt"
	"io"

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

// deleteRoute deletes a route by name in given project.
func deleteRoute(w io.Writer, projectID, name string) error {
	// projectID := "your_project_id"
	// name := "testname"

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

	req := &computepb.DeleteRouteRequest{
		Project: projectID,
		Route:   name,
	}
	op, err := client.Delete(ctx, req)

	if err != nil {
		return fmt.Errorf("unable to delete a route: %w", err)
	}

	if err := op.Wait(ctx); err != nil {
		return fmt.Errorf("unable to wait for the operation: %w", err)
	}

	fmt.Fprintf(w, "Route deleted\n")

	return nil
}

Java

import com.google.cloud.compute.v1.DeleteRouteRequest;
import com.google.cloud.compute.v1.RoutesClient;
import java.io.IOException;
import java.util.UUID;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class DeleteRoute {

  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 Cloud project you want to use.
    String projectId = "your-project-id";
    // Route name you want to delete.
    String routeName = "your-route-name";

    deleteRoute(projectId, routeName);
  }

  // Deletes a route from a project.
  public static void deleteRoute(String projectId, String routeName)
          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 (RoutesClient routesClient = RoutesClient.create()) {
      DeleteRouteRequest request = DeleteRouteRequest.newBuilder()
              .setProject(projectId)
              .setRoute(routeName)
              .setRequestId(UUID.randomUUID().toString())
              .build();
      routesClient.deleteCallable().futureCall(request).get(30, TimeUnit.SECONDS);
    }
  }
}

Python

from __future__ import annotations

import sys
from typing import Any

from google.api_core.extended_operation import ExtendedOperation
from google.cloud import compute_v1


def wait_for_extended_operation(
    operation: ExtendedOperation, verbose_name: str = "operation", timeout: int = 300
) -> Any:
    """
    Waits for the extended (long-running) operation to complete.

    If the operation is successful, it will return its result.
    If the operation ends with an error, an exception will be raised.
    If there were any warnings during the execution of the operation
    they will be printed to sys.stderr.

    Args:
        operation: a long-running operation you want to wait on.
        verbose_name: (optional) a more verbose name of the operation,
            used only during error and warning reporting.
        timeout: how long (in seconds) to wait for operation to finish.
            If None, wait indefinitely.

    Returns:
        Whatever the operation.result() returns.

    Raises:
        This method will raise the exception received from `operation.exception()`
        or RuntimeError if there is no exception set, but there is an `error_code`
        set for the `operation`.

        In case of an operation taking longer than `timeout` seconds to complete,
        a `concurrent.futures.TimeoutError` will be raised.
    """
    result = operation.result(timeout=timeout)

    if operation.error_code:
        print(
            f"Error during {verbose_name}: [Code: {operation.error_code}]: {operation.error_message}",
            file=sys.stderr,
            flush=True,
        )
        print(f"Operation ID: {operation.name}", file=sys.stderr, flush=True)
        raise operation.exception() or RuntimeError(operation.error_message)

    if operation.warnings:
        print(f"Warnings during {verbose_name}:\n", file=sys.stderr, flush=True)
        for warning in operation.warnings:
            print(f" - {warning.code}: {warning.message}", file=sys.stderr, flush=True)

    return result


def delete_route(project_id: str, route_name: str) -> None:
    """
    Delete a route in project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.
        route_name: name of the route to delete.
    """

    route_client = compute_v1.RoutesClient()
    operation = route_client.delete(project=project_id, route=route_name)

    wait_for_extended_operation(operation, "route deletion")

Propagación de cambios de ruta

Cuando agregas o borras una ruta estática, la ruta se propaga a todas las instancias de VM y regiones en tu red de VPC. Un estado de la operación de ruta PENDING o RUNNING indica que el cambio de ruta está en cola.

Después de la cola, el estado de la operación de ruta cambia a DONE. Es posible que se necesiten 30 segundos más antes de que todas las instancias de VM en tu red de VPC y las redes de intercambio de tráfico entre redes de VPC usen una ruta nueva o dejen de usar una ruta anterior.

Si agregas o quitas varias rutas estáticas de forma simultánea, los cambios se pueden aplicar en cualquier orden. No hay ninguna garantía de que el orden en el que envías los cambios de ruta sea el orden en el que se procesan. Diferentes instancias pueden detectar los cambios en momentos diferentes.

Si necesitas realizar cambios de ruta que dependen unos de otros, debes realizar esos cambios de forma secuencial; para ello, realiza los cambios posteriores solo después de que el estado del cambio anterior sea DONE y de que hayan transcurrido 30 segundos adicionales.

Habilita el reenvío de IP para las instancias

De forma predeterminada, el reenvío de IP está inhabilitado y Google Cloud realiza una verificación de direcciones de origen estricta. Sujeto a la configuración de firewall de salida efectiva, una VM puede emitir paquetes con las siguientes fuentes:

• La dirección IPv4 interna principal de la interfaz de red (NIC) de una instancia.
• Cualquier rango de alias de IP que se configura en la NIC de una instancia.
• Si se configura un rango de direcciones IPv6 en la subred y la instancia es de doble pila, cualquiera de las direcciones IPv6 están asignadas a la NIC.
• Una dirección IP interna o externa asociada con una regla de reenvío, para el balanceo de cargas de transferencia o el reenvío de protocolos si la instancia es un backend de un balanceador de cargas de red de transferencia interno o un balanceador de cargas de red de transferencia externo, o una instancia de destino hace referencia a ella.

A fin de usar una VM como un siguiente salto para una ruta, es necesario que la VM reenvíe paquetes cuyos orígenes no coincidan con una de las direcciones IP o los rangos de la lista anterior. Para reenviar paquetes con direcciones de origen arbitrarias, debes habilitar el reenvío de IP:

• Cuando creas o actualizas una VM, debes habilitar el reenvío de IP mediante las instrucciones que se indican en esta sección. La habilitación del reenvío de IP se aplica a todas las NIC de la VM.
• Además de los pasos de esta sección, debes habilitar el reenvío de IP dentro del sistema operativo invitado de VM. Para hacerlo en Linux, establece el valor de uno o ambos de los siguientes parámetros del kernel en 1: net.ipv4.ip_forward (para IPv4) o net.ipv6.conf.all.forwarding (para IPv6).

Para habilitar el reenvío de IP cuando creas una VM, completa los siguientes pasos.

Console

1. En la consola de Google Cloud, ve a la página Instancias de VM.

   Ir a Instancias de VM

2. Haz clic en Crear instancia.

3. En la sección Opciones avanzadas, expande Herramientas de redes, discos, seguridad, administración, usuario único.

4. Expande la sección Herramientas de redes.

5. En la sección Reenvío de IP, selecciona la casilla de verificación Habilitar.

gcloud

Cuando creas una instancia, agrega la marca --can-ip-forward a tu comando:

gcloud compute instances create ... --can-ip-forward

API

Cuando crees una instancia, usa el campo canIpForward para habilitar el reenvío de IP:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
  "canIpForward": true,
  ...other fields
}

Reemplaza lo siguiente:

• PROJECT_ID: El ID del proyecto que contiene la instancia
• ZONE: la zona deb Google Cloud que contiene la instancia

Para obtener más información, consulta el método instances.insert.

Terraform

Puedes usar el recurso de Terraform para crear una instancia de VM con el reenvío de IP habilitado.

En este ejemplo, los argumentos de Terraform tienen valores asignados que puedes cambiar.

resource "google_compute_instance" "default" {
  project      = var.project_id # Replace this with your project ID in quotes
  zone         = "southamerica-east1-b"
  name         = "instance-next-hop"
  machine_type = "e2-medium"
  boot_disk {
    initialize_params {
      image = "debian-cloud/debian-9"
    }
  }
  network_interface {
    network = "default"
  }
  can_ip_forward = true
}

Si deseas obtener más información para aplicar o quitar una configuración de Terraform, consulta los comandos básicos de Terraform.

Después de habilitar el reenvío de IP, continúa con el proceso de creación de VM.

Para habilitar el reenvío de IP en una VM existente, actualiza las propiedades de la instancia canIpForward.

¿Qué sigue?

• Para obtener información sobre las rutas, consulta Rutas.
• Para obtener información sobre las redes VPC de Google Cloud, consulta la descripción general de la nube privada virtual (VPC).
• Si deseas obtener instrucciones para crear y modificar redes de VPC, consulta Crea y administra redes de VPC.