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 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 route statiche.

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 della gcloud CLI né i metodi API mostrano seguenti tipi di route:

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 Route

  2. Nella scheda Route operative, segui questi passaggi:

    • 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 dei percorsi, 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 percorso non sono 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 ottenere 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 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 ottenere 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 delle route che puoi utilizzare e 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. Nel menu Altre azioni alla fine della riga, seleziona Visualizza dettagli 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.

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 le route statiche 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 ulteriori informazioni su come aggiungere e rimuovere subnet, consulta Utilizzare le subnet.

Tutte le route in una rete VPC collegate 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 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 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. Esamina il intervalli IPv4 in modalità automatica per maggiori dettagli.
  • 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 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, solo le VM con quel tag la riceveranno. Tuttavia, le VM con tag ricevono comunque tutti i percorsi che non hanno un tag di rete.

Aggiungere una route statica

Aggiungi un route statico a una rete. Per saperne di più 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 percorsi.

  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 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: invia pacchetti a internet e alle API e ai 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 un indirizzo IP di un'istanza esistente nella rete VPC. Per IPv6 route statiche (Anteprima), l'istanza deve essere dual-stack. Per le limitazioni importanti relative agli indirizzi IP di hop successivo validi, consulta hop successivi della route statica.
    • 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 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 dual-stack. Per importanti limitazioni relative a indirizzi IP dell'hop successivo validi, consulta la sezione Hop successivi e funzionalità.
    • --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: invia 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 maggiori 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 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 viene creato il percorso
  • 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. 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: 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: 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 indirizzo IPv6, l'istanza VM deve essere a doppio stack.
    • nextHopIp: ADDRESS: specifica un indirizzo IP di su 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 l'istanza VM in base al nome della regola di inoltro interna (o all'indirizzo IPv4) e alla 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 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 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 configurata automaticamente per ogni default-internet-gateway rete VPC. Segui questa procedura per ricreare questa route se necessaria.

Console

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

    Vai a Route

  2. Fai clic sulla scheda Gestione percorsi.

  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ò variare da 0 (la prioritaria 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 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 viene creato il percorso
  • 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. 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 percorsi.

  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ù alta) 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 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 percorsi.

  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 il seguente comando 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 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 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, la route si propaga a tutte le regioni e 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 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 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 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 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 per un bilanciatore del carico di rete passthrough interno, un bilanciatore del carico di rete passthrough esterno o a cui fa riferimento un 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. 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'attivazione 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 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 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, gestione, 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 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 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, 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 abilitato l'IP forwarding, continua con la creazione della VM .

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

Passaggi successivi