Utilizzo delle route

Questa pagina descrive come creare e gestire route per le reti Virtual Private Cloud (VPC) in Google Cloud. Questa pagina presuppone che tu abbia familiarità con i diversi tipi di route di Google Cloud e le relative caratteristiche, come descritto in Route.

Ogni nuova rete ha due tipi di route generate dal sistema: una route predefinita, che puoi rimuovere o sostituire, e una route di subnet per ogni subnet. Non puoi rimuovere una route della subnet a meno che non elimini la subnet stessa.

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

Elenca le route per una rete VPC

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

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

Per visualizzare la visualizzazione completa del percorso, utilizza la console Google Cloud. Per elencare e descrivere le route basate su criteri, consulta Utilizzare le route basate su criteri.

Console

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

    Vai a Route

  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 a proprietà tra cui tipo di route, intervallo IP di destinazione e tipo di hop successivo.

  5. (Facoltativo) Fai clic sull'opzione Mostra le route eliminate per attivarla e visualizzare le route eliminate. Per visualizzare il motivo della soppressione di un percorso, posiziona il puntatore del mouse sull'icona nella colonna Stato.

gcloud

Per elencare e visualizzare i dettagli delle route, utilizza i comandi gcloud compute routes. Vengono visualizzate le route di subnet e le route statiche della rete VPC locale e di eventuali reti VPC in peering. Gli altri tipi di percorsi non vengono visualizzati. Per visualizzare tutti i percorsi, utilizza la console Google Cloud.

Per elencare le route:

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

Per visualizzare i dettagli di un percorso:

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 la rete VPC.
  • ROUTE_NAME: il nome del percorso.

API

Per elencare e visualizzare i dettagli delle route, utilizza i metodi routes.list e routes.get. Vengono visualizzate le route di subnet e le route statiche della rete VPC locale e di eventuali reti VPC connesse in peering. Gli altri tipi di percorsi non vengono visualizzati. Per visualizzare tutti i percorsi, utilizza la console Google Cloud.

Per elencare le route:

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

Per visualizzare i dettagli di un percorso:

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

Sostituisci quanto segue:

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

Elenca le route applicabili per un'interfaccia di rete VM

Puoi utilizzare la console Google Cloud per visualizzare le route applicabili per l'interfaccia di rete di una VM. Questa visualizzazione restringe l'elenco di route che puoi utilizzare per il traffico in uscita.

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

Console

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

    Vai a Istanze VM

  2. Individua un'istanza VM nell'elenco. Nel menu Altre azioni alla fine della riga, seleziona Visualizza dettagli rete.

  3. Se un'istanza ha più interfacce di rete, nella sezione 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 visualizzare tutti i route che si applicano all'interfaccia di rete, ordinati per nome.

Aggiungere e rimuovere route statiche

Puoi aggiungere o rimuovere route statiche e route basate su criteri locali per la tua rete VPC. Questa sezione descrive come aggiungere ed eliminare route statici locali. Per ulteriori informazioni su come aggiungere e rimuovere le route basate su criteri, consulta la sezione Utilizzare le route basate su criteri.

I percorsi delle sottoreti vengono aggiunti ed eliminati automaticamente quando aggiungi o elimini una sottorete. Per scoprire di più su come aggiungere e rimuovere le subnet, consulta la sezione Utilizzare le subnet.

Tutte le route in una rete VPC connesse tramite il peering di rete VPC devono essere manipolate nella rete VPC che esporta queste route. Per ulteriori informazioni, consulta la sezione Opzioni di scambio route.

Prima di aggiungere una route statica

Prima di aggiungere una route statica, tieni presente quanto segue:

  • Assicurati di comprendere i diversi tipi di hop successivi che possono essere utilizzati dalle route statiche. Per informazioni sui diversi tipi di hop successivi delle route statiche, inclusi quelli che supportano le destinazioni IPv6, consulta Hop successivi e funzionalità.
  • A meno che non utilizzi subnet ibride, una route statica non può avere un intervallo di destinazione che corrisponda o sia più specifico dell'intervallo di destinazione di una route di subnet o di una subnet in peering. Per maggiori dettagli, consulta Interazioni con route statiche personalizzate nella panoramica delle route e Interazioni tra route statiche e subnet nella documentazione del peering di rete VPC.
  • Per evitare conflitti quando utilizzi una rete VPC in modalità automatica, non creare route statiche le cui destinazioni rientrano in 10.128.0.0/9. Per ulteriori dettagli, consulta gli intervalli IPv4 in modalità automatica.
  • Le destinazioni per le route statiche personalizzate non possono sovrapporsi a nessun intervallo allocato interno.
  • Prima di creare una route statica personalizzata che utilizza una VM come hop successivo, assicurati di conoscere le istanze come hop successivi. Google Cloud convalida l'esistenza di una VM al momento della creazione della route solo se scegli un'istanza di destinazione.
  • Se crei una route utilizzando un tag di rete, solo le VM con quel tag la riceveranno. Tuttavia, le VM con tag ricevono comunque tutti i route che non hanno un tag di rete.

Aggiungere una route statica

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

Console

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

    Vai a Route

  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 il percorso.

  6. Nell'elenco Tipo di percorso, seleziona Percorso 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ò variare da 0 (la priorità più alta) a 65535 (la prioritaria più bassa).

  10. Per rendere il percorso applicabile solo a istanze selezionate con tag di rete corrispondenti, specificali nel campo Tag istanza. Lascia vuoto il campo per rendere la route applicabile a tutte le istanze della rete.

  11. Seleziona un hop successivo per il percorso:

    • Gateway internet predefinito: invia pacchetti a internet e alle API e ai servizi Google
    • Specifica un'istanza: invia i pacchetti all'interfaccia di rete di un'istanza VM. Specifica l'istanza VM per nome e zona. Se la destinazione del percorso è un indirizzo IPv6, l'istanza VM deve essere a doppio stack.
    • Specifica l'indirizzo IP di un'istanza: specifica un indirizzo IP di un'istanza esistente nella rete VPC. Per le route statiche IPv6 (anteprima), l'istanza deve essere a doppio stack. Per le limitazioni importanti relative agli indirizzi IP di hop successivo validi, consulta hop successivi della route statica.
    • Specifica tunnel VPN: invia i pacchetti a un tunnel VPN classica esistente utilizzando il routing statico.
    • Specifica una regola di forwarding di un bilanciatore del carico di rete passthrough interno: invia i pacchetti a un bilanciatore del carico di rete passthrough interno specificato dal nome e dalla regione della regola di forwarding interna. La regola di forwarding può avere un indirizzo IPv4 o IPv6 (Anteprima). La versione IP della regola di forwarding specificata deve corrispondere alla versione IP della route statica creata.

  12. Fai clic su Crea.

gcloud

Crea una nuova route statica personalizzata con il seguente comando 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 della rete VPC che contiene la route
  • DESTINATION_RANGE: gli indirizzi IPv4 o IPv6 di destinazione a cui si applica questa route. La destinazione più ampia possibile è 0.0.0.0/0 per IPv4 o ::/0 per IPv6.
  • PRIORITY: la priorità del route, che può variare da 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 combinazione di parametri:

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

    Per fare in modo che la route statica personalizzata venga applicata 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 su come i tag di rete e le route statiche personalizzate interagiscono tra loro, consulta Route applicabili nella panoramica delle route. Puoi utilizzare i tag con qualsiasi route statica personalizzata.

Per ulteriori informazioni sulla sintassi dell'interfaccia alla gcloud CLI, consulta la documentazione dell'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 viene creato il percorso
  • ROUTE_NAME: il nome del percorso
  • NETWORK: il nome della rete VPC che contiene la route.
  • DESTINATION_RANGE: l'intervallo di indirizzi IPv4 o IPv6 di destinazione a cui si applica questa route. La destinazione più ampia possibile è 0.0.0.0/0 per IPv4 o ::/0 per IPv6.
  • PRIORITY: la priorità del route, che può variare da 0 (la priorità più alta) a 65535 (la priorità più bassa)
  • NEXT_HOP_SPECIFICATION: il hop successivo per la route statica. Utilizza uno dei seguenti parametri o una combinazione di parametri:
    • nextHopGateway: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/gateways/default-internet-gateway: invia 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 l'istanza VM per nome e zona. Se la destinazione della route è un indirizzo IPv6, l'istanza VM deve essere a doppio stack.
    • nextHopIp: ADDRESS: specifica un indirizzo IP di un'istanza esistente nella rete VPC. Per le route statiche IPv6 (anteprima), l'istanza deve essere a doppio stack. Per le limitazioni importanti relative agli indirizzi IP degli hop successivi validi, consulta la sezione Hop successivi e funzionalità.
    • nextHopVpnTunnel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/vpnTunnels/VPN_TUNNEL_NAME: invia i pacchetti a un tunnel VPN classica esistente utilizzando il routing statico.
    • nextHopIlb: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/forwardingRules/FORWARDING_RULE: invia i pacchetti a un bilanciatore del carico di rete passthrough interno. Specifica la regola di forwarding in base al nome (o all'indirizzo IPv4 o IPv6 (Anteprima)) e alla regione. La versione IP della regola di forwarding specificata deve corrispondere alla versione IP della route statica creata.

Per fare in modo che la route statica personalizzata venga applicata 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 su come i tag di rete e le route statiche personalizzate interagiscono tra loro, consulta Route applicabili nella panoramica delle route. Puoi utilizzare i tag con qualsiasi route statica personalizzata.

Per ulteriori informazioni, consulta il metodo routes.insert.

Terraform

Puoi creare una route statica utilizzando un modulo Terraform.

Questa route statica crea una route predefinita per 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 configurata automaticamente per ogni default-internet-gateway rete VPC. Se necessario, segui questi passaggi per ricreare questo percorso.

Console

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

    Vai a Route

  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. In Intervallo IP di destinazione, inserisci 0.0.0.0/0.

  7. Specifica una priorità per il percorso. La priorità può variare da 0 (la prioritaria 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 della rete 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 viene creato il percorso
  • ROUTE_NAME: un nome per il percorso
  • NETWORK_NAME: il nome della rete VPC che contiene la route

Aggiungi una route predefinita IPv6

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

Console

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

    Vai a Route

  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. In Intervallo IP di destinazione, inserisci ::/0.

  7. Specifica una priorità per il percorso. La priorità può variare da 0 (la priorità più alta) a 65535 (la prioritaria 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 della rete VPC che contiene 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 viene creato il percorso
  • ROUTE_NAME: un nome per il percorso
  • NETWORK_NAME: il nome della rete VPC che contiene la route

Modificare una route statica

Non puoi modificare o aggiornare una route statica dopo averla creata. Per modificare un percorso statico, devi eliminarlo e crearne uno sostitutivo.

Eliminare una route statica

Per eliminare un percorso:

Console

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

    Vai a Route

  2. Fai clic sulla scheda Gestione route.

  3. Seleziona la casella di controllo accanto alla regola che vuoi eliminare.

  4. Fai clic su Elimina.

  5. Fai di nuovo clic su Elimina per confermare.

gcloud

Elimina una route statica personalizzata utilizzando il seguente comando gcloud CLI:

gcloud compute routes delete ROUTE_NAME

Sostituisci ROUTE_NAME con il nome del percorso che vuoi eliminare.

API

Elimina una route statica personalizzata per rimuoverla dalla rete VPC utilizzando il 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 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 delle modifiche ai percorsi

Quando aggiungi o elimini una route statica, questa viene propagata a tutte le regioni e alle istanze VM nella tua rete VPC. Uno stato dell'operazione di percorso PENDING o RUNNING indica che la modifica del percorso è in coda.

Dopo l'inserimento in coda, lo stato dell'operazione di routing diventa DONE. Potrebbero essere necessari altri 30 secondi prima che tutte le istanze VM nella rete VPC e nelle reti VPC Network Peering utilizzino una nuova route o smettano di utilizzare una vecchia route.

Se aggiungi o rimuovi più percorsi statici contemporaneamente, le modifiche possono essere applicate in qualsiasi ordine. Non è garantito che l'ordine in cui invii le modifiche al percorso sia quello in cui vengono elaborate. È possibile che istanze diverse vengano a conoscenza delle modifiche in momenti diversi.

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

Abilita l'IP forwarding per le istanze

Per impostazione predefinita, il forwarding IP è disabilitato e Google Cloud esegue un controllo rigoroso dell'indirizzo di origine. In base alla configurazione efficace 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 sulla 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 alla 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 backend per un bilanciatore del carico di rete passthrough interno, un bilanciatore del carico di rete passthrough esterno o se viene fatto riferimento a un'istanza di destinazione.

Per utilizzare una VM come hop successivo per una route, la VM deve inoltrare i pacchetti le cui origini non corrispondono a uno degli indirizzi IP o degli intervalli nell'elenco precedente. Per mandare avanti i pacchetti con indirizzi di origine arbitrari, devi attivare il forwarding IP:

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

Per attivare il forwarding IP 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, gestione, single-tenancy.

  4. Espandi la sezione Networking.

  5. Nella sezione Inoltro IP, seleziona la casella di controllo Attiva.

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 attivare il forwarding IP:

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 l'istanza

Per ulteriori informazioni, consulta il metodo instances.insert.

Terraform

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

In questo esempio, agli argomenti Terraform sono stati assegnati valori che puoi modificare.

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 attivato l'IP forwarding, prosegui con la procedura di creazione della VM.

Per attivare l'IP forwarding su una VM esistente, aggiorna la proprietà dell'istanza canIpForward.

Passaggi successivi