Utilizzo delle route

In questa pagina viene descritto come creare e gestire le route per Reti Virtual Private Cloud (VPC) in Google Cloud. Questa pagina presuppone che tu hanno familiarità con i diversi tipi di route Google Cloud e le relative caratteristiche come descritto in Route.

Ogni nuova rete ha due tipi di route generate dal sistema: una percorso, che puoi rimuovere o sostituire. una route subnet per ognuna delle sue subnet. Non puoi rimuovi una route subnet, a meno che non elimini la subnet corrispondente.

Oltre alle route generate dal sistema, puoi creare altre route route statiche.

Elenca le route per una rete VPC

Puoi utilizzare Google Cloud CLI o l'API per elencare e visualizzare i dettagli sul seguenti tipi di route:

• Route predefinite
• Route subnet
• Route delle subnet in peering
• Route statiche

Né i comandi della gcloud CLI né i metodi API mostrano seguenti tipi di route:

• Route basate su criteri
• Route dinamiche
• Route statiche e dinamiche di peering

Per vedere la visualizzazione completa della route, utilizza la console Google Cloud. Per elencare e descrivere le route basate su criteri, vedi Utilizzare le route basate su criteri route.

Console

1. Nella console Google Cloud, vai alla pagina Route.

   Vai a Routes

2. Nella scheda Route operative, procedi nel seguente modo:

   • Scegli una rete VPC.
   • Scegli una regione.

3. Fai clic su Visualizza.

4. Puoi filtrare in base al tipo di route, all'intervallo IP di destinazione, al tipo di hop successivo e altro ancora.

gcloud

Utilizza i seguenti comandi della gcloud CLI per elencare e visualizzare i dettagli sui percorsi sopra elencati:

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

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

Sostituisci quanto segue:

• NETWORK_NAME: il nome della rete VPC.
• PROJECT_ID: l'ID progetto che contiene rete VPC.
• ROUTE_NAME: il nome del percorso.

API

Utilizza i seguenti metodi dell'API per elencare e visualizzare i dettagli sulle route elencate in precedenza:

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

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

Sostituisci quanto segue:

• PROJECT_ID: l'ID progetto che contiene rete VPC.
• NETWORK_URL: l'URL della rete VPC.
• ROUTE_NAME: il nome del percorso.

Per ulteriori informazioni, consulta Metodo routes.list e il metodo routes.get.

Elenca le route applicabili per un'interfaccia di rete VM

Puoi utilizzare la console Google Cloud per visualizzare le route applicabili per a riga di comando gcloud. Questa visualizzazione restringe l'elenco delle route che puoi utilizzare per il traffico in uscita.

Per visualizzare le route applicabili per un'interfaccia di rete specifica di una VM: questi passaggi.

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Individua un'istanza VM nell'elenco. Nella Menu Altre azioni a alla fine della riga, seleziona Visualizza i dettagli della rete.

3. Se un'istanza ha più interfacce di rete, nel Dettagli interfaccia di rete, seleziona l'interfaccia di rete che vuoi visualizzare.

4. Nella sezione Dettagli firewall e route, fai clic sulla scheda Route per visualizza tutte le route che si applicano all'interfaccia di rete, ordinate per nome di route.

Vai

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/api/iterator"
)

// listRoutes prints a list of routes created in given project.
func listRoutes(w io.Writer, projectID string) error {
	// projectID := "your_project_id"

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

	req := &computepb.ListRoutesRequest{
		Project: projectID,
	}
	routes := client.List(ctx, req)

	for {
		instance, err := routes.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return err
		}
		fmt.Fprintf(w, "- %s\n", *instance.Name)
	}

	return nil
}

Java

import com.google.cloud.compute.v1.ListRoutesRequest;
import com.google.cloud.compute.v1.Route;
import com.google.cloud.compute.v1.RoutesClient;
import com.google.common.collect.Lists;
import java.io.IOException;
import java.util.List;

public class ListRoute {

  public static void main(String[] args) throws IOException {
    // 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";

    listRoutes(projectId);
  }

  // Lists routes from a project.
  public static List<Route> listRoutes(String projectId) throws IOException {
    // 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()) {
      ListRoutesRequest request = ListRoutesRequest.newBuilder()
              .setProject(projectId)
              .build();

      return Lists.newArrayList(routesClient.list(request).iterateAll());
    }
  }
}

Python

from __future__ import annotations

from collections.abc import Iterable

from google.cloud import compute_v1


def list_routes(
    project_id: str,
) -> Iterable[compute_v1.Route]:
    """
    Lists routes in project.

    Args:
        project_id: project ID or project number of the Cloud project you want to use.

    Returns:
        An iterable collection of routes found in given project.
    """

    route_client = compute_v1.RoutesClient()
    return route_client.list(project=project_id)

Aggiungi e rimuovi route statiche

Puoi aggiungere o rimuovere route statiche e basate su criteri che sono locali della tua rete VPC. Questa sezione descrive come aggiungere ed eliminare route statiche locali. Per ulteriori informazioni su come aggiungere e rimuovere basate su criteri, vedi Usa route basate su criteri.

Le route subnet vengono aggiunte ed eliminate automaticamente quando aggiungi o elimini una una subnet. Per ulteriori informazioni su come aggiungere e rimuovere subnet, consulta Utilizzare le subnet.

Tutte le route in una rete VPC connesse Il peering di rete VPC deve essere manipolato nella rete VPC che esporta queste route. Per ulteriori informazioni, consulta Scambio di route opzioni.

Importante: le route statiche non possono essere modificate dopo la creazione, ma possono essere sostituite. Per maggiori dettagli, consulta Modificare una route statica.

Prima di aggiungere una route statica

Prima di aggiungere una route statica, assicurati di comprendere quanto segue:

• Assicurati di comprendere i diversi tipi di hop successivi che instradano le route statiche che è possibile usare. Per informazioni sui diversi tipi di hop successivi delle route statiche, incluse quelle che supportano le destinazioni IPv6, consulta Hop e funzionalità successivi.
• A meno che non utilizzi subnet ibride, una route statica non può avere un intervallo di destinazione corrispondente o più specifico del valore nell'intervallo di destinazione di una subnet o subnet di peering. Per ulteriori dettagli, vedi Interazioni con elementi statici personalizzati Routes nella panoramica e Subnet e route statica interazioni nel documentazione sul peering di rete VPC.
• Per evitare conflitti quando utilizzi una rete in modalità automatica, non creare route statiche le cui destinazioni rientrano in 10.128.0.0/9. Esamina gli intervalli IP riservati per le reti in modalità automatica.
• Le destinazioni delle route statiche personalizzate non possono sovrapporsi a quelle interne intervallo allocato.
• Assicurati di acquisire familiarità con le istanze nel prossimo futuro hop prima di creare un che utilizza una VM come hop successivo. Google Cloud verifica solo che La VM esiste al momento della creazione della route se scegli un hop successivo in esecuzione.
• Se crei una route utilizzando un tag di rete, verranno utilizzate solo le VM con quel tag ricevono quel percorso. Tuttavia, le VM codificate ricevono comunque tutte le route nessun tag di rete.

Nota: per gli hop successivi che utilizzano il router Cloud, puoi facoltativamente utilizzare route apprese personalizzate in alternativa alle route statiche. A differenza delle route statiche, le route apprese personalizzate vengono soppresse automaticamente se le route BGP associate la sessione è stata interrotta. Questo comportamento consente di utilizzare percorsi alternativi nel caso di un'interruzione di rete e ciò potrebbe impedire l'interruzione del traffico. Inoltre, a differenza delle route statiche, le route apprese personalizzate possono essere Collegamenti VLAN Cloud Interconnect e tunnel VPN ad alta disponibilità. Per ulteriori informazioni, vedi Route apprese personalizzate. Questa funzionalità è in Anteprima.

Aggiungi una route statica

Aggiungi una route statica a una rete. Per ulteriori informazioni sui diversi tipi di per gli hop successivi, inclusi quelli che supportano le destinazioni IPv6, consulta Hop e funzionalità successivi.

Console

1. Nella console Google Cloud, vai alla pagina Route.

   Vai a Routes

2. Fai clic sulla scheda Gestione route.

3. Fai clic su Crea route.

4. Specifica un nome e una descrizione per il percorso.

5. Nell'elenco Rete, seleziona una rete esistente per la route.

6. Nell'elenco Tipo di route, seleziona Route statico.

7. Nell'elenco Versione IP, seleziona la versione IP richiesta:

   • Per creare una route statica IPv4, seleziona IPv4.
   • Per creare una route statica IPv6, seleziona IPv6.

8. Specifica un intervallo IP di destinazione. La destinazione più ampia possibile 0.0.0.0/0 per IPv4 o ::/0 per IPv6.

9. Specifica una priorità per il percorso. La priorità può essere compresa tra 0 (la priorità più alta) e 65535 (la priorità più grande) priorità più bassa).

10. Per rendere la route applicabile solo a istanze selezionate con corrispondenze i tag di rete, specificali nel campo Tag istanza. Esci dalla per rendere la route applicabile a tutte le istanze nella rete.

11. Seleziona un hop successivo per percorso:

    • Gateway internet predefinito: consegna i pacchetti a internet e a API e servizi Google
    • Specifica un'istanza: consegna i pacchetti al server di un'istanza VM a riga di comando gcloud. Specifica l'istanza VM per nome e zona. Se route è un indirizzo IPv6, l'istanza VM deve essere dual-stack.
    • Specifica l'indirizzo IP di un'istanza: specifica l'indirizzo IP di un istanza esistente nella rete VPC. Per IPv6 route statiche (Anteprima), l'istanza deve essere dual-stack. Per importanti restrizioni relative a indirizzi IP dell'hop successivo, consulta la sezione route statica successiva hop.
    • Specifica tunnel VPN: consegna i pacchetti a un server VPN classica tunnel utilizzando il routing statico.
    • Specifica una regola di forwarding di un bilanciatore del carico di rete passthrough interno: consegna i pacchetti a un bilanciatore del carico di rete passthrough interno specificato dal nome e dalla regione della regola di forwarding interno.

12. Fai clic su Crea.

gcloud

Crea una nuova route statica personalizzata con la seguente gcloud CLI :

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

Sostituisci quanto segue:

• ROUTE_NAME: il nome del percorso
• NETWORK: il nome del VPC che contiene la route
• DESTINATION_RANGE: l'IPv4 o IPv6 di destinazione a cui si applica la route. La destinazione più ampia possibile è 0.0.0.0/0 per IPv4 o ::/0 per IPv6.
• PRIORITY: il percorso priorità, che può essere compresa tra 0 (la priorità più alta) a 65535 (la priorità più bassa)

• NEXT_HOP_SPECIFICATION: l'hop successivo per la route statica. Utilizza uno dei seguenti parametri o una delle seguenti combinazioni di parametri:

  • --next-hop-gateway=default-internet-gateway: consegna i pacchetti al internet e alle API e ai servizi Google.
  • --next-hop-instance=INSTANCE_NAME e --next-hop-instance-zone=ZONE: consegna di pacchetti all'interfaccia di rete di un'istanza VM esistente. Specifica di un'istanza VM per nome e zona. Se la destinazione della route è Indirizzo IPv6, l'istanza VM deve essere a doppio stack.
  • --next-hop-address=ADDRESS: specifica un IP di un istanza esistente nella rete VPC. Per le route statiche IPv6 (anteprima), l'istanza deve essere dual-stack. Per importanti limitazioni relative a indirizzi IP dell'hop successivo validi, consulta la route statica successiva hop.
  • --next-hop-vpn-tunnel=VPN_TUNNEL_NAME e --next-hop-vpn-tunnel-region=REGION: consegna in un nodo esistente VPN classica tunnel utilizzando il routing statico.
  • --next-hop-ilb=FORWARDING_RULE e --next-hop-ilb-region=REGION: consegna i pacchetti a un bilanciatore del carico di rete passthrough interno. Specifica l'istanza VM in base al nome della regola di forwarding interno (o indirizzo IPv4) e regione.

  Per applicare la route statica personalizzata solo a VM selezionate in base al tag di rete: aggiungi il flag --tags e specifica uno o più tag di rete. Per ulteriori informazioni informazioni sull'interazione tra tag di rete e route statiche personalizzate, consulta Route applicabili nella sezione Route panoramica. Puoi utilizzare i tag con qualsiasi route statica personalizzata.

Per ulteriori informazioni sulla sintassi della gcloud CLI, consulta Documentazione SDK.

API

Crea una nuova route statica personalizzata.

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

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto in cui il percorso viene creato
• ROUTE_NAME: il nome del percorso
• NETWORK: il nome del VPC contenente la route.
• DESTINATION_RANGE: l'IPv4 o IPv6 di destinazione a cui si applica questa route. Il più ampio possibile la destinazione è 0.0.0.0/0 per IPv4 o ::/0 per IPv6.
• PRIORITY: il percorso priorità, che può essere compresa tra 0 (la priorità più alta) a 65535 (la priorità più bassa)
• NEXT_HOP_SPECIFICATION: il successivo hop per la route statica. Utilizza le funzionalità di uno dei seguenti parametri o una combinazione di parametri:
  • nextHopGateway: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/gateways/default-internet-gateway: consegna i pacchetti a internet e alle API e ai servizi Google
  • nextHopInstance: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME: consegna i pacchetti all'interfaccia di rete di un'istanza VM. Specifica la VM per nome e zona. Se la destinazione della route è un IPv6 l'istanza VM deve essere dual-stack.
  • nextHopIp: ADDRESS: specifica un indirizzo IP di su un'istanza esistente nella rete VPC. Per IPv6 route statiche (Anteprima), l'istanza deve essere dual-stack. Per importanti restrizioni relative a indirizzi IP dell'hop successivo, consulta la sezione route statica successiva hop.
  • nextHopVpnTunnel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/vpnTunnels/VPN_TUNNEL_NAME: invia pacchetti a un progetto VPN classica tunnel utilizzando il routing statico.
  • nextHopIlb: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/forwardingRules/FORWARDING_RULE: invia pacchetti a un bilanciatore del carico di rete passthrough interno. Specifica l'istanza VM in base al nome della regola di forwarding interno (o indirizzo IPv4) e regione.

Per applicare la route statica personalizzata solo a VM selezionate in base al tag di rete: aggiungi il campo tags e specifica uno o più tag di rete. Per ulteriori informazioni informazioni sull'interazione tra tag di rete e route statiche personalizzate, consulta Route applicabili nella sezione panoramica. Puoi utilizzare i tag con qualsiasi route statica personalizzata.

Per ulteriori informazioni, consulta routes.insert.

Terraform

Puoi creare una route statica utilizzando una Modulo Terraform.

Questa route statica crea una route predefinita verso 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"
    }
  ]
}

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta: Comandi Terraform di base.

Vai

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)

Aggiungi una route predefinita IPv4

La route statica predefinita IPv4 (0.0.0.0/0) con next-hop-gateway impostato su default-internet-gateway viene configurato automaticamente per ogni rete VPC. Segui questa procedura per ricreare questa route se necessaria.

Console

1. Nella console Google Cloud, vai alla pagina Route.

   Vai a Routes

2. Fai clic sulla scheda Gestione route.

3. Fai clic su Crea route.

4. Specifica un nome e una descrizione per il percorso.

5. Seleziona una rete esistente per il percorso.

6. Per Intervallo IP di destinazione, inserisci 0.0.0.0/0.

7. Specifica una priorità per il percorso. La priorità può essere tra 0 (il priorità più alta) a 65535 (la priorità più bassa).

8. Per Hop successivo, seleziona Gateway internet predefinito.

9. Fai clic su Crea.

gcloud

Ricrea la route predefinita IPv4 per una rete.

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

Sostituisci quanto segue:

• ROUTE_NAME: un nome per il percorso
• NETWORK: il nome del VPC che contiene la route

API

Ricrea la route predefinita IPv4 per una rete.

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

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto in cui il percorso viene creato
• ROUTE_NAME: un nome per il percorso
• NETWORK_NAME: il nome del VPC che contiene la route

Aggiungi una route predefinita IPv6

La route statica predefinita IPv6 (::/0) con il valore di next-hop-gateway impostato su default-internet-gateway viene automaticamente configurata per la rete VPC quando crei uno stack doppio con il tipo di accesso IP esterno. Puoi eliminare per bloccare tutto il traffico IPv6 dalle VM a internet. Tu può anche ricreare il percorso, se necessario.

Console

1. Nella console Google Cloud, vai alla pagina Route.

   Vai a Routes

2. Fai clic sulla scheda Gestione route.

3. Fai clic su Crea route.

4. Specifica un nome e una descrizione per il percorso.

5. Seleziona una rete esistente per il percorso.

6. Per Intervallo IP di destinazione, inserisci ::/0.

7. Specifica una priorità per il percorso. La priorità può essere compresa tra 0 (la priorità più alta) e 65535 (la priorità più grande) priorità più bassa).

8. Per Hop successivo, seleziona Gateway internet predefinito.

9. Fai clic su Crea.

gcloud

Ricrea la route predefinita IPv6 per una rete.

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

Sostituisci quanto segue:

• ROUTE_NAME: un nome per il percorso.
• NETWORK: il nome del VPC contenente la route.

API

Ricrea la route predefinita IPv6 per una rete.

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

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto in cui il percorso viene creato
• ROUTE_NAME: un nome per il percorso
• NETWORK_NAME: il nome del VPC che contiene la route

Modifica una route statica

Non puoi modificare o aggiornare una route statica dopo averla creata. Per modificare un una route statica, devi eliminarla e crearne una sostitutiva.

Elimina una route statica

Per eliminare un percorso, procedi nel seguente modo.

Console

1. Nella console Google Cloud, vai alla pagina Route.

   Vai a Routes

2. Fai clic sulla scheda Gestione route.

3. Seleziona la casella di controllo accanto alla regola da eliminare.

4. Fai clic su Elimina.

5. Fai di nuovo clic su Elimina per confermare.

gcloud

Elimina una route statica personalizzata utilizzando la seguente gcloud CLI :

gcloud compute routes delete ROUTE_NAME

Sostituisci ROUTE_NAME con il nome del percorso da eliminare.

API

Elimina una route statica personalizzata per rimuoverla dal VPC di Google Cloud utilizzando Metodo routes.delete:

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

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto in cui in cui si trova il percorso.
• ROUTE_NAME: il nome della route da eliminare.

Vai

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

Propagazione dei cambi di percorso

Quando aggiungi o elimini una route statica, la route si propaga a tutte le regioni e VM nella tua rete VPC. Un'operazione di route lo stato PENDING o RUNNING indica che il cambio di percorso è in coda.

Dopo la coda, lo stato dell'operazione della route passa a DONE. it potrebbero richiedere altri 30 secondi prima che tutte le istanze VM Rete VPC e reti di peering di rete VPC utilizzare un nuovo percorso o smettere di utilizzare un percorso precedente.

Se aggiungi o rimuovi contemporaneamente più route statiche, le modifiche possono essere applicati in qualsiasi ordine. Non vi è alcuna garanzia che l'ordine di invio le modifiche al percorso sono l'ordine di elaborazione. Istanze diverse potrebbero venire a conoscenza dei cambiamenti in momenti diversi.

Se devi apportare modifiche al percorso che dipendono l'una dall'altra, devi le modifiche in sequenza eseguendo quelle successive solo dopo lo stato della modifica è DONE e sono trascorsi altri 30 secondi.

Abilita l'IP forwarding per le istanze

Per impostazione predefinita, l'IP forwarding è disattivato e Google Cloud esegue in modo rigoroso il controllo dell'indirizzo di origine. Soggetti alla configurazione effettiva del firewall in uscita, una VM può emettere pacchetti con le seguenti origini:

• L'indirizzo IPv4 interno principale dell'interfaccia di rete (NIC) di un'istanza.
• Qualsiasi intervallo IP alias configurato sul NIC di un'istanza.
• Se nella subnet è configurato un intervallo di indirizzi IPv6 e l'istanza a doppio stack, uno qualsiasi degli indirizzi IPv6 assegnati al NIC.
• Un indirizzo IP interno o esterno associato a una regola di forwarding, per il bilanciamento del carico passthrough o il forwarding del protocollo, se l'istanza è un per un bilanciatore del carico di rete passthrough interno, un bilanciatore del carico di rete passthrough esterno o a cui fa riferimento un dell'istanza di destinazione.

Per utilizzare una VM come hop successivo per una route, la VM deve inoltrare i pacchetti Le origini dati non corrispondono a uno degli indirizzi o agli intervalli IP nell'elenco precedente. A inoltrare pacchetti con indirizzi di origine arbitrari, devi abilitare l'IP forwarding:

• Quando crei o aggiorni una VM, abiliti l'IP forwarding seguendo le istruzioni istruzioni in questa sezione. L'abilitazione dell'IP forwarding si applica a tutte le NIC sulla VM.
• Oltre ai passaggi in questa sezione, devi abilitare l'IP forwarding all'interno del sistema operativo guest della VM. Per farlo su Linux, imposta il valore uno o entrambi i seguenti parametri kernel per 1: net.ipv4.ip_forward (per IPv4) o net.ipv6.conf.all.forwarding (per IPv6).

Per abilitare l'IP forwarding quando crei una VM, completa i seguenti passaggi.

Console

1. Nella console Google Cloud, vai alla pagina Istanze VM.

   Vai a Istanze VM

2. Fai clic su Crea istanza.

3. Nella sezione Opzioni avanzate, espandi Networking, dischi, sicurezza single-tenancy.

4. Espandi la sezione Networking.

5. Nella sezione IP forwarding, seleziona la casella di controllo Abilita.

gcloud

Quando crei un'istanza, aggiungi il flag --can-ip-forward al comando:

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

API

Quando crei un'istanza, utilizza il campo canIpForward per abilitare l'IP inoltro:

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

Sostituisci quanto segue:

• PROJECT_ID: l'ID del progetto che contiene l'istanza
• ZONE: la zona Google Cloud contenente istanza

Per ulteriori informazioni, consulta Metodo instances.insert.

Terraform

Puoi utilizzare il comando Terraform risorsa per creare un'istanza VM con l'IP forwarding abilitato.

In questo esempio, gli argomenti Terraform hanno valori assegnati che puoi modifica.

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
}

Per scoprire come applicare o rimuovere una configurazione Terraform, consulta: Comandi Terraform di base.

Dopo aver abilitato l'IP forwarding, continua con la creazione della VM .

Per abilitare l'IP forwarding su una VM esistente, aggiorna canIpForward istanza di Google Cloud.

Passaggi successivi

• Per informazioni sulle route, vedi Route.
• Per informazioni sulle reti VPC di Google Cloud, consulta Panoramica del VPC (Virtual Private Cloud).
• Per istruzioni sulla creazione e sulla modifica delle reti VPC, consulta Creare e gestire le reti VPC.