Utiliser des routes

Console

1. Dans la console Google Cloud , accédez à la page Routes.

   Accéder à la page Routes

2. Dans l'onglet Routes effectives, procédez comme suit :

   • Choisissez un réseau VPC.
   • Sélectionnez une région.

3. Cliquez sur Afficher.

4. Vous pouvez appliquer un filtre en fonction de propriétés telles que le type de route, la plage d'adresses IP de destination et le type de prochain saut.

5. Facultatif : Cliquez sur le bouton Afficher les routes supprimées pour afficher les routes supprimées. Pour afficher la raison pour laquelle une route a été supprimée, pointez sur l'icône de la colonne État.

gcloud

Pour répertorier et afficher les détails des routes de sous-réseau et des routes statiques, utilisez les commandes gcloud compute routes. Ces commandes n'affichent pas d'autres types de routes. Pour afficher toutes les routes, utilisez la console Google Cloud .

Pour lister les routes :

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

Pour obtenir des informations détaillées sur un itinéraire, procédez comme suit :

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

Remplacez les éléments suivants :

• NETWORK_NAME : nom du réseau VPC.
• PROJECT_ID : ID du projet contenant votre réseau VPC
• ROUTE_NAME : nom de la route.

API

Pour répertorier et afficher les détails des routes de sous-réseau et des routes statiques, utilisez les méthodes routes.list et routes.get. Ces méthodes n'affichent pas d'autres types de routes. Pour afficher toutes les routes, utilisez la console Google Cloud .

Pour lister les routes :

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

Pour obtenir des informations détaillées sur un itinéraire, procédez comme suit :

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

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet contenant votre réseau VPC
• NETWORK_URL : URL du réseau VPC.
• ROUTE_NAME : nom de la route.

Console

1. Dans la console Google Cloud , accédez à la page Instances de VM.

   Accéder à la page Instances de VM

2. Recherchez une instance de VM dans la liste. Dans le menu more_vertAutres actions à la fin de la ligne, sélectionnez Afficher les détails du réseau.

3. Si une instance comporte plusieurs interfaces réseau, sélectionnez celle que vous souhaitez afficher dans la section Informations sur l'interface réseau.

4. Dans la section Détails des pare-feu et des routes, cliquez sur l'onglet Routes pour afficher toutes les routes qui s'appliquent à l'interface réseau, triées par nom de route.

Console

1. Dans la console Google Cloud , accédez à la page Routes.

   Accéder à la page Routes

2. Cliquez sur l'onglet Gestion des routes.

3. Cliquez sur Créer une route.

4. Spécifiez un nom et une description pour la route.

5. Dans la liste Réseau, sélectionnez un réseau existant pour la route.

6. Dans la liste Type de route, sélectionnez Route statique.

7. Dans la liste Version IP, sélectionnez la version d'adresse IP requise :

   • Pour créer une route statique IPv4, sélectionnez IPv4.
   • Pour créer une route statique IPv6, sélectionnez IPv6.

8. Spécifiez une plage d'adresses IP de destination. La destination la plus large possible est 0.0.0.0/0 pour IPv4 ou ::/0 pour IPv6.

9. Spécifiez une priorité pour la route. La priorité peut être comprise entre 0 (priorité la plus élevée) et 65535 (priorité la plus basse).

10. Pour rendre la route applicable uniquement à la sélection d'instances associées aux tags réseau correspondants, spécifiez ces tags dans le champ Tags des instances. Laissez le champ vide pour rendre la route applicable à toutes les instances du réseau.

11. Sélectionnez un prochain saut pour la route :

    • Passerelle Internet par défaut : envoie les paquets vers Internet et les API et services Google.
    • Spécifier une instance : envoie les paquets à l'interface réseau d'une instance de VM. Spécifiez l'instance de VM par nom et par zone. Si la destination de la route est une adresse IPv6, l'instance de VM doit être de type double pile ou IPv6 uniquement.
    • Spécifier l'adresse IP d'une instance : indiquez l'adresse IP d'une instance existante dans le réseau VPC. Pour les routes statiques IPv6, l'instance doit être de type double pile ou IPv6 uniquement. Pour connaître les restrictions importantes concernant les adresses IP de saut suivant valides, consultez la section Sauts suivants des routes statiques.
    • Spécifier un tunnel VPN : envoie les paquets à un tunnel VPN classique existant à l'aide d'un routage statique.
    • Spécifier une règle de transfert pour un équilibreur de charge réseau passthrough interne : envoie les paquets à un équilibreur de charge réseau passthrough interne qui est spécifié par le nom et la région de son équilibreur de charge réseau interne. La règle de transfert peut avoir une adresse IPv4 ou IPv6. La version IP de la règle de transfert que vous spécifiez doit correspondre à celle de la route statique que vous créez.

12. Cliquez sur Créer.

gcloud

Créez une route statique personnalisée en exécutant la commande suivante de la gcloud CLI :

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

Remplacez les éléments suivants :

• ROUTE_NAME : nom de la route.
• NETWORK : nom du réseau VPC contenant la route.
• DESTINATION_RANGE : adresses IPv4 ou IPv6 de destination auxquelles cette route s'applique. La destination la plus large possible est 0.0.0.0/0 pour IPv4 ou ::/0 pour IPv6.
• PRIORITY : priorité de la route, qui peut être comprise entre 0 (priorité la plus élevée) et 65535 (priorité la plus basse).

• NEXT_HOP_SPECIFICATION : prochain saut de la route statique. Utilisez l'un des paramètres suivants ou une combinaison de ces paramètres :

  • --next-hop-gateway=default-internet-gateway : envoyez les paquets vers Internet et les API et services Google.
  • --next-hop-instance=INSTANCE_NAME et --next-hop-instance-zone=ZONE : envoyez les paquets à l'interface réseau d'une instance de VM existante. Spécifiez l'instance de VM par nom et par zone. Si la destination de la route est une adresse IPv6, l'instance de VM doit être de type double pile ou IPv6 uniquement.
  • --next-hop-address=ADDRESS : spécifie l'adresse IP d'une instance existante dans le réseau VPC. Pour les routes statiques IPv6, l'instance doit être de type double pile ou IPv6 uniquement. Pour connaître les restrictions importantes concernant les adresses IP de prochain saut valides, consultez Prochains sauts et caractéristiques.
  • --next-hop-vpn-tunnel=VPN_TUNNEL_NAME et --next-hop-vpn-tunnel-region=REGION : envoyez les paquets à un tunnel VPN classique existant à l'aide d'un routage statique.
  • --next-hop-ilb=FORWARDING_RULE et --next-hop-ilb-region=REGION : envoyez les paquets à un équilibreur de charge réseau passthrough interne. Spécifiez la règle de transfert par son nom (ou son adresse IPv4 ou IPv6) et sa région. La version IP de la règle de transfert que vous spécifiez doit correspondre à celle de la route statique que vous créez. Pour en savoir plus sur la configuration des routes statiques vers les équilibreurs de charge réseau passthrough internes, consultez Créer des routes statiques.

  Pour que la route statique personnalisée ne s'applique qu'à certaines VM identifiées par tag réseau, ajoutez l'option --tags et spécifiez un ou plusieurs tags réseau. Pour plus d'informations sur la manière dont les tags réseau et les routes statiques personnalisées fonctionnent ensemble, consultez la section Routes applicables de la page "Présentation des routes". Vous pouvez utiliser des tags avec n'importe quelle route statique personnalisée.

Pour en savoir plus sur la syntaxe de la gcloud CLI, consultez la documentation du SDK.

API

Créez une route statique personnalisée.

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

Remplacez les éléments suivants :

• PROJECT_ID : ID du projet dans lequel votre route est créée.
• ROUTE_NAME : nom de la route.
• NETWORK : nom du réseau VPC contenant la route.
• DESTINATION_RANGE : plage d'adresses IPv4 ou IPv6 de destination à laquelle cette route s'applique. La destination la plus large possible est 0.0.0.0/0 pour IPv4 ou ::/0 pour IPv6.
• PRIORITY : priorité de la route, qui peut être comprise entre 0 (priorité la plus élevée) et 65535 (priorité la plus basse).
• NEXT_HOP_SPECIFICATION : prochain saut de la route statique. Utilisez l'un des paramètres suivants ou une combinaison de ces paramètres :
  • nextHopGateway: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/gateways/default-internet-gateway : envoie les paquets vers Internet et les API et services Google.
  • nextHopInstance: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances/INSTANCE_NAME : envoie les paquets à l'interface réseau d'une instance de VM. Spécifiez l'instance de VM par nom et par zone. Si la destination de la route est une adresse IPv6, l'instance de VM doit être de type double pile ou IPv6 uniquement.
  • nextHopIp: ADDRESS : spécifie l'adresse IP d'une instance existante dans le réseau VPC. Pour les routes statiques IPv6, l'instance doit être de type double pile ou IPv6 uniquement. Pour connaître les restrictions importantes concernant les adresses IP de prochain saut valides, consultez Prochains sauts et caractéristiques.
  • nextHopVpnTunnel: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/vpnTunnels/VPN_TUNNEL_NAME : envoie les paquets à un tunnel VPN classique existant à l'aide d'un routage statique.
  • nextHopIlb: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/forwardingRules/FORWARDING_RULE : envoie les paquets à un équilibreur de charge réseau passthrough interne. Spécifiez la règle de transfert par son nom (ou son adresse IPv4 ou IPv6) et sa région. La version IP de la règle de transfert que vous spécifiez doit correspondre à celle de la route statique que vous créez.

Pour que la route statique personnalisée ne s'applique qu'à certaines VM identifiées par tag réseau, ajoutez le champ tags et spécifiez un ou plusieurs tags réseau. Pour plus d'informations sur la manière dont les tags réseau et les routes statiques personnalisées fonctionnent ensemble, consultez la section Routes applicables de la page "Présentation des routes". Vous pouvez utiliser des tags avec n'importe quelle route statique personnalisée.

Pour plus d'informations, reportez-vous à la méthode routes.insert.

Terraform

Vous pouvez créer une route statique à l'aide d'un module Terraform.

Cette route statique crée une route par défaut vers Internet.

module "google_compute_route" {
  source       = "../../modules/routes" #adding local path
  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
    }
  ]
}

Pour savoir comment appliquer ou supprimer une configuration Terraform, consultez Commandes Terraform de base.

Go

import (
	"context"
	"fmt"
	"io"

	compute "cloud.google.com/go/compute/apiv1"
	computepb "cloud.google.com/go/compute/apiv1/computepb"
	"google.golang.org/protobuf/proto"
)

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

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

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

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

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

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

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

	return nil
}

Java

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

public class CreateRoute {

  public static void main(String[] args)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    // Project ID or project number of the Cloud project you want to use.
    String projectId = "your-project-id";
    // Route name you want to use.
    String routeName = "your-route-name";
    createRoute(projectId, routeName);
  }

  // Create route for a project.
  public static Operation.Status createRoute(String projectId, String routeName)
          throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    try (RoutesClient routesClient = RoutesClient.create()) {
      String nextHopGateway =
              String.format("projects/%s/global/gateways/default-internet-gateway", projectId);

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

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

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

Python

from __future__ import annotations

import sys
from typing import Any

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


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

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

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

    Returns:
        Whatever the operation.result() returns.

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

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

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

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

    return result


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

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

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

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

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

    route = compute_v1.